chore: Discovery module setup

And fix unit tests on DI modules

packages/core/src/di.ts

@@ -3,6 +3,7 @@ import { makeLoggerMiddleware } from "inversify-logger-middleware";
 import { configModuleFactory } from "@internal/config/di/configModule";
 import { usbModuleFactory } from "@internal/usb/di/usbModule";
 import { deviceModelModuleFactory } from "@internal/device-model/di/deviceModelModule";
+import { discoveryModuleFactory } from "@internal/discovery/di/discoveryModule";
 
 const logger = makeLoggerMiddleware();
 
@@ -18,7 +19,8 @@ export const makeContainer = ({
   container.load(
     configModuleFactory({ stub }),
     deviceModelModuleFactory(),
-    usbModuleFactory({ stub })
+    usbModuleFactory({ stub }),
+    discoveryModuleFactory({ stub }),
     // modules go here
   );
 

packages/core/src/internal/discovery/di/discoveryDiTypes.ts

@@ -0,0 +1,3 @@
+export const discoveryDiTypes = {
+  StartDiscoveryUseCase: Symbol.for("StartDiscoveryUseCase"),
+};

packages/core/src/internal/discovery/di/discoveryModule.test.ts

@@ -0,0 +1,31 @@
+import { Container } from "inversify";
+import { StartDiscoveryUseCase } from "@internal/discovery/use-case/UsbHidStartDiscoveryUseCase";
+import { discoveryModuleFactory } from "./discoveryModule";
+import { usbModuleFactory } from "@internal/usb/di/usbModule";
+import { deviceModelModuleFactory } from "@internal/device-model/di/deviceModelModule";
+import { discoveryDiTypes } from "./discoveryDiTypes";
+
+
+describe("discoveryModuleFactory", () => {
+  let container: Container;
+  let mod: ReturnType<typeof discoveryModuleFactory>;
+  beforeEach(() => {
+    mod = discoveryModuleFactory();
+    container = new Container();
+    container.load(
+      mod,
+      // The following modules are injected into discovery module
+      usbModuleFactory(),
+      deviceModelModuleFactory(),
+    );
+  });
+
+  it("should return the device module", () => {
+    expect(mod).toBeDefined();
+  });
+
+  it("should return none mocked use cases", () => {
+    const startDiscoveryUseCase = container.get(discoveryDiTypes.StartDiscoveryUseCase);
+    expect(startDiscoveryUseCase).toBeInstanceOf(StartDiscoveryUseCase);
+  });
+});

packages/core/src/internal/discovery/di/discoveryModule.ts

@@ -0,0 +1,19 @@
+import { ContainerModule } from "inversify";
+import { StartDiscoveryUseCase } from "@internal/discovery/use-case/UsbHidStartDiscoveryUseCase";
+import { discoveryDiTypes } from "./discoveryDiTypes";
+
+type FactoryProps = {
+  stub: boolean;
+};
+
+export const discoveryModuleFactory = ({
+  stub = false,
+}: Partial<FactoryProps> = {}) =>
+  new ContainerModule((bind, _unbind, _isBound, _rebind) => {
+    bind(discoveryDiTypes.StartDiscoveryUseCase).to(StartDiscoveryUseCase);
+
+    if (stub) {
+      // We can rebind our interfaces to their mock implementations
+      // rebind(...).to(....);
+    }
+  });

packages/core/src/internal/discovery/use-case/UsbHidStartDiscoveryUseCase.ts

@@ -0,0 +1,23 @@
+import { Observable } from "rxjs";
+import { inject, injectable } from "inversify";
+import { usbDiTypes } from "@internal/usb/di/usbDiTypes";
+import type { UsbHidTransport } from "@internal/usb/transport/UsbHidTransport";
+import { DiscoveredDevice } from "@internal/usb/model/DiscoveredDevice";
+
+/**
+ * Starts discovering devices connected via USB HID (and later BLE).
+ * 
+ * For the WebHID implementation, this use-case needs to be called as a result of an user interaction (button "click" event for ex).
+ */
+@injectable()
+export class StartDiscoveryUseCase {
+  constructor(
+    @inject(usbDiTypes.UsbHidTransport) private usbHidTransport: UsbHidTransport,
+    // Later: @inject(usbDiTypes.BleTransport) private bleTransport: BleTransport,
+  ) {
+  }
+
+  execute(): Observable<DiscoveredDevice> {
+    return this.usbHidTransport.startDiscovering();
+  }
+}

packages/core/src/internal/usb/di/usbModule.test.ts

@@ -1,6 +1,6 @@
 import { Container } from "inversify";
 import { WebUsbHidTransport } from "@internal/usb/transport/WebUsbHidTransport";
-import { DefaultUsbService } from "@internal/usb/service/DefaultUsbService";
+import { deviceModelModuleFactory } from "@internal/device-model/di/deviceModelModule";
 import { usbModuleFactory } from "./usbModule";
 import { usbDiTypes } from "./usbDiTypes";
 
@@ -10,18 +10,19 @@ describe("usbModuleFactory", () => {
   beforeEach(() => {
     mod = usbModuleFactory();
     container = new Container();
-    container.load(mod);
+    container.load(
+      mod,
+      deviceModelModuleFactory(),
+    );
   });
 
   it("should return the usb module", () => {
     expect(mod).toBeDefined();
   });
 
-  it("should return none mocked services and transport", () => {
+  it("should return none mocked transports", () => {
     const usbHidTransport = container.get(usbDiTypes.UsbHidTransport);
-    const usbService = container.get(usbDiTypes.UsbService);
     expect(usbHidTransport).toBeInstanceOf(WebUsbHidTransport);
-    expect(usbService).toBeInstanceOf(DefaultUsbService);
   });
 });