#1 - WIP: Refactorings

Signed-off-by: Gregor Anders <[email protected]>

Author: gregoranders

package.json

@@ -39,6 +39,7 @@
       "tsx",
       "js"
     ],
+    "reporters": ["jest-spec-reporter"],
     "setupFilesAfterEnv": [
       "jest-enzyme"
     ],
@@ -95,6 +96,7 @@
     "jest-cli": "24.9.0",
     "jest-environment-enzyme": "^7.1.2",
     "jest-enzyme": "^7.1.2",
+    "jest-spec-reporter": "^1.0.10",
     "mime": "2.4.4",
     "node-sass": "4.13.0",
     "react-test-renderer": "16.12.0",

src/application.spec.tsx

@@ -7,7 +7,7 @@ import { RendererService } from "./rendererService";
 
 describe("Application", (): void => {
 
-  const service: RendererService = new RendererService();
+  const service: RendererService = new RendererService(undefined as any, undefined as any);
 
   it("Application export exists", (): void => {
     expect(TestSubject.Application).toBeDefined();

src/button.spec.tsx

@@ -1,15 +1,11 @@
 import { mount, ReactWrapper } from "enzyme";
-// import * as Adapter from "enzyme-adapter-react-16";
 import * as React from "react";
 import * as renderer from "react-test-renderer";
 
 import * as TestSubject from "./button";
 
 describe("Button", (): void => {
 
-  // beforeAll((): void => {
-  //   configure({ adapter: new Adapter() });
-  // });
 
   it("Button export exists", (): void => {
     expect(TestSubject.Button).toBeDefined();

src/ipc.ts

@@ -2,7 +2,7 @@ import { ipcMain, ipcRenderer } from "electron";
 
 export type IPCMessageType = "ping" | "pong";
 
-export type IPCChannel = "main-channel" | "render-channel";
+export type IPCChannel = "main-channel";
 
 export interface IIPCMessage<T> {
   data: T;

src/ipcService.ts

@@ -2,10 +2,17 @@ import * as log from "fancy-log";
 
 import { IIPCMessage, IPCChannel, IPCMessageType } from "./ipc";
 
-export abstract class IpcService<T extends Electron.IpcMainEvent | Electron.IpcRendererEvent> {
+type IpcEventType<T> = T extends Electron.IpcMain ? Electron.IpcMainEvent : Electron.IpcRendererEvent;
 
-  public register(ipc: NodeJS.EventEmitter, channel: string): void {
-    ipc.on(channel, (event: T, ...args: any[]): void => {
+type IpcSenderType<T> = T extends Electron.IpcMain ? Electron.WebContents : Electron.IpcRenderer;
+
+
+export abstract class IpcService<T extends Electron.IpcMain | Electron.IpcRenderer> {
+
+  public constructor(protected ipc: T, protected channel: IPCChannel) {}
+
+  public register(): void {
+    this.ipc.on(this.channel, (event: Electron.IpcMainEvent | Electron.IpcRendererEvent, ...args: any[]): void => {
       if (args && args.length === 1) {
         const ipcMessage: IIPCMessage<any> = args[0];
         this.handleMessage(event, ipcMessage);
@@ -15,10 +22,10 @@ export abstract class IpcService<T extends Electron.IpcMainEvent | Electron.IpcR
     });
   }
 
-  protected abstract handleMessage<MT>(event: T, message: IIPCMessage<MT>): void;
+  protected abstract handleMessage<MT>(event: Electron.IpcMainEvent | Electron.IpcRendererEvent,
+                                       message: IIPCMessage<MT>): void;
 
-  protected send<MT>(sender: Electron.WebContents | Electron.IpcRenderer,
-                     channel: IPCChannel, type: IPCMessageType, data: MT): void {
+  protected send<MT>(sender: IpcSenderType<T>, channel: IPCChannel, type: IPCMessageType, data: MT): void {
     sender.send(channel, {
       data,
       timestamp: new Date(),

src/main.ts

@@ -28,8 +28,8 @@ app.whenReady()
             mode: "right",
           });
         }
-        const service: MainService = new MainService();
-        service.register(ipcMain, "main-channel");
+        const service: MainService = new MainService(ipcMain, "main-channel");
+        service.register();
         browserWindow.show();
       })
       .catch((reason: any): void => {

src/mainService.spec.tsx

@@ -0,0 +1,12 @@
+import { mount, ReactWrapper } from "enzyme";
+import * as React from "react";
+import * as renderer from "react-test-renderer";
+
+import * as TestSubject from "./mainService";
+
+describe("MainService", (): void => {
+
+  it("MainService export exists", (): void => {
+    expect(TestSubject.MainService).toBeDefined();
+  });
+});

src/mainService.ts

@@ -6,20 +6,14 @@ import { IpcService } from "./ipcService";
 
 import { IIPCMessage } from "./ipc";
 
-
-export class MainService extends IpcService<Electron.IpcMainEvent> {
-
-  public constructor() {
-    super();
-    this.register(ipcMain, "main-channel");
-  }
+export class MainService extends IpcService<Electron.IpcMain> {
 
   protected handleMessage<T>(event: Electron.IpcMainEvent, message: IIPCMessage<T>): void {
     switch (message.type) {
       case "ping":
         log.info(message);
-        this.send(event.sender, "main-channel", "pong", message.data);
-        this.send(event.sender, "main-channel", "ping", message.data);
+        this.send(event.sender, this.channel, "pong", message.data);
+        this.send(event.sender, this.channel, "ping", message.data);
         break;
       case "pong":
           log.info(message);

src/renderer.tsx

@@ -7,7 +7,7 @@ import { Application } from "./application";
 
 import { RendererService } from "./rendererService";
 
-const service: RendererService = new RendererService();
-service.register(ipcRenderer, "render-channel");
+const service: RendererService = new RendererService(ipcRenderer, "main-channel");
+service.register();
 
 render(<Application service={ service }/>, document.getElementById("content"));

src/rendererService.spec.tsx

@@ -0,0 +1,42 @@
+import { mount, ReactWrapper } from "enzyme";
+import * as React from "react";
+import * as renderer from "react-test-renderer";
+
+import * as TestSubject from "./rendererService";
+
+describe("RendererService", (): void => {
+
+  it("RendererService export exists", (): void => {
+    expect(TestSubject.RendererService).toBeDefined();
+  });
+
+  it("ping", (): void => {
+    const ipc: any = {
+      send: jest.fn(),
+    };
+
+    const testSubject: TestSubject.RendererService = new TestSubject.RendererService(ipc, "main-channel");
+    testSubject.ping();
+    expect(ipc.send).toHaveBeenCalledTimes(1);
+  });
+
+  it("register", (): void => {
+    const ipc: any = {
+      on: jest.fn(),
+    };
+
+    const testSubject: TestSubject.RendererService = new TestSubject.RendererService(ipc, "main-channel");
+    testSubject.register();
+    expect(ipc.on).toHaveBeenCalledTimes(1);
+  });
+
+  it("callback", (): void => {
+    const ipc: any = {
+      on: jest.fn(),
+    };
+
+    const testSubject: TestSubject.RendererService = new TestSubject.RendererService(ipc, "main-channel");
+    testSubject.register();
+    expect(ipc.on).toHaveBeenCalledTimes(1);
+  });
+});