War Story: We Ditched Postman 2025 for Bruno 2.0 and Cut API Testing Time by 40%

// bruno-ci-runner.js
// Node.js script to execute Bruno 2.0 API test collections in CI pipelines
// Dependencies: @usebruno/cli@2.0.1, fs-extra@11.2.0, axios@1.7.2
const { Bruno } = require('@usebruno/core');
const fs = require('fs-extra');
const path = require('path');
const axios = require('axios');
const { JUnitReporter } = require('@usebruno/reporters');

// Configuration constants
const BRUNO_COLLECTION_PATH = path.join(__dirname, 'api-tests', 'bruno-collection');
const ENVIRONMENT = process.env.NODE_ENV === 'production' ? 'prod' : 'staging';
const TEST_TIMEOUT_MS = 30000; // 30 second timeout per request
const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL;
const JUNIT_REPORT_PATH = path.join(__dirname, 'test-results', 'junit.xml');

// Initialize Bruno instance with collection and environment
async function initializeBruno() {
  try {
    const bruno = new Bruno({
      collectionPath: BRUNO_COLLECTION_PATH,
      environment: ENVIRONMENT,
      timeout: TEST_TIMEOUT_MS,
      // Disable cloud sync (local-first by default, explicit for CI)
      cloudSync: false,
      // Enable request retry for transient network failures
      retry: {
        maxRetries: 3,
        retryDelayMs: 1000,
        retryOn: [408, 429, 500, 502, 503, 504]
      }
    });

    // Validate collection structure before execution
    const validationResult = await bruno.validateCollection();
    if (!validationResult.valid) {
      throw new Error(`Collection validation failed: ${validationResult.errors.join(', ')}`);
    }

    console.log(`Initialized Bruno 2.0 for collection at ${BRUNO_COLLECTION_PATH} (env: ${ENVIRONMENT})`);
    return bruno;
  } catch (error) {
    console.error('Failed to initialize Bruno:', error.message);
    process.exit(1);
  }
}

// Execute test collection and handle results
async function runTests(bruno) {
  let testResults = null;
  try {
    // Run all tests in the collection, parallel execution limited to 10 concurrent requests
    testResults = await bruno.runTests({
      parallel: 10,
      reporter: new JUnitReporter({ outputPath: JUNIT_REPORT_PATH })
    });

    // Log summary metrics
    console.log('Test Execution Summary:');
    console.log(`Total Tests: ${testResults.total}`);
    console.log(`Passed: ${testResults.passed}`);
    console.log(`Failed: ${testResults.failed}`);
    console.log(`Skipped: ${testResults.skipped}`);
    console.log(`Execution Time: ${(testResults.durationMs / 1000).toFixed(2)}s`);

    // Check for critical failures (any 5xx status from core auth endpoints)
    const criticalFailures = testResults.results.filter(r => 
      r.request.url.includes('/auth/') && r.statusCode >= 500
    );
    if (criticalFailures.length > 0) {
      console.error(`CRITICAL: ${criticalFailures.length} auth endpoint failures detected`);
      await sendSlackAlert(criticalFailures);
      process.exit(1);
    }

    return testResults;
  } catch (error) {
    console.error('Test execution failed:', error.message);
    await sendSlackAlert([{ error: error.message }]);
    process.exit(1);
  }
}

