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);
+    }
+}