refactor extra code, duplicates, complexity

- refactor array equality check and add tests
- remove OperatingSystem.Unknown causing extra logic, return undefined instead
- refactor enum validation to share same logic
- refactor scripting language factories to share same logic
- refactor too many args in runCodeAsync
- refactor ScriptCode constructor to reduce complexity
- fix writing useless write to member object since another property write always override it

tests/unit/application/Common/ScriptingLanguage/ScriptingLanguageFactory.spec.ts

@@ -0,0 +1,60 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { ScriptingLanguageFactory } from '@/application/Common/ScriptingLanguage/ScriptingLanguageFactory';
+import { ScriptingLanguageFactoryTestRunner } from './ScriptingLanguageFactoryTestRunner';
+import { EnumRangeTestRunner } from '../EnumRangeTestRunner';
+
+class ScriptingLanguageConcrete extends ScriptingLanguageFactory<number> {
+    public registerGetter(language: ScriptingLanguage, getter: () => number) {
+        super.registerGetter(language, getter);
+    }
+}
+
+describe('ScriptingLanguageFactory', () => {
+    describe('registerGetter', () => {
+        describe('validates language', () => {
+            // arrange
+            const validValue = ScriptingLanguage.batchfile;
+            const getter = () => undefined;
+            const sut = new ScriptingLanguageConcrete();
+            // act
+            const act = (language: ScriptingLanguage) => sut.registerGetter(language, getter);
+            // assert
+            new EnumRangeTestRunner(act)
+                .testOutOfRangeThrows()
+                .testUndefinedValueThrows()
+                .testValidValueDoesNotThrow(validValue);
+        });
+        it('throw when getter is undefined', () => {
+            // arrange
+            const expectedError = `undefined getter`;
+            const language = ScriptingLanguage.batchfile;
+            const getter = undefined;
+            const sut = new ScriptingLanguageConcrete();
+            // act
+            const act = () => sut.registerGetter(language, getter);
+            // assert
+            expect(act).to.throw(expectedError);
+        });
+        it('throw when language is already registered', () => {
+            // arrange
+            const language = ScriptingLanguage.batchfile;
+            const expectedError = `${ScriptingLanguage[language]} is already registered`;
+            const getter = () => undefined;
+            const sut = new ScriptingLanguageConcrete();
+            // act
+            sut.registerGetter(language, getter);
+            const reRegister = () => sut.registerGetter(language, getter);
+            // assert
+            expect(reRegister).to.throw(expectedError);
+        });
+    });
+    describe('create', () => {
+        const sut = new ScriptingLanguageConcrete();
+        sut.registerGetter(ScriptingLanguage.batchfile, () => undefined);
+        const runner = new ScriptingLanguageFactoryTestRunner();
+        runner.testCreateMethod(sut);
+    });
+});
+

tests/unit/application/Common/ScriptingLanguage/ScriptingLanguageFactoryTestRunner.ts

@@ -0,0 +1,48 @@
+import { IScriptingLanguageFactory } from '@/application/Common/ScriptingLanguage/IScriptingLanguageFactory';
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { expect } from 'chai';
+import { EnumRangeTestRunner } from '../EnumRangeTestRunner';
+
+export class ScriptingLanguageFactoryTestRunner<T> {
+    private expectedTypes = new Map<ScriptingLanguage, T>();
+    public expect(language: ScriptingLanguage, resultType: T) {
+        this.expectedTypes.set(language, resultType);
+        return this;
+    }
+    public testCreateMethod(sut: IScriptingLanguageFactory<T>) {
+        if (!sut) { throw new Error('undefined sut'); }
+        testLanguageValidation(sut);
+        testExpectedInstanceTypes(sut, this.expectedTypes);
+    }
+}
+
+function testExpectedInstanceTypes<T>(
+    sut: IScriptingLanguageFactory<T>,
+    expectedTypes: Map<ScriptingLanguage, T>) {
+    describe('create returns expected instances', () => {
+        // arrange
+        for (const language of Array.from(expectedTypes.keys())) {
+            it(ScriptingLanguage[language], () => {
+                // act
+                const expected = expectedTypes.get(language);
+                const result = sut.create(language);
+                // assert
+                expect(result).to.be.instanceOf(expected, `Actual was: ${result.constructor.name}`);
+            });
+        }
+    });
+}
+
+function testLanguageValidation<T>(sut: IScriptingLanguageFactory<T>) {
+    describe('validates language', () => {
+        // arrange
+        const validValue = ScriptingLanguage.batchfile;
+        // act
+        const act = (value: ScriptingLanguage) => sut.create(value);
+        // assert
+        new EnumRangeTestRunner(act)
+            .testOutOfRangeThrows()
+            .testUndefinedValueThrows()
+            .testValidValueDoesNotThrow(validValue);
+    });
+}