Merge pull request #150 from jamesrichford/cli-runner-tests

Cli runner tests
alsatian-test · Sep 14, 2016 · 5ffe96d · 5ffe96d
2 parents 9680618 + 7e0328d
commit 5ffe96d
Show file tree

Hide file tree

Showing 3 changed files with 198 additions and 51 deletions.
diff --git a/cli/alsatian-cli.ts b/cli/alsatian-cli.ts
@@ -11,6 +11,9 @@ let userArguments = new AlsatianCliOptions(process.argv.slice(2));
 let testSet = createTestSet();
 testSet.addTestsFromFiles(userArguments.fileGlobs);
 
+// create alsatian test runner
+let testRunner = new TestRunner();
+
 // run the test set
-let testRunner = new CliTestRunner();
-testRunner.run(testSet, userArguments.timeout);
+let cliTestRunner = new CliTestRunner(testRunner);
+cliTestRunner.run(testSet, userArguments.timeout);
diff --git a/cli/cli-test-runner.ts b/cli/cli-test-runner.ts
@@ -2,7 +2,11 @@ import { TestRunner, TestSet, TestSetResults, TestOutcome } from "../core/alsati
 
 export class CliTestRunner {
 
-   private _testRunner = new TestRunner();
+   public constructor(private _testRunner: TestRunner) {
+      if (!_testRunner) {
+         throw new TypeError("_testRunner must not be null or undefined.");
+      }
+   }
 
    public run(testSet: TestSet, timeout?: number) {
 
@@ -16,11 +20,16 @@ export class CliTestRunner {
             else {
                process.exit(0);
             }
-         });
+         })
+         .catch(this._handleTestSetRunError);
       }
       catch (error) {
-         process.stderr.write(error.message + "\n");
-         process.exit(1);
+         this._handleTestSetRunError(error);
       }
    }
+
+   private _handleTestSetRunError(error: Error)  {
+      process.stderr.write(error.message + "\n");
+      process.exit(1);
+   }
 }
diff --git a/test/unit-tests/cli/cli-test-runner.spec.ts b/test/unit-tests/cli/cli-test-runner.spec.ts
@@ -2,7 +2,7 @@ import { CliTestRunner } from "../../../cli/cli-test-runner";
 import { TestFixtureBuilder } from "../../builders/test-fixture-builder";
 import { TestBuilder } from "../../builders/test-builder";
 import { TestCaseBuilder } from "../../builders/test-case-builder";
