shoulda-matchers 1.0.0 → 1.1.0

data/lib/shoulda/matchers/active_record/query_the_database_matcher.rb

@@ -0,0 +1,107 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+
+      # Ensures that the number of database queries is known. Rails 3.1 or greater is required.
+      #
+      # Options:
+      # * <tt>when_calling</tt> - Required, the name of the method to examine.
+      # * <tt>with</tt> - Used in conjunction with <tt>when_calling</tt> to pass parameters to the method to examine.
+      # * <tt>or_less</tt> - Pass if the database is queried no more than the number of times specified, as opposed to exactly that number of times.
+      #
+      # Examples:
+      #   it { should query_the_database(4.times).when_calling(:complicated_counting_method)
+      #   it { should query_the_database(4.times).or_less.when_calling(:generate_big_report)
+      #   it { should_not query_the_database.when_calling(:cached_count)
+      #
+      def query_the_database(times = nil)
+        QueryTheDatabaseMatcher.new(times)
+      end
+
+      class QueryTheDatabaseMatcher # :nodoc:
+        def initialize(times)
+          if times.respond_to?(:count)
+            @expected_query_count = times.count
+          else
+            @expected_query_count = times
+          end
+        end
+
+        def when_calling(method_name)
+          @method_name = method_name
+          self
+        end
+
+        def with(*method_arguments)
+          @method_arguments = method_arguments
+          self
+        end
+
+        def or_less
+          @expected_count_is_maximum = true
+          self
+        end
+
+        def matches?(subject)
+          @queries = []
+
+          subscriber = ActiveSupport::Notifications.subscribe('sql.active_record') do |name, started, finished, id, payload|
+            @queries << payload unless filter_query(payload)
+          end
+
+          if @method_arguments
+            subject.send(@method_name, *@method_arguments)
+          else
+            subject.send(@method_name)
+          end
+
+          ActiveSupport::Notifications.unsubscribe(subscriber)
+
+          if @expected_count_is_maximum
+            @queries.length <= @expected_query_count
+          elsif @expected_query_count.present?
+            @queries.length == @expected_query_count
+          else
+            @queries.length > 0
+          end
+        end
+
+        def failure_message
+          if @expected_query_count
+            "Expected ##{@method_name} to cause #{@expected_query_count} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
+          else
+            "Expected ##{@method_name} to query the database but it actually caused #{@queries.length} queries:" + friendly_queries
+          end
+        end
+
+        def negative_failure_message
+          if @expected_query_count
+            "Expected ##{@method_name} to not cause #{@expected_query_count} database queries but it actually caused #{@queries.length} queries:" + friendly_queries
+          else
+            "Expected ##{@method_name} to not query the database but it actually caused #{@queries.length} queries:" + friendly_queries
+          end
+        end
+
+        private
+
+        def friendly_queries
+          @queries.map do |query|
+            "\n  (#{query[:name]}) #{query[:sql]}"
+          end.join
+        end
+
+        def filter_query(query)
+          query[:name] == 'SCHEMA' || looks_like_schema(query[:sql])
+        end
+
+        def schema_terms
+          ['FROM sqlite_master', 'PRAGMA', 'SHOW TABLES', 'SHOW KEYS FROM', 'SHOW FIELDS FROM']
+        end
+
+        def looks_like_schema(sql)
+          schema_terms.any? { |term| sql.include?(term) }
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/active_record/serialize_matcher.rb

@@ -0,0 +1,111 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :nodoc:
+
+      # Ensure that the field becomes serialized.
+      #
+      # Options:
+      # * <tt>:as</tt> - tests that the serialized attribute makes use of the class_name option.
+      #
+      # Example:
+      #   it { should serialize(:details) }
+      #   it { should serialize(:details).as(Hash) }
+      #
+      def serialize(name)
+        SerializeMatcher.new(name)
+      end
+
+      class SerializeMatcher # :nodoc:
+        def initialize(name)
+          @name = name.to_s
+        end
+
+        def as(type)
+          @type = type
+          self
+        end
+
+        def as_instance_of(type)
+          @instance_type = type
+          self
+        end
+
+        def matches?(subject)
+          @subject = subject
+          serialization_valid? && type_valid?
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          description = "serialize :#{@name}"
+          description += " class_name => #{@type}" if @type
+          description
+        end
+
+        protected
+
+        def serialization_valid?
+          if model_class.serialized_attributes.keys.include?(@name)
+            true
+          else
+            @missing = "no serialized attribute called :#{@name}"
+            false
+          end
+        end
+
+        def class_valid?
+          if @type
+            klass = model_class.serialized_attributes[@name]
+            if klass == @type
+              true
+            else
+              if klass.respond_to?(:object_class) && klass.object_class == @type
+                true
+              else
+                @missing = ":#{@name} should be a type of #{@type}"
+                false
+              end
+            end
+          else
+            true
+          end
+        end
+
+        def model_class
+          @subject.class
+        end
+
+        def instance_class_valid?
+          if @instance_type
+            if model_class.serialized_attributes[@name].class == @instance_type
+              true
+            else
+              @missing = ":#{@name} should be an instance of #{@type}"
+              false
+            end
+          else
+            true
+          end
+        end
+
+        def type_valid?
+          class_valid? && instance_class_valid?
+        end
+
+        def expectation
+          expectation = "#{model_class.name} to serialize the attribute called :#{@name}"
+          expectation += " with a type of #{@type}" if @type
+          expectation += " with an instance of #{@instance_type}" if @instance_type
+          expectation
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/integrations/rspec.rb

