jasmine-core 2.99.2 → 3.0.0

data/lib/jasmine-core/spec/core/SpyStrategySpec.js

@@ -0,0 +1,202 @@
+describe("SpyStrategy", function() {
+
+  it("defaults its name to unknown", function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy();
+
+    expect(spyStrategy.identity).toEqual("unknown");
+  });
+
+  it("takes a name", function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({name: "foo"});
+
+    expect(spyStrategy.identity).toEqual("foo");
+  });
+
+  it("stubs an original function, if provided", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+
+    spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows an original function to be called, passed through the params and returns it's value", function() {
+    var originalFn = jasmine.createSpy("original").and.returnValue(42),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callThrough();
+    returnValue = spyStrategy.exec(null, ["foo"]);
+
+    expect(originalFn).toHaveBeenCalled();
+    expect(originalFn.calls.mostRecent().args).toEqual(["foo"]);
+    expect(returnValue).toEqual(42);
+  });
+
+  it("can return a specified value when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.returnValue(17);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(17);
+  });
+
+  it("can return specified values in order specified when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+
+    spyStrategy.returnValues('value1', 'value2', 'value3');
+
+    expect(spyStrategy.exec()).toEqual('value1');
+    expect(spyStrategy.exec()).toEqual('value2');
+    expect(spyStrategy.exec()).toBe('value3');
+    expect(spyStrategy.exec()).toBeUndefined();
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows an exception to be thrown when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+
+    spyStrategy.throwError(new TypeError("bar"));
+
+    expect(function() { spyStrategy.exec(); }).toThrowError(TypeError, "bar");
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows a non-Error to be thrown, wrapping it into an exception when executed", function() {
+    var originalFn = jasmine.createSpy("original"),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+
+    spyStrategy.throwError("bar");
+
+    expect(function() { spyStrategy.exec(); }).toThrowError(Error, "bar");
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
+  it("allows a fake function to be called instead", function() {
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+  });
+
+  it("allows a fake async function to be called instead", function(done) {
+    jasmine.getEnv().requireAsyncAwait();
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.callFake(eval("async () => { return 67; }")),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    spyStrategy.exec().then(function (returnValue) {
+      expect(originalFn).not.toHaveBeenCalled();
+      expect(fakeFn).toHaveBeenCalled();
+      expect(returnValue).toEqual(67);
+      done();
+    }).catch(function (err) {
+      done.fail(err);
+    })
+  });
+
+  it("allows a custom strategy to be used", function() {
+    var plan = jasmine.createSpy('custom strategy')
+        .and.returnValue('custom strategy result'),
+      customStrategy = jasmine.createSpy('custom strategy')
+        .and.returnValue(plan),
+      originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: customStrategy
+        }
+      });
+
+    spyStrategy.doSomething(1, 2, 3);
+    expect(customStrategy).toHaveBeenCalledWith(1, 2, 3);
+    expect(spyStrategy.exec(null, ['some', 'args']))
+      .toEqual('custom strategy result');
+    expect(plan).toHaveBeenCalledWith('some', 'args');
+  });
+
+  it("throws an error if a custom strategy doesn't return a function", function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: function() { return 'not a function' }
+        }
+      });
+
+    expect(function() { spyStrategy.doSomething(1, 2, 3) }).toThrowError('Spy strategy must return a function');
+  });
+
+  it("does not allow custom strategies to overwrite existing methods", function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: function() {},
+        customStrategies: {
+          exec: function() {}
+        }
+       });
+
+    expect(spyStrategy.exec).toBe(jasmineUnderTest.SpyStrategy.prototype.exec);
+  });
+
+  it('throws an error when a non-function is passed to callFake strategy', function() {
+    var originalFn = jasmine.createSpy('original'),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        invalidFakes = [5, 'foo', {}, true, false, null, void 0, new Date(), /.*/];
+
+    spyOn(jasmineUnderTest, 'isFunction_').and.returnValue(false);
+    spyOn(jasmineUnderTest, 'isAsyncFunction_').and.returnValue(false);
+
+    expect(function () {
+      spyStrategy.callFake(function() {});
+    }).toThrowError(/^Argument passed to callFake should be a function, got/);
+
+    expect(function () {
+      spyStrategy.callFake(function() {});
+    }).toThrowError(/^Argument passed to callFake should be a function, got/);
+  });
+
+  it("allows a return to plan stubbing after another strategy", function() {
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    returnValue = spyStrategy.exec();
+
+    expect(originalFn).not.toHaveBeenCalled();
+    expect(returnValue).toEqual(67);
+
+    spyStrategy.stub();
+    returnValue = spyStrategy.exec();
+
+    expect(returnValue).toEqual(void 0);
+  });
+
+  it("returns the spy after changing the strategy", function(){
+    var spy = {},
+        spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({getSpy: spyFn});
+
+    expect(spyStrategy.callThrough()).toBe(spy);
+    expect(spyStrategy.returnValue()).toBe(spy);
+    expect(spyStrategy.throwError()).toBe(spy);
+    expect(spyStrategy.callFake(function() {})).toBe(spy);
+    expect(spyStrategy.stub()).toBe(spy);
+  });
+});

