socialcast_shoulda_ext 0.1.2

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle
+Gemfile.lock
+test/debug.log
+test/rails3_root/db/*.sqlite3
+test/rails3_root/tmp
+test/rails3_root/log

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'rails', "~> 3.0.0"
+  gem 'shoulda', '>= 2.11.3'
+  gem 'json', ">= 0"
+  gem 'bundler', ">= 0"
+  gem 'mocha', ">= 0"
+  gem 'sqlite3-ruby', "~> 1.3.2"
+  gem 'ruby-debug', ">= 0"
+end

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011, Geoffrey Hichborn, Socialcast, Inc.
+
+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.rdoc

@@ -0,0 +1,126 @@
+
+= Socialcast Shoulda Extensions
+Adds new matchers and functionality to the shoulda test library
+
+= Installation
+
+In your Gemfile:
+
+  group :test do
+    gem 'socialcast_shoulda_ext', :git => 'git@github.com:socialcast/socialcast-shoulda-ext.git', :require => 'shoulda_ext'
+  end
+  
+If you want to include the trigger_callbacks matcher, also add the following to your test helper:
+
+  ShouldaExt::Matchers::TriggerCallbackMatcher.attach_active_record_callback_hooks!
+
+= Matchers
+
+== RecordCountChangeMatcher
+Test if the count for a model has changed, and by how much.  Requires the context_with_matcher_before_hooks patch, which is included by default.
+
+Provides the following matcher methods:
+
+- create_record(klass_or_symbol)
+  Alias for change_record_count.for(klass_or_symbol).by(1)
+
+- create_records(klass_or_symbol, amount)
+  Alias for change_record_count.for(klass_or_symbol).by(amount)
+
+- destroy_record(klass_or_symbol)
+  Alias for change_record_count.for(klass_or_symbol).by(-1)
+
+- destroy_records(klass_or_symbol, amount) 
+  Alias for change_record_count.for(klass_or_symbol).by(-amount)
+
+- change_record_count
+  Tests the difference in record count before and after the current setup/subject block
+  Can be used with the follow methods:
+  - for(klass_or_symbol)
+    Provides the class which the test is being performed on.  Can be a constant or a symbol
+
+  - by(amount)
+    Provides an expected difference for the number of records for the specified class.
+    Excluding this number will allow the matcher to check for any difference
+
+Examples:
+
+  context "creating a blog article" do
+
+    context "with good parameters" do
+      setup do
+        post :create, :blog => {:title => 'my blog post', :body => 'Ipsum lorem...'}
+      end
+      should create_record :blog
+    end
+
+    context "without a body" do
+      setup do
+        post :create, :blog => {:title => 'my blog post' }
+      end
+      should_not create_record Blog
+    end
+
+  end
+  
+== RespondWithJson
+Check if the controller's response is json
+   
+Examples:
+
+  context ":index.json" do
+    setup do
+      get :index, :format => 'json'
+    end
+    # Just check to see that the response was json
+    should respond_with_json  
+
+    # Evaluate the hash produced by the json yourself
+    should respond_with_json { |json| json.first['blog']['title'] == 'blog post 1'}
+  
+    # Provide an exact match
+    should respond_with_json.exactly(['blog' => {'id' => 1, 'title' => 'blog post 1'}])
+
+    # Provide an exact match with a block
+    should response_with_json.exactly{ |json| JSON.parse(Blog.all.to_json)}
+  end
+ 
+  context ":index.html" do
+    setup do
+      get :index
+    end
+ 
+    # or the negation
+    should_not respond_with_json
+  end
+
+== TriggerCallbackMatcher
+
+Test if create, update, destroy, or save callbacks were triggered.
+
+Requires running
+ShouldaExt::Matchers::TriggerCallbackMatcher.attach_active_record_callback_hooks!
+in your test suite in order to work properly.
+
+Examples:
+
+  context "doing nothing to a record" do
+    subject { Blog.new :title => 'blog title' }
+    should_not trigger_callbacks
+  end
+
+  context "creating a record" do
+    subject { Blog.create! :title => 'blog title' }
+    should trigger_callbacks.for :create
+    should_not trigger_callbacks.for :update, :destroy
+  end
+
+= Integrations
+
+Currently only integrates with test/unit.  RSpec support to come.
+
+= Shoulda Extensions
+
+== ContextWithMatcherBeforeHooks
+
+Adds the ability to define a 'before' method on any method which will be run before each context's setup/subject block.  Used by RecordCountChangeMatcher to record the number of records before the tested operation takes place.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+task :default => :test

data/lib/shoulda_ext.rb

@@ -0,0 +1,7 @@
+require 'shoulda_ext/version'
+
+require 'shoulda'
+require 'shoulda_ext/assertions'
+require 'shoulda_ext/matchers'
+
+require 'shoulda_ext/integrations/test_unit'

data/lib/shoulda_ext/assertions.rb

@@ -0,0 +1,14 @@
+
+module ShouldaExt
+  module Assertions
+    # Asserts the result of object.blank?
+    def assert_blank(object, message = nil)
+      assert(object.blank?, message || "Expected object to be blank")
+    end
+
+    # Asserts the result of !object.blank?
+    def assert_not_blank(object, message = nil)
+      assert(!object.blank?, message || "Expected object to not be blank")
+    end
+  end
+end

data/lib/shoulda_ext/integrations/test_unit.rb

@@ -0,0 +1,13 @@
+
+require 'shoulda_ext/assertions'
+require 'shoulda_ext/matchers'
+require 'test/unit'
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      extend ShouldaExt::Matchers
+      include ShouldaExt::Assertions
+    end
+  end
+end

data/lib/shoulda_ext/matchers.rb

@@ -0,0 +1,9 @@
+
+require 'shoulda_ext/matchers/record_count_change'
+require 'shoulda_ext/matchers/trigger_callback'
+require 'shoulda_ext/matchers/respond_with_json'
+
+module ShouldaExt # :nodoc:
+  module Matchers # :nodoc:
+  end
+end

data/lib/shoulda_ext/matchers/record_count_change.rb

@@ -0,0 +1,127 @@
+
+require 'shoulda_ext/shoulda_patches/context_with_matcher_before_hooks'
+
+module ShouldaExt # :nodoc:
+  module Matchers # :nodoc:
+    
+    # Test if a record of klass is created during the current setup/subject block
+    # Equivilent to change_record_count.for(klass).by(1)
+    def create_record(klass)
+      RecordCountChangeMatcher.new.for(klass).by(1)
+    end
+    
+    # Test if a record of klass is destroyed during the current setup/subject block
+    # Equivilent to change_record_count.for(klass).by(-1)
+    def destroy_record(klass)
+      RecordCountChangeMatcher.new.for(klass).by(-1)
+    end
+
+    # Test if 'count' records of 'klass' are created during the current setup/subject block
+    # Equivilent to change_record_count.for(klass).by(count)
+    def create_records(klass, count)
+      RecordCountChangeMatcher.new.for(klass).by(count)
+    end
+
+    # Test if 'count' records of 'klass' are destroyed during the current setup/subject block  
+    # Equivilent to change_record_count.for(klass).by(-count)
+    def destroy_records(klass, count)
+      RecordCountChangeMatcher.new.for(klass).by(-count)
+    end
+  
+    # Tests the difference in record count before and after the current setup/subject block
+    # Can be used with the follow methods:
+    #   - for(klass)
+    #     Provides the class which the test is being performed on.  Can be a constant or a symbol
+    #
+    #   - by(count)
+    #     Provides an expected difference for the number of records for the specified class.  If 
+    #     this count is not specified, the matcher will test for any difference.
+    #
+    # Examples:
+    # 
+    #     context "creating a blog article" do
+    # 
+    #       context "with good parameters" do
+    #         setup do
+    #           post :create, :blog => {:title => 'my blog post', :body => 'Ipsum lorem...'}
+    #         end
+    # 
+    #         # All of the below are synonomous
+    #         should create_record Blog
+    #         should create_record :blog
+    #         should change_record_count.for(Blog).by(1)
+    #       end
+    # 
+    #       context "without a body" do
+    #         setup do
+    #           post :create, :blog => {:title => 'my blog post' }
+    #         end
+    # 
+    #         # All of the below are synonomous
+    #         should_not create_record Blog
+    #         should_not change_record_count.for(Blog)
+    #       end
+    # 
+    #     end
+    def change_record_count
+      RecordCountChangeMatcher.new
+    end
+    
+    class RecordCountChangeMatcher # :nodoc:
+
+      def before
+        @triggered_before = true
+        @previous_count = @klass.count
+      end
+
+      def for(klass)
+        klass = klass.to_s.classify.constantize if klass.is_a? Symbol
+        @klass = klass
+        self
+      end
+    
+      def by(expected_change)
+        @expected_change = expected_change
+        self
+      end
+
+      def matches?(*)
+        @new_count = @klass.count
+        found_expected?
+      end
+
+      def description
+        "expect #{@klass.name}.count to change#{" by #{@expected_change} records" if @expected_change }"
+      end
+    
+      def failure_message
+        "Expected #{errors.join("\n")}"
+      end
+
+      def negative_failure_message
+        "Did not expect #{errors.join("\n")}"
+      end
+      
+      def errors
+        @errors = []
+        @errors << "Never received :before call.  Please make sure you are running this with a setup/subject block in the current context and the ContextWithMatcherBeforeHooks patch is installed" if !@triggered_before
+        @errors << "#{expected_count} #{@klass.name} records, but found #{@new_count}" if !found_expected? && @expected_change
+        @errors << "#{@klass.name}.count to change" if !found_expected? && !@expected_change
+        @errors
+      end
+
+      def expected_count
+        @previous_count + @expected_change
+      end
+
+      def found_expected?
+        if @expected_change
+          expected_count == @new_count
+        else
+          @new_count != @previous_count
+        end
+      end
+
+    end
+  end
+end

data/lib/shoulda_ext/matchers/respond_with_json.rb

@@ -0,0 +1,99 @@
+module ShouldaExt # :nodoc:
+  module Matchers # :nodoc:
+    
+    # Check if the controller's response is json
+    # 
+    # Example uses:
+    #  context ":index.json" do
+    #   setup do
+    #     get :index, :format => 'json'
+    #   end
+    #   # Just check to see that the response was json
+    #   should respond_with_json  
+    #
+    #   # Evaluate the hash produced by the json yourself
+    #   should respond_with_json { |json| json.first['blog']['title'] == 'blog post 1'}
+    #   
+    #   # Provide an exact match
+    #   should respond_with_json.exactly(['blog' => {'id' => 1, 'title' => 'blog post 1'}])
+    #
+    #   # Provide an exact match with a block
+    #   should response_with_json.exactly{ |json| JSON.parse(Blog.all.to_json)}
+    # end
+    #  
+    # context ":index.html" do
+    #   setup do
+    #     get :index
+    #   end
+    #  
+    #   # or the negation
+    #   should_not respond_with_json
+    # end 
+    def respond_with_json(description = nil, &block)
+      RespondWithJsonMatcher.new(self, description, &block)
+    end
+
+    class RespondWithJsonMatcher
+      def initialize(context, description = nil, &block)
+        @block = block || lambda{|*| true }
+        @description = description
+        @exactly = false
+      end
+      
+      # Provide an exact result directly or using a block argument
+      def exactly(expected_json = nil, &block)
+        @exactly = true
+        @expected_value = expected_json
+        @block = block
+        self
+      end
+      
+      def in_context(context)
+        @context = context
+        self
+      end
+      
+      def description
+        @description ||= "respond with JSON"
+      end
+      
+      def failure_message
+        "Expected to respond with json, but: #{errors.join("\n")}"
+      end
+      
+      def negative_failure_message
+        "Expected not to respond with json, but: #{errors.join("\n")}"
+      end
+      
+      def errors
+        @errors = []
+        @errors << 'Failed to parse the response as JSON' unless @parsable
+        @errors << "Failed to #{'exactly ' if @exactly}match json: expected #{@exactly ? @expected_value.inspect : true}, but found #{@exactly ? @response_json.inspect : @block_result} " unless @json_matched
+        @errors
+      end
+      
+      def json_matched?
+        @expected_value ||= run_block
+        @json_matched ||= @exactly ? @response_json == @expected_value : !!@block_result
+      end
+      
+      def run_block
+        @block_result = @context.instance_exec(@response_json, &@block)
+      end
+      
+      def parsable?
+        @parsable = true
+        @response_json = JSON.parse(@subject.response.body)
+      rescue
+        @parsable = false
+      end
+      
+      def matches?(subject)
+        @subject = subject
+        parsable? and json_matched?
+      end
+    end
+    
+  end
+end
+