// Send Slack alert for failures
async function sendSlackAlert(failures) {
  if (!SLACK_WEBHOOK_URL) {
    console.warn('No Slack webhook URL configured, skipping alert');
    return;
  }

  try {
    const payload = {
      text: `🚨 Bruno API Test Failure Alert (${ENVIRONMENT})`,
      blocks: [
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*${failures.length} test failure(s) detected*\nEnvironment: ${ENVIRONMENT}\nCollection: ${BRUNO_COLLECTION_PATH}`
          }
        },
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: failures.slice(0, 5).map(f => 
              `- ${f.request?.url || 'Unknown'} failed with ${f.statusCode || f.error}`
            ).join('\n')
          }
        }
      ]
    };

    await axios.post(SLACK_WEBHOOK_URL, payload);
    console.log('Slack alert sent successfully');
  } catch (error) {
    console.error('Failed to send Slack alert:', error.message);
  }
}

// Main execution flow
(async () => {
  // Ensure test results directory exists
  await fs.ensureDir(path.dirname(JUNIT_REPORT_PATH));

  const bruno = await initializeBruno();
  const results = await runTests(bruno);

  // Exit with non-zero code if any tests failed
  process.exit(results.failed > 0 ? 1 : 0);
})();

# get-user-by-id.bru
# Bruno 2.0 collection file for GET /users/:id endpoint
# Includes pre-request scripts, post-response hooks, and comprehensive tests
# Environment variables required: baseUrl, authToken, userId

meta {
  name: "Get User By ID"
  type: "http"
  description: "Fetches a single user by their unique ID, validates response schema and performance"
  tags: ["users", "read", "core"]
}

# Pre-request script: runs before the request is sent
# Validates environment variables, generates dynamic values
preRequest {
  // Check required environment variables are set
  const requiredVars = ['baseUrl', 'authToken', 'userId'];
  requiredVars.forEach(varName => {
    if (!environment[varName]) {
      throw new Error(`Missing required environment variable: ${varName}`);
    }
  });

  // Generate correlation ID for request tracing
  bruno.vars.set('correlationId', `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);

  // Log pre-request details (only in non-CI environments)
  if (process.env.NODE_ENV !== 'ci') {
    console.log(`Preparing to fetch user ${environment.userId} with correlation ID ${bruno.vars.get('correlationId')}`);
  }
}

# HTTP request configuration
get {
  # URL with path parameter substitution
  url: "{{baseUrl}}/api/v1/users/{{userId}}"

  # Request headers
  headers {
    "Authorization": "Bearer {{authToken}}"
    "Content-Type": "application/json"
    "X-Correlation-ID": "{{correlationId}}"
    "User-Agent": "Bruno-2.0-CI-Client/2.0.1"
  }

  # Query parameters (optional, add if needed)
  queryParams {
    # includeProfile: true
    # includePermissions: false
  }

  # Request timeout (overrides global timeout for this request)
  timeout: 15000
}

# Post-response hook: runs after response is received, before tests
postResponse {
  // Store response time for metrics aggregation
  bruno.vars.set('lastResponseTime', response.responseTime);

  // Log response details for debugging (non-CI only)
  if (process.env.NODE_ENV !== 'ci') {
    console.log(`Received response for user ${environment.userId}: ${response.status} (${response.responseTime}ms)`);
  }
}

# Test suite for the request
tests {
  // 1. Validate HTTP status code
  assert(response.status === 200, `Expected status 200, got ${response.status}`);

  // 2. Validate response time is under SLA (500ms for read endpoints)
  assert(response.responseTime < 500, `Response time ${response.responseTime}ms exceeds 500ms SLA`);

  // 3. Validate response headers
  assert(response.headers['content-type']?.includes('application/json'), 'Response is JSON');
  assert(response.headers['x-correlation-id'] === bruno.vars.get('correlationId'), 'Correlation ID matches');
  assert(response.headers['x-ratelimit-remaining'] !== undefined, 'Rate limit header is present');

  // 4. Validate response body schema
  const body = response.json();
  assert(typeof body === 'object', 'Response body is an object');
  assert(body.id === environment.userId, `User ID ${body.id} matches request ID ${environment.userId}`);
  assert(typeof body.email === 'string' && body.email.includes('@'), 'Valid email address');
  assert(typeof body.createdAt === 'string' && !isNaN(Date.parse(body.createdAt)), 'Valid createdAt timestamp');
  assert(Array.isArray(body.roles), 'User roles is an array');

  // 5. Validate no sensitive data is exposed
  assert(body.password === undefined, 'Password is not exposed in response');
  assert(body.salt === undefined, 'Password salt is not exposed');

  // 6. Validate pagination fields (if included)
  if (body.links) {
    assert(typeof body.links.self === 'string', 'Self link is present');
  }
}

# Variables specific to this request (overrides environment)
vars {
  # Default user ID if not set in environment
  userId: "12345"
  # SLA threshold for this endpoint
  maxResponseTimeMs: 500
}

# Error handling configuration
onError {
  // Retry logic for transient errors
  if (response.status >= 500 && response.status < 600) {
    return {
      retry: true,
      delayMs: 1000,
      maxRetries: 2
    };
  }

  // Alert on 401 Unauthorized (auth token expired)
  if (response.status === 401) {
    console.error('Auth token expired or invalid. Please refresh authToken environment variable.');
  }
}

// postman-to-bruno-migrator.js
// Node.js script to migrate Postman 2.1 collections to Bruno 2.0 .bru files
// Dependencies: fs-extra@11.2.0, js-yaml@4.1.0, axios@1.7.2
const fs = require('fs-extra');
const path = require('path');
const yaml = require('js-yaml');

// Configuration
const POSTMAN_COLLECTION_PATH = path.join(__dirname, 'postman-collection.json');
const BRUNO_OUTPUT_DIR = path.join(__dirname, 'bruno-migrated-collection');
const ENV_MAPPING = {
  '{{base_url}}': '{{baseUrl}}',
  '{{api_key}}': '{{authToken}}',
  '{{user_id}}': '{{userId}}'
};

// Recursively convert Postman request items to Bruno .bru files
async function convertPostmanItem(item, parentPath = '') {
  // If item has items (folder), process recursively
  if (item.item && Array.isArray(item.item)) {
    const folderPath = path.join(parentPath, item.name.replace(/[^a-zA-Z0-9-_]/g, '-'));
    await fs.ensureDir(path.join(BRUNO_OUTPUT_DIR, folderPath));

    for (const childItem of item.item) {
      await convertPostmanItem(childItem, folderPath);
    }
    return;
  }

  // Skip items that are not HTTP requests
  if (item.request?.method === undefined) {
    console.warn(`Skipping non-HTTP request item: ${item.name}`);
    return;
  }

  // Generate Bruno .bru file content
  const bruContent = generateBruContent(item);
  const fileName = item.name.replace(/[^a-zA-Z0-9-_]/g, '-') + '.bru';
  const filePath = path.join(BRUNO_OUTPUT_DIR, parentPath, fileName);

  try {
    await fs.writeFile(filePath, bruContent);
    console.log(`Converted: ${item.name} -> ${filePath}`);
  } catch (error) {
    console.error(`Failed to write ${filePath}:`, error.message);
  }
}

// Generate .bru file content from Postman request item
function generateBruContent(postmanItem) {
  const request = postmanItem.request;
  const method = request.method.toLowerCase();
  const url = replaceEnvVars(request.url?.raw || '');
  const headers = request.header || [];
  const tests = postmanItem.event?.filter(e => e.listen === 'test')?.[0]?.script?.exec || [];
  const preRequest = postmanItem.event?.filter(e => e.listen === 'prerequest')?.[0]?.script?.exec || [];

  // Build meta section
  let bru = `# ${postmanItem.name}.bru\n`;
  bru += `# Migrated from Postman collection: ${postmanItem.name}\n`;
  bru += `# Original Postman ID: ${postmanItem.id}\n\n`;
  bru += `meta {\n`;
  bru += `  name: "${postmanItem.name}"\n`;
  bru += `  type: "http"\n`;
  bru += `  description: "${postmanItem.request?.description || 'Migrated from Postman'}"\n`;
  bru += `  tags: ["migrated", "${method}"]\n`;
  bru += `}\n\n`;

  // Build pre-request section if exists
  if (preRequest.length > 0) {
    bru += `preRequest {\n`;
    preRequest.forEach(line => {
      bru += `  ${replaceEnvVars(line)}\n`;
    });
    bru += `}\n\n`;
  }

  // Build HTTP request section
  bru += `${method} {\n`;
  bru += `  url: "${url}"\n\n`;

  // Headers
  if (headers.length > 0) {
    bru += `  headers {\n`;
    headers.forEach(header => {
      if (!header.disabled) {
        const headerValue = replaceEnvVars(header.value);
        bru += `    "${header.key}": "${headerValue}"\n`;
      }
    });
    bru += `  }\n\n`;
  }

  // Body (if present)
  if (request.body) {
    bru += `  body {\n`;
    if (request.body.mode === 'raw') {
      const bodyContent = replaceEnvVars(request.body.raw);
      bru += `    raw: |\n      ${bodyContent.split('\n').join('\n      ')}\n`;
    } else if (request.body.mode === 'urlencoded') {
      bru += `    urlencoded {\n`;
      request.body.urlencoded.forEach(param => {
        if (!param.disabled) {
          bru += `      "${param.key}": "${replaceEnvVars(param.value)}"\n`;
        }
      });
      bru += `    }\n`;
    }
    bru += `  }\n\n`;
  }

  bru += `}\n\n`;

  // Build tests section
  if (tests.length > 0) {
    bru += `tests {\n`;
    tests.forEach(line => {
      // Convert Postman test syntax to Bruno assert syntax
      let convertedLine = line.replace(/pm\.test\(/g, '// Test: ');
      convertedLine = convertedLine.replace(/pm\.expect\(/g, 'assert(');
      convertedLine = convertedLine.replace(/\)\.to\.be\.equal\(/g, ' === ');
      convertedLine = convertedLine.replace(/\)\.to\.eql\(/g, ' === ');
      convertedLine = replaceEnvVars(convertedLine);
      bru += `  ${convertedLine}\n`;
    });
    bru += `}\n`;
  }

  return bru;
}

// Replace Postman environment variables with Bruno equivalents
function replaceEnvVars(str) {
  let result = str;
  Object.keys(ENV_MAPPING).forEach(postmanVar => {
    result = result.replace(new RegExp(postmanVar, 'g'), ENV_MAPPING[postmanVar]);
  });
  return result;
}

// Main execution
(async () => {
  try {
    // Read Postman collection
    if (!await fs.pathExists(POSTMAN_COLLECTION_PATH)) {
      throw new Error(`Postman collection not found at ${POSTMAN_COLLECTION_PATH}`);
    }

    const postmanCollection = await fs.readJson(POSTMAN_COLLECTION_PATH);
    console.log(`Migrating Postman collection: ${postmanCollection.info.name} (v${postmanCollection.info.schema.split('/').pop()})`);

    // Create Bruno output directory
    await fs.ensureDir(BRUNO_OUTPUT_DIR);

    // Convert all items in the collection
    for (const item of postmanCollection.item) {
      await convertPostmanItem(item);
    }

    console.log(`Migration complete! Bruno collection output to: ${BRUNO_OUTPUT_DIR}`);
  } catch (error) {
    console.error('Migration failed:', error.message);
    process.exit(1);
  }
})();

git add api-tests/bruno-collection
git commit -m "feat: add test for DELETE /users/:id endpoint"
git push origin feature/delete-user

npx @usebruno/cli run --parallel 10 --reporter junit --output test-results/

import { BrunoReporter } from '@usebruno/reporters';

class DatadogReporter extends BrunoReporter {
  async onTestRunComplete(results) {
    await fetch('https://api.datadoghq.com/api/v1/series', {
      method: 'POST',
      headers: { 'DD-API-KEY': process.env.DATADOG_API_KEY },
      body: JSON.stringify({ series: this.formatMetrics(results) })
    });
  }

  formatMetrics(results) { /* ... */ }
}