jasmine-core 2.9.0 → 2.99.2

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

@@ -1,270 +0,0 @@
-describe("DelayedFunctionScheduler", function() {
-  it("schedules a function for later execution", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn');
-
-    scheduler.scheduleFunction(fn, 0);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(0);
-
-    expect(fn).toHaveBeenCalled();
-  });
-
-  it("schedules a string for later execution", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      strfn = "horrible = true;";
-
-    scheduler.scheduleFunction(strfn, 0);
-
-    scheduler.tick(0);
-
-    expect(horrible).toEqual(true);
-  });
-
-  it("#tick defaults to 0", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn');
-
-    scheduler.scheduleFunction(fn, 0);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick();
-
-    expect(fn).toHaveBeenCalled();
-  });
-
-  it("defaults delay to 0", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn');
-
-    scheduler.scheduleFunction(fn);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(0);
-
-    expect(fn).toHaveBeenCalled();
-  });
-
-  it("optionally passes params to scheduled functions", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn');
-
-    scheduler.scheduleFunction(fn, 0, ['foo', 'bar']);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(0);
-
-    expect(fn).toHaveBeenCalledWith('foo', 'bar');
-  });
-
-  it("scheduled fns can optionally reoccur", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn');
-
-    scheduler.scheduleFunction(fn, 20, [], true);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(20);
-
-    expect(fn.calls.count()).toBe(1);
-
-    scheduler.tick(40);
-
-    expect(fn.calls.count()).toBe(3);
-
-    scheduler.tick(21);
-
-    expect(fn.calls.count()).toBe(4);
-
-  });
-
-  it("increments scheduled fns ids unless one is passed", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
-
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(1);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(2);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0, [], false, 123)).toBe(123);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(3);
-  });
-
-  it("#removeFunctionWithId removes a previously scheduled function with a given id", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      timeoutKey;
-
-    timeoutKey = scheduler.scheduleFunction(fn, 0);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.removeFunctionWithId(timeoutKey);
-
-    scheduler.tick(0);
-
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it("executes recurring functions interleaved with regular functions in the correct order", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      recurringCallCount = 0,
-      recurring = jasmine.createSpy('recurring').and.callFake(function() {
-        recurringCallCount++;
-        if (recurringCallCount < 5) {
-          expect(fn).not.toHaveBeenCalled();
-        }
-      });
-
-    scheduler.scheduleFunction(recurring, 10, [], true);
-    scheduler.scheduleFunction(fn, 50);
-
-    scheduler.tick(60);
-
-    expect(recurring).toHaveBeenCalled();
-    expect(recurring.calls.count()).toBe(6);
-    expect(fn).toHaveBeenCalled();
-  });
-
-  it("schedules a function for later execution during a tick", function () {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      fnDelay = 10;
-
-    scheduler.scheduleFunction(function () {
-      scheduler.scheduleFunction(fn, fnDelay);
-    }, 0);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(fnDelay);
-
-    expect(fn).toHaveBeenCalled();
-  });
-
-  it("#removeFunctionWithId removes a previously scheduled function with a given id during a tick", function () {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      fnDelay = 10,
-      timeoutKey;
-
-    scheduler.scheduleFunction(function () {
-      scheduler.removeFunctionWithId(timeoutKey);
-    }, 0);
-    timeoutKey = scheduler.scheduleFunction(fn, fnDelay);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(fnDelay);
-
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it("executes recurring functions interleaved with regular functions and functions scheduled during a tick in the correct order", function () {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      recurringCallCount = 0,
-      recurring = jasmine.createSpy('recurring').and.callFake(function() {
-        recurringCallCount++;
-        if (recurringCallCount < 5) {
-          expect(fn).not.toHaveBeenCalled();
-        }
-      }),
-      innerFn = jasmine.createSpy('innerFn').and.callFake(function() {
-        expect(recurring.calls.count()).toBe(4);
-        expect(fn).not.toHaveBeenCalled();
-      }),
-      scheduling = jasmine.createSpy('scheduling').and.callFake(function() {
-        expect(recurring.calls.count()).toBe(3);
-        expect(fn).not.toHaveBeenCalled();
-        scheduler.scheduleFunction(innerFn, 10);  // 41ms absolute
-      });
-
-    scheduler.scheduleFunction(recurring, 10, [], true);
-    scheduler.scheduleFunction(fn, 50);
-    scheduler.scheduleFunction(scheduling, 31);
-
-    scheduler.tick(60);
-
-    expect(recurring).toHaveBeenCalled();
-    expect(recurring.calls.count()).toBe(6);
-    expect(fn).toHaveBeenCalled();
-    expect(scheduling).toHaveBeenCalled();
-    expect(innerFn).toHaveBeenCalled();
-  });
-
-  it("executes recurring functions after rescheduling them", function () {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      recurring = function() {
-        expect(scheduler.scheduleFunction).toHaveBeenCalled();
-      };
-
-    scheduler.scheduleFunction(recurring, 10, [], true);
-
-    spyOn(scheduler, "scheduleFunction");
-
-    scheduler.tick(10);
-  });
-
-  it("removes functions during a tick that runs the function", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      spy = jasmine.createSpy('fn'),
-      spyAndRemove = jasmine.createSpy('fn'),
-      fnDelay = 10,
-      timeoutKey;
-
-    spyAndRemove.and.callFake(function() {
-      scheduler.removeFunctionWithId(timeoutKey);
-    });
-
-    scheduler.scheduleFunction(spyAndRemove, fnDelay);
-
-    timeoutKey = scheduler.scheduleFunction(spy, fnDelay, [], true);
-
-    scheduler.tick(2 * fnDelay);
-
-    expect(spy).not.toHaveBeenCalled();
-    expect(spyAndRemove).toHaveBeenCalled();
-  });
-
-  it("removes functions during the first tick that runs the function", function() {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
-      fnDelay = 10,
-      timeoutKey;
-
-    timeoutKey = scheduler.scheduleFunction(fn, fnDelay, [], true);
-    scheduler.scheduleFunction(function () {
-      scheduler.removeFunctionWithId(timeoutKey);
-    }, fnDelay);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    scheduler.tick(3 * fnDelay);
-
-    expect(fn).toHaveBeenCalled();
-    expect(fn.calls.count()).toBe(1);
-  });
-
-  it("updates the mockDate per scheduled time", function () {
-    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      tickDate = jasmine.createSpy('tickDate');
-
-      scheduler.scheduleFunction(function() {});
-      scheduler.scheduleFunction(function() {}, 1);
-
-      scheduler.tick(1, tickDate);
-
-      expect(tickDate).toHaveBeenCalledWith(0);
-      expect(tickDate).toHaveBeenCalledWith(1);
-  })
-});
-

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

