War Story: We Migrated from Insomnia 8 to Bruno 1.5 and Cut API Testing Costs by 100% (Open Source)

// insomnia-to-bruno.js
// Migrates Insomnia v8 JSON exports to Bruno v1.5 collection format
// Usage: node insomnia-to-bruno.js ./insomnia-export.json ./bruno-output/
const fs = require('fs/promises');
const path = require('path');

// Validate CLI args
if (process.argv.length < 4) {
  console.error('Usage: node insomnia-to-bruno.js  ');
  process.exit(1);
}

const INSOMNIA_PATH = process.argv[2];
const OUTPUT_DIR = process.argv[3];

// Insomnia v8 type constants
const INSOMNIA_REQUEST_TYPE = 'request';
const INSOMNIA_FOLDER_TYPE = 'request_group';

// Bruno v1.5 collection schema version
const BRUNO_SCHEMA_VERSION = '1.5.0';

/**
 * Recursively migrates Insomnia request groups to Bruno folders
 * @param {Object} insomniaItem - Insomnia v8 request group object
 * @param {string} currentPath - Current filesystem path for Bruno collection
 * @returns {Promise}
 */
async function migrateFolder(insomniaItem, currentPath) {
  const folderName = insomniaItem.name.replace(/[^a-zA-Z0-9-_]/g, '_');
  const folderPath = path.join(currentPath, folderName);

  try {
    await fs.mkdir(folderPath, { recursive: true });
  } catch (err) {
    console.error(`Failed to create folder ${folderPath}: ${err.message}`);
    throw err;
  }

  // Process child items (requests or subfolders)
  for (const child of insomniaItem.children || []) {
    if (child.type === INSOMNIA_FOLDER_TYPE) {
      await migrateFolder(child, folderPath);
    } else if (child.type === INSOMNIA_REQUEST_TYPE) {
      await migrateRequest(child, folderPath);
    } else {
      console.warn(`Skipping unsupported Insomnia item type: ${child.type} (${child.name})`);
    }
  }
}

/**
 * Migrates a single Insomnia v8 request to Bruno v1.5 request format
 * @param {Object} insomniaRequest - Insomnia request object
 * @param {string} folderPath - Target Bruno folder path
 * @returns {Promise}
 */
async function migrateRequest(insomniaRequest, folderPath) {
  const requestName = insomniaRequest.name.replace(/[^a-zA-Z0-9-_]/g, '_');
  const brunoFilePath = path.join(folderPath, `${requestName}.bru`);

  // Extract Insomnia request details
  const { method, url, headers, body, authentication } = insomniaRequest;
  const brunoRequest = {
    version: BRUNO_SCHEMA_VERSION,
    name: insomniaRequest.name,
    type: 'http',
    request: {
      method: method?.toUpperCase() || 'GET',
      url: url || '',
      headers: headers || {},
      body: body || null,
      auth: authentication || null
    },
    tests: insomniaRequest.tests || [],
    vars: insomniaRequest.vars || {}
  };

  // Handle Insomnia environment variables (convert to Bruno syntax)
  const envVars = insomniaRequest.environment || {};
  for (const [key, value] of Object.entries(envVars)) {
    brunoRequest.vars[key] = typeof value === 'string' ? value.replace(/{{(\w+)}}/g, '{{$1}}') : value;
  }

  try {
    await fs.writeFile(brunoFilePath, JSON.stringify(brunoRequest, null, 2));
    console.log(`Migrated request: ${insomniaRequest.name} -> ${brunoFilePath}`);
  } catch (err) {
    console.error(`Failed to write Bruno file ${brunoFilePath}: ${err.message}`);
    throw err;
  }
}

/**
 * Main migration entry point
 */
async function main() {
  let insomniaExport;
  try {
    const rawData = await fs.readFile(INSOMNIA_PATH, 'utf8');
    insomniaExport = JSON.parse(rawData);
  } catch (err) {
    console.error(`Failed to read Insomnia export: ${err.message}`);
    process.exit(1);
  }

  // Validate Insomnia export schema
  if (!insomniaExport.resources || !Array.isArray(insomniaExport.resources)) {
    console.error('Invalid Insomnia v8 export: missing resources array');
    process.exit(1);
  }

  // Create output directory
  try {
    await fs.mkdir(OUTPUT_DIR, { recursive: true });
  } catch (err) {
    console.error(`Failed to create output directory: ${err.message}`);
    process.exit(1);
  }

  // Find root request groups (top-level folders)
  const rootFolders = insomniaExport.resources.filter(
    item => item.type === INSOMNIA_FOLDER_TYPE && !item.parentId
  );

  // Migrate each root folder
  for (const folder of rootFolders) {
    await migrateFolder(folder, OUTPUT_DIR);
  }

  // Migrate top-level requests (no parent folder)
  const topLevelRequests = insomniaExport.resources.filter(
    item => item.type === INSOMNIA_REQUEST_TYPE && !item.parentId
  );
  for (const request of topLevelRequests) {
    await migrateRequest(request, OUTPUT_DIR);
  }

  console.log(`Migration complete! Bruno collection written to ${OUTPUT_DIR}`);
}

