refactor script compilation to make it easy to add new expressions #41 #53

tests/unit/application/Parser/ScriptingDefinition/CodeSubstituter.spec.ts

@@ -0,0 +1,96 @@
+import 'mocha';
+import { expect } from 'chai';
+import { CodeSubstituter } from '@/application/Parser/ScriptingDefinition/CodeSubstituter';
+import { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expressions/IExpressionsCompiler';
+import { ProjectInformationStub } from '../../../stubs/ProjectInformationStub';
+import { ExpressionsCompilerStub } from '../../../stubs/ExpressionsCompilerStub';
+
+describe('CodeSubstituter', () => {
+    describe('throws with invalid parameters', () => {
+        // arrange
+        const testCases = [{
+                expectedError: 'undefined code',
+                parameters: {
+                    code: undefined,
+                    info: new ProjectInformationStub(),
+            }},
+            {
+                expectedError: 'undefined info',
+                parameters: {
+                    code: 'non empty code',
+                    info: undefined,
+            },
+        }];
+        for (const testCase of testCases) {
+            it(`throws "${testCase.expectedError}" as expected`, () => {
+                const sut = new CodeSubstituterBuilder().build();
+                // act
+                const act = () => sut.substitute(testCase.parameters.code, testCase.parameters.info);
+                // assert
+                expect(act).to.throw(testCase.expectedError);
+            });
+        }
+    });
+    describe('substitutes parameters as expected values', () => {
+        // arrange
+        const info = new ProjectInformationStub();
+        const date = new Date();
+        const testCases = [
+            {
+                parameter: 'homepage',
+                argument: info.homepage,
+            },
+            {
+                parameter: 'version',
+                argument: info.version,
+            },
+            {
+                parameter: 'date',
+                argument: date.toUTCString(),
+            },
+        ];
+        for (const testCase of testCases) {
+            it(`substitutes ${testCase.parameter} as expected`, () => {
+                const compilerStub = new ExpressionsCompilerStub();
+                const sut = new CodeSubstituterBuilder()
+                    .withCompiler(compilerStub)
+                    .withDate(date)
+                    .build();
+                // act
+                sut.substitute('non empty code', info);
+                // assert
+                expect(compilerStub.callHistory).to.have.lengthOf(1);
+                expect(compilerStub.callHistory[0].parameters[testCase.parameter]).to.equal(testCase.argument);
+            });
+        }
+    });
+    it('returns code as it is', () => {
+        // arrange
+        const expected = 'expected-code';
+        const compilerStub = new ExpressionsCompilerStub();
+        const sut = new CodeSubstituterBuilder()
+            .withCompiler(compilerStub)
+            .build();
+        // act
+        sut.substitute(expected, new ProjectInformationStub());
+        // assert
+        expect(compilerStub.callHistory).to.have.lengthOf(1);
+        expect(compilerStub.callHistory[0].code).to.equal(expected);
+    });
+});
+
+class CodeSubstituterBuilder {
+    private compiler: IExpressionsCompiler = new ExpressionsCompilerStub();
+    private date = new Date();
+    public withCompiler(compiler: IExpressionsCompiler) {
+        this.compiler = compiler;
+        return this;
+    }
+    public withDate(date: Date) {
+        this.date = date;
+        return this;
+    }
+    public build() {
+        return new CodeSubstituter(this.compiler, this.date);
+    }
+}

tests/unit/application/Parser/ScriptingDefinition/ScriptingDefinitionParser.spec.ts

@@ -0,0 +1,110 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { ScriptingDefinitionParser } from '@/application/Parser/ScriptingDefinition/ScriptingDefinitionParser';
+import { IEnumParser } from '@/application/Common/Enum';
+import { ICodeSubstituter } from '@/application/Parser/ScriptingDefinition/ICodeSubstituter';
+import { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import { ProjectInformationStub } from '../../../stubs/ProjectInformationStub';
+import { EnumParserStub } from '../../../stubs/EnumParserStub';
+import { ScriptingDefinitionDataStub } from '../../../stubs/ScriptingDefinitionDataStub';
+import { CodeSubstituterStub } from '../../../stubs/CodeSubstituterStub';
+
+describe('ScriptingDefinitionParser', () => {
+    describe('parseScriptingDefinition', () => {
+        it('throws when info is undefined', () => {
+            // arrange
+            const info = undefined;
+            const definition = new ScriptingDefinitionDataStub();
+            const sut = new ScriptingDefinitionParserBuilder()
+                .build();
+            // act
+            const act = () => sut.parse(definition, info);
+            // assert
+            expect(act).to.throw('undefined info');
+        });
+        it('throws when definition is undefined', () => {
+            // arrange
+            const info = new ProjectInformationStub();
+            const definition = undefined;
+            const sut = new ScriptingDefinitionParserBuilder()
+                .build();
+            // act
+            const act = () => sut.parse(definition, info);
+            // assert
+            expect(act).to.throw('undefined definition');
+        });
+        describe('language', () => {
+            it('parses as expected', () => {
+                // arrange
+                const expectedLanguage = ScriptingLanguage.batchfile;
+                const languageText = 'batchfile';
+                const expectedName = 'language';
+                const info = new ProjectInformationStub();
+                const definition = new ScriptingDefinitionDataStub()
+                    .withLanguage(languageText);
+                const parserMock = new EnumParserStub<ScriptingLanguage>()
+                    .setup(expectedName, languageText, expectedLanguage);
+                const sut = new ScriptingDefinitionParserBuilder()
+                    .withParser(parserMock)
+                    .build();
+                // act
+                const actual = sut.parse(definition, info);
+                // assert
+                expect(actual.language).to.equal(expectedLanguage);
+            });
+        });
+        describe('substitutes code as expected', () => {
+            // arrange
+            const code = 'hello';
+            const expected = 'substituted';
+            const testCases = [
+                {
+                    name: 'startCode',
+                    getActualValue: (result: IScriptingDefinition) => result.startCode,
+                    data: new ScriptingDefinitionDataStub()
+                        .withStartCode(code),
+                },
+                {
+                    name: 'endCode',
+                    getActualValue: (result: IScriptingDefinition) => result.endCode,
+                    data: new ScriptingDefinitionDataStub()
+                        .withEndCode(code),
+                },
+            ];
+            for (const testCase of testCases) {
+                it(testCase.name, () => {
+                    const info = new ProjectInformationStub();
+                    const substituterMock = new CodeSubstituterStub()
+                        .setup(code, info, expected);
+                    const sut = new ScriptingDefinitionParserBuilder()
+                        .withSubstituter(substituterMock)
+                        .build();
+                    // act
+                    const definition = sut.parse(testCase.data, info);
+                    // assert
+                    const actual = testCase.getActualValue(definition);
+                    expect(actual).to.equal(expected);
+                });
+            }
+        });
+    });
+});
+
+class ScriptingDefinitionParserBuilder {
+    private languageParser: IEnumParser<ScriptingLanguage> = new EnumParserStub<ScriptingLanguage>()
+        .setupDefaultValue(ScriptingLanguage.shellscript);
+    private codeSubstituter: ICodeSubstituter = new CodeSubstituterStub();
+
+    public withParser(parser: IEnumParser<ScriptingLanguage>) {
+        this.languageParser = parser;
+        return this;
+    }
+    public withSubstituter(substituter: ICodeSubstituter) {
+        this.codeSubstituter = substituter;
+        return this;
+    }
+    public build() {
+        return new ScriptingDefinitionParser(this.languageParser, this.codeSubstituter);
+    }
+}