-import { Expect, AsyncTest, TestCase, SpyOn, Setup, Teardown, TestSet } from "../../../core/alsatian-core";
+import { Expect, AsyncTest, TestCase, SpyOn, Setup, Teardown, TestSet, TestOutcome, TestRunner } from "../../../core/alsatian-core";
 import { Promise } from "../../../promise/promise";
 
 export class CliTestRunnerTests {
@@ -29,6 +29,12 @@ export class CliTestRunnerTests {
       process.stderr.write = this._originalStdErr;
    }
 
+   @TestCase(null)
+   @TestCase(undefined)
+   public nullOrUndefinedTestRunnerThrowsError(testRunner: TestRunner) {
+      Expect(() => new CliTestRunner(testRunner)).toThrowError(TypeError, "_testRunner must not be null or undefined.");
+   }
+
    @AsyncTest()
    public noTestFixturesExitsWithError() {
       let testSet = <TestSet>{};
@@ -37,7 +43,7 @@ export class CliTestRunnerTests {
 
          (<any>testSet).testFixtures = [ ];
 
-         let cliTestRunner = new CliTestRunner();
+         let cliTestRunner = new CliTestRunner(new TestRunner());
 
          cliTestRunner.run(testSet);
 
@@ -61,7 +67,7 @@ export class CliTestRunnerTests {
 
          (<any>testSet).testFixtures = [ ];
 
-         let cliTestRunner = new CliTestRunner();
+         let cliTestRunner = new CliTestRunner(new TestRunner());
 
          cliTestRunner.run(testSet);
 
@@ -88,48 +94,177 @@ export class CliTestRunnerTests {
             .addTest(new TestBuilder().addTestCase(new TestCaseBuilder().build()).build())
             .build() ];
 
-            let cliTestRunner = new CliTestRunner();
+         let cliTestRunner = new CliTestRunner(new TestRunner());
+
+         cliTestRunner.run(testSet);
+
+         setTimeout(() => {
+            try {
+               Expect(process.exit).not.toHaveBeenCalledWith(1);
+               resolve();
+            }
+            catch (error) {
+               console.log((process.exit as any).calls);
+               reject(error);
+            }
+         });
+      });
+   }
+
+   @AsyncTest()
+   public oneErroringTestFixturesExitsWithError() {
+      let testSet = <TestSet>{};
+
+      return new Promise<void>((resolve, reject) => {
+
+         (<any>testSet).testFixtures = [
+            new TestFixtureBuilder()
+            .withFixture({ "erroringTest": () => { throw new Error(); } })
+            .addTest(new TestBuilder().withKey("erroringTest").build())
+            .build() ];
+
+         let cliTestRunner = new CliTestRunner(new TestRunner());
+
+         cliTestRunner.run(testSet);
+
+         setTimeout(() => {
+            try {
+               Expect(process.exit).toHaveBeenCalledWith(1);
+               resolve();
+            }
+            catch (error) {
+               reject(error);
+            }
+         });
+      });
+   }
+
+   @TestCase(TestOutcome.Error)
+   @TestCase(TestOutcome.Fail)
+   @AsyncTest()
+   public failingResultsOutcomeExitsWithError(outcome: TestOutcome) {
+      let testSet = <TestSet>{};
+
+      let testRunner = new TestRunner();
+      let testRunnerResolve: (resolvedValue: any) => any;
+
+      let testRunnerSpy = SpyOn(testRunner, "run");
+
+      testRunnerSpy.andReturn(new Promise((resolve, reject) => {
+         testRunnerResolve = resolve;
+      }));
+
+      testRunnerSpy.andStub();
+
+      return new Promise<void>((resolve, reject) => {
+
+         let cliTestRunner = new CliTestRunner(testRunner);
+
+         cliTestRunner.run(testSet);
+
+         testRunnerResolve({ outcome: outcome });
+
+         setTimeout(() => {
+            try {
+               Expect(process.exit).toHaveBeenCalledWith(1);
+               resolve();
+            }
+            catch (error) {
+               reject(error);
+            }
+         });
+      });
+   }
+
+   @AsyncTest()
+   public runThrowsErrorExitsWithError(outcome: TestOutcome) {
+      let testSet = <TestSet>{};
+
+      let testRunner = new TestRunner();
+
+      SpyOn(testRunner, "run").andCall(() => { throw new Error(); });
+
+      return new Promise<void>((resolve, reject) => {
+
+         let cliTestRunner = new CliTestRunner(testRunner);
+
+         cliTestRunner.run(testSet);
+
+         setTimeout(() => {
+            try {
+               Expect(process.exit).toHaveBeenCalledWith(1);
+               resolve();
+            }
+            catch (error) {
+               reject(error);
+            }
+         });
+      });
+   }
+
+   @TestCase("something bad")
+   @TestCase("another even worse thing")
+   @TestCase("awfully terrible")
+   @AsyncTest()
+   public runThrowsErrorOutputsErrorMessage(errorMessage: string) {
+      let testSet = <TestSet>{};
+
+      let testRunner = new TestRunner();
+
+      SpyOn(testRunner, "run").andCall(() => { throw new Error(errorMessage); });
+
+      return new Promise<void>((resolve, reject) => {
+
+         let cliTestRunner = new CliTestRunner(testRunner);
+
+         cliTestRunner.run(testSet);
+
+         setTimeout(() => {
+            try {
+               Expect(process.stderr.write).toHaveBeenCalledWith(errorMessage + "\n");
+               resolve();
+            }
+            catch (error) {
+               reject(error);
+            }
+         });
+      });
+   }
+
+   @TestCase(TestOutcome.Skip)
+   @TestCase(TestOutcome.Pass)
+   @AsyncTest()
+   public passingResultsOutcomeExitsWithNoError(outcome: TestOutcome) {
+      let testSet = <TestSet>{};
+
+      let testRunner = new TestRunner();
+      let testRunnerResolve: (resolvedValue: any) => any;
+
+      let testRunnerSpy = SpyOn(testRunner, "run");
 
-            cliTestRunner.run(testSet);
+      testRunnerSpy.andReturn(new Promise((resolve, reject) => {
+         testRunnerResolve = resolve;
+      }));
 
-            setTimeout(() => {
-               try {
-                  Expect(process.exit).not.toHaveBeenCalledWith(1);
-                  resolve();
-               }
-               catch (error) {
-                  console.log((process.exit as any).calls);
-                  reject(error);
-               }
-            });
+      testRunnerSpy.andStub();
+
+      return new Promise<void>((resolve, reject) => {
+
+         let cliTestRunner = new CliTestRunner(testRunner);
+
+         cliTestRunner.run(testSet);
+
+         testRunnerResolve({ outcome: outcome });
+
+         setTimeout(() => {
+            try {
+               Expect(process.exit).toHaveBeenCalledWith(0);
+               resolve();
+            }
+            catch (error) {
+               reject(error);
+            }
          });
-      }
-
-      @AsyncTest()
-      public oneErroringTestFixturesExitsWithError() {
-         let testSet = <TestSet>{};
-
-         return new Promise<void>((resolve, reject) => {
-
-            (<any>testSet).testFixtures = [
-               new TestFixtureBuilder()
-               .withFixture({ "erroringTest": () => { throw new Error(); } })
-               .addTest(new TestBuilder().withKey("erroringTest").build())
-               .build() ];
-
-               let cliTestRunner = new CliTestRunner();
-
-               cliTestRunner.run(testSet);
-
-               setTimeout(() => {
-                  try {
-                     Expect(process.exit).toHaveBeenCalledWith(1);
-                     resolve();
-                  }
-                  catch (error) {
-                     reject(error);
-                  }
-               });
-            });
-         }
-      }
+      });
+   }
+}