raus22-jspec 2.0.4

data/spec/spec.matchers.js

@@ -0,0 +1,382 @@
+
+describe 'Matchers'
+
+  describe 'eql'
+    it 'should work with strings'
+      'test'.should.eql 'test'
+      'test'.should.not.eql 'foo'
+    end
+    
+    it 'should work with numbers'
+      11.should.eql 11
+      10.should.not.eql 11
+    end
+    
+    it 'should loosely compare numbers as strings'
+      '11'.should.eql 11
+      '10'.should.not.eql 11
+    end
+    
+    it 'should hash compare 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'
+      { foo : 'bar' }.should.eql { foo : 'bar' }
+    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
+      foo.should.not.eql bar
+    end
+    
+    it 'should work with constructors'
+      Array.should.eql Array
+      Array.should.not.eql Object
+    end
+  end
+  
+  describe 'equal'
+    it 'should perform strict comparisons'
+      'test'.should.equal 'test'
+      '1'.should.not.equal 1
+      true.should.be true
+      '1'.should.not.be true
+    end
+  end
+  
+  describe 'match'
+    it 'should match regular expressions'
+      'foobar'.should.match(/foo/)
+      'foobar'.should.not.match(/barfoo/)
+    end
+  end
+  
+  describe 'be_empty'
+    it 'should consider any object responding to a length of 0 to be empty'
+      ''.should.be_empty
+      ' '.should.not.be_empty
+      [].should.be_empty
+      { length : 0 }.should.be_empty
+    end
+  end
+  
+  describe 'be_null'
+    it 'should check if a value is null'
+      a = 0
+      b = null
+      null.should.be_null
+      0.should.not.be_null
+      a.should.not.be_null
+      b.should.be_null
+    end
+  end
+  
+  describe 'have_length'
+    it 'should compare the length of an object'
+      'foo'.should.have_length 3
+      [1, 2].should.have_length 2
+    end
+  end
+  
+  describe 'have_length_within'
+    it 'should check if an object has a length within the specified range'
+      'foo'.should.have_length_within 2..4
+      'f'.should.not.have_length_within 2..4
+    end
+  end
+  
+  describe 'have_prop'
+    it 'should check if a property exists'
+      'foo'.should.have_prop 'length'
+    end
+    
+    it 'should check that a property has a specific value'
+      'foo'.should.have_prop 'length', 3
+      { length : '3' }.should.have_prop 'length', 3
+    end
+    
+    it 'should check object hashes'
+      { foo : 1..3 }.should.have_prop 'foo',  1..3
+    end
+    
+    it 'should fail when the property does not exist'
+      'foo'.should.not.have_prop 'foo'
+      'foo'.should.not.have_prop 'foo', 'bar'
+    end
+    
+    it 'should fail when it is a function'
+      'foo'.should.not.have_prop 'toString'
+    end
+  end
+  
+  describe 'have_property'
+    it 'should check if a property exists'
+      'foo'.should.have_property 'length'
+    end
+    
+    it 'should check that a property has a specific value'
+      'foo'.should.have_property 'length', 3
+      { length : '3' }.should.not.have_property 'length', 3
+    end
+    
+    it 'should fail when the property does not exist'
+      'foo'.should.not.have_property 'foo'
+      'foo'.should.not.have_property 'foo', 'bar'
+    end
+    
+    it 'should fail when it is a function'
+      'foo'.should.not.have_property 'toString'
+    end
+  end
+  
+  describe 'respond_to'
+    it 'should check if an object contains a method'
+      'test'.should.respond_to('toString')
+      'test'.should.not.respond_to('rawr')
+    end
+  end
+  
+  describe 'include'
+    it 'should check if an object includes a property'
+      { hey : 'there' }.should.include 'hey'
+      { hey : 'there' }.should.not.include 'foo'
+    end
+    
+    it 'should check if a regular expression includes a string'
+      (/(foo)?bar/).should.include '(foo)'
+    end
+    
+    it 'should check if a function body includes a string'
+      -{ return [foo, bar] }.should.include 'foo', 'bar'
+    end
+    
+    it 'should check if an array contains element(s)'
+      [1,2,3].should.include 1
+      [1,2,3].should.include 1, 2, 3
+      [1].should.not.include 0
+      ['foo', 'bar'].should.include 'foo', 'bar'
+      ['foo', 'bar'].should.include 'bar', 'foo'
+      ['foo', 'bar'].should.not.include 'foo', 'rawr'
+      ['foo', 'bar'].should.not.include 'rawr', 'foo'
+    end
+    
+    it 'should check hashes of array elements'
+      [1, [2]].should.include [2]
+      [1, [2]].should.include [2], 1
+      [1, { two : 'three' }].should.include { two : 'three' } 
+    end
+  end
+  
+  describe 'be_a'
+    it 'should compare the constructor of an object'
+      'test'.should.be_a String
+      [].should.be_an Array
+    end
+  end
+
+  describe 'throw_error'
+    it 'should check if an error is thrown'
+      -{ throw 'error' }.should_throw_error
+      -{ return 'test' }.should_not_throw_error
+    end
+    
+    it 'should check if an error with a specific message is thrown'
+      -{ throw 'some foo bar' }.should.throw_error('some foo bar')
+      -{ throw 'some foo bar' }.should.throw_error(/foo bar/)
+      -{ throw 'some foo bar' }.should.not.throw_error(/rawr/)
+      -{ throw 'some foo bar' }.should.not.throw_error('rawr')
+    end
+    
+    it 'should check if an error of a specific constructor is thrown'
+      -{ throw new Error('foo') }.should.throw_error(Error)
+      -{ throw new TypeError('foo') }.should.throw_error(TypeError)
+      -{ throw 'foo' }.should.not.throw_error(Error)
+    end
+  end
+  
+  describe 'be_an_instance_of'
+    it 'should check that an object is an instance of another'
+      MyObject = function(){}
+      myInstance = new MyObject()
+      {}.should.be_an_instance_of Object
+      [].should.be_an_instance_of Array
+      MyObject.should.be_an_instance_of Function
+      myInstance.should.be_an_instance_of MyObject
+      myInstance.should.be_an_instance_of Object
+    end
+  end
+  
+  describe 'be_type'
+    it 'should compare the type of an object via typeof'
+      'hey'.should.be_type 'string'
+      {}.should.be_type 'object'
+    end
+  end
+
+  describe 'be_within'
+    it 'should check if a number is within a range'
+      5.should.be_within 1..10
+      15.should.not.be_within 10..5
+    end
+  end
+  
+  describe 'have'
+    it 'should check the length of a property'
+      person = { pets : ['izzy', 'niko'] }
+      person.should.have 2, 'pets'
+      person.should.not.have 3, 'pets'
+    end
+  end
+  
+  describe 'have_at_least'
+    it 'should check if a object has at least n of a property'
+      person = { pets : ['izzy', 'niko'] }
+      person.should.have_at_least 1, 'pets'
+      person.should.have_at_least 2, 'pets'
+      person.should.not.have_at_least 3, 'pets'
+    end
+  end
+  
+  describe 'have_at_most'
+    it 'should check if an object has at most n of a property'
+      person = { pets : ['izzy', 'niko'] }
+      person.should.have_at_most 2, 'pets'
+      person.should.have_at_most 3, 'pets'
+      person.should.not.have_at_most 1, 'pets'
+    end
+  end
+  
+  describe 'be_within'
+    it 'should check that an object has within n..n of a property'
+      person = { pets : ['izzy', 'niko'] }
+      person.should.have_within 1..2, 'pets'
+      person.should.have_within 2..5, 'pets'
+      person.should.not.have_within 5..10, 'pets'
+    end
+  end
+  
+  describe 'receive'
+    before_each
+      person = { toString : function(){ return 'person' }}
+      personWithPets = {
+        toString : function(){ return 'personWithPets'    },
+        getPets  : function()     { return ['izzy']       },
+        addPet   : function(name) { return ['izzy', name] },
+        addPets  : function(a, b) { return ['izzy', a, b] }
+      }
+    end
+    
+    it 'should fail when the method does not exist'
+      person.should.receive('getPets')
+    end
+    
+    it 'should fail when the method is never invoked'
+      personWithPets.should.receive('getPets')
+    end
+    
+    it 'should pass when the method is invoked'
+      personWithPets.should.receive('getPets')
+      personWithPets.getPets()
+    end
+    
+    it 'should pass and original method should still return its result'
+      personWithPets.should.receive('getPets')
+      personWithPets.getPets().should.eql ['izzy']
+    end
+    
+    it 'should pass when the proper value is returned'
+      personWithPets.should.receive('getPets').and_return(['izzy'])
+      personWithPets.getPets()
+    end
+    
+    it 'should fail when improper value is returned'
+      personWithPets.should.receive('getPets').and_return(['niko'])
+      personWithPets.getPets()
+    end
+    
+    it 'should fail when not invoked the expected number of times'
+      personWithPets.should.receive('getPets', 'twice').and_return(['izzy'])
+      personWithPets.getPets()
+    end
+    
+    it 'should fail when not invoked many times'
+      personWithPets.should.receive('getPets', 3).and_return(['izzy'])
+      personWithPets.getPets()
+      personWithPets.getPets()
+    end
+    
+    it 'should pass when invoked the expected number of times'
+      personWithPets.should.receive('getPets', 'twice').and_return(['izzy'])
+      personWithPets.getPets()
+      personWithPets.getPets()
+    end
+    
+    it 'should fail when not invoked with specific arguments'
+      personWithPets.should.receive('addPet', 'once').with_args('suki')
+      personWithPets.addPet('niko')
+    end
+    
+    it 'should pass when a method is invoked with specific arguments'
+      personWithPets.should.receive('addPet', 'once').with_args('suki')
+      personWithPets.addPet('suki')
+    end
+    
+    it 'should fail when expecting multiple arguments'
+      personWithPets.should.receive('addPets').with_args('suki', 'max')
+      personWithPets.addPets('suki')
+    end
+    
+    it 'should pass with multiple arguments'
+      personWithPets.should.receive('addPets').with_args('suki', 'max')
+      personWithPets.addPets('suki', 'max')
+    end
+    
+    it 'should pass with arguments and return value'
+      personWithPets.should.receive('addPet').with_args('suki').and_return(['izzy', 'suki'])
+      personWithPets.addPet('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'])
+    end
+    
+    it 'should pass when argument is the correct type'
+      personWithPets.should.receive('addPet').with_args(an_instance_of(String))
+      personWithPets.addPet('suki')
+    end
+    
+    it 'should fail when return type is incorrect'
+      personWithPets.should.receive('addPet').and_return(an_instance_of(String))
+      personWithPets.addPet('suki')
+    end
+        
+    it 'should pass when return type is correct'
+      personWithPets.should.receive('addPet').and_return(an_instance_of(Array))
+      personWithPets.addPet('suki')
+    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')
+    end
+        
+    it 'should pass when checking the type of multiple args and return types'
+      personWithPets.should.receive('addPets').with_args(an_instance_of(String), an_instance_of(String)).and_return(an_instance_of(Array))
+      personWithPets.addPets('suki', 'max')
+    end
+    
+    it 'should pass when checking for method calls to core prototypes'
+      array = ['foo', 'bar']
+      array.should.receive('toString').and_return('foo,bar')
+      'array: ' + array
+    end
+  end
+  
+end

