vendure/shared/omit.spec.ts

import { omit } from './omit';

declare const File: any;

describe('omit()', () => {

    it('returns a new object', () => {
        const obj = { foo: 1, bar: 2 };
        expect(omit(obj, ['bar'])).not.toBe(obj);
    });

    it('works with 1-level-deep objects', () => {
        expect(omit({ foo: 1, bar: 2 }, ['bar'])).toEqual({ foo: 1 });
        expect(omit({ foo: 1, bar: 2 }, ['bar', 'foo'])).toEqual({});
    });

    it('works with deeply-nested objects', () => {
        expect(omit({
            name: {
                first: 'joe',
                last: 'smith',
            },
            address: {
                number: 12,
            },
        }, ['address'])).toEqual({
            name: {
                first: 'joe',
                last: 'smith',
            },
        });
    });

    describe('recursive', () => {

        it('returns a new object', () => {
            const obj = { foo: 1, bar: 2 };
            expect(omit(obj, ['bar'], true)).not.toBe(obj);
        });

        it('works with 1-level-deep objects', () => {
            const input = {
                foo: 1,
                bar: 2,
                baz: 3,
            };
            const expected = { foo: 1, baz: 3 };

            expect(omit(input, ['bar'], true)).toEqual(expected);
        });

        it('works with 2-level-deep objects', () => {
            const input = {
                foo: 1,
                bar: {
                    bad: true,
                    good: true,
                },
                baz: {
                    bad: true,
                },
            };
            const expected = {
                foo: 1,
                bar: {
                    good: true,
                },
                baz: {},
            };

            expect(omit(input, ['bad'], true)).toEqual(expected);
        });

        it('works with array of objects', () => {
            const input = {
                foo: 1,
                bar: [
                    {
                        bad: true,
                        good: true,
                    },
                    { bad: true },
                ],
            };
            const expected = {
                foo: 1,
                bar: [
                    { good: true },
                    {},
                ],
            };

            expect(omit(input, ['bad'], true)).toEqual(expected);
        });

        it('works top-level array', () => {
            const input = [
                { foo: 1 },
                { bad: true },
                { bar: 2 },
            ];
            const expected = [
                { foo: 1 },
                {},
                { bar: 2 },
            ];

            expect(omit(input, ['bad'], true)).toEqual(expected);
        });

        it('preserves File objects', () => {
            const file = new File([], 'foo');
            const input = [
                { foo: 1 },
                { bad: true },
                { bar: file },
            ];
            const expected = [
                { foo: 1 },
                {},
                { bar: file },
            ];

            expect(omit(input, ['bad'], true)).toEqual(expected);
        });
    });
});