// Execute with error handling
main().catch(err => {
  console.error('Migration failed:', err.message);
  process.exit(1);
});

// bruno/checkout-service/create-order.bru
// Bruno v1.5 request file for Checkout Service createOrder endpoint
// Includes pre-request validation, retry logic, and response assertions
{
  \"version\": \"1.5.0\",
  \"name\": \"Create Order\",
  \"type\": \"http\",
  \"request\": {
    \"method\": \"POST\",
    \"url\": \"{{baseUrl}}/api/v1/orders\",
    \"headers\": {
      \"Content-Type\": \"application/json\",
      \"X-Trace-Id\": \"{{$random.uuid}}\",
      \"Authorization\": \"Bearer {{authToken}}\"
    },
    \"body\": {
      \"mode\": \"json\",
      \"json\": {
        \"userId\": \"{{testUserId}}\",
        \"items\": [
          {
            \"productId\": \"{{testProductId}}\",
            \"quantity\": 2,
            \"unitPrice\": 49.99
          }
        ],
        \"shippingAddress\": {
          \"street\": \"123 Main St\",
          \"city\": \"Austin\",
          \"state\": \"TX\",
          \"zip\": \"78701\"
        }
      }
    },
    \"auth\": null,
    \"params\": []
  },
  \"tests\": [
    {
      \"name\": \"Response status is 201 Created\",
      \"script\": \"function validateStatus(response) { if (response.status !== 201) { throw new Error(`Expected 201, got ${response.status}`); } }\"
    },
    {
      \"name\": \"Response has valid orderId\",
      \"script\": \"function validateOrderId(response) { const body = JSON.parse(response.body); if (!body.orderId || typeof body.orderId !== 'string') { throw new Error('Missing or invalid orderId in response'); } }\"
    },
    {
      \"name\": \"Response total matches calculated amount\",
      \"script\": \"function validateTotal(response) { const body = JSON.parse(response.body); const expectedTotal = 49.99 * 2; if (Math.abs(body.total - expectedTotal) > 0.01) { throw new Error(`Expected total ${expectedTotal}, got ${body.total}`); } }\"
    },
    {
      \"name\": \"Retry on 429 Rate Limit\",
      \"script\": \"function retryOnRateLimit(response, context) { if (response.status === 429) { const retryCount = context.retryCount || 0; if (retryCount < 3) { context.retryCount = retryCount + 1; context.delay = 1000 * Math.pow(2, retryCount); return 'retry'; } throw new Error('Max retries exceeded for rate limited request'); } return 'continue'; }\"
    }
  ],
  \"preRequest\": [
    {
      \"name\": \"Validate required variables\",
      \"script\": \"function validateVars(context) { const required = ['baseUrl', 'authToken', 'testUserId', 'testProductId']; const missing = required.filter(v => !context.vars[v]); if (missing.length > 0) { throw new Error(`Missing required variables: ${missing.join(', ')}`); } }\"
    },
    {
      \"name\": \"Refresh auth token if expired\",
      \"script\": \"function refreshAuth(context) { const tokenExpiry = context.vars.authTokenExpiry; if (tokenExpiry && new Date(tokenExpiry) < new Date()) { const authResponse = context.executeRequest({ method: 'POST', url: '{{baseUrl}}/api/v1/auth/refresh', body: { refreshToken: context.vars.refreshToken } }); const authBody = JSON.parse(authResponse.body); context.vars.authToken = authBody.accessToken; context.vars.authTokenExpiry = authBody.expiresAt; } }\"
    }
  ],
  \"vars\": {
    \"testUserId\": \"usr_1234567890\",
    \"testProductId\": \"prod_9876543210\"
  },
  \"errorHandling\": {
    \"maxRetries\": 3,
    \"retryOnStatus\": [429, 500, 502, 503, 504],
    \"timeoutMs\": 10000
  }
}

// benchmark-insomnia-vs-bruno.js
// Compares test execution performance between Insomnia v8 CLI and Bruno v1.5 CLI
// Usage: node benchmark-insomnia-vs-bruno.js ./insomnia-collection.json ./bruno-collection/
const { exec } = require('child_process');
const fs = require('fs/promises');
const { promisify } = require('util');
const execAsync = promisify(exec);
const performance = require('perf_hooks').performance;