data/spec/spec.rhino.js

@@ -0,0 +1,12 @@
+
+load('lib/jspec.js')
+load('spec/spec.grammar-less.js')
+
+JSpec
+.exec('spec/spec.grammar.js')
+.exec('spec/spec.js')
+.exec('spec/spec.matchers.js')
+.exec('spec/spec.utils.js')
+.exec('spec/spec.shared-behaviors.js')
+.run({ formatter : JSpec.formatters.Terminal, failuresOnly : true })
+.report()

data/spec/spec.shared-behaviors.js

@@ -0,0 +1,51 @@
+
+describe 'Shared Behaviors'
+  describe 'User'
+    before
+      User = function(name) { this.name = name }
+      user = new User('joe')
+    end
+    
+    it 'should have a name'
+      user.should.have_property 'name'
+    end
+    
+    describe 'Administrator'
+      should_behave_like('User')
+
+      before
+        Admin = function(name) { this.name = name }
+        Admin.prototype.may = function(perm){ return true }
+        user = new Admin('tj')
+      end
+
+      it 'should have access to all permissions'
+        user.may('edit pages').should.be_true
+      end
+
+      describe 'Super Administrator'
+        should_behave_like('Administrator')
+
+        before
+          SuperAdmin = function(name) { this.name = name }
+          SuperAdmin.prototype.may = function(perm){ return true }
+          user = new SuperAdmin('tj')
+        end
+      end
+    end
+  end
+
+  describe 'findSuite'
+    it 'should find a suite by full description'
+      JSpec.findSuite('Shared Behaviors User Administrator').should.be_a JSpec.Suite
+    end
+    
+    it 'should find a suite by name'
+      JSpec.findSuite('User').should.be_a JSpec.Suite
+    end
+    
+    it 'should return null when not found'
+      JSpec.findSuite('Rawr').should.be_null
+    end
+  end
+end

