jspec 2.11.13 → 3.0.0

data/spec/{helpers.js → unit/helpers.js}

@@ -3,10 +3,12 @@ JSpec.include({
   name: 'Helpers',
   utilities : {
     mock_it : function(body) {
+      JSpec.assert = false
       var spec = new JSpec.Spec('mock', body)
       var prev = JSpec.currentSpec
       JSpec.runSpec(spec)
       JSpec.currentSpec = prev
+      JSpec.assert = true
       return spec
     }
   },

data/spec/{spec.fixtures.js → unit/spec.fixtures.js}

@@ -2,7 +2,6 @@
 describe 'Utility'
   describe 'fixture()'
     it 'should return a files contents'
-      fixture('fixtures/test.html').should.eql '<p>test</p>'
       fixture('test.html').should.eql '<p>test</p>'
       fixture('test').should.eql '<p>test</p>'
     end

data/spec/{spec.grammar.js → unit/spec.grammar.js}

@@ -121,16 +121,6 @@ describe 'Grammar'
 		  true.should.be(true);
 		end
 	end
-	
-  describe "with some tabs"
-		before_each
-		  foo = 'baz'
-		end
-    
-    it 'should work'
-      foo.should.eql 'baz'
-    end
-  end
   
   describe 'with nested describe'
     it 'should work'
@@ -248,4 +238,4 @@ __END__
 this should not matter because it is
 considered a comment by the JSpec grammar :)
 and is sometimes useful for temp reference info 
-when writting specs.
+when writting specs.

data/spec/{spec.jquery.js → unit/spec.jquery.js}

@@ -18,23 +18,6 @@ describe 'jQuery'
     end
   end
   
-  describe 'async'
-    it 'should load mah cookies (textfile)'
-      $.get('async', function(text){
-        text.should_eql 'cookies!'
-      })
-    end
-
-    it 'should load mah cookies twice (ensure multiple async requests work)'
-      $.get('async', function(text){
-        text.should.eql 'cookies!'
-      })
-      $.get('async', function(text){
-        text.should.not.eql 'rawr'
-      })
-    end 
-  end
-  
   describe 'matchers'
     before_each
       html = '<p><label><em>Save?</em></label>                 \

data/spec/{spec.jquery.xhr.js → unit/spec.jquery.xhr.js}

@@ -4,32 +4,43 @@ describe 'jQuery'
     it "should call the success function when 200"
       mock_request().and_return('{ foo: "bar" }', 'application/json')
       var successCalled = false
+      var errorCalled = false
       $.ajax({
         type: "POST",
         url: 'foo',
         dataType: 'json',
         success: function() {
           successCalled = true
+        },
+        error: function(xhr, status, e) {
+          alert(status)
+          errorCalled = true
         }
       })
       successCalled.should.be_true
+      errorCalled.should.be_false
     end
-  
+    
     it "should call the error function when 404"
       mock_request().and_return('{ foo: "bar" }', 'application/json', 404)
+      var successCalled = false
       var errorCalled = false
       $.ajax({
         type: "POST",
         url: 'foo',
         dataType: 'json',
+        success: function() {
+          successCalled = true
+        },
         error: function() {
           errorCalled = true
         }
       })
+      successCalled.should.be_false
       errorCalled.should.be_true
     end
   end
-
+  
   describe '.getJSON()'
     it 'should work with mockRequest'
       mockRequest().and_return('{ foo : "bar" }')

data/spec/unit/spec.js

@@ -0,0 +1,187 @@
+
+describe 'Failing specs'
+
+  it 'should fail'
+    spec = mock_it(function(){
+      'test'.should.not.eql 'test'
+    })
+    spec.should.have_failure_message('expected "test" to not eql "test"')
+  end
+
+  it 'should fail with one faulty assertion'
+    spec = mock_it(function() {
+      'test'.should.equal 'test' 
+      'test'.should.equal 'foo'
+    })
+    spec.should.have_failure_message('expected "test" to be "foo"')
+  end
+  
+  it 'should fail and print array with square braces'
+    spec = mock_it(function() {
+      [1,2].should.equal [1,3]
+    })
+    spec.should.have_failure_message("expected [ 1, 2 ] to be [ 1, 3 ]")
+  end
+  
+  it 'should fail and print nested array'
+    spec = mock_it(function() {
+      [1, ['foo']].should.equal [1, ['bar', ['whatever', 1.0, { foo : 'bar', bar : { 1 : 2 } }]]]
+    })
+    spec.should.have_failure_message(/^expected \[\s*1,\s*\[\s*"foo"/)
+  end
+  
+  it 'should fail with selector for jQuery objects'
+    spec = mock_it(function() {
+      elem = { jquery : '1.3.1', selector : '.foobar' } 
+      elem.should.eql 'foo'  
+    })
+    spec.should.have_failure_message('expected selector ".foobar" to eql "foo"')
+  end
+  
+  it 'should fail with negated message'
+    spec = mock_it(function(){
+      '1'.should.not.be_true
+    })
+    spec.should.have_failure_message(/expected "1" to not be true/)
+  end
+  
+  it 'should fail with positive message'
+    spec = mock_it(function() {
+      false.should.be_true
+    })
+    spec.should.have_failure_message(/expected false to be true/)
+  end
+  
+  describe 'throw_error'
+    before
+      // The Error.name property is not defined in IE
+      Error.name = "Error"
+    end
+
+    it 'should fail saying which error has been thrown'
+      spec = mock_it(function() {
+        -{ throw 'foo' }.should.throw_error 'bar'
+      })
+      spec.should.have_failure_message('expected exception of "bar" to be thrown, but got "foo"')
+    end
+
+    it 'should fail saying no error was thrown'
+      spec = mock_it(function() {
+        -{ }.should.throw_error 'foo'
+      })
+      spec.should.have_failure_message('expected exception of "foo" to be thrown, but nothing was')
+    end
+
+    it 'should fail saying no error matching was thrown'
+      spec = mock_it(function() {
+        -{ throw 'bar' }.should.throw_error(/foo/)
+      })
+      spec.should.have_failure_message('expected exception matching /foo/ to be thrown, but got "bar"')
+    end
+
+    it 'should fail saying constructors'
+      spec = mock_it(function() {
+        // IE loses scope of virtually everything once global inside nested eval()s
+        // Create everything we need here.
+        function CustomError(message) { this.message = message }
+        CustomError.prototype.toString = -{ return 'CustomError: oh no' }
+        -{ throw new CustomError('oh no') }.should.throw_error(Error)
+      })
+      spec.should.have_failure_message("expected Error to be thrown, but got CustomError: oh no")
+    end
+
+    it 'should fail saying multiple arg messages'
+      spec = mock_it(function() {
+        // IE loses scope of virtually everything once global inside nested eval()s
+        // Create everything we need here.
+        function CustomError(message) { this.message = message }
+        CustomError.name = "CustomError"
+        CustomError.prototype.toString = function(){ return 'CustomError: oh no' }
+        -{ throw new CustomError('oh no') }.should.throw_error(CustomError, /foo/)
+      })
+      spec.should.have_failure_message("expected CustomError and exception matching /foo/ to be thrown, but got CustomError: oh no")
+    end
+  end
+  
+  it 'should fail with constructor name'
+    spec = mock_it(function() {
+      function Foo(){ this.toString = function(){ return '<Foo>' }}
+      Foo.name = "Foo"
+      foo = new Foo
+      foo.should.not.be_an_instance_of Foo
+    })
+    spec.should.have_failure_message("expected <Foo> to not be an instance of Foo")
+  end
+  
+  it 'should fail with message of first failure'
+    spec = mock_it(function() {
+      true.should.be_true
+      'bar'.should.match(/foo/gm)
+      'bar'.should.include 'foo'
+    })
+    spec.should.have_failure_message('expected "bar" to match /foo/gm')
+  end
+  
+  it 'should fail with list'
+    spec = mock_it(function() {
+      ['foo', 'bar'].should.include 'foo', 'car'
+    })
+    spec.should.have_failure_message('expected [ "foo", "bar" ] to include "foo", "car"')
+  end
+  
+  it 'should list all failure messages'
+    spec = mock_it(function() {
+      false.should.be_true
+      true.should.be_false
+    })
+    spec.should.have_failure_message('expected false to be true ')
+    spec.should.have_failure_message('expected true to be false ')
+  end
+  
+  it 'should catch exceptions throw within specs'
+    spec = mock_it(function() {
+      // IE loses scope of virtually everything once global inside nested eval()s
+      // Create everything we need here.
+      Error.prototype.toString = -{ return "Error: " + this.message }
+      throw new Error('Oh noes!')
+    })
+    spec.should.have_failure_message(/Error: Oh noes!/)
+  end
+  
+  it 'should catch exceptions without constructors'
+    spec = mock_it(function() {
+      throw 'oh noes'
+    })
+    spec.should.have_failure_message(/oh noes/)
+  end
+  
+  it 'should catch indirect exceptions'
+    spec = mock_it(function() {
+      iDoNotExist.neitherDoI()
+    })
+    // NOTE: Most browsers will specifically mention iDoNotExist being undefined.
+    // IE only reports an Error.
+    spec.should.have_failure_message(/Error/)
+  end
+  
+end
+
+describe 'Contexts'
+  before 
+    JSpec.context = { iLike : 'cookies' }
+  end
+
+  after
+    JSpec.context = null
+  end
+
+  it 'should be replaceable'
+    iLike.should.equal 'cookies'
+  end
+end
+
+describe 'Misc'
+  it 'requires implementation'
+  end
+end
+

data/spec/{spec.matchers.js → unit/spec.matchers.js}

@@ -12,18 +12,32 @@ describe 'Matchers'
       10.should.not.eql 11
     end
     
-    it 'should loosely compare numbers as strings'
-      '11'.should.eql 11
-      '10'.should.not.eql 11
+    it 'should work with regular expressions'
+      a = /foo/
+      b = /foo/
+      c = /foo/g
+      d = /bar/
+      a.should.eql a
+      a.should.eql b
+      a.should.not.eql c
+      a.should.not.eql d
     end
     
-    it 'should hash compare arrays'
+    it 'should work with dates'
+      a = new Date('May 25 1987')
+      b = new Date('May 25 1987')
+      c = new Date('May 25 1988')
+      a.should.eql b
+      a.should.not.eql c
+    end
+    
+    it 'should work with arrays'
       [1, 2].should.eql [1, 2]
       [1, 2].should.not.eql [1, 3]
       [1, 2, [3], { foo : 'bar' }].should.eql [1, 2, [3], { foo : 'bar' }]
     end
     
-    it 'should hash compare objects'
+    it 'should work with objects'
       { foo : 'bar' }.should.eql { foo : 'bar' }
     end
     
@@ -33,11 +47,10 @@ describe 'Matchers'
       a.should.eql b
     end
     
-    it 'should hash compare arbitrary objects'
-      Foo = function(){}, Bar = function(){}
-      Bar.prototype = { doSomething : function(){ }}
-      foo = new Foo, foo2 = new Foo, bar = new Bar
-      foo.should.eql foo2
+    it 'should work with functions'
+      function foo(){}
+      function bar(){}
+      foo.should.eql foo
       foo.should.not.eql bar
     end
     
@@ -90,8 +103,8 @@ describe 'Matchers'
   
   describe 'be_undefined'
     it 'should check if a var is defined'
-      var foo
-      foo.should.be_undefined
+      var rawr
+      rawr.should.be_undefined
     end
   end
   
@@ -116,7 +129,7 @@ describe 'Matchers'
     
     it 'should check that a property has a specific value'
       'foo'.should.have_prop 'length', 3
-      { length : '3' }.should.have_prop 'length', 3
+      { length : 3 }.should.have_prop 'length', 3
     end
     
     it 'should check object hashes'
@@ -212,19 +225,24 @@ describe 'Matchers'
     end
     
     it 'should check if an error of a specific constructor is thrown'
+      function CustomError(message) { this.message = message }
+      CustomError.name = "CustomError"
       -{ throw new Error('foo') }.should.throw_error(Error)
-      -{ throw new TypeError('foo') }.should.throw_error(TypeError)
-      -{ throw 'foo' }.should.throw_error Error
-      -{ throw 'foo' }.should.not.throw_error TypeError
+      -{ throw new CustomError('foo') }.should.throw_error(CustomError)
+      -{ throw 'foo' }.should.not.throw_error CustomError
     end
     
     it 'should check if an error with a specific constructor and message is thrown'
-      -{ throw new TypeError('oh no!') }.should.throw_error(TypeError, 'oh no!')
-      -{ throw new TypeError('oh no!') }.should.not.throw_error(TypeError, 'foo bar')
-      -{ throw new TypeError('oh no!') }.should.throw_error(TypeError, /oh no/)
-      -{ throw new TypeError('oh no!') }.should.not.throw_error(TypeError, /foo bar/)
-      -{ throw new TypeError('oh no!') }.should.not.throw_error(Error, 'oh no!')
-      -{ throw new TypeError('oh no!') }.should.not.throw_error(Error, 'foo bar')
+      Error.name = "Error"
+      function CustomError(message) { this.message = message }
+      CustomError.name = "CustomError"
+      CustomError.prototype.toString = function(){ return 'CustomError: oh no!' }
+      -{ throw new CustomError('oh no!') }.should.throw_error(CustomError, 'oh no!')
+      -{ throw new CustomError('oh no!') }.should.not.throw_error(CustomError, 'foo bar')
+      -{ throw new CustomError('oh no!') }.should.throw_error(CustomError, /oh no/)
+      -{ throw new CustomError('oh no!') }.should.not.throw_error(CustomError, /foo bar/)
+      -{ throw new CustomError('oh no!') }.should.not.throw_error(Error, 'oh no!')
+      -{ throw new CustomError('oh no!') }.should.not.throw_error(Error, 'foo bar')
     end
   end
   
@@ -393,104 +411,161 @@ describe 'Matchers'
     end
                                      
     it 'should fail when the method does not exist'
-      person.should.receive('getPets')
+      spec = mock_it(function(){
+        person.should.receive('getPets')
+      })
+      spec.should.have_failure_message('expected person.getPets() to be called once, but  was not called')
     end
     
     it 'should fail when the method is never invoked'
-      personWithPets.should.receive('getPets')
+      spec = mock_it(function(){
+        personWithPets.should.receive('getPets')
+      })
+      spec.should.have_failure_message('expected personWithPets.getPets() to be called once, but  was not called')
     end
     
     it 'should fail when improper value is returned'
-      personWithPets.should.receive('getPets').and_return(['niko'])
-      personWithPets.getPets()
+      spec = mock_it(function(){
+        personWithPets.should.receive('getPets').and_return(['niko'])
+        personWithPets.getPets()
+      })
+      spec.should.have_failure_message('expected personWithPets.getPets() to return [ "niko" ] but got [ "izzy" ]')
     end
     
     it 'should fail when checking the type of multiple args and return types'
-      personWithPets.should.receive('addPets').with_args(an_instance_of(String), an_instance_of(Array)).and_return(an_instance_of(Array))
-      personWithPets.addPets('suki', 'max')
+      spec = mock_it(function(){
+        personWithPets.should.receive('addPets').with_args(an_instance_of(String), an_instance_of(Array)).and_return(an_instance_of(Array))
+        personWithPets.addPets('suki', 'max')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() to be called with an instance of String, an instance of Array but was called with "suki", "max"')
     end
         
     it 'should fail when not invoked the expected number of times'
-      personWithPets.should.receive('getPets', 'twice').and_return(['izzy'])
-      personWithPets.getPets()
+      spec = mock_it(function(){
+        personWithPets.should.receive('getPets', 'twice').and_return(['izzy'])
+        personWithPets.getPets()
+      })
+      spec.should.have_failure_message('expected personWithPets.getPets() to be called twice, but  was called once')
     end
     
     it 'should fail when not invoked many times'
-      personWithPets.should.receive('getPets', 3).and_return(['izzy'])
-      personWithPets.getPets()
-      personWithPets.getPets()
+      spec = mock_it(function(){
+        personWithPets.should.receive('getPets', 3).and_return(['izzy'])
+        personWithPets.getPets()
+        personWithPets.getPets()
+      })
+      spec.should.have_failure_message('expected personWithPets.getPets() to be called 3 times, but  was called twice')
     end
     
     it 'should fail when not invoked with specific arguments'
-      personWithPets.should.receive('addPet', 'once').with_args('suki')
-      personWithPets.addPet('niko')
+      spec = mock_it(function(){
+        personWithPets.should.receive('addPet', 'once').with_args('suki')
+        personWithPets.addPet('niko')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPet() to be called with "suki" but was called with "niko"')
     end
     
     it 'should fail when expecting multiple arguments'
-      personWithPets.should.receive('addPets').with_args('suki', 'max')
-      personWithPets.addPets('suki')
+      spec = mock_it(function(){
+        personWithPets.should.receive('addPets').with_args('suki', 'max')
+        personWithPets.addPets('suki')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() to be called with "suki", "max" but was called with "suki"')
     end
     
     it 'should fail when argument is of the wrong type'
-      personWithPets.should.receive('addPet').with_args(an_instance_of(String))
-      personWithPets.addPet(['suki'])
+      spec = mock_it(function(){
+        personWithPets.should.receive('addPet').with_args(an_instance_of(String))
+        personWithPets.addPet(['suki'])
+      })
+      spec.should.have_failure_message('expected personWithPets.addPet() to be called with an instance of String but was called with [ "suki" ]')
     end
     
     it 'should fail when return type is incorrect'
-      personWithPets.should.receive('addPet').and_return(an_instance_of(String))
-      personWithPets.addPet('suki')
+      spec = mock_it(function(){
+        personWithPets.should.receive('addPet').and_return(an_instance_of(String))
+        personWithPets.addPet('suki')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPet() to return an instance of String but got [ "izzy", "suki" ]')
     end
         
     it 'should fail with negation when a method is called'
-      personWithPets.should.not.receive('addPets')
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets')
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to be called once, but  was called once')
     end
 
     it 'should fail with negation with args'
-      personWithPets.should.not.receive('addPets').with_args('izzy')
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets').with_args('izzy')
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to be called with "izzy" but was')
     end
     
     it 'should fail with negation with return values'
-      personWithPets.should.not.receive('addPets').with_args('izzy').and_return(an_instance_of(Array))
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets').with_args('izzy').and_return(an_instance_of(Array))
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to return an instance of Array but it did')
     end
     
     it 'should fail with negation when called once with no times specified'
-      personWithPets.should.not.receive('addPets')
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets')
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to be called once, but  was called once')
     end
     
     it 'should fail with negation when called more than once with no times specified'
-      personWithPets.should.not.receive('addPets')
-      personWithPets.addPets('izzy')
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets')
+        personWithPets.addPets('izzy')
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to be called once, but  was called twice')
     end
         
     it 'should fail with negation when called more than the times specified'
-      personWithPets.should.not.receive('addPets', 3)
-      personWithPets.addPets('izzy')
-      personWithPets.addPets('izzy')
-      personWithPets.addPets('izzy')
-      personWithPets.addPets('izzy')
+      spec = mock_it(function(){
+        personWithPets.should.not.receive('addPets', 3)
+        personWithPets.addPets('izzy')
+        personWithPets.addPets('izzy')
+        personWithPets.addPets('izzy')
+        personWithPets.addPets('izzy')
+      })
+      spec.should.have_failure_message('expected personWithPets.addPets() not to be called 3 times, but  was called 4 times')
     end
     
     it 'should fail with boolean args'
-      foo = { bar : function(arg){ return arg }}
-      foo.should.receive('bar').with_args(true)
-      foo.bar(false)
+      spec = mock_it(function(){
+        foo = { bar : function(arg){ return arg }}
+        foo.should.receive('bar').with_args(true)
+        foo.bar(false)
+      })
+      spec.should.have_failure_message('expected [object Object].bar() to be called with true but was called with false')
     end
     
     it 'should fail with boolean return value true'
-      foo = { bar : function(){ return true }}
-      foo.should.receive('bar').and_return(false)
-      foo.bar()
+      spec = mock_it(function(){
+        foo = { bar : function(){ return true }}
+        foo.should.receive('bar').and_return(false)
+        foo.bar()
+      })
+      spec.should.have_failure_message('expected [object Object].bar() to return false but got true')
     end
     
     it 'should fail with boolean return value false'
-      foo = { bar : function(){ return false }}
-      foo.should.receive('bar').and_return(true)
-      foo.bar()
+      spec = mock_it(function(){
+        foo = { bar : function(){ return false }}
+        foo.should.receive('bar').and_return(true)
+        foo.bar()
+      })
+      spec.should.have_failure_message('expected [object Object].bar() to return true but got false')
     end
   end