Modified injector class to be more modular

oliverschwendener · Apr 20, 2018 · ec78dcc · ec78dcc
1 parent 311016c
commit ec78dcc
Show file tree

Hide file tree

Showing 12 changed files with 176 additions and 103 deletions.
diff --git a/src/tests/integration/search-plugins/programs-plugin.test.ts b/src/tests/integration/search-plugins/programs-plugin.test.ts
@@ -1,7 +1,14 @@
 import { ProgramsPlugin } from "../../../ts/search-plugins/programs-plugin";
+import { platform } from "os";
+import { WindowsProgramRepository } from "../../../ts/programs-plugin/windows-program-repository";
+import { MacOsProgramRepository } from "../../../ts/programs-plugin/macos-program-repository";
 
 describe(ProgramsPlugin.name, (): void => {
-    const plugin = new ProgramsPlugin();
+    const programRepo = platform() === "win32"
+        ? new WindowsProgramRepository()
+        : new MacOsProgramRepository();
+
+    const plugin = new ProgramsPlugin(programRepo);
 
     describe(plugin.getAllItems.name, (): void => {
         it("should return some programs", (): void => {

diff --git a/src/tests/unit/injector.test.ts b/src/tests/unit/injector.test.ts
@@ -7,128 +7,117 @@ import { Windows10SettingsSearchPlugin } from "../../ts/search-plugins/windows-1
 import { MacOsSettingsPlugin } from "../../ts/search-plugins/mac-os-settings-plugin";
 import { WindowsProgramRepository } from "../../ts/programs-plugin/windows-program-repository";
 import { MacOsProgramRepository } from "../../ts/programs-plugin/macos-program-repository";
-
-const winPlatformString = "win32";
-const macOsPlatformString = "darwin";
+import { DirectorySeparator } from "../../ts/directory-separator";
+import { join } from "path";
+import { FileExecutionCommandBuilder } from "../../ts/builders/file-execution-command-builder";
+import { FileLocationExecutionCommandBuilder } from "../../ts/builders/file-location-execution-command-builder";
+import { FilePathRegex } from "../../ts/file-path-regex";
+import { OpenUrlWithDefaultBrowserCommandBuilder } from "../../ts/builders/open-url-with-default-browser-command-builder";
+import { SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG } from "constants";
+import { StylesheetPath } from "../../ts/builders/stylesheet-path-builder";
+import { TrayIconPathBuilder } from "../../ts/builders/tray-icon-path-builder";
+import { OperatingSystemNotSupportedError } from "../../ts/errors/operatingsystem-not-supported-error";
+
+const win = "win32";
+const mac = "darwin";
+const testFilePath = join("example", "file", "path");
+const testUrl = "https://github.com";
 
 describe(Injector.name, () => {
     describe(Injector.getDirectorySeparator.name, () => {
         it("should return the correct directory separator", () => {
-            const actual = Injector.getDirectorySeparator(platform());
-
-            const expected = platform() === "win32"
-                ? "\\"
-                : "/";
+            const actualWin = Injector.getDirectorySeparator(win);
+            const actualMac = Injector.getDirectorySeparator(mac);
 
-            expect(actual).toBe(expected);
+            expect(actualWin).toBe(DirectorySeparator.WindowsDirectorySeparator);
+            expect(actualMac).toBe(DirectorySeparator.macOsDirectorySeparator);
         });
     });
 
     describe(Injector.getFileExecutionCommand.name, () => {
         it("should return a file execution command", () => {
-            const actual = Injector.getFileExecutionCommand(platform(), "");
-            expect(actual).not.toBe(undefined);
-            expect(actual).not.toBe(null);
+            const actualWin = Injector.getFileExecutionCommand(win, testFilePath);
+            const actualMac = Injector.getFileExecutionCommand(mac, testFilePath);
+
+            expect(actualWin).toBe(FileExecutionCommandBuilder.buildWindowsFileExecutionCommand(testFilePath));
+            expect(actualMac).toBe(FileExecutionCommandBuilder.buildMacOsFileExecutionCommand(testFilePath));
         });
     });
 
     describe(Injector.getFileLocationExecutionCommand.name, () => {
         it("should return a file location execution command", () => {
-            const actual = Injector.getFileLocationExecutionCommand(platform(), "");
-            expect(actual).not.toBe(undefined);
-            expect(actual).not.toBe(null);
+            const actualWin = Injector.getFileLocationExecutionCommand(win, testFilePath);
+            const actualMac = Injector.getFileLocationExecutionCommand(mac, testFilePath);
+
+            expect(actualWin).toBe(FileLocationExecutionCommandBuilder.buildWindowsLocationExecutionCommand(testFilePath));
+            expect(actualMac).toBe(FileLocationExecutionCommandBuilder.buildMacOsLocationExecutionCommand(testFilePath));
         });
     });
 
     describe(Injector.getFilePathRegExp.name, () => {
         it("should return a valid file path regexp", () => {
-            const filePathRegexp = Injector.getFilePathRegExp(platform());
-
-            expect(filePathRegexp).not.toBe(undefined);
-            expect(filePathRegexp).not.toBe(null);
-
-            let regexIsValid = true;
-
-            try {
-                const regexp = new RegExp(filePathRegexp);
-            } catch (error) {
-                regexIsValid = false;
-            }
+            const actualWin = Injector.getFilePathRegExp(win);
+            const actualMac = Injector.getFilePathRegExp(mac);
 
-            expect(regexIsValid).toBe(true);
+            expect(actualWin.source).toBe(FilePathRegex.windowsFilePathRegExp.source);
+            expect(actualMac.source).toBe(FilePathRegex.macOsFilePathRegexp.source);
         });
     });
 
     describe(Injector.getIconManager.name, () => {
-        it("should return an icon manager for the current OS", () => {
-            const iconManager = Injector.getIconManager(platform());
-
-            const actual = platform() === "win32"
-                ? iconManager instanceof WindowsIconManager
-                : iconManager instanceof MacOsIconManager;
+        it("should return an icon manager", () => {
+            const actualWin = Injector.getIconManager(win);
+            const acutalMac = Injector.getIconManager(mac);
 
-            expect(iconManager).not.toBe(undefined);
-            expect(iconManager).not.toBe(null);
-            expect(actual).toBe(true);
+            expect(actualWin instanceof WindowsIconManager).toBe(true);
+            expect(acutalMac instanceof MacOsIconManager).toBe(true);
         });
     });
 
     describe(Injector.getOpenUrlWithDefaultBrowserCommand.name, () => {
         it("should return an command to open up default browser with URL", () => {
-            const actual = Injector.getOpenUrlWithDefaultBrowserCommand(platform(), "");
-            expect(actual).not.toBe(undefined);
-            expect(actual).not.toBe(null);
-        });
-    });
+            const actualWin = Injector.getOpenUrlWithDefaultBrowserCommand(win, testUrl);
+            const acutalMac = Injector.getOpenUrlWithDefaultBrowserCommand(mac, testUrl);
 
-    describe(Injector.getOperatingSystemSettingsPlugin.name, () => {
-        it("should return an operating system settings plugin for the current OS", () => {
-            const osSystemSettingsPlugin = Injector.getOperatingSystemSettingsPlugin(platform());
-
-            const actual = platform() === "win32"
-                ? osSystemSettingsPlugin instanceof Windows10SettingsSearchPlugin
-                : osSystemSettingsPlugin instanceof MacOsSettingsPlugin;
-
-            expect(osSystemSettingsPlugin).not.toBe(undefined);
-            expect(osSystemSettingsPlugin).not.toBe(null);
-            expect(actual).toBe(true);
+            expect(actualWin).toBe(OpenUrlWithDefaultBrowserCommandBuilder.buildWindowsCommand(testUrl));
+            expect(acutalMac).toBe(OpenUrlWithDefaultBrowserCommandBuilder.buildMacCommand(testUrl));
         });
     });
 
-    describe(Injector.getProgramRepository.name, () => {
-        it("should return a program repository for the current OS", () => {
-            const programRepository = Injector.getProgramRepository(platform());
-
-            const actual = platform() === "win32"
-                ? programRepository instanceof WindowsProgramRepository
-                : programRepository instanceof MacOsProgramRepository;
+    describe(Injector.getOperatingSystemSettingsPlugin.name, () => {
+        it("should return an operating system settings search plugin", () => {
+            const actualWin = Injector.getOperatingSystemSettingsPlugin(win);
+            const actualMac = Injector.getOperatingSystemSettingsPlugin(mac);
 
-            expect(programRepository).not.toBe(undefined);
-            expect(programRepository).not.toBe(null);
-            expect(actual).toBe(true);
+            expect(actualWin instanceof Windows10SettingsSearchPlugin).toBe(true);
+            expect(actualMac instanceof MacOsSettingsPlugin).toBe(true);
         });
     });
 
     describe(Injector.getStyleSheetPath.name, () => {
         it("should return a stylesheet path", () => {
-            const styleSheetPath = Injector.getStyleSheetPath(platform());
+            const actualWin = Injector.getStyleSheetPath(win);
+            const actualMac = Injector.getStyleSheetPath(mac);
 
-            expect(styleSheetPath).not.toBe(undefined);
-            expect(styleSheetPath).not.toBe(null);
+            expect(actualWin).toBe(StylesheetPath.Windows);
+            expect(actualMac).toBe(StylesheetPath.MacOs);
         });
     });
 
     describe(Injector.getTrayIconPath.name, () => {
         it("should return a tray icon path", () => {
-            const trayIconPath = Injector.getTrayIconPath(platform(), "");
-            expect(trayIconPath).not.toBe(undefined);
-            expect(trayIconPath).not.toBe(null);
+            const actualWin = Injector.getTrayIconPath(win, testFilePath);
+            const actualMac = Injector.getTrayIconPath(mac, testFilePath);
+
+            expect(actualWin).toBe(TrayIconPathBuilder.buildWindowsTrayIconPath(testFilePath));
+            expect(actualMac).toBe(TrayIconPathBuilder.buildMacOsTrayIconPath(testFilePath));
         });
     });
 
     describe(Injector.getWebUrlRegExp.name, () => {
         it("should return a valid web url regexp", () => {
             const webUrlRegexp = Injector.getWebUrlRegExp();
+
             expect(webUrlRegexp).not.toBe(undefined);
             expect(webUrlRegexp).not.toBe(null);
 
@@ -143,4 +132,23 @@ describe(Injector.name, () => {
             expect(regexIsValid).toBe(true);
         });
     });
+
+    it(`should throw an ${OperatingSystemNotSupportedError.name} when passing in an unsupported platform`, () => {
+        const invalidPlatforms = ["linux", "gugus", "mac", "android", "ios"];
+
+        let errorCounter = 0;
+        let errorIsCorrectType = false;
+
+        for (const invalidPlatform of invalidPlatforms) {
+            try {
+                Injector.getDirectorySeparator(invalidPlatform);
+            } catch (error) {
+                errorCounter++;
+                errorIsCorrectType = error instanceof OperatingSystemNotSupportedError;
+            }
+        }
+
+        expect(errorCounter).toBe(invalidPlatforms.length);
+        expect(errorIsCorrectType).toBe(true);
+    });
 });
diff --git a/src/ts/builders/file-execution-command-builder.ts b/src/ts/builders/file-execution-command-builder.ts
@@ -0,0 +1,9 @@
+export class FileExecutionCommandBuilder {
+    public static buildWindowsFileExecutionCommand(filePath: string): string {
+        return `start "" "${filePath}"`;
+    }
+
+    public static buildMacOsFileExecutionCommand(filePath: string): string {
+        return `open "${filePath}"`;
+    }
+}
diff --git a/src/ts/builders/file-location-execution-command-builder.ts b/src/ts/builders/file-location-execution-command-builder.ts
@@ -0,0 +1,9 @@
+export class FileLocationExecutionCommandBuilder {
+    public static buildWindowsLocationExecutionCommand(filePath: string): string {
+        return `start explorer.exe /select,"${filePath}"`;
+    }
+
+    public static buildMacOsLocationExecutionCommand(filePath: string): string {
+        return `open -R "${filePath}"`;
+    }
+}
diff --git a/src/ts/builders/open-url-with-default-browser-command-builder.ts b/src/ts/builders/open-url-with-default-browser-command-builder.ts
@@ -0,0 +1,9 @@
+export class OpenUrlWithDefaultBrowserCommandBuilder {
+    public static buildWindowsCommand(url: string): string {
+        return `start "" "${url}"`;
+    }
+
+    public static buildMacCommand(url: string): string {
+        return `open "${url}"`;
+    }
+}
diff --git a/src/ts/builders/stylesheet-path-builder.ts b/src/ts/builders/stylesheet-path-builder.ts
@@ -0,0 +1,4 @@
+export enum StylesheetPath {
+    Windows = "./build/css/windows.css",
+    MacOs = "./build/css/mac.css",
+}
diff --git a/src/ts/builders/tray-icon-path-builder.ts b/src/ts/builders/tray-icon-path-builder.ts
@@ -0,0 +1,11 @@
+import { join } from "path";
+
+export class TrayIconPathBuilder {
+    public static buildWindowsTrayIconPath(pathToProjectRoot: string): string {
+        return join(pathToProjectRoot, "img/icons/win/icon.ico");
+    }
+
+    public static buildMacOsTrayIconPath(pathToProjectRoot: string): string {
+        return join(pathToProjectRoot, "img/icons/mac/ueliTemplate.png");
+    }
+}
diff --git a/src/ts/directory-separator.ts b/src/ts/directory-separator.ts
@@ -0,0 +1,4 @@
+export enum DirectorySeparator {
+    WindowsDirectorySeparator = "\\",
+    macOsDirectorySeparator = "/",
+}
diff --git a/src/ts/file-path-regex.ts b/src/ts/file-path-regex.ts
@@ -0,0 +1,4 @@
+export class FilePathRegex {
+    public static readonly windowsFilePathRegExp = /^[a-zA-Z]:\\[\\\S|*\S]?.*$/;
+    public static readonly macOsFilePathRegexp = /^\/$|(^(?=\/)|^\.|^\.\.)(\/(?=[^/\0])[^/\0]+)*\/?$/;
+}
diff --git a/src/ts/injector.ts b/src/ts/injector.ts
@@ -11,19 +11,20 @@ import { WindowsProgramRepository } from "./programs-plugin/windows-program-repo
 import { MacOsSettingsPlugin } from "./search-plugins/mac-os-settings-plugin";
 import { SearchPlugin } from "./search-plugins/search-plugin";
 import { Windows10SettingsSearchPlugin } from "./search-plugins/windows-10-settings-plugin";
+import { DirectorySeparator } from "./directory-separator";
+import { OperatingSystemNotSupportedError } from "./errors/operatingsystem-not-supported-error";
+import { FileExecutionCommandBuilder } from "./builders/file-execution-command-builder";
+import { FileLocationExecutionCommandBuilder } from "./builders/file-location-execution-command-builder";
+import { FilePathRegex } from "./file-path-regex";
+import { OpenUrlWithDefaultBrowserCommandBuilder } from "./builders/open-url-with-default-browser-command-builder";
+import { StylesheetPath } from "./builders/stylesheet-path-builder";
+import { TrayIconPathBuilder } from "./builders/tray-icon-path-builder";
 
 export class Injector {
   public static getWebUrlRegExp(): RegExp {
     return new RegExp(/^((https?:)?[/]{2})?([a-z0-9]+[.])+[a-z]+.*$/i, "gi");
   }
 
-  public static getProgramRepository(platform: string): ProgramRepository {
-    switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return new WindowsProgramRepository();
-      case OperatingSystem.macOS: return new MacOsProgramRepository();
-    }
-  }
-
   public static getIconManager(platform: string): IconManager {
     switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return new WindowsIconManager();
@@ -33,43 +34,51 @@ export class Injector {
 
   public static getOpenUrlWithDefaultBrowserCommand(platform: string, url: string): string {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return `start "" "${url}"`;
-      case OperatingSystem.macOS: return `open "${url}"`;
+      case OperatingSystem.Windows:
+        return OpenUrlWithDefaultBrowserCommandBuilder.buildWindowsCommand(url);
+      case OperatingSystem.macOS:
+        return OpenUrlWithDefaultBrowserCommandBuilder.buildMacCommand(url);
     }
   }
 
   public static getFileExecutionCommand(platform: string, filePath: string): string {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return `start "" "${filePath}"`;
-      case OperatingSystem.macOS: return `open "${filePath}"`;
+      case OperatingSystem.Windows:
+        return FileExecutionCommandBuilder.buildWindowsFileExecutionCommand(filePath);
+      case OperatingSystem.macOS:
+        return FileExecutionCommandBuilder.buildMacOsFileExecutionCommand(filePath);
     }
   }
 
   public static getFileLocationExecutionCommand(platform: string, filePath: string): string {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return `start explorer.exe /select,"${filePath}"`;
-      case OperatingSystem.macOS: return `open -R "${filePath}"`;
+      case OperatingSystem.Windows:
+        return FileLocationExecutionCommandBuilder.buildWindowsLocationExecutionCommand(filePath);
+      case OperatingSystem.macOS:
+        return FileLocationExecutionCommandBuilder.buildMacOsLocationExecutionCommand(filePath);
     }
   }
 
   public static getFilePathRegExp(platform: string): RegExp {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return new RegExp(/^[a-zA-Z]:\\[\\\S|*\S]?.*$/, "gi");
-      case OperatingSystem.macOS: return new RegExp(/^\/$|(^(?=\/)|^\.|^\.\.)(\/(?=[^/\0])[^/\0]+)*\/?$/, "gi");
+      case OperatingSystem.Windows: return new RegExp(FilePathRegex.windowsFilePathRegExp, "gi");
+      case OperatingSystem.macOS: return new RegExp(FilePathRegex.macOsFilePathRegexp, "gi");
     }
   }
 
-  public static getDirectorySeparator(platform: string): string {
+  public static getDirectorySeparator(platform: string): DirectorySeparator {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return "\\";
-      case OperatingSystem.macOS: return "/";
+      case OperatingSystem.Windows: return DirectorySeparator.WindowsDirectorySeparator;
+      case OperatingSystem.macOS: return DirectorySeparator.macOsDirectorySeparator;
     }
   }
 
   public static getTrayIconPath(platform: string, pathToProjectRoot: string): string {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return path.join(pathToProjectRoot, "img/icons/win/icon.ico");
-      case OperatingSystem.macOS: return path.join(pathToProjectRoot, "img/icons/mac/ueliTemplate.png");
+      case OperatingSystem.Windows:
+        return TrayIconPathBuilder.buildWindowsTrayIconPath(pathToProjectRoot);
+      case OperatingSystem.macOS:
+        return TrayIconPathBuilder.buildMacOsTrayIconPath(pathToProjectRoot);
     }
   }
 
@@ -82,8 +91,8 @@ export class Injector {
 
   public static getStyleSheetPath(platform: string): string {
     switch (Injector.getOperatingSystem(platform)) {
-      case OperatingSystem.Windows: return "./build/css/windows.css";
-      case OperatingSystem.macOS: return "./build/css/mac.css";
+      case OperatingSystem.Windows: return StylesheetPath.Windows;
+      case OperatingSystem.macOS: return StylesheetPath.MacOs;
     }
   }
 
@@ -93,6 +102,6 @@ export class Injector {
       case "darwin": return OperatingSystem.macOS;
     }
 
-    throw new Error("This operating system is not supported");
+    throw new OperatingSystemNotSupportedError();
   }
 }