MACHIN

6/node_modules/jasmine-node/spec/reporter_spec.js

@@ -0,0 +1,495 @@
+var jasmineNode = require(__dirname + "/../lib/jasmine-node/reporter").jasmineNode;
+
+describe('TerminalReporter', function() {
+  beforeEach(function() {
+    var config = {}
+    this.reporter = new jasmineNode.TerminalReporter(config);
+  });
+
+  describe("initialize", function() {
+    it('initializes print_ from config', function() {
+      var config = { print: true };
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.print_).toBeTruthy();
+    });
+
+    it('initializes color_ from config', function() {
+      var config = { color: true }
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.color_).toEqual(jasmineNode.TerminalReporter.prototype.ANSIColors);
+    });
+
+    it('initializes includeStackTrace_ from config', function () {
+        var config = {}
+        this.reporter = new jasmineNode.TerminalReporter(config);
+        expect(this.reporter.includeStackTrace_).toBeTruthy();
+    });
+
+    it('sets the started_ flag to false', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.started_).toBeFalsy();
+    });
+
+    it('sets the finished_ flag to false', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.finished_).toBeFalsy();
+    });
+
+    it('initializes the suites_ array', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.suites_.length).toEqual(0);
+    });
+
+    it('initializes the specResults_ to an Object', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.specResults_).toBeDefined();
+    });
+
+    it('initializes the failures_ array', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.failures_.length).toEqual(0);
+    });
+
+    it('sets the callback_ property to false by default', function() {
+      var config = {}
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.callback_).toEqual(false)
+    });
+
+    it('sets the callback_ property to onComplete if supplied', function() {
+      var foo = function() { }
+      var config = { onComplete: foo }
+      this.reporter = new jasmineNode.TerminalReporter(config);
+      expect(this.reporter.callback_).toBe(foo)
+    });
+  });
+
+  describe('when the report runner starts', function() {
+    beforeEach(function() {
+      this.spy = spyOn(this.reporter, 'printLine_');
+
+      var runner = {
+        topLevelSuites: function() {
+          var suites = [];
+          var suite = { id: 25 };
+          suites.push(suite);
+          return suites;
+        }
+      };
+      this.reporter.reportRunnerStarting(runner);
+    });
+
+    it('sets the started_ field to true', function() {
+      expect(this.reporter.started_).toBeTruthy();
+    });
+
+    it('sets the startedAt field', function() {
+      // instanceof does not work cross-context (such as when run with requirejs)
+      var ts = Object.prototype.toString;
+      expect(ts.call(this.reporter.startedAt)).toBe(ts.call(new Date()));
+    });
+
+    it('buildes the suites_ collection', function() {
+      expect(this.reporter.suites_.length).toEqual(1);
+      expect(this.reporter.suites_[0].id).toEqual(25);
+    });
+  });
+
+  describe('the summarize_ creates suite and spec tree', function() {
+    beforeEach(function() {
+      this.spec = {
+        id: 1,
+        description: 'the spec',
+        isSuite: false
+      }
+    });
+
+    it('creates a summary object from spec', function() {
+      var result = this.reporter.summarize_(this.spec);
+
+      expect(result.id).toEqual(1);
+      expect(result.name).toEqual('the spec');
+      expect(result.type).toEqual('spec');
+      expect(result.children.length).toEqual(0);
+    });
+
+    it('creates a summary object from suite with 1 spec', function() {
+      var env = { nextSuiteId: false }
+      var suite = new jasmine.Suite(env, 'suite name', undefined, undefined);
+      suite.description = 'the suite';
+      suite.parentSuite = null;
+      suite.children_.push(this.spec);
+
+      var result = this.reporter.summarize_(suite);
+      expect(result.name).toEqual('the suite');
+      expect(result.type).toEqual('suite');
+      expect(result.children.length).toEqual(1);
+
+      var suiteChildSpec = result.children[0];
+      expect(suiteChildSpec.id).toEqual(1);
+    });
+  });
+
+  describe('reportRunnerResults', function() {
+    beforeEach(function() {
+      this.printLineSpy = spyOn(this.reporter, 'printLine_');
+    });
+
+    it('generates the report', function() {
+      var failuresSpy = spyOn(this.reporter, 'reportFailures_');
+      var printRunnerResultsSpy = spyOn(this.reporter, 'printRunnerResults_').
+                          andReturn('this is the runner result');
+
+      var callbackSpy = spyOn(this.reporter, 'callback_');
+
+      var runner = {
+        results: function() {
+          var result = { failedCount: 0 };
+          return result;
+        },
+        specs: function() { return []; }
+      };
+      this.reporter.startedAt = new Date();
+
+      this.reporter.reportRunnerResults(runner);
+
+      expect(failuresSpy).toHaveBeenCalled();
+      expect(this.printLineSpy).toHaveBeenCalled();
+      expect(callbackSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('reportSpecResults', function() {
+    beforeEach(function() {
+      this.printSpy = spyOn(this.reporter, 'print_');
+      this.spec = {
+        id: 1,
+        description: 'the spec',
+        isSuite: false,
+        results: function() {
+          var result = {
+            passed: function() { return true; }
+          }
+          return result;
+        }
+      }
+    });
+
+    it('prints a \'.\' for pass', function() {
+      this.reporter.reportSpecResults(this.spec);
+      expect(this.printSpy).toHaveBeenCalledWith('.');
+    });
+
+    it('prints an \'F\' for failure', function() {
+      var addFailureToFailuresSpy = spyOn(this.reporter, 'addFailureToFailures_');
+      var results = function() {
+        var result = {
+          passed: function() { return false; }
+        }
+        return result;
+      }
+      this.spec.results = results;
+
+      this.reporter.reportSpecResults(this.spec);
+
+      expect(this.printSpy).toHaveBeenCalledWith('F');
+      expect(addFailureToFailuresSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('addFailureToFailures', function() {
+    it('adds message and stackTrace to failures_', function() {
+      var spec = {
+        suite: {
+          getFullName: function() { return 'Suite name' }
+        },
+        description: 'the spec',
+        results: function() {
+          var result = {
+            items_: function() {
+              var theItems = new Array();
+              var item = {
+                passed_: false,
+                message: 'the message',
+                trace: {
+                  stack: 'the stack'
+                }
+              }
+              theItems.push(item);
+              return theItems;
+            }.call()
+          };
+          return result;
+        }
+      };
+
+      this.reporter.addFailureToFailures_(spec);
+
+      var failures = this.reporter.failures_;
+      expect(failures.length).toEqual(1);
+      var failure = failures[0];
+      expect(failure.spec).toEqual('Suite name the spec');
+      expect(failure.message).toEqual('the message');
+      expect(failure.stackTrace).toEqual('the stack');
+    });
+  });
+
+  describe('prints the runner results', function() {
+    beforeEach(function() {
+      this.runner = {
+        results: function() {
+          var _results = {
+            totalCount: 23,
+            failedCount: 52
+          };
+          return _results;
+        },
+        specs: function() {
+          var _specs = new Array();
+          spec = {
+            results: function() {
+              var _results = {
+                skipped: false
+              }
+              return _results;
+            }
+          };
+          _specs.push(spec);
+          return _specs;
+        }
+      };
+    });
+
+    it('uses the specs\'s length, totalCount and failedCount', function() {
+      var message = this.reporter.printRunnerResults_(this.runner);
+      expect(message).toEqual('1 test, 23 assertions, 52 failures, 0 skipped\n');
+    });
+  });
+
+  describe('reports failures', function() {
+    beforeEach(function() {
+      this.printSpy = spyOn(this.reporter, 'print_');
+      this.printLineSpy = spyOn(this.reporter, 'printLine_');
+    });
+
+    it('does not report anything when there are no failures', function() {
+      this.reporter.failures_ = new Array();
+
+      this.reporter.reportFailures_();
+
+      expect(this.printLineSpy).not.toHaveBeenCalled();
+    });
+
+    it('prints the failures', function() {
+      var failure = {
+        spec: 'the spec',
+        message: 'the message',
+        stackTrace: 'the stackTrace'
+      }
+
+      this.reporter.failures_ = new Array();
+      this.reporter.failures_.push(failure);
+
+      this.reporter.reportFailures_();
+
+      var generatedOutput =
+                 [ [ '\n' ],
+                 [ '\n' ],
+                 [ '  1) the spec' ],
+                 [ '   Message:' ],
+                 [ '     the message' ],
+                 [ '   Stacktrace:' ] ];
+
+      expect(this.printLineSpy).toHaveBeenCalled();
+      expect(this.printLineSpy.argsForCall).toEqual(generatedOutput);
+
+      expect(this.printSpy).toHaveBeenCalled();
+      expect(this.printSpy.argsForCall[0]).toEqual(['Failures:']);
+      expect(this.printSpy.argsForCall[1]).toEqual(['     the stackTrace']);
+    });
+
+    it('prints the failures without a Stacktrace', function () {
+        var config = { includeStackTrace: false };
+        this.reporter = new jasmineNode.TerminalReporter(config);
+        this.printSpy = spyOn(this.reporter, 'print_');
+        this.printLineSpy = spyOn(this.reporter, 'printLine_');
+
+        var failure = {
+            spec: 'the spec',
+            message: 'the message',
+            stackTrace: 'the stackTrace'
+        }
+
+        this.reporter.failures_ = new Array();
+        this.reporter.failures_.push(failure);
+
+        this.reporter.reportFailures_();
+
+        var generatedOutput =
+                 [ [ '\n' ],
+                 [ '\n' ],
+                 [ '  1) the spec' ],
+                 [ '   Message:' ],
+                 [ '     the message' ] ];
+
+        expect(this.printLineSpy).toHaveBeenCalled();
+        expect(this.printLineSpy.argsForCall).toEqual(generatedOutput);
+
+        expect(this.printSpy).toHaveBeenCalled();
+        expect(this.printSpy.argsForCall[0]).toEqual(['Failures:']);
+        expect(this.printSpy.argsForCall[1]).toBeUndefined();
+    });
+  });
+});
+
+describe('TerminalVerboseReporter', function() {
+  beforeEach(function() {
+    var config = {}
+    this.verboseReporter = new jasmineNode.TerminalVerboseReporter(config);
+    this.addFailureToFailuresSpy = spyOn(this.verboseReporter, 'addFailureToFailures_');
+    this.spec = {
+      id: 23,
+      results: function() {
+        return {
+          failedCount: 1,
+          getItems: function() {
+            return ["this is the message"];
+          }
+        }
+      }
+    };
+  });
+
+  describe('#reportSpecResults', function() {
+    it('adds the spec to the failures_', function() {
+      this.verboseReporter.reportSpecResults(this.spec);
+
+      expect(this.addFailureToFailuresSpy).toHaveBeenCalledWith(this.spec);
+    });
+
+    it('adds a new object to the specResults_', function() {
+      this.verboseReporter.reportSpecResults(this.spec);
+
+      expect(this.verboseReporter.specResults_[23].messages).toEqual(['this is the message']);
+      expect(this.verboseReporter.specResults_[23].result).toEqual('failed');
+    });
+  });
+
+  describe('#buildMessagesFromResults_', function() {
+    beforeEach(function() {
+      this.suite = {
+        id: 17,
+        type: 'suite',
+        name: 'a describe block',
+        suiteNestingLevel: 0,
+        children: [],
+        getFullName: function() { return "A spec"; },
+      };
+
+      this.spec = {
+        id: 23,
+        type: 'spec',
+        name: 'a spec block',
+        children: []
+      };
+
+      this.verboseReporter.specResults_['23'] = {
+        result: 'passed',
+        runtime: 200
+      };
+
+      this.verboseReporter.suiteResults_['17'] = {
+        runtime: 500
+      };
+
+    });
+
+    it('does not build anything when the results collection is empty', function() {
+      var results = [],
+          messages = [];
+
+      this.verboseReporter.buildMessagesFromResults_(messages, results);
+
+      expect(messages.length).toEqual(0);
+    });
+
+    it('adds a single suite to the messages', function() {
+      var results = [],
+          messages = [];
+
+      results.push(this.suite);
+
+      this.verboseReporter.buildMessagesFromResults_(messages, results);
+
+      expect(messages.length).toEqual(2);
+      expect(messages[0]).toEqual('');
+      expect(messages[1]).toEqual('a describe block - 500 ms');
+    });
+
+    it('adds a single spec with success to the messages', function() {
+      var results = [],
+          messages = [];
+
+      this.passSpy = spyOn(this.verboseReporter.color_, 'pass');
+
+      results.push(this.spec);
+
+      this.verboseReporter.buildMessagesFromResults_(messages, results);
+
+      expect(this.passSpy).toHaveBeenCalled();
+      expect(messages.length).toEqual(1);
+      expect(messages[0]).toEqual('a spec block - 200 ms');
+    });
+
+    it('adds a single spec with failure to the messages', function() {
+      var results = [],
+          messages = [];
+
+      this.verboseReporter.specResults_['23'].result = 'failed';
+
+      this.passSpy = spyOn(this.verboseReporter.color_, 'pass');
+      this.failSpy = spyOn(this.verboseReporter.color_, 'fail');
+
+      results.push(this.spec);
+
+      this.verboseReporter.buildMessagesFromResults_(messages, results);
+
+      expect(this.failSpy).toHaveBeenCalled();
+      expect(this.passSpy).not.toHaveBeenCalled();
+    });
+
+    it('adds a suite, a suite and a single spec with success to the messages', function() {
+      var results = [],
+          messages = [];
+
+      var subSuite = new Object();
+      subSuite.id = '29';
+      subSuite.type = 'suite';
+      subSuite.name = 'a sub describe block';
+      subSuite.suiteNestingLevel = 1;
+      subSuite.children = [];
+      subSuite.children.push(this.spec);
+
+      this.suite.children.push(subSuite);
+      results.push(this.suite);
+
+      this.verboseReporter.suiteResults_['29'] = {
+        runtime: 350
+      };
+
+      this.verboseReporter.buildMessagesFromResults_(messages, results);
+
+      expect(messages.length).toEqual(5);
+      expect(messages[0]).toEqual('');
+      expect(messages[1]).toEqual('a describe block - 500 ms');
+      expect(messages[2]).toEqual('');
+      expect(messages[3]).toEqual('    a sub describe block - 350 ms');
+      expect(messages[4]).toEqual('        a spec block - 200 ms');
+    });
+  });
+});