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

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