jasmine-core 3.0.0 → 3.1.0

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

@@ -1,364 +0,0 @@
-describe("SpyRegistry", function() {
-  function createSpy(name, originalFn) {
-    return jasmineUnderTest.Spy(name, originalFn);
-  }
-
-  describe("#spyOn", function() {
-    it("checks for the existence of the object", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy});
-      expect(function() {
-        spyRegistry.spyOn(void 0, 'pants');
-      }).toThrowError(/could not find an object/);
-    });
-
-    it("checks that a method name was passed", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-        expect(function() {
-          spyRegistry.spyOn(subject);
-        }).toThrowError(/No method name supplied/);
-    });
-
-    it("checks that the object is not `null`", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry();
-      expect(function() {
-        spyRegistry.spyOn(null, 'pants');
-      }).toThrowError(/could not find an object/);
-    });
-
-    it("checks that the method name is not `null`", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-      expect(function() {
-        spyRegistry.spyOn(subject, null);
-      }).toThrowError(/No method name supplied/);
-    });
-
-    it("checks for the existence of the method", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-      expect(function() {
-        spyRegistry.spyOn(subject, 'pants');
-      }).toThrowError(/method does not exist/);
-    });
-
-    it("checks if it has already been spied upon", function() {
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy
-        }),
-        subject = { spiedFunc: function() {} };
-
-      spyRegistry.spyOn(subject, 'spiedFunc');
-
-      expect(function() {
-        spyRegistry.spyOn(subject, 'spiedFunc');
-      }).toThrowError(/has already been spied upon/);
-    });
-
-    it("checks if it can be spied upon", function() {
-      var scope = {};
-
-      function myFunc() {
-        return 1;
-      }
-
-      Object.defineProperty(scope, 'myFunc', {
-        get: function() {
-          return myFunc;
-        }
-      });
-
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
-        subject = { spiedFunc: scope.myFunc };
-
-      expect(function() {
-        spyRegistry.spyOn(scope, 'myFunc');
-      }).toThrowError(/is not declared writable or has no setter/);
-
-      expect(function() {
-        spyRegistry.spyOn(subject, 'spiedFunc');
-      }).not.toThrowError(/is not declared writable or has no setter/);
-    });
-
-    it("overrides the method on the object and returns the spy", function() {
-      var originalFunctionWasCalled = false,
-        spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
-        subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
-
-      var spy = spyRegistry.spyOn(subject, 'spiedFunc');
-
-      expect(subject.spiedFunc).toEqual(spy);
-    });
-  });
-
-  describe("#spyOnProperty", function() {
-    it("checks for the existence of the object", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry();
-      expect(function() {
-        spyRegistry.spyOnProperty(void 0, 'pants');
-      }).toThrowError(/could not find an object/);
-    });
-
-    it("checks that a property name was passed", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-        expect(function() {
-          spyRegistry.spyOnProperty(subject);
-        }).toThrowError(/No property name supplied/);
-    });
-
-    it("checks for the existence of the method", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-      expect(function() {
-        spyRegistry.spyOnProperty(subject, 'pants');
-      }).toThrowError(/property does not exist/);
-    });
-
-    it("checks for the existence of access type", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
-        subject = {};
-
-      Object.defineProperty(subject, 'pants', {
-        get: function() { return 1; },
-        configurable: true
-      });
-
-      expect(function() {
-        spyRegistry.spyOnProperty(subject, 'pants', 'set');
-      }).toThrowError(/does not have access type/);
-    });
-
-    it("checks if it has already been spied upon", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
-        subject = {};
-
-      Object.defineProperty(subject, 'spiedProp', {
-        get: function() { return 1; },
-        configurable: true
-      });
-
-      spyRegistry.spyOnProperty(subject, 'spiedProp');
-
-      expect(function() {
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-      }).toThrowError(/has already been spied upon/);
-    });
-
-    it("checks if it can be spied upon", function() {
-      var subject = {};
-
-      Object.defineProperty(subject, 'myProp', {
-        get: function() {}
-      });
-
-      Object.defineProperty(subject, 'spiedProp', {
-        get: function() {},
-        configurable: true
-      });
-
-      var spyRegistry = new jasmineUnderTest.SpyRegistry();
-
-      expect(function() {
-        spyRegistry.spyOnProperty(subject, 'myProp');
-      }).toThrowError(/is not declared configurable/);
-
-      expect(function() {
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-      }).not.toThrowError(/is not declared configurable/);
-    });
-
-    it("overrides the property getter on the object and returns the spy", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
-        subject = {},
-        returnValue = 1;
-
-      Object.defineProperty(subject, 'spiedProperty', {
-        get: function() { return returnValue; },
-        configurable: true
-      });
-
-      expect(subject.spiedProperty).toEqual(returnValue);
-
-      var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty');
-      var getter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').get;
-
-      expect(getter).toEqual(spy);
-      expect(subject.spiedProperty).toBeUndefined();
-    });
-
-    it("overrides the property setter on the object and returns the spy", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
-        subject = {},
-        returnValue = 1;
-
-      Object.defineProperty(subject, 'spiedProperty', {
-        get: function() { return returnValue; },
-        set: function() {},
-        configurable: true
-      });
-
-      var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty', 'set');
-      var setter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').set;
-
-      expect(subject.spiedProperty).toEqual(returnValue);
-      expect(setter).toEqual(spy);
-    });
-  });
-
-  describe("#clearSpies", function() {
-    it("restores the original functions on the spied-upon objects", function() {
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy
-        }),
-        originalFunction = function() {},
-        subject = { spiedFunc: originalFunction };
-
-      spyRegistry.spyOn(subject, 'spiedFunc');
-      spyRegistry.clearSpies();
-
-      expect(subject.spiedFunc).toBe(originalFunction);
-    });
-
-    it("restores the original functions, even when that spy has been replace and re-spied upon", function() {
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy
-        }),
-        originalFunction = function() {},
-        subject = { spiedFunc: originalFunction };
-
-      spyRegistry.spyOn(subject, 'spiedFunc');
-
-      // replace the original spy with some other function
-      subject.spiedFunc = function() {};
-
-      // spy on the function in that location again
-      spyRegistry.spyOn(subject, 'spiedFunc');
-
-      spyRegistry.clearSpies();
-
-      expect(subject.spiedFunc).toBe(originalFunction);
-    });
-
-    it("does not add a property that the spied-upon object didn't originally have", function() {
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy
-        }),
-        originalFunction = function() {},
-        subjectParent = {spiedFunc: originalFunction};
-
-      var subject = Object.create(subjectParent);
-
-      expect(subject.hasOwnProperty('spiedFunc')).toBe(false);
-
-      spyRegistry.spyOn(subject, 'spiedFunc');
-      spyRegistry.clearSpies();
-
-      expect(subject.hasOwnProperty('spiedFunc')).toBe(false);
-      expect(subject.spiedFunc).toBe(originalFunction);
-    });
-
-    it("restores the original function when it\'s inherited and cannot be deleted", function() {
-      var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy
-        }),
-        originalFunction = function() {},
-        subjectParent = {spiedFunc: originalFunction};
-
-      var subject = Object.create(subjectParent);
-
-      spyRegistry.spyOn(subject, 'spiedFunc');
-
-      // simulate a spy that cannot be deleted
-      Object.defineProperty(subject, 'spiedFunc', {
-        configurable: false
-      });
-
-      spyRegistry.clearSpies();
-
-      expect(jasmineUnderTest.isSpy(subject.spiedFunc)).toBe(false);
-    });
-
-    it("restores window.onerror by overwriting, not deleting", function() {
-      function FakeWindow() {
-      }
-      FakeWindow.prototype.onerror = function() {};
-
-      var spies = [],
-        global = new FakeWindow(),
-        spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
-          createSpy: createSpy,
-          global: global
-        });
-
-      spyRegistry.spyOn(global, 'onerror');
-      spyRegistry.clearSpies();
-      expect(global.onerror).toBe(FakeWindow.prototype.onerror);
-      expect(global.hasOwnProperty('onerror')).toBe(true);
-    });
-  });
-
-    describe('spying on properties', function() {
-      it("restores the original properties on the spied-upon objects", function() {
-        var spies = [],
-          spyRegistry = new jasmineUnderTest.SpyRegistry({
-            currentSpies: function() { return spies; },
-            createSpy: createSpy
-          }),
-          originalReturn = 1,
-          subject = {};
-
-        Object.defineProperty(subject, 'spiedProp', {
-          get: function() { return originalReturn; },
-          configurable: true
-        });
-
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-        spyRegistry.clearSpies();
-
-        expect(subject.spiedProp).toBe(originalReturn);
-      });
-
-      it("does not add a property that the spied-upon object didn't originally have", function() {
-        var spies = [],
-          spyRegistry = new jasmineUnderTest.SpyRegistry({
-            currentSpies: function() { return spies; },
-            createSpy: createSpy
-          }),
-          originalReturn = 1,
-          subjectParent = {};
-
-        Object.defineProperty(subjectParent, 'spiedProp', {
-          get: function() { return originalReturn; },
-          configurable: true
-        });
-
-        var subject = Object.create(subjectParent);
-
-        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
-
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-        spyRegistry.clearSpies();
-
-        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
-        expect(subject.spiedProp).toBe(originalReturn);
-      });
-    });
-});

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