data/lib/jasmine-core/spec/core/StackTraceSpec.js

@@ -0,0 +1,166 @@
+describe("StackTrace", function() {
+  it("understands Chrome/IE/Edge style traces", function() {
+    var raw = 
+      'Error: nope\n' +
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+
+    var result = new jasmineUnderTest.StackTrace(raw);
+
+    expect(result.message).toEqual('Error: nope');
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  it("understands Node style traces", function() {
+    var raw = 'Error\n' +
+      '  at /somewhere/jasmine/lib/jasmine-core/jasmine.js:4255:9\n' +
+      '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)\n' +
+      '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)\n' +
+      '  at runCallback (timers.js:672:20)';
+    var result = new jasmineUnderTest.StackTrace(raw);
+
+    expect(result.message).toEqual('Error');
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '  at /somewhere/jasmine/lib/jasmine-core/jasmine.js:4255:9',
+        func: undefined,
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 4255
+      },
+      {
+        raw: '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)',
+        func: 'QueueRunner.complete [as onComplete]',
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 579
+      },
+      {
+        raw: '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)',
+        func: 'Immediate.<anonymous>',
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 4314
+      },
+      {
+        raw: '  at runCallback (timers.js:672:20)',
+        func: 'runCallback',
+        file: 'timers.js',
+        line: 672
+      }
+    ]);
+  });
+
+  it("understands Safari/Firefox/Phantom-OS X style traces", function() {
+    var raw = 
+      'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+      'run@http://localhost:8888/__jasmine__/jasmine.js:4320:27';
+    var result = new jasmineUnderTest.StackTrace(raw);
+
+    expect(result.message).toBeFalsy();
+    expect(result.style).toEqual('webkit');
+    expect(result.frames).toEqual([
+      {
+        raw: 'http://localhost:8888/__spec__/core/UtilSpec.js:115:28',
+        func: undefined,
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: 'run@http://localhost:8888/__jasmine__/jasmine.js:4320:27',
+        func: 'run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  it("does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces", function() {
+    var raw = 'randomcharsnotincludingwhitespace';
+    var result = new jasmineUnderTest.StackTrace(raw);
+    expect(result.style).toBeNull();
+    expect(result.frames).toEqual([
+      { raw: raw }
+    ]);
+  });
+
+  it("understands Phantom-Linux style traces", function() {
+    var raw = 
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+
+    var result = new jasmineUnderTest.StackTrace(raw);
+
+    expect(result.message).toBeFalsy();
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  it("ignores blank lines", function() {
+    var raw = 
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n';
+
+    var result = new jasmineUnderTest.StackTrace(raw);
+
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      }
+    ]);
+  });
+
+  it("omits properties except 'raw' for frames that are not understood", function() {
+    var raw = 
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+      '    but this is quite unexpected\n' +
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+
+    var result = new jasmineUnderTest.StackTrace(raw);
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    but this is quite unexpected'
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+});

data/lib/jasmine-core/spec/core/SuiteSpec.js

@@ -0,0 +1,123 @@
+describe("Suite", function() {
+
+  it("keeps its id", function() {
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
+        env: env,
+        id: 456,
+        description: "I am a suite"
+      });
+
+    expect(suite.id).toEqual(456);
+  });
+
+  it("returns blank full name for top level suite", function() {
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
+        env: env,
+        description: "I am a suite"
+      });
+
+    expect(suite.getFullName()).toEqual("");
+  });
+
+  it("returns its full name when it has parent suites", function() {
+    var env = new jasmineUnderTest.Env(),
+      parentSuite = new jasmineUnderTest.Suite({
+        env: env,
+        description: "I am a parent suite",
+        parentSuite: jasmine.createSpy('pretend top level suite')
+      }),
+      suite = new jasmineUnderTest.Suite({
+        env: env,
+        description: "I am a suite",
+        parentSuite: parentSuite
+      });
+
+    expect(suite.getFullName()).toEqual("I am a parent suite I am a suite");
+  });
+
+  it("adds before functions in order of needed execution", function() {
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerBefore = jasmine.createSpy('outerBeforeEach'),
+      innerBefore = jasmine.createSpy('insideBeforeEach');
+
+    suite.beforeEach(outerBefore);
+    suite.beforeEach(innerBefore);
+
+    expect(suite.beforeFns).toEqual([innerBefore, outerBefore]);
+  });
+
+  it("adds after functions in order of needed execution", function() {
+    var env = new jasmineUnderTest.Env(),
+      suite = new jasmineUnderTest.Suite({
+        env: env,
+        description: "I am a suite"
+      }),
+      outerAfter = jasmine.createSpy('outerAfterEach'),
+      innerAfter = jasmine.createSpy('insideAfterEach');
+
+    suite.afterEach(outerAfter);
+    suite.afterEach(innerAfter);
+
+    expect(suite.afterFns).toEqual([innerAfter, outerAfter]);
+  });
+
+  it('has a status of failed if any expectations have failed', function() {
+    var suite = new jasmineUnderTest.Suite({
+      expectationResultFactory: function() { return 'hi'; }
+    });
+
+    suite.addExpectationResult(false);
+    expect(suite.status()).toBe('failed');
+  });
+
+  it("retrieves a result with updated status", function() {
+    var suite = new jasmineUnderTest.Suite({});
+
+    expect(suite.getResult().status).toBe('passed');
+  });
+
+  it("retrieves a result with pending status", function() {
+    var suite = new jasmineUnderTest.Suite({});
+    suite.pend();
+
+    expect(suite.getResult().status).toBe('pending');
+  });
+
+  it("throws an ExpectationFailed when receiving a failed expectation when throwOnExpectationFailure is set", function() {
+    var suite = new jasmineUnderTest.Suite({
+      expectationResultFactory: function(data) { return data; },
+      throwOnExpectationFailure: true
+    });
+
+    expect(function() {
+      suite.addExpectationResult(false, 'failed');
+    }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
+
+    expect(suite.status()).toBe('failed');
+    expect(suite.result.failedExpectations).toEqual(['failed']);
+  });
+
+  it("does not add an additional failure when an expectation fails", function(){
+    var suite = new jasmineUnderTest.Suite({});
+
+    suite.onException(new jasmineUnderTest.errors.ExpectationFailed());
+
+    expect(suite.getResult().failedExpectations).toEqual([]);
+  });
+
+  describe('#sharedUserContext', function() {
+    beforeEach(function() {
+      this.suite = new jasmineUnderTest.Suite({});
+    });
+
+    it('returns a UserContext', function() {
+      expect(this.suite.sharedUserContext().constructor).toBe(jasmineUnderTest.UserContext);
+    });
+  });
+});