Modified injector for better testing

oliverschwendener · Apr 20, 2018 · a124923 · a124923
1 parent 7c1621d
commit a124923
Show file tree

Hide file tree

Showing 17 changed files with 99 additions and 75 deletions.
diff --git a/src/tests/unit/execution-argument-validators/file-path-execution-argument-validator.test.ts b/src/tests/unit/execution-argument-validators/file-path-execution-argument-validator.test.ts
@@ -2,13 +2,19 @@ import { FilePathExecutionArgumentValidator } from "../../../ts/execution-argume
 import { Injector } from "../../../ts/injector";
 import { OperatingSystem } from "../../../ts/operating-system";
 import { invalidMacOsFilePaths, invalidWindowsFilePaths, validMacOsFilePaths, validWindowsFilePaths } from "../test-helpers";
+import { platform } from "os";
 
 describe(FilePathExecutionArgumentValidator.name, (): void => {
     const validator = new FilePathExecutionArgumentValidator();
 
     describe(validator.isValidForExecution.name, (): void => {
-        const validInputs = Injector.getCurrentOperatingSystem() === OperatingSystem.Windows ? validWindowsFilePaths : validMacOsFilePaths;
-        const invalidInputs = Injector.getCurrentOperatingSystem() === OperatingSystem.Windows ? invalidWindowsFilePaths : invalidMacOsFilePaths;
+        const validInputs = platform() === "win32"
+            ? validWindowsFilePaths
+            : validMacOsFilePaths;
+
+        const invalidInputs = platform() === "win32"
+            ? invalidWindowsFilePaths
+            : invalidMacOsFilePaths;
 
         it("should return true when passing in a valid argument", (): void => {
             for (const validInput of validInputs) {

diff --git a/src/tests/unit/injector.test.ts b/src/tests/unit/injector.test.ts
@@ -8,46 +8,41 @@ import { MacOsSettingsPlugin } from "../../ts/search-plugins/mac-os-settings-plu
 import { WindowsProgramRepository } from "../../ts/programs-plugin/windows-program-repository";
 import { MacOsProgramRepository } from "../../ts/programs-plugin/macos-program-repository";
 
-describe(Injector.name, () => {
-    describe(Injector.getCurrentOperatingSystem.name, () => {
-        it("should return the current operating system", () => {
-            const actual = Injector.getCurrentOperatingSystem();
-            const expected = platform() === "win32"
-                ? OperatingSystem.Windows
-                : OperatingSystem.macOS;
-
-            expect(actual).toBe(expected);
-        });
-    });
+const winPlatformString = "win32";
+const macOsPlatformString = "darwin";
 
+describe(Injector.name, () => {
     describe(Injector.getDirectorySeparator.name, () => {
         it("should return the correct directory separator", () => {
-            const actual = Injector.getDirectorySeparator();
-            const expected = platform() === "win32" ? "\\" : "/";
+            const actual = Injector.getDirectorySeparator(platform());
+
+            const expected = platform() === "win32"
+                ? "\\"
+                : "/";
 
             expect(actual).toBe(expected);
         });
     });
 
     describe(Injector.getFileExecutionCommand.name, () => {
         it("should return a file execution command", () => {
-            const actual = Injector.getFileExecutionCommand("");
+            const actual = Injector.getFileExecutionCommand(platform(), "");
             expect(actual).not.toBe(undefined);
             expect(actual).not.toBe(null);
         });
     });
 
     describe(Injector.getFileLocationExecutionCommand.name, () => {
         it("should return a file location execution command", () => {
-            const actual = Injector.getFileLocationExecutionCommand("");
+            const actual = Injector.getFileLocationExecutionCommand(platform(), "");
             expect(actual).not.toBe(undefined);
             expect(actual).not.toBe(null);
         });
     });
 
     describe(Injector.getFilePathRegExp.name, () => {
         it("should return a valid file path regexp", () => {
-            const filePathRegexp = Injector.getFilePathRegExp();
+            const filePathRegexp = Injector.getFilePathRegExp(platform());
 
             expect(filePathRegexp).not.toBe(undefined);
             expect(filePathRegexp).not.toBe(null);
@@ -66,7 +61,8 @@ describe(Injector.name, () => {
 
     describe(Injector.getIconManager.name, () => {
         it("should return an icon manager for the current OS", () => {
-            const iconManager = Injector.getIconManager();
+            const iconManager = Injector.getIconManager(platform());
+
             const actual = platform() === "win32"
                 ? iconManager instanceof WindowsIconManager
                 : iconManager instanceof MacOsIconManager;
@@ -79,15 +75,16 @@ describe(Injector.name, () => {
 
     describe(Injector.getOpenUrlWithDefaultBrowserCommand.name, () => {
         it("should return an command to open up default browser with URL", () => {
-            const actual = Injector.getOpenUrlWithDefaultBrowserCommand("");
+            const actual = Injector.getOpenUrlWithDefaultBrowserCommand(platform(), "");
             expect(actual).not.toBe(undefined);
             expect(actual).not.toBe(null);
         });
     });
 
     describe(Injector.getOperatingSystemSettingsPlugin.name, () => {
         it("should return an operating system settings plugin for the current OS", () => {
-            const osSystemSettingsPlugin = Injector.getOperatingSystemSettingsPlugin();
+            const osSystemSettingsPlugin = Injector.getOperatingSystemSettingsPlugin(platform());
+
             const actual = platform() === "win32"
                 ? osSystemSettingsPlugin instanceof Windows10SettingsSearchPlugin
                 : osSystemSettingsPlugin instanceof MacOsSettingsPlugin;
@@ -100,7 +97,8 @@ describe(Injector.name, () => {
 
     describe(Injector.getProgramRepository.name, () => {
         it("should return a program repository for the current OS", () => {
-            const programRepository = Injector.getProgramRepository();
+            const programRepository = Injector.getProgramRepository(platform());
+
             const actual = platform() === "win32"
                 ? programRepository instanceof WindowsProgramRepository
                 : programRepository instanceof MacOsProgramRepository;
@@ -113,15 +111,16 @@ describe(Injector.name, () => {
 
     describe(Injector.getStyleSheetPath.name, () => {
         it("should return a stylesheet path", () => {
-            const styleSheetPath = Injector.getStyleSheetPath();
+            const styleSheetPath = Injector.getStyleSheetPath(platform());
+
             expect(styleSheetPath).not.toBe(undefined);
             expect(styleSheetPath).not.toBe(null);
         });
     });
 
     describe(Injector.getTrayIconPath.name, () => {
         it("should return a tray icon path", () => {
-            const trayIconPath = Injector.getTrayIconPath("");
+            const trayIconPath = Injector.getTrayIconPath(platform(), "");
             expect(trayIconPath).not.toBe(undefined);
             expect(trayIconPath).not.toBe(null);
         });

diff --git a/src/tests/unit/input-validators/file-path-input-validator.test.ts b/src/tests/unit/input-validators/file-path-input-validator.test.ts
@@ -1,6 +1,7 @@
 import { Injector } from "../../../ts/injector";
 import { FilePathInputValidator } from "../../../ts/input-validators/file-path-input-validator";
 import { OperatingSystem } from "../../../ts/operating-system";
+import { platform } from "os";
 
 describe(FilePathInputValidator.name, (): void => {
     const validator = new FilePathInputValidator();
@@ -32,8 +33,13 @@ describe(FilePathInputValidator.name, (): void => {
     ];
 
     describe(validator.isValidForSearchResults.name, (): void => {
-        const validInputs = Injector.getCurrentOperatingSystem() === OperatingSystem.Windows ? validWindowsFilePaths : validMacOsFilePaths;
-        const invalidInputs = Injector.getCurrentOperatingSystem() === OperatingSystem.Windows ? invalidWindowsFilePaths : invalidMacOsFilePaths;
+        const validInputs = platform() === "win32"
+            ? validWindowsFilePaths
+            : validMacOsFilePaths;
+
+        const invalidInputs = platform() === "win32"
+            ? invalidWindowsFilePaths
+            : invalidMacOsFilePaths;
 
         it("should return true when passing in a valid argument", (): void => {
             for (const validInput of validInputs) {

diff --git a/src/ts/execution-argument-validators/file-path-execution-argument-validator.ts b/src/ts/execution-argument-validators/file-path-execution-argument-validator.ts
@@ -1,9 +1,10 @@
 import { Injector } from "../injector";
 import { ExecutionArgumentValidator } from "./execution-argument-validator";
+import { platform } from "os";
 
 export class FilePathExecutionArgumentValidator implements ExecutionArgumentValidator {
     public isValidForExecution(executionArgument: string): boolean {
-        const regex = Injector.getFilePathRegExp();
+        const regex = Injector.getFilePathRegExp(platform());
         return regex.test(executionArgument);
     }
 }
diff --git a/src/ts/execution-service.ts b/src/ts/execution-service.ts
@@ -21,6 +21,11 @@ import { ExecutionArgumentValidatorExecutorCombination } from "./execution-argum
 import { IpcChannels } from "./ipc-channels";
 import { EmailAddressInputValidator } from "./input-validators/email-address-input-validator";
 import { EmailAddressExecutionArgumentValidator } from "./execution-argument-validators/email-address-execution-argument-validator";
+import { platform } from "os";
+
+const currentOperatingSystem = platform() === "win32"
+    ? OperatingSystem.Windows
+    : OperatingSystem.macOS;
 
 export class ExecutionService {
     private validatorExecutorCombinations = [
@@ -51,7 +56,7 @@ export class ExecutionService {
     ] as ExecutionArgumentValidatorExecutorCombination[];
 
     constructor() {
-        if (Injector.getCurrentOperatingSystem() === OperatingSystem.Windows) {
+        if (currentOperatingSystem === OperatingSystem.Windows) {
             this.validatorExecutorCombinations.push(
                 {
                     executor: new WindowsSettingsExecutor(),

diff --git a/src/ts/executors/file-path-executor.ts b/src/ts/executors/file-path-executor.ts
@@ -1,10 +1,11 @@
 import * as childProcess from "child_process";
 import { Injector } from "../injector";
 import { Executor } from "./executor";
+import { platform } from "os";
 
 export class FilePathExecutor implements Executor {
     public execute(filePath: string): void {
-        const command = Injector.getFileExecutionCommand(filePath);
+        const command = Injector.getFileExecutionCommand(platform(), filePath);
         this.handleExecution(command);
     }
 
@@ -13,7 +14,7 @@ export class FilePathExecutor implements Executor {
     }
 
     public openFileLocation(filePath: string): void {
-        const command = Injector.getFileLocationExecutionCommand(filePath);
+        const command = Injector.getFileLocationExecutionCommand(platform(), filePath);
         this.handleExecution(command);
     }
 

diff --git a/src/ts/executors/web-search-executor.ts b/src/ts/executors/web-search-executor.ts
@@ -2,6 +2,7 @@ import { exec } from "child_process";
 import { Config } from "../config";
 import { Injector } from "../injector";
 import { Executor } from "./executor";
+import { platform } from "os";
 
 export class WebSearchExecutor implements Executor {
     private webSearches = Config.webSearches;
@@ -13,7 +14,7 @@ export class WebSearchExecutor implements Executor {
     public execute(executionArgument: string): void {
         for (const webSearch of this.webSearches) {
             if (executionArgument.startsWith(`${webSearch.prefix}${Config.webSearchSeparator}`)) {
-                const command = Injector.getOpenUrlWithDefaultBrowserCommand(executionArgument);
+                const command = Injector.getOpenUrlWithDefaultBrowserCommand(platform(), executionArgument);
                 exec(command, (err, stout, sterr) => {
                     if (err) {
                         throw err;

diff --git a/src/ts/executors/web-url-executor.ts b/src/ts/executors/web-url-executor.ts
@@ -1,10 +1,11 @@
 import * as childProcess from "child_process";
 import { Injector } from "../injector";
 import { Executor } from "./executor";
+import { platform } from "os";
 
 export class WebUrlExecutor implements Executor {
     public execute(url: string): void {
-        const command = Injector.getOpenUrlWithDefaultBrowserCommand(url);
+        const command = Injector.getOpenUrlWithDefaultBrowserCommand(platform(), url);
         this.handleCommandExecution(command);
     }
 

diff --git a/src/ts/helpers/file-helpers.ts b/src/ts/helpers/file-helpers.ts
@@ -54,13 +54,15 @@ export class FileHelpers {
                 // do nothing
             }
         }).filter((maybe) => maybe !== undefined) as string[];
+
         return accessibleFiles;
     }
 
     public static getFilesFromFoldersRecursively(folderPaths: string[]): string[] {
         const result = folderPaths.map((folderPath) => {
             return FileHelpers.getFilesFromFolderRecursively(folderPath);
         }).reduce((acc, files) => acc.concat(files));
+
         return result;
     }
 

diff --git a/src/ts/injector.ts b/src/ts/injector.ts
@@ -13,85 +13,86 @@ import { SearchPlugin } from "./search-plugins/search-plugin";
 import { Windows10SettingsSearchPlugin } from "./search-plugins/windows-10-settings-plugin";
 
 export class Injector {
-  public static getCurrentOperatingSystem(): OperatingSystem {
-    switch (os.platform()) {
-      case "win32": return OperatingSystem.Windows;
-      case "darwin": return OperatingSystem.macOS;
-      default: throw new Error("This operating system is not supported");
-    }
-  }
-
   public static getWebUrlRegExp(): RegExp {
     return new RegExp(/^((https?:)?[/]{2})?([a-z0-9]+[.])+[a-z]+.*$/i, "gi");
   }
 
-  public static getProgramRepository(): ProgramRepository {
-    switch (Injector.getCurrentOperatingSystem()) {
+  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(): IconManager {
-    switch (Injector.getCurrentOperatingSystem()) {
+  public static getIconManager(platform: string): IconManager {
+    switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return new WindowsIconManager();
       case OperatingSystem.macOS: return new MacOsIconManager();
     }
   }
 
-  public static getOpenUrlWithDefaultBrowserCommand(url: string): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  public static getOpenUrlWithDefaultBrowserCommand(platform: string, url: string): string {
+    switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return `start "" "${url}"`;
       case OperatingSystem.macOS: return `open "${url}"`;
     }
   }
 
-  public static getFileExecutionCommand(filePath: string): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  public static getFileExecutionCommand(platform: string, filePath: string): string {
+    switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return `start "" "${filePath}"`;
       case OperatingSystem.macOS: return `open "${filePath}"`;
     }
   }
 
-  public static getFileLocationExecutionCommand(filePath: string): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  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}"`;
     }
   }
 
-  public static getFilePathRegExp(): RegExp {
-    switch (Injector.getCurrentOperatingSystem()) {
+  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");
     }
   }
 
-  public static getDirectorySeparator(): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  public static getDirectorySeparator(platform: string): string {
+    switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return "\\";
       case OperatingSystem.macOS: return "/";
     }
   }
 
-  public static getTrayIconPath(pathToProjectRoot: string): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  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");
     }
   }
 
-  public static getOperatingSystemSettingsPlugin(): SearchPlugin {
-    switch (Injector.getCurrentOperatingSystem()) {
+  public static getOperatingSystemSettingsPlugin(platform: string): SearchPlugin {
+    switch (Injector.getOperatingSystem(platform)) {
       case OperatingSystem.Windows: return new Windows10SettingsSearchPlugin();
       case OperatingSystem.macOS: return new MacOsSettingsPlugin();
     }
   }
 
-  public static getStyleSheetPath(): string {
-    switch (Injector.getCurrentOperatingSystem()) {
+  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";
     }
   }
+
+  private static getOperatingSystem(platform: string): OperatingSystem {
+    switch (platform) {
+      case "win32": return OperatingSystem.Windows;
+      case "darwin": return OperatingSystem.macOS;
+    }
+
+    throw new Error("This operating system is not supported");
+  }
 }
diff --git a/src/ts/input-validators/file-path-input-validator.ts b/src/ts/input-validators/file-path-input-validator.ts
@@ -1,9 +1,10 @@
 import { Injector } from "../injector";
 import { InputValidator } from "./input-validator";
+import { platform } from "os";
 
 export class FilePathInputValidator implements InputValidator {
     public isValidForSearchResults(userInput: string): boolean {
-        const regex = Injector.getFilePathRegExp();
+        const regex = Injector.getFilePathRegExp(platform());
         return regex.test(userInput);
     }
 }