@@ -1,177 +0,0 @@
-describe('Spies', function () {
-  var env;
-
-  beforeEach(function() {
-    env = new jasmineUnderTest.Env();
-  });
-
-  describe("createSpy", function() {
-    var TestClass;
-
-    beforeEach(function() {
-      TestClass = function() {};
-      TestClass.prototype.someFunction = function() {};
-      TestClass.prototype.someFunction.bob = "test";
-    });
-
-    it("preserves the properties of the spied function", function() {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-
-      expect(spy.bob).toEqual("test");
-    });
-
-    it("warns the user that we intend to overwrite an existing property", function() {
-      TestClass.prototype.someFunction.and = "turkey";
-
-      expect(function() {
-        env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      }).toThrowError("Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon");
-    });
-
-    it("adds a spyStrategy and callTracker to the spy", function() {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-
-      expect(spy.and).toEqual(jasmine.any(jasmineUnderTest.SpyStrategy));
-      expect(spy.calls).toEqual(jasmine.any(jasmineUnderTest.CallTracker));
-    });
-
-    it("tracks the argument of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
-
-      spy("arg");
-
-      expect(trackSpy.calls.mostRecent().args[0].args).toEqual(["arg"]);
-    });
-
-    it("tracks the context of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
-
-      var contextObject = { spyMethod: spy };
-      contextObject.spyMethod();
-
-      expect(trackSpy.calls.mostRecent().args[0].object).toEqual(contextObject);
-    });
-
-    it("tracks the return value of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
-
-      spy.and.returnValue("return value");
-      spy();
-
-      expect(trackSpy.calls.mostRecent().args[0].returnValue).toEqual("return value");
-    });
-
-    it("preserves arity of original function", function () {
-      var functions = [
-        function nullary () {},
-        function unary (arg) {},
-        function binary (arg1, arg2) {},
-        function ternary (arg1, arg2, arg3) {},
-        function quaternary (arg1, arg2, arg3, arg4) {},
-        function quinary (arg1, arg2, arg3, arg4, arg5) {},
-        function senary (arg1, arg2, arg3, arg4, arg5, arg6) {}
-      ];
-
-      for (var arity = 0; arity < functions.length; arity++) {
-        var someFunction = functions[arity],
-            spy = env.createSpy(someFunction.name, someFunction);
-
-        expect(spy.length).toEqual(arity);
-      }
-    });
-  });
-
-  describe("createSpyObj", function() {
-    it("should create an object with spy methods and corresponding return values when you call jasmine.createSpyObj() with an object", function () {
-      var spyObj = env.createSpyObj('BaseName', {'method1': 42, 'method2': 'special sauce' });
-
-      expect(spyObj.method1()).toEqual(42);
-      expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
-
-      expect(spyObj.method2()).toEqual('special sauce');
-      expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
-    });
-
-
-    it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
-      var spyObj = env.createSpyObj('BaseName', ['method1', 'method2']);
-
-      expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
-      expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
-    });
-
-    it("should allow you to omit the baseName", function() {
-      var spyObj = env.createSpyObj(['method1', 'method2']);
-
-      expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      expect(spyObj.method1.and.identity).toEqual('unknown.method1');
-      expect(spyObj.method2.and.identity).toEqual('unknown.method2');
-    });
-
-    it("should throw if you do not pass an array or object argument", function() {
-      expect(function() {
-        env.createSpyObj('BaseName');
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
-    });
-
-    it("should throw if you pass an empty array argument", function() {
-      expect(function() {
-        env.createSpyObj('BaseName', []);
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
-    });
-
-    it("should throw if you pass an empty object argument", function() {
-      expect(function() {
-        env.createSpyObj('BaseName', {});
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
-    });
-  });
-
-  it("can use different strategies for different arguments", function() {
-    var spy = env.createSpy('foo');
-    spy.and.returnValue(42);
-    spy.withArgs('baz', 'grault').and.returnValue(-1);
-    spy.withArgs('thud').and.returnValue('bob');
-
-    expect(spy('foo')).toEqual(42);
-    expect(spy('baz', 'grault')).toEqual(-1);
-    expect(spy('thud')).toEqual('bob');
-    expect(spy('baz', 'grault', 'waldo')).toEqual(42);
-  });
-
-  it("uses custom equality testers when selecting a strategy", function() {
-    var spy = env.createSpy('foo');
-    spy.and.returnValue(42);
-    spy.withArgs(jasmineUnderTest.any(String)).and.returnValue(-1);
-
-    expect(spy('foo')).toEqual(-1);
-    expect(spy({})).toEqual(42);
-  });
-
-  it("can reconfigure an argument-specific strategy", function() {
-    var spy = env.createSpy('foo');
-    spy.withArgs('foo').and.returnValue(42);
-    spy.withArgs('foo').and.returnValue(17);
-    expect(spy('foo')).toEqual(17);
-  });
-
-  describe("When withArgs is used without a base strategy", function() {
-    it("uses the matching strategy", function() {
-      var spy = env.createSpy('foo');
-      spy.withArgs('baz').and.returnValue(-1);
-
-      expect(spy('baz')).toEqual(-1);
-    });
-
-    it("throws if the args don't match", function() {
-      var spy = env.createSpy('foo');
-      spy.withArgs('bar').and.returnValue(-1);
-
-      expect(function() { spy('baz', {qux: 42}); }).toThrowError('Spy \'foo\' receieved a call with arguments [ \'baz\', Object({ qux: 42 }) ] but all configured strategies specify other arguments.');
-    });
-  });
-});