Comparing Postman 11.0 vs. Bruno 2.0 for API Testing in 2026

// Bruno 2.0 Programmatic Test Runner
// Requires: bruno-sdk@2.0.1, dotenv@16.4.5
// Run: node bruno-runner.js --collection ./petstore-collection --env staging
const { Bruno } = require('@usebruno/sdk');
const dotenv = require('dotenv');
const path = require('path');
const fs = require('fs/promises');
const { program } = require('commander');

// Load environment variables from .env file
dotenv.config({ path: path.join(__dirname, '.env') });

// Configure CLI arguments
program
  .option('-c, --collection ', 'Path to Bruno collection directory', './collection')
  .option('-e, --env ', 'Environment name to use', 'local')
  .option('-r, --retries ', 'Number of retries for failed requests', '2')
  .option('--fail-fast', 'Stop execution on first failure')
  .parse(process.argv);

const options = program.opts();

// Validate collection path exists
async function validateCollectionPath(collectionPath) {
  try {
    const stats = await fs.stat(collectionPath);
    if (!stats.isDirectory()) {
      throw new Error(`Collection path ${collectionPath} is not a directory`);
    }
    // Check for bruno.json config file
    await fs.access(path.join(collectionPath, 'bruno.json'));
  } catch (error) {
    console.error(`Invalid collection path: ${error.message}`);
    process.exit(1);
  }
}

// Initialize Bruno instance with error handling
async function initBruno() {
  try {
    const bruno = new Bruno({
      collectionPath: options.collection,
      environment: options.env,
      retries: parseInt(options.retries, 10),
      failFast: options.failFast || false,
      // Enable request/response logging for debugging
      logging: {
        level: 'info',
        format: 'json'
      }
    });

    // Register global error handler for network errors
    bruno.on('request:error', (error, request) => {
      console.error(`Request failed for ${request.name}: ${error.message}`);
      // Log to file for post-mortem analysis
      fs.appendFile(
        path.join(__dirname, 'bruno-errors.log'),
        `${new Date().toISOString()} | ${request.name} | ${error.message}
`
      );
    });

    // Register test failure handler
    bruno.on('test:fail', (testResult, request) => {
      console.error(`Test failed for ${request.name}: ${testResult.error}`);
    });

    return bruno;
  } catch (error) {
    console.error(`Failed to initialize Bruno: ${error.message}`);
    process.exit(1);
  }
}

