Back to Repositories

Validating Fixture-Based Import Conversions in Insomnia

This test suite validates the importer functionality in Insomnia by testing fixture-based input/output conversions. It ensures reliable data transformation and unique resource ID generation across different import scenarios.

Test Coverage Overview

The test suite provides comprehensive coverage of fixture-based import scenarios.

Key areas tested include:

File input validation
Content conversion accuracy
Resource ID uniqueness verification
Multiple fixture format handling
Error cases for malformed inputs

Implementation Analysis

The testing approach uses Jest/Vitest with dynamic fixture loading for scalable test cases. Implementation leverages describe.each() for iterative testing across multiple fixtures, with mocked timestamps ensuring consistent snapshots.

Technical patterns include:

Dynamic fixture discovery and loading
Snapshot comparison for output validation
Mock date implementations
Duplicate ID detection

Technical Details

Testing infrastructure includes:

Vitest as the test runner
File system operations for fixture handling
Snapshot testing for output validation
Mock implementations via vi.spyOn
Dynamic test generation using describe.each
UTF-8 encoding for file operations

Best Practices Demonstrated

The test suite exemplifies robust testing practices through systematic fixture organization and thorough validation.

Notable practices include:

Isolated test cases with mock resets
Consistent assertion counts
Comprehensive error checking
Modular fixture organization
Deterministic timestamp handling

kong/insomnia

packages/insomnia/src/utils/importers/importers/index.test.ts

            
import fs from 'fs';
import path from 'path';
import { afterEach, describe, expect, it, vi } from 'vitest';

import { convert } from '../convert';

const fixturesPath = path.join(__dirname, './fixtures');
const fixtures = fs.readdirSync(fixturesPath);
describe('Fixtures', () => {
  afterEach(() => {
    vi.restoreAllMocks(); // Resets all mocks
  });
  describe.each(fixtures)('Import %s', name => {
    const dir = path.join(fixturesPath, `./${name}`);
    const inputs = fs
      .readdirSync(dir)
      .filter(name => name.match(/^(.+)-?input\.[^.]+$/));

    for (const input of inputs) {
      const prefix = input.replace(/-input\.[^.]+/, '');

      if (prefix.startsWith('skip')) {
        continue;
      }

      it(input, async () => {
        vi.spyOn(Date, 'now').mockImplementation(() => 1622117984000);

        expect.assertions(3);

        expect(typeof input).toBe('string');
        const inputContents = fs.readFileSync(path.join(dir, input), 'utf8');
        expect(typeof inputContents).toBe('string');

        const results = await convert(inputContents);
        results.data.__export_date = '';
        expect(results.data).toMatchSnapshot();

        const ids = new Set();
        for (const resource of results.data.resources) {
          if (ids.has(resource?._id)) {
            const json = JSON.stringify(resource, null, '\t');
            throw new Error(`Export contained multiple duplicate IDs: ${json}`);
          }
          ids.add(resource?._id);
        }
      });
    }
  });
});