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

import 'mocha';
import { expect } from 'chai';
import { ScriptingDefinition } from '@/domain/ScriptingDefinition';
import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
import { getEnumValues } from '@/application/Common/Enum';

describe('ScriptingDefinition', () => {
  describe('language', () => {
    describe('sets as expected', () => {
      // arrange
      const expectedValues = getEnumValues(ScriptingLanguage);
      expectedValues.forEach((expected) => {
        it(ScriptingLanguage[expected], () => {
          // act
          const sut = new ScriptingDefinitionBuilder()
            .withLanguage(expected)
            .build();
          // assert
          expect(sut.language).to.equal(expected);
        });
      });
    });
    it('throws if unknown', () => {
      // arrange
      const unknownValue: ScriptingLanguage = 666;
      const errorMessage = `unsupported language: ${unknownValue}`;
      // act
      const act = () => new ScriptingDefinitionBuilder()
        .withLanguage(unknownValue)
        .build();
      // assert
      expect(act).to.throw(errorMessage);
    });
  });
  describe('fileExtension', () => {
    describe('returns expected for each language', () => {
      // arrange
      const testCases = new Map<ScriptingLanguage, string>([
        [ScriptingLanguage.batchfile, 'bat'],
        [ScriptingLanguage.shellscript, 'sh'],
      ]);
      Array.from(testCases.entries()).forEach((test) => {
        const language = test[0];
        const expectedExtension = test[1];
        it(`${ScriptingLanguage[language]} has ${expectedExtension}`, () => {
          // act
          const sut = new ScriptingDefinitionBuilder()
            .withLanguage(language)
            .build();
          // assert
          expect(sut.fileExtension, expectedExtension);
        });
      });
    });
  });
  describe('startCode', () => {
    it('sets as expected', () => {
      // arrange
      const expected = 'REM start-code';
      // act
      const sut = new ScriptingDefinitionBuilder()
        .withStartCode(expected)
        .build();
      // assert
      expect(sut.startCode).to.equal(expected);
    });
    it('throws when undefined', () => {
      // arrange
      const expectedError = 'undefined start code';
      const undefinedValues = ['', undefined];
      for (const undefinedValue of undefinedValues) {
        // act
        const act = () => new ScriptingDefinitionBuilder()
          .withStartCode(undefinedValue)
          .build();
        // assert
        expect(act).to.throw(expectedError);
      }
    });
  });
  describe('endCode', () => {
    it('sets as expected', () => {
      // arrange
      const expected = 'REM end-code';
      // act
      const sut = new ScriptingDefinitionBuilder()
        .withEndCode(expected)
        .build();
      // assert
      expect(sut.endCode).to.equal(expected);
    });
    it('throws when undefined', () => {
      // arrange
      const expectedError = 'undefined end code';
      const undefinedValues = ['', undefined];
      for (const undefinedValue of undefinedValues) {
        // act
        const act = () => new ScriptingDefinitionBuilder()
          .withEndCode(undefinedValue)
          .build();
        // assert
        expect(act).to.throw(expectedError);
      }
    });
  });
});

class ScriptingDefinitionBuilder {
  private language = ScriptingLanguage.shellscript;

  private startCode = 'REM start-code';

  private endCode = 'REM end-code';

  public withLanguage(language: ScriptingLanguage): ScriptingDefinitionBuilder {
    this.language = language;
    return this;
  }

  public withStartCode(startCode: string): ScriptingDefinitionBuilder {
    this.startCode = startCode;
    return this;
  }

  public withEndCode(endCode: string): ScriptingDefinitionBuilder {
    this.endCode = endCode;
    return this;
  }

  public build(): ScriptingDefinition {
    return new ScriptingDefinition(this.language, this.startCode, this.endCode);
  }
}