// Main execution flow
async function main() {
  console.log(`Starting Bruno 2.0 test run for collection: ${options.collection}`);
  console.log(`Environment: ${options.env}, Retries: ${options.retries}`);

  // Validate inputs
  await validateCollectionPath(options.collection);

  // Initialize Bruno
  const bruno = await initBruno();

  // Run all tests in collection
  try {
    const results = await bruno.runAll();

    // Generate summary report
    const summary = {
      totalRequests: results.totalRequests,
      passed: results.passed,
      failed: results.failed,
      skipped: results.skipped,
      avgLatencyMs: results.avgLatencyMs,
      durationMs: results.durationMs
    };

    console.log('
=== Test Run Summary ===');
    console.log(JSON.stringify(summary, null, 2));

    // Write detailed report to file
    await fs.writeFile(
      path.join(__dirname, `bruno-report-${Date.now()}.json`),
      JSON.stringify(results, null, 2)
    );

    // Exit with non-zero code if any tests failed
    if (results.failed > 0) {
      console.error(`
${results.failed} tests failed. Exiting with error code.`);
      process.exit(1);
    } else {
      console.log('
All tests passed successfully!');
      process.exit(0);
    }
  } catch (error) {
    console.error(`Test run crashed: ${error.message}`);
    process.exit(1);
  }
}

// Handle uncaught exceptions
process.on('uncaughtException', (error) => {
  console.error(`Uncaught exception: ${error.message}`);
  process.exit(1);
});

// Run main function
main();

// Postman 11.0 AI Test Generator & Newman Runner
// Requires: newman@6.1.0, postman-api-client@3.2.1, dotenv@16.4.5
// Run: node postman-ai-runner.js --collection 12345-abcde --api-key $POSTMAN_API_KEY
const { PostmanClient } = require('postman-api-client');
const newman = require('newman');
const dotenv = require('dotenv');
const path = require('path');
const fs = require('fs/promises');
const { program } = require('commander');

// Load environment variables
dotenv.config({ path: path.join(__dirname, '.env') });

// Configure CLI arguments
program
  .option('-c, --collection ', 'Postman Collection ID (from Postman app)')
  .option('-a, --api-key ', 'Postman API Key (overrides POSTMAN_API_KEY env var)')
  .option('-e, --environment ', 'Postman Environment ID')
  .option('--disable-ai', 'Skip AI test generation, use existing tests')
  .option('--iterations ', 'Number of test iterations', '1')
  .parse(process.argv);

const options = program.opts();

// Validate required arguments
if (!options.collection) {
  console.error('Error: --collection is required');
  program.help();
}

// Initialize Postman client
async function initPostmanClient() {
  const apiKey = options.apiKey || process.env.POSTMAN_API_KEY;
  if (!apiKey) {
    console.error('Error: Postman API key not provided. Set POSTMAN_API_KEY or use --api-key');
    process.exit(1);
  }

  try {
    const client = new PostmanClient({ apiKey });
    // Verify API key is valid
    await client.verifyApiKey();
    console.log('Postman client initialized successfully');
    return client;
  } catch (error) {
    console.error(`Failed to initialize Postman client: ${error.message}`);
    process.exit(1);
  }
}

// Generate AI tests for collection
async function generateAITests(client, collectionId) {
  console.log(`Generating AI tests for collection ${collectionId}...`);
  try {
    const response = await client.ai.generateTests({
      collectionId: collectionId,
      testType: 'integration',
      includeEdgeCases: true,
      // Postman 11.0 AI config
      model: 'postman-gpt-4-2026',
      temperature: 0.2
    });

    if (response.status !== 'success') {
      throw new Error(`AI test generation failed: ${response.error}`);
    }

    // Save generated tests to collection
    await client.collections.update(collectionId, {
      tests: response.tests
    });

    console.log(`Generated ${response.tests.length} AI tests successfully`);
    return response.tests;
  } catch (error) {
    console.error(`AI test generation failed: ${error.message}`);
    if (options.disableAi) {
      console.log('AI disabled, proceeding with existing tests');
      return [];
    }
    process.exit(1);
  }
}

// Run collection with Newman
async function runWithNewman(collectionId, environmentId) {
  console.log('Starting Newman test run...');
  return new Promise((resolve, reject) => {
    newman.run({
      collection: `https://api.getpostman.com/collections/${collectionId}?apikey=${options.apiKey || process.env.POSTMAN_API_KEY}`,
      environment: environmentId ? `https://api.getpostman.com/environments/${environmentId}?apikey=${options.apiKey || process.env.POSTMAN_API_KEY}` : undefined,
      iterationCount: parseInt(options.iterations, 10),
      reporters: ['cli', 'json'],
      reporterOptions: {
        json: {
          export: path.join(__dirname, `newman-report-${Date.now()}.json`)
        }
      },
      // Error handling for failed requests
      bail: false,
      timeout: 30000,
      timeoutRequest: 10000
    }, (err, summary) => {
      if (err) {
        reject(new Error(`Newman run failed: ${err.message}`));
      } else {
        resolve(summary);
      }
    });
  });
}

// Main execution flow
async function main() {
  console.log(`Starting Postman 11.0 test run for collection: ${options.collection}`);

  // Initialize Postman client
  const client = await initPostmanClient();

  // Generate AI tests (unless disabled)
  if (!options.disableAi) {
    await generateAITests(client, options.collection);
  }

  // Run tests with Newman
  try {
    const summary = await runWithNewman(options.collection, options.environment);

    // Print summary
    console.log('
=== Newman Test Summary ===');
    console.log(`Total requests: ${summary.run.stats.requests.total}`);
    console.log(`Passed: ${summary.run.stats.testScripts.passed}`);
    console.log(`Failed: ${summary.run.stats.testScripts.failed}`);
    console.log(`Avg latency: ${summary.run.timings.responseAverage}ms`);
    console.log(`Total duration: ${summary.run.timings.completed - summary.run.timings.started}ms`);

    // Exit with error if tests failed
    if (summary.run.stats.testScripts.failed > 0) {
      process.exit(1);
    }
  } catch (error) {
    console.error(`Test run failed: ${error.message}`);
    process.exit(1);
  }
}

// Handle uncaught exceptions
process.on('uncaughtException', (error) => {
  console.error(`Uncaught exception: ${error.message}`);
  process.exit(1);
});

main();

// Cross-Tool Benchmark Script: Postman 11.0 vs Bruno 2.0
// Requires: @usebruno/sdk@2.0.1, newman@6.1.0, dotenv@16.4.5
// Run: node benchmark.js --postman-collection 12345-abcde --bruno-collection ./petstore-bru
const { Bruno } = require('@usebruno/sdk');
const newman = require('newman');
const { PostmanClient } = require('postman-api-client');
const dotenv = require('dotenv');
const path = require('path');
const fs = require('fs/promises');
const { program } = require('commander');

// Load env vars
dotenv.config();

// CLI config
program
  .option('-p, --postman-collection ', 'Postman Collection ID')
  .option('-b, --bruno-collection ', 'Bruno Collection Path')
  .option('-e, --environment ', 'Environment name', 'staging')
  .option('-i, --iterations ', 'Number of benchmark iterations', '3')
  .parse(process.argv);

const options = program.opts();

// Validate inputs
if (!options.postmanCollection || !options.brunoCollection) {
  console.error('Error: Both --postman-collection and --bruno-collection are required');
  program.help();
}

// Run Bruno benchmark
async function runBrunoBenchmark() {
  console.log('Running Bruno 2.0 benchmark...');
  try {
    const bruno = new Bruno({
      collectionPath: options.brunoCollection,
      environment: options.environment,
      retries: 0,
      logging: { level: 'error' }
    });

    const results = [];
    for (let i = 0; i < parseInt(options.iterations, 10); i++) {
      console.log(`Bruno iteration ${i + 1}/${options.iterations}`);
      const runResult = await bruno.runAll();
      results.push({
        iteration: i + 1,
        avgLatencyMs: runResult.avgLatencyMs,
        totalDurationMs: runResult.durationMs,
        passed: runResult.passed,
        failed: runResult.failed
      });
    }

    // Calculate averages
    const avgLatency = results.reduce((sum, r) => sum + r.avgLatencyMs, 0) / results.length;
    const avgDuration = results.reduce((sum, r) => sum + r.totalDurationMs, 0) / results.length;
    return {
      tool: 'Bruno 2.0',
      avgLatencyMs: Math.round(avgLatency),
      avgDurationMs: Math.round(avgDuration),
      totalPassed: results.reduce((sum, r) => sum + r.passed, 0),
      totalFailed: results.reduce((sum, r) => sum + r.failed, 0)
    };
  } catch (error) {
    console.error(`Bruno benchmark failed: ${error.message}`);
    return null;
  }
}

// Run Postman benchmark
async function runPostmanBenchmark() {
  console.log('Running Postman 11.0 benchmark...');
  const apiKey = process.env.POSTMAN_API_KEY;
  if (!apiKey) {
    console.error('POSTMAN_API_KEY not set for Postman benchmark');
    return null;
  }

  try {
    const results = [];
    for (let i = 0; i < parseInt(options.iterations, 10); i++) {
      console.log(`Postman iteration ${i + 1}/${options.iterations}`);
      const runResult = await new Promise((resolve, reject) => {
        newman.run({
          collection: `https://api.getpostman.com/collections/${options.postmanCollection}?apikey=${apiKey}`,
          iterationCount: 1,
          reporters: ['json'],
          reporterOptions: {
            json: { export: path.join(__dirname, 'postman-temp-report.json') }
          }
        }, (err, summary) => {
          if (err) reject(err);
          else resolve(summary);
        });
      });

      results.push({
        iteration: i + 1,
        avgLatencyMs: runResult.run.timings.responseAverage,
        totalDurationMs: runResult.run.timings.completed - runResult.run.timings.started,
        passed: runResult.run.stats.testScripts.passed,
        failed: runResult.run.stats.testScripts.failed
      });

      // Clean up temp report
      await fs.unlink(path.join(__dirname, 'postman-temp-report.json')).catch(() => {});
    }

    // Calculate averages
    const avgLatency = results.reduce((sum, r) => sum + r.avgLatencyMs, 0) / results.length;
    const avgDuration = results.reduce((sum, r) => sum + r.totalDurationMs, 0) / results.length;
    return {
      tool: 'Postman 11.0',
      avgLatencyMs: Math.round(avgLatency),
      avgDurationMs: Math.round(avgDuration),
      totalPassed: results.reduce((sum, r) => sum + r.passed, 0),
      totalFailed: results.reduce((sum, r) => sum + r.failed, 0)
    };
  } catch (error) {
    console.error(`Postman benchmark failed: ${error.message}`);
    return null;
  }
}

// Main execution
async function main() {
  console.log('Starting cross-tool benchmark...');
  const [brunoResults, postmanResults] = await Promise.all([
    runBrunoBenchmark(),
    runPostmanBenchmark()
  ]);

  // Generate comparison report
  const report = {
    timestamp: new Date().toISOString(),
    iterations: parseInt(options.iterations, 10),
    results: [brunoResults, postmanResults].filter(r => r !== null)
  };

  // Write report to file
  const reportPath = path.join(__dirname, `benchmark-report-${Date.now()}.json`);
  await fs.writeFile(reportPath, JSON.stringify(report, null, 2));
  console.log(`
Benchmark report written to ${reportPath}`);

  // Print summary
  console.log('
=== Benchmark Results ===');
  report.results.forEach(r => {
    console.log(`
${r.tool}:`);
    console.log(`  Avg Latency: ${r.avgLatencyMs}ms`);
    console.log(`  Avg Duration: ${r.avgDurationMs}ms`);
    console.log(`  Total Passed: ${r.totalPassed}`);
    console.log(`  Total Failed: ${r.totalFailed}`);
  });

  // Clean up
  process.exit(0);
}

// Error handling
process.on('uncaughtException', (error) => {
  console.error(`Uncaught exception: ${error.message}`);
  process.exit(1);
});

main();

#!/bin/bash
# .husky/pre-commit
npx bruno validate ./api-tests || exit 1
npx bruno format ./api-tests --check || exit 1
echo "Bruno collection validation passed"

// Trigger AI test generation for GraphQL collection
const { PostmanClient } = require('postman-api-client');
const client = new PostmanClient({ apiKey: process.env.POSTMAN_API_KEY });
const response = await client.ai.generateTests({
  collectionId: '12345-abcde',
  graphqlSchema: fs.readFileSync('./schema.graphql', 'utf8'),
  includeEdgeCases: true
});

# Convert Postman collection to Bruno format
npx bruno-converter postman-to-bruno ./postman-collection.json ./bruno-collection