@@ -35,4 +35,3 @@ if defined?(::ActionMailer)
     end
   end
 end
-

data/lib/shoulda/matchers/version.rb

@@ -1,5 +1,5 @@
 module Shoulda
   module Matchers
-    VERSION = "1.0.0".dup
+    VERSION = '1.1.0'.freeze
   end
 end

data/shoulda-matchers.gemspec

@@ -0,0 +1,30 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+require 'shoulda/matchers/version'
+
+Gem::Specification.new do |s|
+  s.name        = "shoulda-matchers"
+  s.version     = Shoulda::Matchers::VERSION.dup
+  s.authors     = ["Tammer Saleh", "Joe Ferris", "Ryan McGeary", "Dan Croak",
+                   "Matt Jankowski", "Stafford Brunk"]
+  s.date        = Time.now.strftime("%Y-%m-%d")
+  s.email       = "support@thoughtbot.com"
+  s.homepage    = "http://thoughtbot.com/community/"
+  s.summary     = "Making tests easy on the fingers and eyes"
+  s.description = "Making tests easy on the fingers and eyes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('activesupport', '>= 3.0.0')
+
+  s.add_development_dependency('appraisal',   '~> 0.4.0')
+  s.add_development_dependency('aruba')
+  s.add_development_dependency('bourne',      '~> 1.1.2')
+  s.add_development_dependency('bundler',     '~> 1.1.0')
+  s.add_development_dependency('cucumber',    '~> 1.1.9')
+  s.add_development_dependency('rails',       '~> 3.0')
+  s.add_development_dependency('rake',        '~> 0.9.2')
+  s.add_development_dependency('rspec-rails', '~> 2.6.1')
+end

data/spec/fixtures/addresses.yml

@@ -0,0 +1,3 @@
+first:
+  title: Home
+  addressable: first (User)

data/spec/fixtures/posts.yml

@@ -0,0 +1,5 @@
+first:
+  id: 1
+  title: My Cute Kitten!
+  body: This is totally a cute kitten
+  user_id: 1

data/spec/fixtures/tags.yml

@@ -0,0 +1,9 @@
+first:
+  id: 1
+  name: Stuff
+second:
+  id: 2
+  name: Rails
+third:
+  id: 3
+  name: Nothing

data/spec/fixtures/users.yml

@@ -0,0 +1,6 @@
+first:
+  id: 1
+  name: Some dude
+  age: 2
+  email: none@none.com
+  ssn: 123456789

data/spec/shoulda/action_controller/assign_to_matcher_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::AssignToMatcher do
+  it "should include the actual class in the failure message" do
+    define_constant(:WrongClass) do
+      def to_s; "wrong class" end
+    end
+
+    controller = build_response { @var = WrongClass.new }
+    matcher = Shoulda::Matchers::ActionController::AssignToMatcher.new(:var).with_kind_of(Fixnum)
+    matcher.matches?(controller)
+
+    matcher.failure_message.should =~ /but got wrong class \(WrongClass\)$/
+  end
+
+  context "a controller that assigns to an instance variable" do
+    let(:controller) { build_response { @var = 'value' } }
+
+    it "should accept assigning to that variable" do
+      controller.should assign_to(:var)
+    end
+
+    it "should accept assigning to that variable with the correct class" do
+      controller.should assign_to(:var).with_kind_of(String)
+    end
+
+    it "should reject assigning to that variable with another class" do
+      controller.should_not assign_to(:var).with_kind_of(Fixnum)
+    end
+
+    it "should accept assigning the correct value to that variable" do
+      controller.should assign_to(:var).with('value')
+    end
+
+    it "should reject assigning another value to that variable" do
+      controller.should_not assign_to(:var).with('other')
+    end
+
+    it "should reject assigning to another variable" do
+      controller.should_not assign_to(:other)
+    end
+
+    it "should accept assigning to the same value in the test context" do
+      expected = 'value'
+      controller.should assign_to(:var).in_context(self).with { expected }
+    end
+
+    it "should reject assigning to the another value in the test context" do
+      expected = 'other'
+      controller.should_not assign_to(:var).in_context(self).with { expected }
+    end
+  end
+
+  context "a controller that assigns a nil value to an instance variable" do
+    let(:controller) { build_response { @var = nil } }
+
+    it "should accept assigning to that variable" do
+      controller.should assign_to(:var)
+    end
+  end
+end