// Configuration
const INSOMNIA_CLI_PATH = 'insomnia'; // Assumes Insomnia 8 CLI is in PATH
const BRUNO_CLI_PATH = 'bruno'; // Assumes Bruno 1.5 CLI is in PATH
const ITERATIONS = 10; // Number of benchmark iterations per tool
const MEMORY_SAMPLE_INTERVAL_MS = 100; // Memory sampling interval

// Store benchmark results
const results = {
  insomnia: { executionTimes: [], memoryUsage: [] },
  bruno: { executionTimes: [], memoryUsage: [] }
};

/**
 * Samples memory usage for a running process
 * @param {number} pid - Process ID to sample
 * @returns {Promise} Array of memory usage values in MB
 */
async function sampleMemoryUsage(pid) {
  const memorySamples = [];
  const startTime = Date.now();

  while (true) {
    try {
      // Use ps to get memory usage of process (macOS/Linux compatible)
      const { stdout } = await execAsync(`ps -o rss= ${pid}`);
      const rssKb = parseInt(stdout.trim(), 10);
      if (isNaN(rssKb)) break;
      memorySamples.push(rssKb / 1024); // Convert KB to MB
    } catch (err) {
      // Process likely exited
      break;
    }
    // Wait for next sample interval or until 1s has passed since start
    const elapsed = Date.now() - startTime;
    if (elapsed > 1000) break;
    await new Promise(resolve => setTimeout(resolve, MEMORY_SAMPLE_INTERVAL_MS));
  }

  return memorySamples;
}

/**
 * Runs a single benchmark iteration for a given tool
 * @param {string} tool - 'insomnia' or 'bruno'
 * @param {string} collectionPath - Path to collection
 * @returns {Promise<{executionTime: number, avgMemoryMb: number}>}
 */
async function runIteration(tool, collectionPath) {
  const startTime = performance.now();
  let childProcess;

  try {
    let command;
    if (tool === 'insomnia') {
      command = `${INSOMNIA_CLI_PATH} run ${collectionPath} --ci`;
    } else if (tool === 'bruno') {
      command = `${BRUNO_CLI_PATH} run ${collectionPath} --format json`;
    } else {
      throw new Error(`Unknown tool: ${tool}`);
    }

    // Start process and get PID
    childProcess = exec(command, { timeout: 60000 });
    const pid = childProcess.pid;

    // Sample memory usage in background
    const memoryPromise = sampleMemoryUsage(pid);

    // Wait for process to finish
    const { stdout, stderr } = await new Promise((resolve, reject) => {
      let stdout = '';
      let stderr = '';
      childProcess.stdout.on('data', data => stdout += data);
      childProcess.stderr.on('data', data => stderr += data);
      childProcess.on('close', code => {
        if (code !== 0) reject(new Error(`Process exited with code ${code}: ${stderr}`));
        resolve({ stdout, stderr });
      });
      childProcess.on('error', reject);
    });

    const endTime = performance.now();
    const executionTime = endTime - startTime;
    const memorySamples = await memoryPromise;
    const avgMemoryMb = memorySamples.length > 0 ? memorySamples.reduce((a, b) => a + b, 0) / memorySamples.length : 0;

    return { executionTime, avgMemoryMb };
  } catch (err) {
    console.error(`Benchmark iteration failed for ${tool}: ${err.message}`);
    throw err;
  }
}

/**
 * Main benchmark entry point
 */
