jasmine-core 3.0.0 → 3.1.0

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

@@ -1,202 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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);
-    });
-  });
-});