chai-backbone-rails 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chai-backbone-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Matthijs Groen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+# Backbone::Chai
+
+Some matchers to help testing backbone structures.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'chai-backbone-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install chai-backbone-rails
+
+## Usage
+
+    #= require chai-backbone
+
+### Triggers
+
+    model.should.trigger("change", with: [model]).when -> model.set attribute: "value"
+
+this can also be chained further:
+
+    model.should.trigger("change").and.trigger("change:attribute").when -> model.set attribute: "value"
+    model.should.trigger("change").and.not.trigger("reset").when -> model.set attribute: "value"
+
+### Routing (will be ported soon!)
+
+    "page/3".should.route_to myRouter, "openPage", arguments: ["3"]
+    "page/3".should.route_to myRouter, "openPage", considering: [conflictingRouter]
+
+### Sinon (will be ported soon!)
+
+Matchers have also been added for sinonjs. 
+
+    #= require sinon-chai
+    chai.use sinonChai
+
+These are not complete yet, see tests and code for details.
+
+    spy.should.have.been.called.exactly(x).times
+    spy.should.have.been.called.before otherSpy
+    spy.should.have.been.called.after otherSpy
+    spy.should.have.been.called.with "argument1", 2, "argument3"
+    spy.should.have.been.not_called
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/chai-backbone-rails.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/chai-backbone-rails/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Matthijs Groen"]
+  gem.email         = ["matthijs.groen@gmail.com"]
+  gem.description   = %q{Chai.js matchers for Backbone.js framework}
+  gem.summary       = %q{A set of assertion matchers to test Backbone code using Konacha in Rails}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "chai-backbone-rails"
+  gem.require_paths = ["lib"]
+  gem.version       = Chai::Backbone::Rails::VERSION
+end

data/lib/chai-backbone-rails.rb

@@ -0,0 +1,10 @@
+require "chai-backbone-rails/version"
+
+module Chai
+  module Backbone
+    module Rails
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end

data/lib/chai-backbone-rails/version.rb

@@ -0,0 +1,7 @@
+module Chai
+  module Backbone
+    module Rails
+      VERSION = "0.0.1"
+    end
+  end
+end

data/test/sinon-chai_spec.js.coffee

@@ -0,0 +1,96 @@
+#= require spec_helper
+
+describe "Sinon Chai Matchers", ->
+
+  callback = null
+
+  beforeEach -> callback = sinon.spy()
+
+  describe "#not_called", ->
+
+    it "passes if not called", ->
+      expect(-> callback.should.have.been.not_called).to.not.throw()
+
+    it "raises AsserionError if called", ->
+      callback()
+      expect(-> callback.should.have.been.not_called).throw(/been called/)
+
+  describe "called", ->
+
+    describe "#exactly", ->
+      it "raises AssertionError if not called", ->
+        expect(-> callback.should.have.been.called.exactly(2).times).to.throw(/been called exactly twice, but it was called 0 times/)
+
+      it "passes if matches", ->
+        callback()
+        expect(-> callback.should.have.been.called.exactly(1).time).to.not.throw()
+
+      it "raises AssertionError if called more than specified", ->
+        callback()
+        callback()
+        callback()
+        callback()
+        expect(-> callback.should.have.been.called.exactly(3).times).to.throw(/been called exactly thrice, but it was called 4 times/)
+
+    describe "#before", ->
+      second = null
+
+      beforeEach -> second = sinon.spy()
+
+      it "raises AssertionError if first not called", ->
+        second()
+        expect(-> callback.should.have.been.called.before(second)).to.throw(/been called before/)
+
+      it "passes if second not called", ->
+        callback()
+        expect(-> callback.should.have.been.called.before(second)).to.not.throw()
+
+      it "raises AssertionError if order is wrong", ->
+        second()
+        callback()
+        expect(-> callback.should.have.been.called.before(second)).to.throw(/been called before/)
+
+      it "passes if second if spies are called in correct order", ->
+        callback()
+        second()
+        expect(-> callback.should.have.been.called.before(second)).to.not.throw()
+
+    describe "#after", ->
+      second = null
+
+      beforeEach -> second = sinon.spy()
+
+      it "raises AssertionError if first not called", ->
+        second()
+        expect(-> callback.should.have.been.called.after(second)).to.throw(/been called before/)
+
+      it "raises AssertionError if second not called", ->
+        callback()
+        expect(-> callback.should.have.been.called.after(second)).to.throw(/been called before/)
+
+      it "raises AssertionError if order is wrong", ->
+        callback()
+        second()
+        expect(-> callback.should.have.been.called.after(second)).to.throw(/been called before/)
+
+      it "passes if second if spies are called in correct order", ->
+        second()
+        callback()
+        expect(-> callback.should.have.been.called.after(second)).to.not.throw()
+
+    describe "#with", ->
+
+      it "raises AssertionError if callback not called", ->
+        expect(-> callback.should.have.been.called.with(1)).to.throw(/been called with arguments/)
+
+      it "passes if parameters match exactly", ->
+        callback(1)
+        expect(-> callback.should.have.been.called.with(1)).to.not.throw()
+
+      it "raises AssertionError if parameters do not match", ->
+        callback(4)
+        expect(-> callback.should.have.been.called.with(5)).to.throw(/been called with arguments/)
+
+      it "passes if more than specified parameters are passed", ->
+        callback(1,2,3)
+        expect(-> callback.should.have.been.called.with(1,2)).to.not.throw()

