Increase testability through dependency injection

- Remove existing integration tests for hooks as they're redundant after
  this change.
- Document the pattern in relevant documentation.
- Introduce `useEnvironment` to increase testability.
- Update components to inject dependencies rather than importing hooks
  directly.

tests/integration/presentation/components/Shared/Hooks/UseApplication.spec.ts

@@ -1,29 +0,0 @@
-import 'mocha';
-import { expect } from 'chai';
-import { useApplication } from '@/presentation/components/Shared/Hooks/UseApplication';
-import { ApplicationFactory } from '@/application/ApplicationFactory';
-
-describe('UseApplication', () => {
-  it('should return the actual application from factory', async () => {
-    // arrange
-    const expected = await ApplicationFactory.Current.getApp();
-
-    // act
-    const { application } = useApplication(expected);
-
-    // assert
-    expect(application).to.equal(expected);
-  });
-
-  it('should return the actual info from the application', async () => {
-    // arrange
-    const app = await ApplicationFactory.Current.getApp();
-    const expected = app.info;
-
-    // act
-    const { info } = useApplication();
-
-    // assert
-    expect(info).to.equal(expected);
-  });
-});

tests/integration/presentation/components/Shared/Hooks/UseCollectionState.spec.ts

@@ -1,83 +0,0 @@
-import 'mocha';
-import { expect } from 'chai';
-import { useCollectionState } from '@/presentation/components/Shared/Hooks/UseCollectionState';
-import { IReadOnlyApplicationContext } from '@/application/Context/IApplicationContext';
-
-describe('UseCollectionState', () => {
-  describe('currentContext', () => {
-    it('multiple calls get the same instance', () => {
-      // act
-      const firstContext = useCollectionState().currentContext;
-      const secondContext = useCollectionState().currentContext;
-      // assert
-      expect(firstContext).to.equal(secondContext);
-    });
-  });
-
-  describe('currentState', () => {
-    it('returns current collection state', () => {
-      // arrange
-      const { currentContext } = useCollectionState();
-      const expectedState = currentContext.state;
-
-      // act
-      const { currentState } = useCollectionState();
-      const actualState = currentState.value;
-
-      // assert
-      expect(expectedState).to.equal(actualState);
-    });
-    it('returns changed collection state', () => {
-      // arrange
-      const { currentContext, currentState, modifyCurrentContext } = useCollectionState();
-      const newOs = pickNonCurrentOs(currentContext);
-
-      // act
-      modifyCurrentContext((context) => {
-        context.changeContext(newOs);
-      });
-      const expectedState = currentContext.state;
-
-      // assert
-      expect(currentState.value).to.equal(expectedState);
-    });
-  });
-
-  describe('modifyCurrentContext', () => {
-    it('modifies the current context', () => {
-      // arrange
-      const { currentContext, currentState, modifyCurrentContext } = useCollectionState();
-      const expectedOs = pickNonCurrentOs(currentContext);
-
-      // act
-      modifyCurrentContext((context) => {
-        context.changeContext(expectedOs);
-      });
-
-      // assert
-      expect(currentContext.state.os).to.equal(expectedOs);
-      expect(currentState.value.os).to.equal(expectedOs);
-    });
-  });
-
-  describe('modifyCurrentState', () => {
-    it('modifies the current state', () => {
-      // arrange
-      const { currentState, modifyCurrentState } = useCollectionState();
-      const expectedFilter = 'expected-filter';
-
-      // act
-      modifyCurrentState((state) => {
-        state.filter.setFilter(expectedFilter);
-      });
-
-      // assert
-      const actualFilter = currentState.value.filter.currentFilter.query;
-      expect(actualFilter).to.equal(expectedFilter);
-    });
-  });
-});
-
-function pickNonCurrentOs(context: IReadOnlyApplicationContext) {
-  return context.app.getSupportedOsList().find((os) => os !== context.state.os);
-}

tests/unit/presentation/components/Shared/Hooks/UseApplication.spec.ts

@@ -3,8 +3,21 @@ import { expect } from 'chai';
 import { useApplication } from '@/presentation/components/Shared/Hooks/UseApplication';
 import { ApplicationStub } from '@tests/unit/shared/Stubs/ApplicationStub';
 import { ProjectInformationStub } from '@tests/unit/shared/Stubs/ProjectInformationStub';
+import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
 describe('UseApplication', () => {
+  describe('application is absent', () => {
+    itEachAbsentObjectValue((absentValue) => {
+      // arrange
+      const expectedError = 'missing application';
+      const applicationValue = absentValue;
+      // act
+      const act = () => useApplication(applicationValue);
+      // assert
+      expect(act).to.throw(expectedError);
+    });
+  });
+
   it('should return expected info', () => {
     // arrange
     const expectedInfo = new ProjectInformationStub()

tests/unit/presentation/components/Shared/Hooks/UseCollectionState.spec.ts

@@ -9,6 +9,18 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
 import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
 
 describe('UseCollectionState', () => {
+  describe('context is absent', () => {
+    itEachAbsentObjectValue((absentValue) => {
+      // arrange
+      const expectedError = 'missing context';
+      const contextValue = absentValue;
+      // act
+      const act = () => useCollectionState(contextValue);
+      // assert
+      expect(act).to.throw(expectedError);
+    });
+  });
+
   describe('currentContext', () => {
     it('returns current context', () => {
       // arrange

tests/unit/presentation/components/Shared/Hooks/UseEnvironment.spec.ts

@@ -0,0 +1,28 @@
+import 'mocha';
+import { expect } from 'chai';
+import { useEnvironment } from '@/presentation/components/Shared/Hooks/UseEnvironment';
+import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { EnvironmentStub } from '@tests/unit/shared/Stubs/EnvironmentStub';
+
+describe('UseEnvironment', () => {
+  describe('environment is absent', () => {
+    itEachAbsentObjectValue((absentValue) => {
+      // arrange
+      const expectedError = 'missing environment';
+      const environmentValue = absentValue;
+      // act
+      const act = () => useEnvironment(environmentValue);
+      // assert
+      expect(act).to.throw(expectedError);
+    });
+  });
+
+  it('returns expected environment', () => {
+    // arrange
+    const expectedEnvironment = new EnvironmentStub();
+    // act
+    const actualEnvironment = useEnvironment(expectedEnvironment);
+    // assert
+    expect(actualEnvironment).to.equal(expectedEnvironment);
+  });
+});