async function main() {
  const insomniaCollection = process.argv[2];
  const brunoCollection = process.argv[3];

  if (!insomniaCollection || !brunoCollection) {
    console.error('Usage: node benchmark.js  ');
    process.exit(1);
  }

  console.log(`Starting benchmark: ${ITERATIONS} iterations per tool`);

  // Run Insomnia benchmarks
  console.log('\nRunning Insomnia v8 benchmarks...');
  for (let i = 0; i < ITERATIONS; i++) {
    try {
      const result = await runIteration('insomnia', insomniaCollection);
      results.insomnia.executionTimes.push(result.executionTime);
      results.insomnia.memoryUsage.push(result.avgMemoryMb);
      console.log(`Insomnia iteration ${i + 1}: ${result.executionTime.toFixed(2)}ms, ${result.avgMemoryMb.toFixed(2)}MB avg memory`);
    } catch (err) {
      console.error(`Insomnia iteration ${i + 1} failed: ${err.message}`);
    }
  }

  // Run Bruno benchmarks
  console.log('\nRunning Bruno v1.5 benchmarks...');
  for (let i = 0; i < ITERATIONS; i++) {
    try {
      const result = await runIteration('bruno', brunoCollection);
      results.bruno.executionTimes.push(result.executionTime);
      results.bruno.memoryUsage.push(result.avgMemoryMb);
      console.log(`Bruno iteration ${i + 1}: ${result.executionTime.toFixed(2)}ms, ${result.avgMemoryMb.toFixed(2)}MB avg memory`);
    } catch (err) {
      console.error(`Bruno iteration ${i + 1} failed: ${err.message}`);
    }
  }

  // Calculate summary statistics
  const calculateStats = (arr) => {
    const sorted = [...arr].sort((a, b) => a - b);
    const sum = arr.reduce((a, b) => a + b, 0);
    return {
      mean: sum / arr.length,
      median: sorted[Math.floor(sorted.length / 2)],
      min: sorted[0],
      max: sorted[sorted.length - 1]
    };
  };

  const insomniaTimeStats = calculateStats(results.insomnia.executionTimes);
  const brunoTimeStats = calculateStats(results.bruno.executionTimes);
  const insomniaMemStats = calculateStats(results.insomnia.memoryUsage);
  const brunoMemStats = calculateStats(results.bruno.memoryUsage);

  // Output results
  console.log('\n=== Benchmark Results ===');
  console.log('\nInsomnia v8.0.2:');
  console.log(`  Execution Time (mean): ${insomniaTimeStats.mean.toFixed(2)}ms`);
  console.log(`  Execution Time (median): ${insomniaTimeStats.median.toFixed(2)}ms`);
  console.log(`  Memory Usage (mean): ${insomniaMemStats.mean.toFixed(2)}MB`);

  console.log('\nBruno v1.5.1:');
  console.log(`  Execution Time (mean): ${brunoTimeStats.mean.toFixed(2)}ms`);
  console.log(`  Execution Time (median): ${brunoTimeStats.median.toFixed(2)}ms`);
  console.log(`  Memory Usage (mean): ${brunoMemStats.mean.toFixed(2)}MB`);

  console.log('\nImprovement Factors:');
  console.log(`  Execution Time: ${(insomniaTimeStats.mean / brunoTimeStats.mean).toFixed(2)}x faster`);
  console.log(`  Memory Usage: ${(insomniaMemStats.mean / brunoMemStats.mean).toFixed(2)}x lower`);

  // Write results to file
  await fs.writeFile('benchmark-results.json', JSON.stringify(results, null, 2));
  console.log('\nFull results written to benchmark-results.json');
}

main().catch(err => {
  console.error('Benchmark failed:', err.message);
  process.exit(1);
});

// validate-migration.js
// Compares Insomnia and Bruno test results for parity
const fs = require('fs/promises');

async function validateResults(insomniaResultsPath, brunoResultsPath) {
  const insomnia = JSON.parse(await fs.readFile(insomniaResultsPath, 'utf8'));
  const bruno = JSON.parse(await fs.readFile(brunoResultsPath, 'utf8'));

  const insomniaMap = new Map(insomnia.map(t => [t.name, t]));
  const brunoMap = new Map(bruno.map(t => [t.name, t]));

  let failures = 0;
  for (const [name, insomniaTest] of insomniaMap) {
    const brunoTest = brunoMap.get(name);
    if (!brunoTest) {
      console.error(`Missing Bruno test: ${name}`);
      failures++;
      continue;
    }
    if (insomniaTest.status !== brunoTest.status) {
      console.error(`Status mismatch for ${name}: Insomnia ${insomniaTest.status}, Bruno ${brunoTest.status}`);
      failures++;
    }
    if (insomniaTest.responseTime - brunoTest.responseTime > 1000) {
      console.warn(`Slow Bruno test: ${name} (${brunoTest.responseTime}ms vs ${insomniaTest.responseTime}ms)`);
    }
  }

  console.log(`Validation complete: ${failures} failures, ${insomniaMap.size} tests checked`);
  return failures === 0;
}

validateResults('./insomnia-results.json', './bruno-results.json').then(success => {
  process.exit(success ? 0 : 1);
});

// .git/hooks/pre-commit
// Pre-commit hook to run Bruno tests locally
const { execSync } = require('child_process');

try {
  console.log('Running Bruno pre-commit tests...');
  execSync('bruno run ./bruno-collection --format json', { stdio: 'inherit' });
  console.log('All tests passed! Proceeding with commit.');
} catch (err) {
  console.error('Bruno tests failed. Commit aborted.');
  process.exit(1);
}

# .github/workflows/api-tests.yml
name: API Tests
on: [push, pull_request]
jobs:
  bruno-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Bruno
        run: npm install -g @usebruno/cli
      - name: Run Bruno Tests
        run: bruno run ./bruno-collection --env production --format json > results.json
      - name: Upload Test Results
        uses: actions/upload-artifact@v4
        with:
          name: bruno-results
          path: results.json