Add more and unify tests for absent object cases

- Unify test data for nonexistence of an object/string and collection.
- Introduce more test through adding missing test data to existing tests.
- Improve logic for checking absence of values to match tests.
- Add missing tests for absent value validation.
- Update documentation to include shared test functionality.

tests/unit/application/Context/ApplicationContext.spec.ts

@@ -8,6 +8,7 @@ import { IApplication } from '@/domain/IApplication';
 import { ApplicationStub } from '@tests/unit/stubs/ApplicationStub';
 import { CategoryCollectionStub } from '@tests/unit/stubs/CategoryCollectionStub';
 import { EnumRangeTestRunner } from '@tests/unit/application/Common/EnumRangeTestRunner';
+import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
 describe('ApplicationContext', () => {
   describe('changeContext', () => {
@@ -125,18 +126,33 @@ describe('ApplicationContext', () => {
         expect(duplicates.length).to.be.equal(0);
       });
     });
+    describe('throws with invalid os', () => {
+      new EnumRangeTestRunner((os: OperatingSystem) => {
+        // arrange
+        const sut = new ObservableApplicationContextFactory()
+          .construct();
+        // act
+        sut.changeContext(os);
+      })
+      // assert
+        .testOutOfRangeThrows()
+        .testAbsentValueThrows()
+        .testInvalidValueThrows(OperatingSystem.Android, 'os "Android" is not defined in application');
+    });
   });
   describe('ctor', () => {
     describe('app', () => {
-      it('throw when app is undefined', () => {
-        // arrange
-        const expectedError = 'undefined app';
-        const app = undefined;
-        const os = OperatingSystem.Windows;
-        // act
-        const act = () => new ApplicationContext(app, os);
-        // assert
-        expect(act).to.throw(expectedError);
+      describe('throw when app is missing', () => {
+        itEachAbsentObjectValue((absentValue) => {
+          // arrange
+          const expectedError = 'missing app';
+          const app = absentValue;
+          const os = OperatingSystem.Windows;
+          // act
+          const act = () => new ApplicationContext(app, os);
+          // assert
+          expect(act).to.throw(expectedError);
+        });
       });
     });
     describe('collection', () => {
@@ -188,7 +204,7 @@ describe('ApplicationContext', () => {
         // assert
         new EnumRangeTestRunner(act)
           .testOutOfRangeThrows()
-          .testUndefinedValueThrows()
+          .testAbsentValueThrows()
           .testInvalidValueThrows(OperatingSystem.Android, 'os "Android" is not defined in application');
       });
     });

tests/unit/application/Context/ApplicationContextFactory.spec.ts

@@ -8,6 +8,7 @@ import { IApplication } from '@/domain/IApplication';
 import { EnvironmentStub } from '@tests/unit/stubs/EnvironmentStub';
 import { ApplicationStub } from '@tests/unit/stubs/ApplicationStub';
 import { CategoryCollectionStub } from '@tests/unit/stubs/CategoryCollectionStub';
+import { expectThrowsAsync } from '@tests/unit/shared/Assertions/ExpectThrowsAsync';
 
 describe('ApplicationContextFactory', () => {
   describe('buildContext', () => {
@@ -23,6 +24,15 @@ describe('ApplicationContextFactory', () => {
         // assert
         expect(expected).to.equal(context.app);
       });
+      it('throws when null', async () => {
+        // arrange
+        const expectedError = 'missing factory';
+        const factory = null;
+        // act
+        const act = async () => { await buildContext(factory); };
+        // assert
+        expectThrowsAsync(act, expectedError);
+      });
     });
     describe('environment', () => {
       describe('sets initial OS as expected', () => {
@@ -69,6 +79,16 @@ describe('ApplicationContextFactory', () => {
           expect(expectedOs).to.equal(actual, `Expected: ${OperatingSystem[expectedOs]}, actual: ${OperatingSystem[actual]}`);
         });
       });
+      it('throws when null', async () => {
+        // arrange
+        const expectedError = 'missing environment';
+        const factory = mockFactoryWithApp(undefined);
+        const environment = null;
+        // act
+        const act = async () => { await buildContext(factory, environment); };
+        // assert
+        expectThrowsAsync(act, expectedError);
+      });
     });
   });
 });

tests/unit/application/Context/State/Code/ApplicationCode.spec.ts

@@ -13,6 +13,8 @@ import { ScriptingDefinitionStub } from '@tests/unit/stubs/ScriptingDefinitionSt
 import { CategoryStub } from '@tests/unit/stubs/CategoryStub';
 import { ScriptStub } from '@tests/unit/stubs/ScriptStub';
 import { CategoryCollectionStub } from '@tests/unit/stubs/CategoryCollectionStub';
+import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { UserSelectionStub } from '@tests/unit/stubs/UserSelectionStub';
 
 describe('ApplicationCode', () => {
   describe('ctor', () => {
@@ -46,6 +48,41 @@ describe('ApplicationCode', () => {
       // assert
       expect(actual).to.equal(expected.code);
     });
+    describe('throws when userSelection is missing', () => {
+      itEachAbsentObjectValue((absentValue) => {
+        // arrange
+        const expectedError = 'missing userSelection';
+        const userSelection = absentValue;
+        const definition = new ScriptingDefinitionStub();
+        // act
+        const act = () => new ApplicationCode(userSelection, definition);
+        // assert
+        expect(act).to.throw(expectedError);
+      });
+    });
+    describe('throws when scriptingDefinition is missing', () => {
+      itEachAbsentObjectValue((absentValue) => {
+        // arrange
+        const expectedError = 'missing scriptingDefinition';
+        const userSelection = new UserSelectionStub([]);
+        const definition = absentValue;
+        // act
+        const act = () => new ApplicationCode(userSelection, definition);
+        // assert
+        expect(act).to.throw(expectedError);
+      });
+    });
+    it('throws when generator is missing', () => {
+      // arrange
+      const expectedError = 'missing generator';
+      const userSelection = new UserSelectionStub([]);
+      const definition = new ScriptingDefinitionStub();
+      const generator = null;
+      // act
+      const act = () => new ApplicationCode(userSelection, definition, generator);
+      // assert
+      expect(act).to.throw(expectedError);
+    });
   });
   describe('changed event', () => {
     describe('code', () => {

tests/unit/application/Context/State/Code/Generation/UserScriptGenerator.spec.ts

@@ -6,6 +6,8 @@ import { ICodeBuilderFactory } from '@/application/Context/State/Code/Generation
 import { ICodeBuilder } from '@/application/Context/State/Code/Generation/ICodeBuilder';
 import { ScriptStub } from '@tests/unit/stubs/ScriptStub';
 import { ScriptingDefinitionStub } from '@tests/unit/stubs/ScriptingDefinitionStub';
+import { itEachAbsentObjectValue, itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { SelectedScriptStub } from '@tests/unit/stubs/SelectedScriptStub';
 
 describe('UserScriptGenerator', () => {
   describe('scriptingDefinition', () => {
@@ -18,8 +20,7 @@ describe('UserScriptGenerator', () => {
           .withCode('code\nmulti-lined')
           .toSelectedScript();
         const definition = new ScriptingDefinitionStub()
-          .withStartCode(startCode)
-          .withEndCode(undefined);
+          .withStartCode(startCode);
         const expectedStart = `${startCode}\n`;
         // act
         const code = sut.buildCode([script], definition);
@@ -27,24 +28,25 @@ describe('UserScriptGenerator', () => {
         const actual = code.code;
         expect(actual.startsWith(expectedStart));
       });
-      it('is not prepended if empty', () => {
-        // arrange
-        const codeBuilderStub = new CodeBuilderStub();
-        const sut = new UserScriptGenerator(mockCodeBuilderFactory(codeBuilderStub));
-        const script = new ScriptStub('id')
-          .withCode('code\nmulti-lined')
-          .toSelectedScript();
-        const definition = new ScriptingDefinitionStub()
-          .withStartCode(undefined)
-          .withEndCode(undefined);
-        const expectedStart = codeBuilderStub
-          .appendFunction(script.script.name, script.script.code.execute)
-          .toString();
-        // act
-        const code = sut.buildCode([script], definition);
-        // assert
-        const actual = code.code;
-        expect(actual.startsWith(expectedStart));
+      describe('is not prepended if empty', () => {
+        itEachAbsentStringValue((absentValue) => {
+          // arrange
+          const codeBuilderStub = new CodeBuilderStub();
+          const sut = new UserScriptGenerator(mockCodeBuilderFactory(codeBuilderStub));
+          const script = new ScriptStub('id')
+            .withCode('code\nmulti-lined')
+            .toSelectedScript();
+          const definition = new ScriptingDefinitionStub()
+            .withStartCode(absentValue);
+          const expectedStart = codeBuilderStub
+            .appendFunction(script.script.name, script.script.code.execute)
+            .toString();
+          // act
+          const code = sut.buildCode([script], definition);
+          // assert
+          const actual = code.code;
+          expect(actual.startsWith(expectedStart));
+        });
       });
     });
     describe('endCode', () => {
@@ -64,23 +66,38 @@ describe('UserScriptGenerator', () => {
         const actual = code.code;
         expect(actual.endsWith(expectedEnd));
       });
-      it('is not appended if empty', () => {
+      describe('is not appended if empty', () => {
+        itEachAbsentStringValue((absentValue) => {
+          // arrange
+          const codeBuilderStub = new CodeBuilderStub();
+          const sut = new UserScriptGenerator(mockCodeBuilderFactory(codeBuilderStub));
+          const script = new ScriptStub('id')
+            .withCode('code\nmulti-lined')
+            .toSelectedScript();
+          const expectedEnd = codeBuilderStub
+            .appendFunction(script.script.name, script.script.code.execute)
+            .toString();
+          const definition = new ScriptingDefinitionStub()
+            .withEndCode(absentValue);
+          // act
+          const code = sut.buildCode([script], definition);
+          // assert
+          const actual = code.code;
+          expect(actual.endsWith(expectedEnd));
+        });
+      });
+    });
+    describe('throws when absent', () => {
+      itEachAbsentObjectValue((absentValue) => {
         // arrange
-        const codeBuilderStub = new CodeBuilderStub();
-        const sut = new UserScriptGenerator(mockCodeBuilderFactory(codeBuilderStub));
-        const script = new ScriptStub('id')
-          .withCode('code\nmulti-lined')
-          .toSelectedScript();
-        const expectedEnd = codeBuilderStub
-          .appendFunction(script.script.name, script.script.code.execute)
-          .toString();
-        const definition = new ScriptingDefinitionStub()
-          .withEndCode(undefined);
+        const expectedError = 'missing definition';
+        const sut = new UserScriptGenerator();
+        const scriptingDefinition = absentValue;
+        const selectedScripts = [new SelectedScriptStub('a')];
         // act
-        const code = sut.buildCode([script], definition);
+        const act = () => sut.buildCode(selectedScripts, scriptingDefinition);
         // assert
-        const actual = code.code;
-        expect(actual.endsWith(expectedEnd));
+        expect(act).to.throw(expectedError);
       });
     });
   });
@@ -200,6 +217,21 @@ describe('UserScriptGenerator', () => {
       });
     });
   });
+  describe('selectedScripts', () => {
+    describe('throws when absent', () => {
+      itEachAbsentObjectValue((absentValue) => {
+        // arrange
+        const expectedError = 'missing scripts';
+        const sut = new UserScriptGenerator();
+        const scriptingDefinition = new ScriptingDefinitionStub();
+        const selectedScripts = absentValue;
+        // act
+        const act = () => sut.buildCode(selectedScripts, scriptingDefinition);
+        // assert
+        expect(act).to.throw(expectedError);
+      });
+    });
+  });
 });
 
 function mockCodeBuilderFactory(mock: ICodeBuilder): ICodeBuilderFactory {