diff --git a/.gitignore b/.gitignore
index fe4ab11..aef762f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,7 @@
#ignore node_modules, as the node project is not "deployed" per se: http://www.mikealrogers.com/posts/nodemodules-in-git.html
/node_modules
-
+.idea
/generated
.sass-cache
diff --git a/.idea/.name b/.idea/.name
new file mode 100644
index 0000000..9bcc8d4
--- /dev/null
+++ b/.idea/.name
@@ -0,0 +1 @@
+jasmine-stealth
\ No newline at end of file
diff --git a/.idea/encodings.xml b/.idea/encodings.xml
new file mode 100644
index 0000000..e206d70
--- /dev/null
+++ b/.idea/encodings.xml
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/.idea/jasmine-stealth.iml b/.idea/jasmine-stealth.iml
new file mode 100644
index 0000000..d078066
--- /dev/null
+++ b/.idea/jasmine-stealth.iml
@@ -0,0 +1,12 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/.idea/jsLibraryMappings.xml b/.idea/jsLibraryMappings.xml
new file mode 100644
index 0000000..708c294
--- /dev/null
+++ b/.idea/jsLibraryMappings.xml
@@ -0,0 +1,8 @@
+
+
+
+
+
+
+
+
diff --git a/.idea/libraries/jasmine_stealth_node_modules.xml b/.idea/libraries/jasmine_stealth_node_modules.xml
new file mode 100644
index 0000000..ae25c28
--- /dev/null
+++ b/.idea/libraries/jasmine_stealth_node_modules.xml
@@ -0,0 +1,14 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ $PROJECT_DIR$/Gruntfile.js
+
+
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1412125441386
+ 1412125441386
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/README.md b/README.md
index bb22076..ebcf500 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,10 @@ jasmine-stealth is a [Jasmine](https://github.com/pivotal/jasmine) helper that a
# Conditional Stubbing
+## stealthy
+
+One of the biggest changes is to prepare for Jasmine 2.x suport, which exposes "Spy" differently. We can no longer add new functions directly to the protoype. So, the functions we used to add to the prototype are now simply being added to the spy instance by using the new `stealthy` method. `someSpy = jasmine.createSpy()` becomes `someSpy = stealthy(jasmine.createSpy())`.
+
## "when" + "thenReturn"
One annoyance with Jasmine spies is the default semantics of `Spy#andReturn` limits you to a single return value, regardless of which arguments a spy is invoked with. However, the arguments a spy is called with *usually matter* to the spec. None of your out-of-the-box options are great:
@@ -25,7 +29,7 @@ Enter jasmine-stealth, which adds a `#when` method to Jasmine's spies. It lets y
describe("multiple stubbings", function() {
var someSpy;
beforeEach(function() {
- someSpy = jasmine.createSpy();
+ someSpy = stealthy(jasmine.createSpy());
someSpy.when("pirate", { booty: ["jewels",jasmine.any(String)]}).thenReturn("argh!");
someSpy.when("panda",1).thenReturn("sad");
});
@@ -190,7 +194,7 @@ See this example:
``` javascript
-spy = jasmine.createSpy();
+spy = stealthy(jasmine.createSpy());
spy('foo',function(){});
spy('bar',function(){});
spy('baz',function(){});
diff --git a/app/js/jasmine-stealth.coffee b/app/js/jasmine-stealth.coffee
index 87de4c6..d15f60d 100644
--- a/app/js/jasmine-stealth.coffee
+++ b/app/js/jasmine-stealth.coffee
@@ -38,24 +38,6 @@
unfakes.push ->
owner[thingToFake] = originalThing
- #stub nomenclature
-
- root.stubFor = root.spyOn
- jasmine.createStub = jasmine.createSpy
- jasmine.createStubObj = (baseName, stubbings) ->
- if stubbings.constructor is Array
- jasmine.createSpyObj baseName, stubbings
- else
- obj = {}
- for name of stubbings
- stubbing = stubbings[name]
- obj[name] = jasmine.createSpy(baseName + "." + name)
- if _(stubbing).isFunction()
- obj[name].andCallFake stubbing
- else
- obj[name].andReturn stubbing
- obj
-
whatToDoWhenTheSpyGetsCalled = (spy) ->
matchesStub = (stubbing,args,context) ->
switch stubbing.type
@@ -76,18 +58,75 @@
i++
priorPlan.apply(spy, arguments)
- jasmine.Spy::whenContext = (context) ->
- spy = this
- spy._stealth_stubbings ||= []
- whatToDoWhenTheSpyGetsCalled(spy)
- stubChainer(spy, "context", context)
- jasmine.Spy::when = ->
- spy = this
- ifThis = jasmine.util.argsToArray(arguments)
- spy._stealth_stubbings ||= []
- whatToDoWhenTheSpyGetsCalled(spy)
- stubChainer(spy, "args", ifThis)
+ addStealthyToPrototype = () ->
+ jasmine.Spy::whenContext = (context) ->
+ spy = this
+ spy._stealth_stubbings ||= []
+ whatToDoWhenTheSpyGetsCalled(spy)
+ stubChainer(spy, "context", context)
+
+ jasmine.Spy::when = ->
+ spy = this
+ ifThis = jasmine.util.argsToArray(arguments)
+ spy._stealth_stubbings ||= []
+ whatToDoWhenTheSpyGetsCalled(spy)
+ stubChainer(spy, "args", ifThis)
+
+ jasmine.Spy::mostRecentCallThat = (callThat, context) ->
+ i = @calls.length - 1
+ while i >= 0
+ return @calls[i] if callThat.call(context or this, @calls[i]) is true
+ i--
+ return
+
+ whatToDoWhenTheSpyGetsCalledInstance = (spy) ->
+ matchesStub = (stubbing, args, context) ->
+ switch stubbing.type
+ when "args" then jasmine.matchersUtil.equals(stubbing.ifThis, jasmine.util.argsToArray(args))
+ when "context" then jasmine.matchersUtil.equals(stubbing.ifThis, context)
+
+ priorPlan = spy.and.exec();
+ spy.and.callFake ->
+ i = 0
+ while i < spy._stealth_stubbings.length
+ stubbing = spy._stealth_stubbings[i]
+
+ if matchesStub(stubbing,arguments,this)
+
+ if stubbing.satisfaction == "callFake"
+ return stubbing.thenThat(arguments...)
+ else
+ return stubbing.thenThat
+ i++
+ priorPlan
+
+ stealthy = (spy) ->
+ spy.whenContext = (context) ->
+ spy._stealth_stubbings ||= []
+ whatToDoWhenTheSpyGetsCalledInstance(spy)
+ stubChainer(spy, "context", context)
+
+ spy.when = () ->
+ ifThis = jasmine.util.argsToArray(arguments)
+ spy._stealth_stubbings ||= []
+ whatToDoWhenTheSpyGetsCalledInstance(spy)
+ stubChainer(spy, "args", ifThis)
+
+ spy.mostRecentCallThat = (callThat, context) ->
+ i = @calls.length - 1
+ while i >= 0
+ return @calls[i] if callThat.call(context or this, @calls[i]) is true
+ i--
+ spy
+
+
+ if jasmine.Spy
+ addStealthyToPrototype()
+ else
+ originalCreateSpy = jasmine.createSpy
+ jasmine.createSpy = () ->
+ stealthy(originalCreateSpy.apply(this, arguments))
stubChainer = (spy, type, ifThis) ->
addStubbing = (satisfaction) ->
@@ -95,41 +134,54 @@
spy._stealth_stubbings.unshift({type, ifThis, satisfaction, thenThat})
spy
- thenReturn: addStubbing("return")
+ thenReturn: addStubbing("returnValue")
thenCallFake: addStubbing("callFake")
- jasmine.Spy::mostRecentCallThat = (callThat, context) ->
- i = @calls.length - 1
-
- while i >= 0
- return @calls[i] if callThat.call(context or this, @calls[i]) is true
- i--
-
- ## Matchers
-
- class jasmine.Matchers.ArgThat extends jasmine.Matchers.Any
- constructor: (matcher) ->
- @matcher = matcher
-
- jasmineMatches: (actual) ->
- @matcher(actual)
-
- jasmine.Matchers.ArgThat::matches = jasmine.Matchers.ArgThat::jasmineMatches #backwards compatibility for jasmine 1.1
- jasmine.argThat = (expected) -> new jasmine.Matchers.ArgThat(expected)
+ #stub nomenclature
- class jasmine.Matchers.Capture extends jasmine.Matchers.Any
- constructor: (captor) ->
- @captor = captor
+ root.stubFor = root.spyOn
+ jasmine.createStub = jasmine.createSpy
+ jasmine.createStubObj = (baseName, stubbings) ->
+ if stubbings.constructor is Array
+ jasmine.createSpyObj baseName, stubbings
+ else
+ obj = {}
+ for name of stubbings
+ stubbing = stubbings[name]
+ obj[name] = jasmine.createSpy(baseName + "." + name)
+ if _(stubbing).isFunction()
+ obj[name].and.callFake stubbing
+ else
+ obj[name].and.returnValue stubbing
+ obj
- jasmineMatches: (actual) ->
- @captor.value = actual
- true
- jasmine.Matchers.Capture::matches = jasmine.Matchers.Capture::jasmineMatches #backwards compatibility for jasmine 1.1
- class Captor
- capture: ->
- new jasmine.Matchers.Capture(@)
+ ## Matchers
- jasmine.captor = () -> new Captor()
+# class jasmine.Matchers.ArgThat extends jasmine.Matchers.Any
+# constructor: (matcher) ->
+# @matcher = matcher
+#
+# jasmineMatches: (actual) ->
+# @matcher(actual)
+#
+# jasmine.Matchers.ArgThat::matches = jasmine.Matchers.ArgThat::jasmineMatches #backwards compatibility for jasmine 1.1
+# jasmine.argThat = (expected) -> new jasmine.Matchers.ArgThat(expected)
+#
+# class jasmine.Matchers.Capture extends jasmine.Matchers.Any
+# constructor: (captor) ->
+# @captor = captor
+#
+# jasmineMatches: (actual) ->
+# @captor.value = actual
+# true
+#
+# jasmine.Matchers.Capture::matches = jasmine.Matchers.Capture::jasmineMatches #backwards compatibility for jasmine 1.1
+#
+# class Captor
+# capture: ->
+# new jasmine.Matchers.Capture(@)
+#
+# jasmine.captor = () -> new Captor()
)()
diff --git a/config/spec.json b/config/spec.json
index aa0cc54..ec3e161 100644
--- a/config/spec.json
+++ b/config/spec.json
@@ -1,5 +1,5 @@
{
- "framework" : "jasmine",
+ "framework" : "jasmine2",
"launch_in_dev" : ["Chrome"],
"launch_in_ci" : ["PhantomJS"],
"src_files" : [
diff --git a/spec/helpers/jasmine-only.js b/spec/helpers/jasmine-only.js
deleted file mode 100644
index 01e2a67..0000000
--- a/spec/helpers/jasmine-only.js
+++ /dev/null
@@ -1,103 +0,0 @@
-/* jasmine-only - 0.1.0
- * Exclusivity spec helpers for jasmine: `describe.only` and `it.only`
- * https://github.com/davemo/jasmine-only
- */
-(function() {
- var __hasProp = {}.hasOwnProperty,
- __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
- (function(jasmine) {
- var describeOnly, env, itOnly, root;
-
- root = this;
- env = jasmine.getEnv();
- describeOnly = function(description, specDefinitions) {
- var suite;
-
- suite = new jasmine.Suite(this, description, null, this.currentSuite);
- suite.exclusive_ = 1;
- this.exclusive_ = Math.max(this.exclusive_, 1);
- return this.describe_(suite, specDefinitions);
- };
- itOnly = function(description, func) {
- var spec;
-
- spec = this.it(description, func);
- spec.exclusive_ = 2;
- this.exclusive_ = 2;
- return spec;
- };
- env.exclusive_ = 0;
- env.describe = function(description, specDefinitions) {
- var suite;
-
- suite = new jasmine.Suite(this, description, null, this.currentSuite);
- return this.describe_(suite, specDefinitions);
- };
- env.describe_ = function(suite, specDefinitions) {
- var declarationError, e, parentSuite;
-
- parentSuite = this.currentSuite;
- if (parentSuite) {
- parentSuite.add(suite);
- } else {
- this.currentRunner_.add(suite);
- }
- this.currentSuite = suite;
- declarationError = null;
- try {
- specDefinitions.call(suite);
- } catch (_error) {
- e = _error;
- declarationError = e;
- }
- if (declarationError) {
- this.it("encountered a declaration exception", function() {
- throw declarationError;
- });
- }
- this.currentSuite = parentSuite;
- return suite;
- };
- env.specFilter = function(spec) {
- return this.exclusive_ <= spec.exclusive_;
- };
- env.describe.only = function() {
- return describeOnly.apply(env, arguments);
- };
- env.it.only = function() {
- return itOnly.apply(env, arguments);
- };
- root.describe.only = function(description, specDefinitions) {
- return env.describe.only(description, specDefinitions);
- };
- root.it.only = function(description, func) {
- return env.it.only(description, func);
- };
- root.iit = root.it.only;
- root.ddescribe = root.describe.only;
- jasmine.Spec = (function(_super) {
- __extends(Spec, _super);
-
- function Spec(env, suite, description) {
- this.exclusive_ = suite.exclusive_;
- Spec.__super__.constructor.call(this, env, suite, description);
- }
-
- return Spec;
-
- })(jasmine.Spec);
- return jasmine.Suite = (function(_super) {
- __extends(Suite, _super);
-
- function Suite(env, suite, specDefinitions, parentSuite) {
- this.exclusive_ = parentSuite && parentSuite.exclusive_ || 0;
- Suite.__super__.constructor.call(this, env, suite, specDefinitions, parentSuite);
- }
-
- return Suite;
-
- })(jasmine.Suite);
- })(jasmine);
-
-}).call(this);
diff --git a/spec/jasmine-stealth-spec.coffee b/spec/jasmine-stealth-spec.coffee
index 732d505..c1d4c26 100644
--- a/spec/jasmine-stealth-spec.coffee
+++ b/spec/jasmine-stealth-spec.coffee
@@ -3,6 +3,9 @@
root.context = root.describe
root.xcontext = root.xdescribe
+ root.xcontext = root.xdescribe
+
+
describe "jasmine-stealth", ->
describe "aliases", ->
@@ -11,14 +14,15 @@
describe ".stubFor", ->
context "existing method", ->
Given -> root.lolol = -> "roflcopter"
- When -> stubFor(root, "lolol").andReturn("lol")
+ When -> stubFor(root, "lolol").and.returnValue("lol")
Then -> root.lolol() == "lol"
context "non-existing method", ->
Given -> @obj = { woot: null }
- When -> spyOn(@obj, "woot").andReturn("troll")
+ When -> spyOn(@obj, "woot").and.returnValue("troll")
Then -> @obj.woot() == "troll"
+
describe "#when", ->
Given -> @spy = jasmine.createSpy("my spy")
@@ -26,6 +30,7 @@
Then -> expect(@spy.when("a").thenReturn("")).toBe(@spy)
Then -> expect(@spy.when("a").thenCallFake((->))).toBe(@spy)
+
describe "#thenReturn", ->
context "the stubbing is unmet", ->
Given -> @spy.when("53").thenReturn("yay!")
@@ -79,16 +84,16 @@
When -> @spy("panda", "baby")
Then -> expect(@fake).toHaveBeenCalledWith("panda", "baby")
- context "default andReturn plus some conditional stubbing", ->
- Given -> @spy.andReturn "football"
+ context "default and.returnValue plus some conditional stubbing", ->
+ Given -> @spy.and.returnValue "football"
Given -> @spy.when("bored").thenReturn "baseball"
describe "it doesn't appear to invoke the spy", ->
Then -> expect(@spy).not.toHaveBeenCalled()
- Then -> @spy.callCount == 0
- Then -> @spy.calls.length == 0
- Then -> @spy.argsForCall.length == 0
- Then -> expect(@spy.mostRecentCall).toEqual({})
+ Then -> @spy.calls.count() == 0
+# Then -> @spy.calls.any() == 0
+# Then -> @spy.argsForCall.length == 0
+ Then -> expect(@spy.calls.mostRecent()).toEqual({})
context "stubbing is not satisfied", ->
Then -> @spy("anything at all") == "football"
@@ -97,16 +102,16 @@
Then -> @spy("bored") == "baseball"
context "default andCallFake plus some conditional stubbing", ->
- Given -> @spy.andCallFake (s1,s2) -> s2
+ Given -> @spy.and.callFake (s1,s2) -> s2
Given -> @spy.when("function").thenCallFake -> "football"
Given -> @spy.when("value").thenReturn "baseball"
describe "it doesn't appear to invoke the spy", ->
Then -> expect(@spy).not.toHaveBeenCalled()
- Then -> @spy.callCount == 0
- Then -> @spy.calls.length == 0
- Then -> @spy.argsForCall.length == 0
- Then -> expect(@spy.mostRecentCall).toEqual({})
+ Then -> @spy.calls.count() == 0
+# Then -> @spy.calls.length == 0
+# Then -> @spy.argsForCall.length == 0
+ Then -> expect(@spy.calls.mostRecent()).toEqual({})
context "default stubbing is satisfied", ->
Then -> @spy("cricket", "tennis") == "tennis"
@@ -162,7 +167,7 @@
Then -> @subject.a() == 5
Then -> @subject.b() == 8
- describe "jasmine.argThat (jasmine.Matchers.ArgThat)", ->
+ xdescribe "jasmine.argThat (jasmine.Matchers.ArgThat)", ->
context "with when()", ->
Given -> @spy = jasmine.createSpy()
Given -> @spy.when(jasmine.argThat (arg) -> arg > 5).thenReturn("YAY")
@@ -184,7 +189,7 @@
Then -> false == jasmine.getEnv().equals_(5, jasmine.argThat (arg) -> arg == 4)
Then -> false == jasmine.getEnv().equals_(5, jasmine.argThat (arg) -> arg != 5)
- describe "jasmine.captor, #capture() & .value", ->
+ xdescribe "jasmine.captor, #capture() & .value", ->
Given -> @captor = jasmine.captor()
Given -> @spy = jasmine.createSpy()
When -> @spy("foo!")
@@ -230,7 +235,7 @@
context "stubbing the model's method", ->
Given -> @modelSpies = spyOnConstructor(root, "Model", "toJSON")
Given -> @subject = new root.View()
- Given -> @modelSpies.toJSON.andReturn("some json")
+ Given -> @modelSpies.toJSON.and.returnValue("some json")
When -> @result = @subject.serialize()
Then -> expect(@result).toEqual
model: "some json"