privacy.sexy/tests/unit/application/Parser/CategoryParser.spec.ts

import 'mocha';
import { expect } from 'chai';
import { parseCategory } from '@/application/Parser/CategoryParser';
import { parseScript } from '@/application/Parser/Script/ScriptParser';
import { parseDocUrls } from '@/application/Parser/DocumentationParser';
import { ScriptCompilerStub } from '@tests/unit/stubs/ScriptCompilerStub';
import { ScriptDataStub } from '@tests/unit/stubs/ScriptDataStub';
import { CategoryCollectionParseContextStub } from '@tests/unit/stubs/CategoryCollectionParseContextStub';
import { LanguageSyntaxStub } from '@tests/unit/stubs/LanguageSyntaxStub';
import { CategoryDataStub } from '@tests/unit/stubs/CategoryDataStub';

describe('CategoryParser', () => {
  describe('parseCategory', () => {
    describe('invalid category', () => {
      it('throws when undefined', () => {
        // arrange
        const expectedMessage = 'category is null or undefined';
        const category = undefined;
        const context = new CategoryCollectionParseContextStub();
        // act
        const act = () => parseCategory(category, context);
        // assert
        expect(act).to.throw(expectedMessage);
      });
      it('throws when children are empty', () => {
        // arrange
        const categoryName = 'test';
        const expectedMessage = `category has no children: "${categoryName}"`;
        const category = new CategoryDataStub()
          .withName(categoryName)
          .withChildren([]);
        const context = new CategoryCollectionParseContextStub();
        // act
        const act = () => parseCategory(category, context);
        // assert
        expect(act).to.throw(expectedMessage);
      });
      it('throws when children are undefined', () => {
        // arrange
        const categoryName = 'test';
        const expectedMessage = `category has no children: "${categoryName}"`;
        const category = new CategoryDataStub()
          .withName(categoryName)
          .withChildren(undefined);
        const context = new CategoryCollectionParseContextStub();
        // act
        const act = () => parseCategory(category, context);
        // assert
        expect(act).to.throw(expectedMessage);
      });
      it('throws when name is empty or undefined', () => {
        // arrange
        const expectedMessage = 'category has no name';
        const invalidNames = ['', undefined];
        invalidNames.forEach((invalidName) => {
          const category = new CategoryDataStub()
            .withName(invalidName);
          const context = new CategoryCollectionParseContextStub();
          // act
          const act = () => parseCategory(category, context);
          // assert
          expect(act).to.throw(expectedMessage);
        });
      });
    });
    it('throws when context is undefined', () => {
      // arrange
      const expectedError = 'undefined context';
      const context = undefined;
      const category = new CategoryDataStub();
      // act
      const act = () => parseCategory(category, context);
      // assert
      expect(act).to.throw(expectedError);
    });
    it('returns expected docs', () => {
      // arrange
      const url = 'https://privacy.sexy';
      const expected = parseDocUrls({ docs: url });
      const category = new CategoryDataStub()
        .withDocs(url);
      const context = new CategoryCollectionParseContextStub();
      // act
      const actual = parseCategory(category, context).documentationUrls;
      // assert
      expect(actual).to.deep.equal(expected);
    });
    describe('parses expected subscript', () => {
      it('single script with code', () => {
        // arrange
        const script = ScriptDataStub.createWithCode();
        const context = new CategoryCollectionParseContextStub();
        const expected = [parseScript(script, context)];
        const category = new CategoryDataStub()
          .withChildren([script]);
        // act
        const actual = parseCategory(category, context).scripts;
        // assert
        expect(actual).to.deep.equal(expected);
      });
      it('single script with function call', () => {
        // arrange
        const script = ScriptDataStub.createWithCall();
        const compiler = new ScriptCompilerStub()
          .withCompileAbility(script);
        const context = new CategoryCollectionParseContextStub()
          .withCompiler(compiler);
        const expected = [parseScript(script, context)];
        const category = new CategoryDataStub()
          .withChildren([script]);
        // act
        const actual = parseCategory(category, context).scripts;
        // assert
        expect(actual).to.deep.equal(expected);
      });
      it('multiple scripts with function call and code', () => {
        // arrange
        const callableScript = ScriptDataStub.createWithCall();
        const scripts = [callableScript, ScriptDataStub.createWithCode()];
        const category = new CategoryDataStub()
          .withChildren(scripts);
        const compiler = new ScriptCompilerStub()
          .withCompileAbility(callableScript);
        const context = new CategoryCollectionParseContextStub()
          .withCompiler(compiler);
        const expected = scripts.map((script) => parseScript(script, context));
        // act
        const actual = parseCategory(category, context).scripts;
        // assert
        expect(actual).to.deep.equal(expected);
      });
      it('script is created with right context', () => { // test through script validation logic
        // arrange
        const commentDelimiter = 'should not throw';
        const duplicatedCode = `${commentDelimiter} duplicate-line\n${commentDelimiter} duplicate-line`;
        const parseContext = new CategoryCollectionParseContextStub()
          .withSyntax(new LanguageSyntaxStub().withCommentDelimiters(commentDelimiter));
        const category = new CategoryDataStub()
          .withChildren([
            new CategoryDataStub()
              .withName('sub-category')
              .withChildren([
                ScriptDataStub
                  .createWithoutCallOrCodes()
                  .withCode(duplicatedCode),
              ]),
          ]);
        // act
        const act = () => parseCategory(category, parseContext).scripts;
        // assert
        expect(act).to.not.throw();
      });
    });
    it('returns expected subcategories', () => {
      // arrange
      const expected = [new CategoryDataStub()
        .withName('test category')
        .withChildren([ScriptDataStub.createWithCode()]),
      ];
      const category = new CategoryDataStub()
        .withName('category name')
        .withChildren(expected);
      const context = new CategoryCollectionParseContextStub();
      // act
      const actual = parseCategory(category, context).subCategories;
      // assert
      expect(actual).to.have.lengthOf(1);
      expect(actual[0].name).to.equal(expected[0].category);
      expect(actual[0].scripts.length).to.equal(expected[0].children.length);
    });
  });
});