data/vendor/assets/javascripts/chai-backbone.js.coffee

@@ -0,0 +1,113 @@
+#= require underscore
+
+((chaiBackbone) ->
+  # Module systems magic dance.
+  if (typeof require == "function" && typeof exports == "object" && typeof module == "object")
+    # NodeJS
+    module.exports = chaiBackbone
+  else if (typeof define == "function" && define.amd)
+    # AMD
+    define -> chaiBackbone
+  else
+    # Other environment (usually <script> tag): plug in to global chai instance directly.
+    chai.use chaiBackbone
+)((chai, utils) ->
+  inspect = utils.inspect
+  flag = utils.flag
+
+  # Verifies if the subject fires a trigger 'when' events happen
+  #
+  # Examples:
+  #   model.should.trigger("change", with: [model]).when -> model.set attribute: "value"
+  #   model.should.not.trigger("change:thing").when -> model.set attribute: "value"
+  #   model.should.trigger("change").and.not.trigger("change:thing").when -> model.set attribute: "value"
+  #
+  # @param trigger the trigger expected to be fired
+  chai.Assertion.addMethod 'trigger', (trigger, options = {}) ->
+    definedActions = flag(this, 'whenActions') || []
+
+    # Add a around filter to the when actions
+    definedActions.push
+      negate: flag(this, 'negate')
+
+      # set up the callback to trigger
+      before: (context) ->
+        @callback = sinon.spy()
+        flag(context, 'object').on trigger, @callback
+
+      # verify if our callback is triggered
+      after: (context) ->
+        negate = flag(context, 'negate')
+        flag(context, 'negate', @negate)
+        context.assert @callback.calledOnce,
+          "expected to trigger #{trigger}",
+          "expected not to trigger #{trigger}"
+
+        if options.with?
+          context.assert @callback.calledWith(options.with...),
+            "expected trigger to be called with #{inspect options.with}, but was called with #{inspect @callback.args[0]}.",
+            "expected trigger not to be called with #{inspect options.with}, but was"
+        flag(context, 'negate', negate)
+    flag(this, 'whenActions', definedActions)
+
+  chai.Assertion.addMethod 'when', (val) ->
+    definedActions = flag(this, 'whenActions') || []
+
+    action.before?(this) for action in definedActions
+    val() # execute the 'when'
+    action.after?(this) for action in definedActions
+)
+
+  ## Verify if a url fragment is routed to a certain method on the router
+  ## Options:
+  ## - you can consider multiple routers to test routing priorities
+  ## - you can indicate expected arguments to test url extractions
+  ##
+  ## Examples:
+  ##
+  ##   class MyRouter extends Backbone.Router
+  ##     routes:
+  ##       "home/:page/:other": "homeAction"
+  ##
+  ##   myRouter = new MyRouter
+  ##
+  ##   "home/stuff/thing".should.route_to(myRouter, "homeAction")
+  ##   "home/stuff/thing".should.route_to(myRouter, "homeAction", arguments: ["stuff", "thing"])
+  ##   "home/stuff/thing".should.route_to(myRouter, "homeAction", consider: [otherRouterWithPossiblyConflictingRoute])
+  ##
+  #route_to: (router, methodName, options = {}) ->
+    ## move possible active Backbone history out of the way temporary
+    #current_history = Backbone.history
+
+    ## reset history to clear active routes
+    #Backbone.history = new Backbone.History
+
+    #spy = sinon.spy router, methodName # spy on our expected method call
+    #router._bindRoutes() # inject router routes into our history
+    #if options.considering? # if multiple routers are provided load their routes aswell
+      #consideredRouter._bindRoutes() for consideredRouter in options.considering
+
+    ## manually set the root option to prevent calling Backbone.history.start() which is global
+    #Backbone.history.options =
+      #root: '/'
+
+    ## fire our route to test
+    #Backbone.history.loadUrl @obj
+
+    ## set back our history. The spy should have our collected info now
+    #Backbone.history = current_history
+    ## restore the router method
+    #router[methodName].restore()
+
+    ## now assert if everything went according to spec
+    #@assert spy.calledOnce,
+      #"expected '#{@obj}' to route to #{methodName}",
+      #"expected '#{@obj}' not to route to #{methodName}"
+
+    ## verify arguments if they were provided
+    #if options.arguments?
+      #@assert spy.calledWith(options.arguments...),
+        #"expected '#{methodName}' to be called with #{chai.inspect options.arguments}, but was called with #{chai.inspect spy.args[0]} instead",
+        #"expected '#{methodName}' not to be called with #{chai.inspect options.arguments}, but was"
+
+

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: chai-backbone-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matthijs Groen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-16 00:00:00.000000000 Z
+dependencies: []
+description: Chai.js matchers for Backbone.js framework
+email:
+- matthijs.groen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- chai-backbone-rails.gemspec
+- lib/chai-backbone-rails.rb
+- lib/chai-backbone-rails/version.rb
+- test/sinon-chai_spec.js.coffee
+- vendor/assets/javascripts/chai-backbone.js.coffee
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A set of assertion matchers to test Backbone code using Konacha in Rails
+test_files:
+- test/sinon-chai_spec.js.coffee