squidex/frontend/app/shared/state/table-fields.spec.ts

/*
 * Squidex Headless CMS
 *
 * @license
 * Copyright (c) Squidex UG (haftungsbeschränkt). All rights reserved.
 */

import { of } from 'rxjs';
import { IMock, Mock, Times } from 'typemoq';

import { DateTime, Version } from '@app/framework';

import {
    createProperties,
    MetaFields,
    RootFieldDto,
    SchemaDetailsDto,
    TableField,
    TableFields,
    UIState
} from '@app/shared/internal';

describe('TableFields', () => {
    let uiState: IMock<UIState>;

    const schema =
        new SchemaDetailsDto({}, '1', 'my-schema', '', {},
            false,
            false,
            DateTime.now(), 'me',
            DateTime.now(), 'me',
            new Version('1'),
            [
                new RootFieldDto({}, 1, 'string', createProperties('String'), 'invariant')
            ]);

    beforeEach(() => {
        uiState = Mock.ofType<UIState>();
    });

    const INVALID_CONFIGS = [
        { case: 'empty', fields: [] },
        { case: 'invalid', fields: ['invalid'] }
    ];

    INVALID_CONFIGS.forEach(test => {
        it(`should provide default fields if config is ${test.case}`, () => {
            let fields: ReadonlyArray<TableField>;
            let fieldNames: ReadonlyArray<string>;

            uiState.setup(x => x.getUser<string[]>('schemas.my-schema.view', []))
                .returns(() => of(test.fields));

            const tableFields = new TableFields(uiState.object, schema);

            tableFields.listFields.subscribe(result => fields = result);
            tableFields.listFieldNames.subscribe(result => fieldNames = result);

            expect(fields!).toEqual([
                MetaFields.lastModifiedByAvatar,
                schema.fields[0],
                MetaFields.statusColor,
                MetaFields.lastModified
            ]);

            expect(fieldNames!).toEqual([
                MetaFields.lastModifiedByAvatar,
                schema.fields[0].name,
                MetaFields.statusColor,
                MetaFields.lastModified
            ]);
        });
    });

    INVALID_CONFIGS.forEach(test => {
        it(`should remove ui state if config is ${test.case}`, () => {
            uiState.setup(x => x.getUser<string[]>('schemas.my-schema.view', []))
                .returns(() => of([]));

            const tableFields = new TableFields(uiState.object, schema);

            tableFields.updateFields(test.fields, true);

            uiState.verify(x => x.removeUser('schemas.my-schema.view'), Times.once());

            expect().nothing();
        });
    });

    it('should eliminate invalid fields from the config', () => {
        let fields: ReadonlyArray<TableField>;
        let fieldNames: ReadonlyArray<string>;

        const config = ['invalid', MetaFields.version];

        uiState.setup(x => x.getUser<string[]>('schemas.my-schema.view', []))
            .returns(() => of(config));

        const tableFields = new TableFields(uiState.object, schema);

        tableFields.listFields.subscribe(result => fields = result);
        tableFields.listFieldNames.subscribe(result => fieldNames = result);

        expect(fields!).toEqual([
            MetaFields.version
        ]);

        expect(fieldNames!).toEqual([
            MetaFields.version
        ]);
    });

    it('should update config when fields are saved', () => {
        uiState.setup(x => x.getUser<string[]>('schemas.my-schema.view', []))
            .returns(() => of([]));

        const tableFields = new TableFields(uiState.object, schema);

        const config = ['invalid', MetaFields.version];

        tableFields.updateFields(config, true);

        uiState.verify(x => x.set('schemas.my-schema.view', [MetaFields.version], true), Times.once());

        expect().nothing();
    });
});