Jest Integration

/**
 * Sets up Jest globals and snapshot functionality
 * Configures snapshot state, serializers, and expect integration
 * @param options - Configuration options for Jest globals setup
 * @returns Promise resolving to configured SnapshotState
 */
function setupJestGlobals(options: SetupOptions): Promise<SnapshotState>;

/**
 * Configuration options for Jest globals setup
 */
interface SetupOptions {
  /** Jest project configuration */
  config: Config.ProjectConfig;
  /** Jest global configuration */
  globalConfig: Config.GlobalConfig;
  /** Local require function for loading modules */
  localRequire: (moduleName: string) => Plugin;
  /** Path to the test file being executed */
  testPath: string;
}

/**
 * Snapshot state management for test files
 * Handles snapshot creation, matching, and cleanup
 */
interface SnapshotState {
  /** Number of snapshots added during test run */
  added: number;
  /** Number of snapshots matched during test run */
  matched: number;
  /** Number of snapshots that didn't match */
  unmatched: number;
  /** Number of snapshots updated during test run */
  updated: number;
  
  /** Mark snapshots as checked for a specific test */
  markSnapshotsAsCheckedForTest(testName: string): void;
  
  /** Get count of unchecked snapshots */
  getUncheckedCount(): number;
  
  /** Get keys of unchecked snapshots */
  getUncheckedKeys(): Array<string>;
  
  /** Remove unchecked snapshot keys */
  removeUncheckedKeys(): void;
  
  /** Save snapshot state and return status */
  save(): { deleted: boolean };
}

/**
 * Installs jest-each parameterized testing functionality
 * Adds .each method to test and describe functions
 * @param environment - Jest test environment to enhance
 */
function installEach(environment: JestEnvironment): void;

/**
 * Installs error handling for deprecated/private Jasmine APIs
 * Throws errors when deprecated features are used if errorOnDeprecated is enabled
 * @param global - Global object to install error handling into
 */
function installErrorOnPrivate(global: Global.Global): void;

/**
 * Jest expect integration setup
 * Configures expect matchers and assertion handling
 */
interface ExpectIntegration {
  /** Set up expect with configuration */
  setupExpect(options: { expand: boolean }): void;
  
  /** Extract expected assertion errors */
  extractExpectedAssertionsErrors(): Array<{
    actual: string;
    expected: string;
    error: Error;
  }>;
  
  /** Get suppressed errors from expect */
  getSuppressedErrors(): Array<Error>;
  
  /** Set expect state */
  setState(state: {
    currentTestName?: string;
    snapshotState?: SnapshotState;
    testPath?: string;
    suppressedErrors?: Array<Error>;
  }): void;
}

// Parameterized it tests
it.each([
  [1, 2, 3],
  [2, 3, 5],
  [3, 4, 7]
])("should add %i + %i = %i", (a, b, expected) => {
  expect(a + b).toBe(expected);
});

// Parameterized describe blocks
describe.each([
  ["positive", 1],
  ["negative", -1],
  ["zero", 0]
])("number behavior: %s", (description, value) => {
  it(`should handle ${description} numbers`, () => {
    expect(typeof value).toBe("number");
  });
});

// Object-based parameterization
it.each([
  { a: 1, b: 2, expected: 3 },
  { a: 2, b: 3, expected: 5 }
])("should add $a + $b = $expected", ({ a, b, expected }) => {
  expect(a + b).toBe(expected);
});

// Concurrent parameterized tests
it.concurrent.each([
  [1, 100],
  [2, 200], 
  [3, 300]
])("should process %i to get %i", async (input, expected) => {
  const result = await processAsync(input);
  expect(result).toBe(expected);
});

// Snapshot testing works automatically
it("should match snapshot", () => {
  const data = { name: "test", value: 42 };
  expect(data).toMatchSnapshot();
});

// Inline snapshots
it("should match inline snapshot", () => {
  const result = formatData({ id: 1, name: "test" });
  expect(result).toMatchInlineSnapshot(`
    Object {
      "formatted": "test (1)",
    }
  `);
});

/**
 * Snapshot serializer plugin interface
 */
interface Plugin {
  /** Test if this serializer should handle the value */
  test(val: any): boolean;
  /** Serialize the value to a string */
  serialize(val: any, config: any, indentation: string, depth: number, refs: any): string;
}

// Custom serializer in Jest config
module.exports = {
  snapshotSerializers: [
    "my-custom-serializer",
    "<rootDir>/custom-serializer.js"
  ]
};

// Custom serializer implementation
module.exports = {
  test(val) {
    return val && val.constructor && val.constructor.name === "MyClass";
  },
  serialize(val) {
    return `MyClass { value: ${val.value} }`;
  }
};

// Global timeout in Jest config
module.exports = {
  testTimeout: 10000, // 10 second default timeout
};

// Per-test timeout
it("should complete quickly", async () => {
  await fastOperation();
}, 1000); // 1 second timeout

// Jasmine-style timeout configuration
beforeEach(() => {
  jasmine.DEFAULT_TIMEOUT_INTERVAL = 15000;
});

// Module mocking works automatically
jest.mock("./my-module");

// Function mocking  
const mockFn = jest.fn();
mockFn.mockReturnValue("mocked value");

// Spy integration with Jasmine spies
const spy = spyOn(obj, "method");
expect(spy).toHaveBeenCalled();

// Jest config with setup files
module.exports = {
  setupFilesAfterEnv: [
    "<rootDir>/setup-tests.js",
    "<rootDir>/custom-matchers.js"
  ]
};

// Setup file example (setup-tests.js)
import "jest-extended"; // Additional matchers

// Custom matcher
expect.extend({
  toBeWithinRange(received, floor, ceiling) {
    const pass = received >= floor && received <= ceiling;
    return {
      pass,
      message: () => 
        `expected ${received} to be within range ${floor} - ${ceiling}`
    };
  }
});

// Jest config with environment
module.exports = {
  testEnvironment: "jsdom", // or "node"
  testEnvironmentOptions: {
    url: "http://localhost"
  }
};

// Environment-specific globals are available
if (typeof window !== "undefined") {
  // Browser/jsdom environment
  expect(window.location.href).toBe("http://localhost/");
} else {
  // Node environment  
  expect(process.env.NODE_ENV).toBeDefined();
}

// Complete Jest configuration for jest-jasmine2
module.exports = {
  testRunner: "jest-jasmine2",
  testEnvironment: "node",
  testTimeout: 10000,
  maxConcurrency: 4,
  setupFilesAfterEnv: ["<rootDir>/setup.js"],
  snapshotSerializers: ["my-serializer"],
  fakeTimers: {
    enableGlobally: true,
    legacyFakeTimers: false
  },
  clearMocks: true,
  resetMocks: false,
  restoreMocks: true
};