start-os/ui/test/config.test.ts

import { displayUniqueBy } from '../src/app/app-config/config-cursor'

function assert (predicate: boolean, message: string) {
    if (!predicate) {
        throw new Error('Assertion Failed: ' + message)
    }
}

function assertEq (a: any, b: any, message: string) {
    assert(a === b, message)
}

function test () {
    assertEq(
        displayUniqueBy(
            'foo',
            {
                type: 'object',
                name: 'Object',
                spec: {
                    'foo': {
                        type: 'string',
                        name: 'Foo',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                },
                nullByDefault: false,
                nullable: false,
                uniqueBy: 'foo',
            },
            {
                foo: 'foo-val',
            },
        ),
        'Foo',
        'base string uses name mapping',
    )
    assertEq(
        displayUniqueBy(
            {
                any: [
                    'foo',
                    'bar',
                ],
            },
            {
                type: 'object',
                name: 'Object',
                spec: {
                    'foo': {
                        type: 'string',
                        name: 'Foo',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                    'bar': {
                        type: 'string',
                        name: 'Bar',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                },
                nullByDefault: false,
                nullable: false,
                uniqueBy: {
                    any: [
                        'foo',
                        'bar',
                    ],
                },
            },
            {
                foo: 'foo-val',
                bar: 'bar-val',
            },
        ),
        'Foo and Bar',
        '`any` must be joined with `and`',
    )
    assertEq(
        displayUniqueBy(
            {
                all: [
                    'foo',
                    'bar',
                ],
            },
            {
                type: 'object',
                name: 'Object',
                spec: {
                    'foo': {
                        type: 'string',
                        name: 'Foo',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                    'bar': {
                        type: 'string',
                        name: 'Bar',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                },
                nullByDefault: false,
                nullable: false,
                uniqueBy: {
                    all: [
                        'foo',
                        'bar',
                    ],
                },
            },
            {
                foo: 'foo-val',
                bar: 'bar-val',
            },
        ),
        'Foo or Bar',
        '`all` must be joined with `or`',
    )
    assertEq(
        displayUniqueBy(
            {
                any: [
                    'foo',
                    {
                        all: [
                            'bar',
                            'baz',
                        ],
                    },
                ],
            },
            {
                type: 'object',
                name: 'Object',
                spec: {
                    'foo': {
                        type: 'string',
                        name: 'Foo',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                    'bar': {
                        type: 'string',
                        name: 'Bar',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                    'baz': {
                        type: 'string',
                        name: 'Baz',
                        nullable: true,
                        copyable: false,
                        masked: false,
                    },
                },
                nullByDefault: false,
                nullable: false,
                uniqueBy: {
                    any: [
                        'foo',
                        {
                            all: [
                                'bar',
                                'baz',
                            ],
                        },
                    ],
                },
            },
            {
                foo: 'foo-val',
                bar: 'bar-val',
                baz: 'baz-val',
            },
        ),
        'Foo and (Bar or Baz)',
        '`any` of `all` is correct',
    )
    assertEq(
        displayUniqueBy(
            {
                any: [
                    'foo',
                    {
                        all: [
                            'bar',
                            'baz',
                        ],
                    },
                ],
            },
            {
                type: 'union',
                name: 'Union',
                tag: {
                    id: 'variant',
                    name: 'Variant',
                    'variant-names': {
                        'variant-a': 'Variant A',
                        'variant-b': 'Variant B',
                    },
                },
                variants: {
                    'variant-a': {
                        'foo': {
                            type: 'string',
                            name: 'Foo',
                            nullable: true,
                            copyable: false,
                            masked: false,
                        },
                        'bar': {
                            type: 'string',
                            name: 'Bar',
                            nullable: true,
                            copyable: false,
                            masked: false,
                        },
                        'baz': {
                            type: 'string',
                            name: 'Baz',
                            nullable: true,
                            copyable: false,
                            masked: false,
                        },
                    },
                    'variant-b': { },
                },
                uniqueBy: {
                    any: [
                        'foo',
                        {
                            all: [
                                'bar',
                                'baz',
                            ],
                        },
                    ],
                },
                default: 'variant-a',
            },
            {
                variant: 'variant-a',
                foo: 'foo-val',
                bar: 'bar-val',
                baz: 'baz-val',
            },
        ),
        'Foo and (Bar or Baz)',
        'union is correct',
    )
}