@@ -1,200 +0,0 @@
-// TODO: Fix these unit tests!
-describe("Env", function() {
-  var env;
-  beforeEach(function() {
-    env = new jasmineUnderTest.Env();
-  });
-
-  describe("#pending", function() {
-    it("throws the Pending Spec exception", function() {
-      expect(function() {
-        env.pending();
-      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
-    });
-
-    it("throws the Pending Spec exception with a custom message", function() {
-      expect(function() {
-        env.pending('custom message');
-      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message');
-    });
-  });
-
-  describe("#topSuite", function() {
-    it("returns the Jasmine top suite for users to traverse the spec tree", function() {
-      var suite = env.topSuite();
-      expect(suite.description).toEqual('Jasmine__TopLevel__Suite');
-    });
-  });
-
-  it('can configure specs to throw errors on expectation failures', function() {
-    env.throwOnExpectationFailure(true);
-
-    spyOn(jasmineUnderTest, 'Spec');
-    env.it('foo', function() {});
-    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: true
-    }));
-  });
-
-  it('can configure suites to throw errors on expectation failures', function() {
-    env.throwOnExpectationFailure(true);
-
-    spyOn(jasmineUnderTest, 'Suite');
-    env.describe('foo', function() {});
-    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: true
-    }));
-  });
-
-  describe('#describe', function () {
-    it("throws an error when given arguments", function() {
-      expect(function() {
-        env.describe('done method', function(done) {});
-      }).toThrowError('describe does not expect any arguments');
-    });
-
-    it('throws an error when it receives a non-fn argument', function() {
-      // Some versions of PhantomJS return [object DOMWindow] when
-      // Object.prototype.toString.apply is called with `undefined` or `null`.
-      // In a similar fashion, IE8 gives [object Object] for both `undefined`
-      // and `null`. We mostly just want these tests to check that using
-      // anything other than a function throws an error.
-      expect(function() {
-        env.describe('undefined arg', undefined);
-      }).toThrowError(/describe expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-      expect(function() {
-        env.describe('null arg', null);
-      }).toThrowError(/describe expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
-
-      expect(function() {
-        env.describe('array arg', []);
-      }).toThrowError('describe expects a function argument; received [object Array]');
-      expect(function() {
-        env.describe('object arg', {});
-      }).toThrowError('describe expects a function argument; received [object Object]');
-
-      expect(function() {
-        env.describe('fn arg', function() {});
-      }).not.toThrowError('describe expects a function argument; received [object Function]');
-    });
-  });
-
-  describe('#it', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.it('undefined arg', null);
-      }).toThrowError(/it expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
-    });
-
-    it('does not throw when it is not given a fn argument', function() {
-      expect(function() {
-        env.it('pending spec');
-      }).not.toThrow();
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.it('async', jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-
-  describe('#xit', function() {
-    it('calls spec.pend with "Temporarily disabled with xit"', function() {
-      var pendSpy = jasmine.createSpy();
-      spyOn(env, 'it').and.returnValue({
-        pend: pendSpy
-      });
-      env.xit('foo', function() {});
-      expect(pendSpy).toHaveBeenCalledWith('Temporarily disabled with xit');
-    });
-
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.xit('undefined arg', null);
-      }).toThrowError(/xit expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
-    });
-
-    it('does not throw when it is not given a fn argument', function() {
-      expect(function() {
-        env.xit('pending spec');
-      }).not.toThrow();
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.xit('async', jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-
-  describe('#fit', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.fit('undefined arg', undefined);
-      }).toThrowError(/fit expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-    });
-  });
-
-  describe('#beforeEach', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.beforeEach(undefined);
-      }).toThrowError(/beforeEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.beforeEach(jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-
-  describe('#beforeAll', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.beforeAll(undefined);
-      }).toThrowError(/beforeAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.beforeAll(jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-
-  describe('#afterEach', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.afterEach(undefined);
-      }).toThrowError(/afterEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.afterEach(jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-
-  describe('#afterAll', function () {
-    it('throws an error when it receives a non-fn argument', function() {
-      expect(function() {
-        env.afterAll(undefined);
-      }).toThrowError(/afterAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
-    });
-
-    it('accepts an async function', function() {
-      jasmine.getEnv().requireAsyncAwait();
-      expect(function() {
-        env.afterAll(jasmine.getEnv().makeAsyncAwaitFunction());
-      }).not.toThrow();
-    });
-  });
-});

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

@@ -1,63 +0,0 @@
-describe("ExceptionFormatter", function() {
-  describe("#message", function() {
-    it('formats Firefox exception messages', function() {
-      var sampleFirefoxException = {
-          fileName: 'foo.js',
-          lineNumber: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleFirefoxException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats Webkit exception messages', function() {
-      var sampleWebkitException = {
-          sourceURL: 'foo.js',
-          line: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleWebkitException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats V8 exception messages', function() {
-      var sampleV8 = {
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleV8);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
-    });
-
-    it("formats thrown exceptions that aren't errors", function() {
-      var thrown = "crazy error",
-          exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-          message = exceptionFormatter.message(thrown);
-
-      expect(message).toEqual("crazy error thrown");
-    });
-  });
-
-  describe("#stack", function() {
-    it("formats stack traces from Webkit, Firefox, node.js or IE10+", function() {
-      if (jasmine.getEnv().ieVersion < 10 || jasmine.getEnv().safariVersion < 6) { return; }
-
-      var error;
-      try { throw new Error("an error") } catch(e) { error = e; }
-
-      expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
-    });
-
-    it("returns null if no Error provided", function() {
-      expect(new jasmineUnderTest.ExceptionFormatter().stack()).toBeNull();
-    });
-  });
-});

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

@@ -1,68 +0,0 @@
-describe('Exceptions:', function() {
-  var env;
-
-  beforeEach(function() {
-    env = new jasmineUnderTest.Env();
-  });
-
-  describe('with break on exception', function() {
-    it('should not catch the exception', function() {
-      env.catchExceptions(false);
-      env.describe('suite for break on exceptions', function() {
-        env.it('should break when an exception is thrown', function() {
-          throw new Error('I should hit a breakpoint!');
-        });
-      });
-      var spy = jasmine.createSpy('spy');
-
-      try {
-        env.execute();
-        spy();
-      }
-      catch (e) {}
-
-      expect(spy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("with catch on exception", function() {
-    it('should handle exceptions thrown, but continue', function(done) {
-      var secondTest = jasmine.createSpy('second test');
-      env.describe('Suite for handles exceptions', function () {
-        env.it('should be a test that fails because it throws an exception', function() {
-          throw new Error();
-        });
-        env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
-      });
-
-      var expectations = function() {
-        expect(secondTest).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
-    });
-
-    it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
-      var secondDescribe = jasmine.createSpy("second describe");
-      env.describe("a suite that throws an exception", function () {
-        env.it("is a test that should pass", function () {
-         this.expect(true).toEqual(true);
-        });
-
-        throw new Error("top level error");
-      });
-      env.describe("a suite that doesn't throw an exception", secondDescribe);
-
-      var expectations = function() {
-        expect(secondDescribe).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
-    });
-  });
-});
-

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

@@ -1,61 +0,0 @@
-describe("buildExpectationResult", function() {
-  it("defaults to passed", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: 'some-value'});
-    expect(result.passed).toBe('some-value');
-  });
-
-  it("message defaults to Passed for passing specs", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: true, message: 'some-value'});
-    expect(result.message).toBe('Passed.');
-  });
-
-  it("message returns the message for failing expectations", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: false, message: 'some-value'});
-    expect(result.message).toBe('some-value');
-  });
-
-  it("delegates message formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {message: 'foo'},
-      messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
-
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        messageFormatter: messageFormatter
-      });
-
-    expect(messageFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.message).toEqual('foo');
-  });
-
-  it("delegates stack formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
-
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        stackFormatter: stackFormatter
-      });
-
-    expect(stackFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.stack).toEqual('foo');
-  });
-
-  it("matcherName returns passed matcherName", function() {
-    var result = jasmineUnderTest.buildExpectationResult({matcherName: 'some-value'});
-    expect(result.matcherName).toBe('some-value');
-  });
-
-  it("expected returns passed expected", function() {
-    var result = jasmineUnderTest.buildExpectationResult({expected: 'some-value'});
-    expect(result.expected).toBe('some-value');
-  });
-
-  it("actual returns passed actual", function() {
-    var result = jasmineUnderTest.buildExpectationResult({actual: 'some-value'});
-    expect(result.actual).toBe('some-value');
-  });
-});