data/spec/spec.utils.js

@@ -0,0 +1,138 @@
+
+describe 'Utility'
+  describe 'wait'
+    it 'should wait for n milliseconds'
+      wait(2000)
+      setTimeout(function(){
+        true.should.be true
+      }, 1500)
+    end
+    
+    it 'should wait for n seconds'
+      wait(3, 'seconds')
+      setTimeout(function(){
+        true.should.be true
+      }, 2500)
+    end
+  end
+  
+  describe 'query'
+    it 'should return a pairs value'
+      query('suite', '?suite=Positive%20specs').should.equal 'Positive specs'
+    end
+    
+    it 'should return null when key is not present'
+      query('foo', '?suite=Positive%20specs').should.be_null
+    end
+  end
+  
+  describe 'strip'
+    it 'should strip whitespace by default'
+      strip(" foo \n\n").should.equal 'foo'
+    end
+    
+    it 'should strip the characters passed'
+      strip('[foo]', '\\[\\]').should.equal 'foo'
+    end
+  end
+  
+  describe 'each'
+    it 'should iterate an array'
+      result = []
+      each([1,2,3], function(value){
+        result.push(value)
+      })
+      result.should.eql [1,2,3]
+    end
+    
+    it 'should iterate words in a string'
+      result = []
+      each('some foo bar', function(value){
+        result.push(value)
+      })
+      result.should.eql ['some', 'foo', 'bar']
+    end
+  end
+  
+  describe 'map'
+    it 'should return an array of mapped values'
+      result = map([1,2,3], function(value){
+        return value * 2
+      })
+      result.should.eql [2,4,6]
+    end
+    
+    it 'should inherit the ability to iterate words in a string'
+      result = map('some foo bar', function(i, value){
+        return i + '-' + value
+      })
+      result.should.eql ['0-some', '1-foo', '2-bar']
+    end
+  end
+  
+  describe 'inject'
+    it 'should provide a memo object while iterating, not expecting returning of memo for composits'
+      result = inject([1,2,3], [], function(memo, value){
+        memo.push(value)
+      })
+      result.should.eql [1,2,3]
+    end
+    
+    it 'should require returning of memo for scalar variables'
+      result = inject([1,2,3], false, function(memo, value){
+        return memo ? memo : value == 2
+      })
+      result.should.be_true
+    end
+  end
+  
+  describe 'any'
+    it 'should return null when no matches are found'
+      result = any('some foo bar', function(value){
+        return value.length > 5
+      })
+      result.should.be_null
+    end
+    
+    it 'should return the value of the first matching expression'
+      result = any('foo some bar', function(value){
+        return value.length > 3
+      })
+      result.should.eql 'some'
+    end
+  end
+  
+  describe 'select'
+    it 'should return an array of values when the callback evaluates to true'
+      result = select('some foo bar baz stuff', function(value){
+        return value.length > 3
+      })
+      result.should.eql ['some', 'stuff']
+    end
+  end
+  
+  describe 'last'
+    it 'should return the last element in an array'
+      last(['foo', 'bar']).should.eql 'bar'
+    end
+  end
+  
+  describe 'argumentsToArray'
+    it 'should return an array of arguments'
+      func = function(){ return argumentsToArray(arguments) }
+      func('foo', 'bar').should.eql ['foo', 'bar']
+    end
+    
+    it 'should return the offset of an arguments array'
+      func = function(){ return argumentsToArray(arguments, 2) }
+      func('foo', 'bar', 'baz').should.eql ['baz']
+    end
+  end
+  
+  describe 'does'
+    it 'should assert without reporting'
+      does('foo', 'eql', 'foo')
+      JSpec.currentSpec.assertions.should.have_length 0
+    end
+  end
+end