Issue testing type guards with generics

[Goldziher]

Hi there,

First of - thanks for this library. Its very helpful.

I am having issues testing type guards that use generics. For example, I have a guard that looks like this

const createGuard = <T>(
    validator: (value: unknown) => boolean,
    label: string,
) => {
    return (input: unknown, throwError = false): input is T => {
        if (!validator(input)) {
            if (throwError) {
                throw new TypeError(`expected input to be ${label}`);
            }
            return false;
        }
        return true;
    };
};

export function isArray<T>(
    input: unknown,
    valueGuard: (value: unknown) => boolean,
    throwError = false,
): input is T[] {
    return createGuard<T[]>(
        (value) => Array.isArray(value) && value.every(valueGuard),
        'Array',
    )(input, throwError);
}

I then test it like so:

describe('isArray', () => {
    it('returns true for positively tested array values', () => {
        expect(isArray<string>(stringArray, isString)).toBeTruthy();
        expect(isArray<number>(numberArray, isNumber)).toBeTruthy();
        expect(isArray<symbol>(symbolArray, isSymbol)).toBeTruthy();
        expect(isArray<object>(recordArray, isObject)).toBeTruthy();
        expect(
            isArray<string | number>(
                [...stringArray, ...numberArray],
                isUnion<string | number>(isString, isNumber),
            ),
        ).toBeTruthy();
    });
    it('returns false for negatively tested array values', () => {
        expect(isArray<string>(stringArray, isNumber)).toBeFalsy();
        expect(isArray<number>(numberArray, isString)).toBeFalsy();
        expect(isArray<symbol>(symbolArray, isObject)).toBeFalsy();
        expect(isArray<object>(recordArray, isSymbol)).toBeFalsy();
        expect(
            isArray<string | number>(
                [...symbolArray, ...recordArray],
                isUnion<string | number>(isString, isNumber),
            ),
        ).toBeFalsy();
    });
    it('returns false for non-array values', () => {
        expect(isArray<string>('', isString)).toBeFalsy();
        expect(isArray<string>(null, isString)).toBeFalsy();
        expect(isArray<string>(123, isString)).toBeFalsy();
        expect(isArray<string>(Symbol(), isString)).toBeFalsy();
        expect(isArray<string>({}, isString)).toBeFalsy();
    });
    it('throws error when throwError = true', () => {
        expect(() => isArray<string>('', isString, true)).toThrow();
        expect(() => isArray<string>(null, isString, true)).toThrow();
        expect(() => isArray<string>(123, isString, true)).toThrow();
    });
    it('guards type correctly', () => {
        const unknownArray: unknown = [...stringArray];
        if (isArray<string>(unknownArray, isString)) {
            expectTypeOf(unknownArray).toMatchTypeOf(stringArray);
        }
    });
});

Note the last it() where I use the expect-type library. This is the only way i figured that actually works for testing generics with this library. Is there another solution or maybe a planned fix?

[mmkal]

What you have there doesn't look too bad to me, although I agree it'd be nice to fit in one statement. One possible way that avoids a runtime check (untested, but could be worth a try):

const isStringArray = (x: unknown) => isArray<string>(x, isString)
expectTypeOf(isStringArray).guards.toEqualTypeOf<string[]>()

Is there a particular API you would like to see here?

[Goldziher]

I'm not sure about the api. I would though like an api that allows testing generics.

[mmkal]

I'm not sure it's possible to propagate generics... generically. But @Goldziher if you think of a specific way you would like your test to look, please reopen/comment/create a new issue with that. You can write some imaginary code if you like. Closing until that point.