Added tests for input validation service

src/tests/unit/fake-input-validator.ts

@@ -0,0 +1,13 @@
+import { InputValidator } from "../../ts/input-validators/input-validator";
+
+export class FakeInputValidator implements InputValidator {
+    private returnValue: boolean;
+
+    constructor(returnValue: boolean) {
+        this.returnValue = returnValue;
+    }
+
+    public isValidForSearchResults(userInput: string): boolean {
+        return this.returnValue;
+    }
+}

src/tests/unit/fake-searcher.ts

@@ -0,0 +1,14 @@
+import { Searcher } from "../../ts/searcher/searcher";
+import { SearchResultItem } from "../../ts/search-result-item";
+
+export class FakeSearcher implements Searcher {
+    private searchResultItems: SearchResultItem[];
+
+    constructor(searchResultItems: SearchResultItem[]) {
+        this.searchResultItems = searchResultItems;
+    }
+
+    public getSearchResult(userInput: string): SearchResultItem[] {
+        return this.searchResultItems;
+    }
+}

src/tests/unit/input-validation-service.test.ts

@@ -0,0 +1,115 @@
+import { InputValidationService } from "../../ts/input-validation-service";
+import { InputValidatorSearcherCombination } from "../../ts/input-validator-searcher-combination";
+import { FakeSearcher } from "./fake-searcher";
+import { FakeInputValidator } from "./fake-input-validator";
+import { SearchResultItem } from "../../ts/search-result-item";
+
+describe(InputValidationService.name, (): void => {
+    describe("getSearchResults", () => {
+        it("should return an empty array if user input is an empty string, undefined or null", (): void => {
+            const userInputs = [
+                "",
+                "     ",
+                undefined,
+                null,
+            ];
+
+            const combinations = [
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 1" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(true),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 2" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 3" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+            ];
+
+            const inputValidationService = new InputValidationService(combinations);
+
+            for (const userInput of userInputs) {
+                const actual = inputValidationService.getSearchResult(userInput as string);
+                expect(actual.length).toBe(0);
+            }
+        });
+
+        it("should return an empty array when combinations are an empty array", () => {
+            const inputValidationService = new InputValidationService([]);
+            const actual = inputValidationService.getSearchResult("anything");
+            expect(actual.length).toBe(0);
+        });
+
+        it("should return an empty array if user input matches none of the searchers", (): void => {
+            const combinations = [
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 1" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 2" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 3" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+            ];
+
+            const inputValidationService = new InputValidationService(combinations);
+
+            const actual = inputValidationService.getSearchResult("something");
+
+            expect(actual.length).toBe(0);
+        });
+
+        it("should return all items if user input matches all searchers", (): void => {
+            const combinations = [
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 1" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(true),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 2" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(true),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 3" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(true),
+                },
+            ];
+            const inputValidationService = new InputValidationService(combinations);
+
+            const actual = inputValidationService.getSearchResult("something");
+
+            expect(actual.length).toBe(3);
+        });
+
+        it("should return only the items that match the user input", (): void => {
+            const combinations = [
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 1" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 2" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(true),
+                },
+                {
+                    searcher: new FakeSearcher([{ name: "Search Result 3" }] as SearchResultItem[]),
+                    validator: new FakeInputValidator(false),
+                },
+            ];
+
+            const inputValidationService = new InputValidationService(combinations);
+
+            const actual = inputValidationService.getSearchResult("something");
+
+            expect(actual.length).toBe(1);
+            expect(actual[0].name).toBe("Search Result 2");
+        });
+    });
+});

src/ts/helpers/string-helpers.ts

@@ -6,7 +6,7 @@ export class StringHelpers {
     }
 
     public static stringIsWhiteSpace(value: string): boolean {
-        if (value === undefined) {
+        if (value === undefined || value === null) {
             return true;
         }
 

src/ts/input-validation-service.ts

@@ -24,15 +24,16 @@ export class InputValidationService {
 
     public getSearchResult(userInput: string): SearchResultItem[] {
         let result = [] as SearchResultItem[];
-        userInput = StringHelpers.trimAndReplaceMultipleWhiteSpacesWithOne(userInput);
 
-        if (StringHelpers.stringIsWhiteSpace(userInput)) {
+        if (userInput === undefined || userInput === null || StringHelpers.stringIsWhiteSpace(userInput)) {
             return result;
         }
 
+        const trimmedUserInput = StringHelpers.trimAndReplaceMultipleWhiteSpacesWithOne(userInput);
+
         for (const combination of this.validatorSearcherCombinations) {
-            if (combination.validator.isValidForSearchResults(userInput)) {
-                result = result.concat(combination.searcher.getSearchResult(userInput));
+            if (combination.validator.isValidForSearchResults(trimmedUserInput)) {
+                result = result.concat(combination.searcher.getSearchResult(trimmedUserInput));
             }
         }