apisurf/lib/utilities/parseFunctionSignature.test.js

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

import { describe, expect, it } from '@jest/globals';
import { parseFunctionSignature } from './parseFunctionSignature.js';
describe('parseFunctionSignature', () => {
    it('should parse a simple arrow function', () => {
        const lines = [
            'export const greet = (name: string) => console.log(name);'
        ];
        const result = parseFunctionSignature(lines, 0, 'greet');
        expect(result).toEqual({
            name: 'greet',
            kind: 'function',
            signature: 'export const greet = (name: string) => ...',
            parameters: ['name: string'],
            returnType: undefined
        });
    });
    it('should parse a function with return type', () => {
        const lines = [
            'export const add = (a: number, b: number): number => a + b;'
        ];
        const result = parseFunctionSignature(lines, 0, 'add');
        expect(result).toEqual({
            name: 'add',
            kind: 'function',
            signature: 'export const add = (a: number, b: number): number => ...',
            parameters: ['a: number', 'b: number'],
            returnType: 'number'
        });
    });
    it('should parse an async arrow function', () => {
        const lines = [
            'export const fetchData = async (url: string): Promise<Data> => {'
        ];
        const result = parseFunctionSignature(lines, 0, 'fetchData');
        expect(result).toEqual({
            name: 'fetchData',
            kind: 'function',
            signature: 'export const fetchData = async (url: string): Promise<Data> => ...',
            parameters: ['url: string'],
            returnType: 'Promise<Data>'
        });
    });
    it('should parse a function with no parameters', () => {
        const lines = [
            'export const getTimestamp = (): number => Date.now();'
        ];
        const result = parseFunctionSignature(lines, 0, 'getTimestamp');
        expect(result).toEqual({
            name: 'getTimestamp',
            kind: 'function',
            signature: 'export const getTimestamp = (): number => ...',
            parameters: [],
            returnType: 'number'
        });
    });
    it('should parse a multi-line function signature', () => {
        const lines = [
            'export const processData = (',
            '  data: Data,',
            '  options: Options',
            '): ProcessedData => {',
            '  // implementation',
            '}'
        ];
        const result = parseFunctionSignature(lines, 0, 'processData');
        expect(result).toEqual({
            name: 'processData',
            kind: 'function',
            signature: 'export const processData = ( data: Data, options: Options ): ProcessedData => ...',
            parameters: ['data: Data', 'options: Options'],
            returnType: 'ProcessedData'
        });
    });
    it('should parse a function with complex parameter types', () => {
        const lines = [
            'export const transform = (input: string | number, config?: { mode: string }): Result => {}'
        ];
        const result = parseFunctionSignature(lines, 0, 'transform');
        expect(result).toEqual({
            name: 'transform',
            kind: 'function',
            signature: 'export const transform = (input: string | number, config?: { mode: string }): Result => ...',
            parameters: ['input: string | number', 'config?: { mode: string }'],
            returnType: 'Result'
        });
    });
    it('should parse let and var declarations', () => {
        const linesLet = [
            'export let handler = (event: Event): void => { /* handle */ };'
        ];
        const resultLet = parseFunctionSignature(linesLet, 0, 'handler');
        expect(resultLet).toEqual({
            name: 'handler',
            kind: 'function',
            signature: 'export let handler = (event: Event): void => ...',
            parameters: ['event: Event'],
            returnType: 'void'
        });
        const linesVar = [
            'export var callback = (err: Error, data: any) => console.log(err, data);'
        ];
        const resultVar = parseFunctionSignature(linesVar, 0, 'callback');
        expect(resultVar).toEqual({
            name: 'callback',
            kind: 'function',
            signature: 'export var callback = (err: Error, data: any) => ...',
            parameters: ['err: Error', 'data: any'],
            returnType: undefined
        });
    });
    it('should return null for non-arrow functions', () => {
        const lines = [
            'export const value = 42;'
        ];
        const result = parseFunctionSignature(lines, 0, 'value');
        expect(result).toBeNull();
    });
    it('should return null for regular function declarations', () => {
        const lines = [
            'export function regularFunction(x: number): number { return x * 2; }'
        ];
        const result = parseFunctionSignature(lines, 0, 'regularFunction');
        expect(result).toBeNull();
    });
    it('should parse functions with generic type parameters', () => {
        const lines = [
            'export const identity = <T>(value: T): T => value;'
        ];
        const result = parseFunctionSignature(lines, 0, 'identity');
        expect(result).toEqual({
            name: 'identity',
            kind: 'function',
            signature: 'export const identity = <T>(value: T): T => ...',
            parameters: ['value: T'],
            returnType: 'T'
        });
    });
    it('should parse functions with rest parameters', () => {
        const lines = [
            'export const log = (...args: any[]): void => console.log(...args);'
        ];
        const result = parseFunctionSignature(lines, 0, 'log');
        expect(result).toEqual({
            name: 'log',
            kind: 'function',
            signature: 'export const log = (...args: any[]): void => ...',
            parameters: ['...args: any[]'],
            returnType: 'void'
        });
    });
});