data/spec/shoulda/action_controller/filter_param_matcher_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::FilterParamMatcher do
+  context "given parameter filters" do
+    before do
+      Rails.application.config.filter_parameters = [:secret]
+    end
+
+    it "should accept filtering that parameter" do
+      nil.should filter_param(:secret)
+    end
+
+    it "should reject filtering another parameter" do
+      matcher = filter_param(:other)
+      matcher.matches?(nil).should be_false
+      matcher.failure_message.should include("Expected other to be filtered")
+      matcher.failure_message.should =~ /secret/
+    end
+  end
+end

data/spec/shoulda/action_controller/redirect_to_matcher_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RedirectToMatcher do
+  context "a controller that redirects" do
+    let(:controller) do
+      build_response { redirect_to '/some/url' }
+    end
+
+    it "accepts redirecting to that url" do
+      controller.should redirect_to('/some/url')
+    end
+
+    it "rejects redirecting to a different url" do
+      controller.should_not redirect_to('/some/other/url')
+    end
+
+    it "accepts redirecting to that url in a block" do
+      controller.should redirect_to('somewhere') { '/some/url' }
+    end
+
+    it "rejects redirecting to a different url in a block" do
+      controller.should_not redirect_to('somewhere else') { '/some/other/url' }
+    end
+  end
+
+  context "a controller that doesn't redirect" do
+    let(:controller) do
+      build_response { render :text => 'hello' }
+    end
+
+    it "rejects redirecting to a url" do
+      controller.should_not redirect_to('/some/url')
+    end
+  end
+
+  it "provides the correct description when provided a block" do
+    matcher = redirect_to('somewhere else') { '/some/other/url' }
+    matcher.description.should == 'redirect to somewhere else'
+  end
+end

data/spec/shoulda/action_controller/render_template_matcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActionController::RenderTemplateMatcher do
+  include ActionController::TemplateAssertions
+
+  context "a controller that renders a template" do
+    let(:controller) { build_response(:action => 'show') { render } }
+
+    it "accepts rendering that template" do
+      controller.should render_template(:show)
+    end
+
+    it "rejects rendering a different template" do
+      controller.should_not render_template(:index)
+    end
+
+    it "accepts rendering that template in the given context" do
+      controller.should render_template(:show).in_context(self)
+    end
+
+    it "rejects rendering a different template in the given context" do
+      controller.should_not render_template(:index).in_context(self)
+    end
+  end
+
+  context "a controller that renders a partial" do
+    let(:controller) { build_response(:partial => '_customer') { render :partial => 'customer' } }
+
+    it "accepts rendering that partial" do
+      controller.should render_template(:partial => '_customer')
+    end
+
+    it "rejects rendering a different template" do
+      controller.should_not render_template(:partial => '_client')
+    end
+
+    it "accepts rendering that template in the given context" do
+      controller.should render_template(:partial => '_customer').in_context(self)
+    end
+
+    it "rejects rendering a different template in the given context" do
+      controller.should_not render_template(:partial => '_client').in_context(self)
+    end
+  end
+
+  context "a controller that doesn't render partials" do
+    let(:controller) { build_response(:action => 'show') { render } }
+
+    it "should not render a partial" do
+      controller.should render_template(:partial => false)
+    end
+  end
+
+  context "a controller that renders a partial several times" do
+    let(:controller) { build_response(:partial => '_customer') { render :partial => 'customer', :collection => [1,2] } }
+
+    it "accepts rendering that partial twice" do
+      controller.should render_template(:partial => '_customer', :count => 2)
+    end
+  end
+
+  context "a  controller that doesn't render a template" do
+    let(:controller) { build_response { render :nothing => true } }
+
+    it "rejects rendering a template" do
+      controller.should_not render_template(:show)
+    end
+  end
+end