apisurf/lib/utilities/parseParameters.test.js

Analyze API surface changes between npm package versions to catch breaking changes

import { describe, it, expect } from '@jest/globals';
import { parseParameters, isOptionalParameter, getParameterName, getParameterType } from './parseParameters.js';
describe('parseParameters', () => {
    it('should parse simple parameters', () => {
        const params = parseParameters('name: string, age: number');
        expect(params).toEqual(['name: string', 'age: number']);
    });
    it('should handle nested generic types', () => {
        const params = parseParameters('items: Array<string>, map: Map<string, number>');
        expect(params).toEqual(['items: Array<string>', 'map: Map<string, number>']);
    });
    it('should handle function types in parameters', () => {
        const params = parseParameters('callback: (value: string) => void, data: string');
        expect(params).toEqual(['callback: (value: string) => void', 'data: string']);
    });
    it('should handle object types', () => {
        const params = parseParameters('options: { timeout: number; retries: number }, name: string');
        expect(params).toEqual(['options: { timeout: number; retries: number }', 'name: string']);
    });
    it('should handle optional parameters', () => {
        const params = parseParameters('name: string, prefix?: string');
        expect(params).toEqual(['name: string', 'prefix?: string']);
    });
    it('should handle default parameters', () => {
        const params = parseParameters('name: string, greeting: string = "Hello"');
        expect(params).toEqual(['name: string', 'greeting: string = "Hello"']);
    });
    it('should handle complex nested types', () => {
        const params = parseParameters('handler: (event: { type: string; data: any }) => Promise<void>');
        expect(params).toEqual(['handler: (event: { type: string; data: any }) => Promise<void>']);
    });
    it('should handle empty parameters', () => {
        expect(parseParameters('')).toEqual([]);
        expect(parseParameters('  ')).toEqual([]);
    });
    it('should handle union types', () => {
        const params = parseParameters('value: string | number, flag: boolean');
        expect(params).toEqual(['value: string | number', 'flag: boolean']);
    });
    it('should handle tuple types', () => {
        const params = parseParameters('coords: [number, number], data: string');
        expect(params).toEqual(['coords: [number, number]', 'data: string']);
    });
    it('should handle template literal types', () => {
        const params = parseParameters('event: `on${string}`, handler: Function');
        expect(params).toEqual(['event: `on${string}`', 'handler: Function']);
    });
});
describe('isOptionalParameter', () => {
    it('should identify optional parameters with ?', () => {
        expect(isOptionalParameter('name?: string')).toBe(true);
        expect(isOptionalParameter('name: string')).toBe(false);
    });
    it('should identify parameters with default values as optional', () => {
        expect(isOptionalParameter('greeting: string = "Hello"')).toBe(true);
        expect(isOptionalParameter('name: string = getName()')).toBe(true);
    });
    it('should handle complex types', () => {
        expect(isOptionalParameter('handler?: (event: Event) => void')).toBe(true);
        expect(isOptionalParameter('handler: (event: Event) => void')).toBe(false);
    });
});
describe('getParameterName', () => {
    it('should extract parameter names', () => {
        expect(getParameterName('name: string')).toBe('name');
        expect(getParameterName('age: number')).toBe('age');
    });
    it('should handle optional parameters', () => {
        expect(getParameterName('prefix?: string')).toBe('prefix');
    });
    it('should handle parameters without types', () => {
        expect(getParameterName('value')).toBe('value');
    });
    it('should handle destructured parameters', () => {
        expect(getParameterName('{ x, y }: Point')).toBe('{ x, y }: Point');
        expect(getParameterName('[first, second]: string[]')).toBe('[first, second]: string[]');
    });
});
describe('getParameterType', () => {
    it('should extract parameter types', () => {
        expect(getParameterType('name: string')).toBe('string');
        expect(getParameterType('age: number')).toBe('number');
    });
    it('should handle complex types', () => {
        expect(getParameterType('items: Array<string>')).toBe('Array<string>');
        expect(getParameterType('handler: (event: Event) => void')).toBe('(event: Event) => void');
    });
    it('should handle default values', () => {
        expect(getParameterType('greeting: string = "Hello"')).toBe('string');
        expect(getParameterType('count: number = 0')).toBe('number');
    });
    it('should return any for untyped parameters', () => {
        expect(getParameterType('value')).toBe('any');
    });
});