privacy.sexy/tests/unit/domain/Application.spec.ts

import 'mocha';
import { expect } from 'chai';
import { Application } from '@/domain/Application';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { CategoryCollectionStub } from '@tests/unit/stubs/CategoryCollectionStub';
import { ProjectInformationStub } from '@tests/unit/stubs/ProjectInformationStub';

describe('Application', () => {
    describe('getCollection', () => {
        it('returns undefined if not found', () => {
            // arrange
            const expected = undefined;
            const info = new ProjectInformationStub();
            const collections = [ new CategoryCollectionStub().withOs(OperatingSystem.Windows) ];
            // act
            const sut = new Application(info, collections);
            const actual = sut.getCollection(OperatingSystem.Android);
            // assert
            expect(actual).to.equals(expected);
        });
        it('returns expected when multiple collections exist', () => {
            // arrange
            const os = OperatingSystem.Windows;
            const expected = new CategoryCollectionStub().withOs(os);
            const info = new ProjectInformationStub();
            const collections = [ expected, new CategoryCollectionStub().withOs(OperatingSystem.Android) ];
            // act
            const sut = new Application(info, collections);
            const actual = sut.getCollection(os);
            // assert
            expect(actual).to.equals(expected);
        });
    });
    describe('ctor', () => {
        describe('info', () => {
            it('throws if undefined', () => {
                // arrange
                const expectedError = 'undefined project information';
                const info = undefined;
                const collections = [new CategoryCollectionStub()];
                // act
                const act = () => new Application(info, collections);
                // assert
                expect(act).to.throw(expectedError);
            });
            it('sets as expected', () => {
                // arrange
                const expected = new ProjectInformationStub();
                const collections = [new CategoryCollectionStub()];
                // act
                const sut = new Application(expected, collections);
                // assert
                expect(sut.info).to.equal(expected);
            });
        });
        describe('collections', () => {
            describe('throws on invalid value', () => {
                // arrange
                const testCases = [
                    {
                        name: 'undefined',
                        expectedError: 'undefined collections',
                        value: undefined,
                    },
                    {
                        name: 'empty',
                        expectedError: 'no collection in the list',
                        value: [],
                    },
                    {
                        name: 'undefined value in list',
                        expectedError: 'undefined collection in the list',
                        value: [ new CategoryCollectionStub(), undefined ],
                    },
                    {
                        name: 'two collections with same OS',
                        expectedError: 'multiple collections with same os: windows',
                        value: [
                            new CategoryCollectionStub().withOs(OperatingSystem.Windows),
                            new CategoryCollectionStub().withOs(OperatingSystem.Windows),
                            new CategoryCollectionStub().withOs(OperatingSystem.BlackBerry),
                         ],
                    },
                ];
                for (const testCase of testCases) {
                    const info = new ProjectInformationStub();
                    const collections = testCase.value;
                    // act
                    const act = () => new Application(info, collections);
                    // assert
                    expect(act).to.throw(testCase.expectedError);
                }
            });
            it('sets as expected', () => {
                // arrange
                const info = new ProjectInformationStub();
                const expected = [new CategoryCollectionStub()];
                // act
                const sut = new Application(info, expected);
                // assert
                expect(sut.collections).to.equal(expected);
            });
        });
    });
    describe('getSupportedOsList', () => {
        it('returns expected', () => {
            // arrange
            const expected = [ OperatingSystem.Windows, OperatingSystem.macOS ];
            const info = new ProjectInformationStub();
            const collections = expected.map((os) => new CategoryCollectionStub().withOs(os));
            // act
            const sut = new Application(info, collections);
            const actual = sut.getSupportedOsList();
            // assert
            expect(actual).to.deep.equal(expected);
        });
    });
});