shoulda-matchers 1.4.2 → 1.5.0

data/spec/shoulda/matchers/active_record/have_db_column_matcher_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
+  it 'accepts an existing database column' do
+    model(:nickname => :string).should have_db_column(:nickname)
+  end
+
+  it 'rejects a nonexistent database column' do
+    define_model(:employee).new.should_not have_db_column(:nickname)
+  end
+
+  context '#of_type' do
+    it 'accepts a column of correct type' do
+      model(:nickname => :string).
+        should have_db_column(:nickname).of_type(:string)
+    end
+
+    it 'rejects a nonexistent database column' do
+      define_model(:superhero).new.
+        should_not have_db_column(:nickname).of_type(:string)
+    end
+
+    it 'rejects a column of wrong type' do
+      model(:nickname => :integer).
+        should_not have_db_column(:nickname).of_type(:string)
+    end
+  end
+
+  context 'with precision option' do
+    it 'accepts a column of correct precision' do
+      with_table(:salary, :decimal, :precision => 5).
+        should have_db_column(:salary).with_options(:precision => 5)
+    end
+
+    it 'rejects a column of wrong precision' do
+      with_table(:salary, :decimal, :precision => 6).
+        should_not have_db_column(:salary).with_options(:precision => 5)
+    end
+  end
+
+  context 'with limit option' do
+    it 'accepts a column of correct limit' do
+      with_table(:email, :string, :limit => 255).
+        should have_db_column(:email).with_options(:limit => 255)
+    end
+
+    it 'rejects a column of wrong limit' do
+      with_table(:email, :string, :limit => 100).
+        should_not have_db_column(:email).with_options(:limit => 255)
+    end
+  end
+
+  context 'with default option' do
+    it 'accepts a column with correct default' do
+      with_table(:admin, :boolean, :default => false).
+        should have_db_column(:admin).with_options(:default => false)
+    end
+
+    it 'rejects a column with wrong default' do
+      with_table(:admin, :boolean, :default => true).
+        should_not have_db_column(:admin).with_options(:default => false)
+    end
+  end
+
+  context 'with null option' do
+    it 'accepts a column of correct null' do
+      with_table(:admin, :boolean, :null => false).
+        should have_db_column(:admin).with_options(:null => false)
+    end
+
+    it 'rejects a column of wrong null' do
+      with_table(:admin, :boolean, :null => true).
+        should_not have_db_column(:admin).with_options(:null => false)
+    end
+  end
+
+  context 'with scale option' do
+    it 'accepts a column of correct scale' do
+      with_table(:salary, :decimal, :precision => 10, :scale => 2).
+        should have_db_column(:salary).with_options(:scale => 2)
+    end
+
+    it 'rejects a column of wrong scale' do
+      with_table(:salary, :decimal, :precision => 10, :scale => 4).
+        should_not have_db_column(:salary).with_options(:scale => 2)
+    end
+  end
+
+  context 'with primary option' do
+    it 'accepts a column that is primary' do
+      with_table(:id, :integer, :primary => true).
+        should have_db_column(:id).with_options(:primary => true)
+    end
+
+    it 'rejects a column that is not primary' do
+      with_table(:whatever, :integer, :primary => false).
+        should_not have_db_column(:whatever).with_options(:primary => true)
+    end
+  end
+
+  def model(options = {})
+    define_model(:employee, options).new
+  end
+
+  def with_table(column_name, column_type, options)
+    create_table 'employees' do |table|
+      table.send(column_type, column_name, options)
+    end
+    define_model_class('Employee').new
+  end
+end

data/spec/shoulda/matchers/active_record/have_db_index_matcher_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
+  context 'have_db_index' do
+    it 'accepts an existing index' do
+      with_index_on(:age).should have_db_index(:age)
+    end
+
+    it 'rejects a nonexistent index' do
+      define_model(:employee).new.should_not have_db_index(:age)
+    end
+  end
+
+  context 'have_db_index with unique option' do
+    it 'accepts an index of correct unique' do
+      with_index_on(:ssn, :unique => true).
+        should have_db_index(:ssn).unique(true)
+    end
+
+    it 'rejects an index of wrong unique' do
+      with_index_on(:ssn, :unique => false).
+        should_not have_db_index(:ssn).unique(true)
+    end
+  end
+
+  context 'have_db_index on multiple columns' do
+    it 'accepts an existing index' do
+      db_connection = create_table 'geocodings' do |table|
+        table.integer :geocodable_id
+        table.string  :geocodable_type
+      end
+      db_connection.add_index :geocodings, [:geocodable_type, :geocodable_id]
+      define_model_class('Geocoding').new.
+        should have_db_index([:geocodable_type, :geocodable_id])
+    end
+
+    it 'rejects a nonexistent index' do
+      create_table 'geocodings' do |table|
+        table.integer :geocodable_id
+        table.string  :geocodable_type
+      end
+      define_model_class('Geocoding').new.
+        should_not have_db_index([:geocodable_type, :geocodable_id])
+    end
+  end
+
+  it 'join columns with and when describing multiple columns' do
+    have_db_index([:user_id, :post_id]).description.should =~ /on columns user_id and post_id/
+  end
+
+  it 'describes a unique index as unique' do
+    have_db_index(:user_id).unique(true).description.should =~ /a unique index/
+  end
+
+  it 'describes a non-unique index as non-unique' do
+    have_db_index(:user_id).unique(false).description.should =~ /a non-unique index/
+  end
+
+  it "does not display an index's uniqueness when it's not important" do
+    have_db_index(:user_id).description.should_not =~ /unique/
+  end
+
+  it 'allows an IndexDefinition to have a truthy value for unique' do
+    index_definition = stub('ActiveRecord::ConnectionAdapters::IndexDefinition',
+      :unique => 7, :name => :age)
+    matcher = have_db_index(:age).unique(true)
+    matcher.stubs(:matched_index => index_definition)
+
+    with_index_on(:age).should matcher
+  end
+
+  def with_index_on(column_name, index_options = {})
+    create_table 'employees' do |table|
+      table.integer column_name
+    end.add_index(:employees, column_name, index_options)
+    define_model_class('Employee').new
+  end
+end

data/spec/shoulda/matchers/active_record/have_readonly_attributes_matcher_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
+  context 'a read-only attribute' do
+    it 'accepts' do
+      with_readonly_attr.should have_readonly_attribute(:attr)
+    end
+  end
+
+  context 'an attribute that is not part of the read-only set' do
+    it 'rejects being read-only' do
+      model = define_model :example, :attr => :string, :other => :string do
+        attr_readonly :attr
+      end.new
+
+      model.should_not have_readonly_attribute(:other)
+    end
+  end
+
+  context 'an attribute on a class with no readonly attributes' do
+    it 'rejects being read-only' do
+      define_model(:example, :attr => :string).new.
+        should_not have_readonly_attribute(:attr)
+    end
+
+    it 'assigns a failure message' do
+      model = define_model(:example, :attr => :string).new
+      matcher = have_readonly_attribute(:attr)
+
+      matcher.matches?(model)
+
+      matcher.failure_message_for_should.should_not be_nil
+    end
+  end
+
+  def with_readonly_attr
+    define_model :example, :attr => :string do
+      attr_readonly :attr
+    end.new
+  end
+end

data/spec/shoulda/{active_record → matchers/active_record}/query_the_database_matcher_spec.rb

@@ -10,36 +10,36 @@ describe Shoulda::Matchers::ActiveRecord::QueryTheDatabaseMatcher do
     end
   end
 
-  it "accepts the correct number of queries when there is a single query" do
+  it 'accepts the correct number of queries when there is a single query' do
     @parent.should query_the_database(1.times).when_calling(:count)
   end
 
-  it "accepts any number of queries when no number is specified" do
+  it 'accepts any number of queries when no number is specified' do
     @parent.should query_the_database.when_calling(:count)
   end
 
-  it "rejects any number of queries when no number is specified" do
+  it 'rejects any number of queries when no number is specified' do
     @parent.should_not query_the_database.when_calling(:to_s)
   end
 
-  it "accepts the correct number of queries when there are two queries" do
+  it 'accepts the correct number of queries when there are two queries' do
     nonsense = lambda do
       @parent.create.kittens.create
     end
     nonsense.should query_the_database(2.times).when_calling(:call)
   end
 
-  it "rejects the wrong number of queries" do
+  it 'rejects the wrong number of queries' do
     @parent.should_not query_the_database(10.times).when_calling(:count)
   end
 
-  it "accepts fewer than the specified maximum" do
+  it 'accepts fewer than the specified maximum' do
     @parent.should query_the_database(5.times).or_less.when_calling(:count)
   end
 
-  it "passes arguments to the method to examine" do
-    model = stub("Model", :count => nil)
-    model.should_not query_the_database.when_calling(:count).with("arguments")
-    model.should have_received(:count).with("arguments")
+  it 'passes arguments to the method to examine' do
+    model = stub('Model', :count => nil)
+    model.should_not query_the_database.when_calling(:count).with('arguments')
+    model.should have_received(:count).with('arguments')
   end
 end

data/spec/shoulda/matchers/active_record/serialize_matcher_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
+  it 'accepts when the attribute is serialized' do
+    with_serialized_attr.should serialize(:attr)
+  end
+
+  context 'when attribute is not serialized' do
+    it 'rejects' do
+      unserialized_model.should_not serialize(:attr)
+    end
+
+    it 'assigns a helpful failure message' do
+      matcher = serialize(:attr)
+
+      matcher.matches?(unserialized_model)
+
+      matcher.failure_message_for_should.should =~ /to serialize the attribute called :attr/
+    end
+
+    it 'assigns a helpful failure message when using #as' do
+      matcher = serialize(:attr).as(Hash)
+
+      matcher.matches?(unserialized_model)
+
+      matcher.failure_message_for_should.should =~ /with a type of Hash/
+    end
+
+    it 'assigns a helpful failure message when using #as_instance_of' do
+      matcher = serialize(:attr).as_instance_of(Hash)
+
+      matcher.matches?(unserialized_model)
+
+      matcher.failure_message_for_should.should =~ /with an instance of Hash/
+    end
+
+    def unserialized_model
+      @model ||= define_model(:example, :attr => :string).new
+    end
+  end
+
+  context 'an attribute that is serialized as a specific type' do
+    it 'accepts when the types match' do
+      with_serialized_attr(Hash).should serialize(:attr).as(Hash)
+    end
+
+    it 'rejects when the types do not match' do
+      with_serialized_attr(Hash).should_not serialize(:attr).as(String)
+    end
+
+    it 'rejects when using as_instance_of' do
+      with_serialized_attr(Hash).should_not serialize(:attr).as_instance_of(Hash)
+    end
+  end
+
+  context 'a serializer that is an instance of a class' do
+    it 'accepts when using #as_instance_of' do
+      define_serializer(:ExampleSerializer)
+      with_serialized_attr(ExampleSerializer.new).
+        should serialize(:attr).as_instance_of(ExampleSerializer)
+    end
+
+    it 'rejects when using #as' do
+      define_serializer(:ExampleSerializer)
+      with_serialized_attr(ExampleSerializer.new).
+        should_not serialize(:attr).as(ExampleSerializer)
+    end
+  end
+
+  def with_serialized_attr(type = nil)
+    define_model(:example, :attr => :string) do
+      if type
+        serialize :attr, type
+      else
+        serialize :attr
+      end
+    end.new
+  end
+
+  def define_serializer(name)
+    define_class(name) do
+      def load(*); end
+      def dump(*); end
+    end
+  end
+end

data/spec/shoulda/{independent → matchers/independent}/delegate_matcher_spec.rb

@@ -1,33 +1,59 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::Independent::DelegateMatcher do
+  context '#description' do
+    context 'by default' do
+      it 'states that it should delegate method to the right object' do
+        matcher = delegate_method(:method_name).to(:target)
+
+        matcher.description.should == 'delegate method #method_name to :target'
+      end
+    end
+
+    context 'with #as chain' do
+      it 'states that it should delegate method to the right object and method' do
+        matcher = delegate_method(:method_name).to(:target).as(:alternate)
+
+        matcher.description.should == 'delegate method #method_name to :target as #alternate'
+      end
+    end
+
+    context 'with #with_argument chain' do
+      it 'states that it should delegate method to the right object with right argument' do
+        matcher = delegate_method(:method_name).to(:target).with_arguments(:foo, :bar => [1, 2])
+
+        matcher.description.should ==
+          'delegate method #method_name to :target with arguments: [:foo, {:bar=>[1, 2]}]'
+      end
+    end
+  end
+
   it 'supports chaining on #to' do
     matcher = delegate_method(:method)
+
     matcher.to(:another_method).should == matcher
   end
 
   it 'supports chaining on #with_arguments' do
     matcher = delegate_method(:method)
+
     matcher.with_arguments(1, 2, 3).should == matcher
   end
 
   it 'supports chaining on #as' do
     matcher = delegate_method(:method)
+
     matcher.as(:some_other_method).should == matcher
   end
 
-  it 'should raise an error if no delegation target is defined' do
-    object = Object.new
-    expect {
-      object.should delegate_method(:name)
-    }.to raise_exception Shoulda::Matchers::Independent::DelegateMatcher::TargetNotDefinedError
+  it 'raises an error if no delegation target is defined' do
+    expect { Object.new.should delegate_method(:name) }.
+      to raise_exception described_class::TargetNotDefinedError
   end
 
-  it 'should raise an error if called with #should_not' do
-    object = Object.new
-    expect {
-      object.should_not delegate_method(:name).to(:anyone)
-    }.to raise_exception Shoulda::Matchers::Independent::DelegateMatcher::InvalidDelegateMatcher
+  it 'raises an error if called with #should_not' do
+    expect { Object.new.should_not delegate_method(:name).to(:anyone) }.
+      to raise_exception described_class::InvalidDelegateMatcher
   end
 
   context 'given a method that does not delegate' do
@@ -39,9 +65,10 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       end
     end
 
-    it 'does not match' do
+    it 'rejects' do
       post_office = PostOffice.new
       matcher = delegate_method(:deliver_mail).to(:mailman)
+
       matcher.matches?(post_office).should be_false
     end
 
@@ -52,7 +79,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       matcher.matches?(post_office)
 
       message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman'
-      matcher.failure_message.should == message
+      matcher.failure_message_for_should.should == message
     end
 
     it 'uses the proper syntax for class methods in errors' do
@@ -61,12 +88,12 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
       matcher.matches?(PostOffice)
 
       message = 'Expected PostOffice.deliver_mail to delegate to PostOffice.mailman'
-      matcher.failure_message.should == message
+      matcher.failure_message_for_should.should == message
     end
   end
 
   context 'given a method that delegates properly' do
-    before do
+    it 'accepts' do
       define_class(:mailman)
       define_class(:post_office) do
         def deliver_mail
@@ -76,12 +103,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
         def mailman
           Mailman.new
         end
-      end
-    end
-
-    it 'matches' do
-      post_office = PostOffice.new
-      post_office.should delegate_method(:deliver_mail).to(:mailman)
+      end.new.should delegate_method(:deliver_mail).to(:mailman)
     end
   end
 
@@ -100,17 +122,17 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     end
 
     context 'when given the correct arguments' do
-      it 'matches' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('221B Baker St.', :hastily => true)
-        post_office.should matcher
+      it 'accepts' do
+        PostOffice.new.should delegate_method(:deliver_mail).
+          to(:mailman).with_arguments('221B Baker St.', :hastily => true)
       end
     end
 
     context 'when not given the correct arguments' do
-      it 'does not match' do
+      it 'rejects' do
         post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).with_arguments('123 Nowhere Ln.')
+        matcher = delegate_method(:deliver_mail).to(:mailman).
+          with_arguments('123 Nowhere Ln.')
         matcher.matches?(post_office).should be_false
       end
 
@@ -121,7 +143,7 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
         matcher.matches?(post_office)
 
         message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman with arguments: ["123 Nowhere Ln."]'
-        matcher.failure_message.should == message
+        matcher.failure_message_for_should.should == message
       end
     end
   end
@@ -141,15 +163,14 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
     end
 
     context 'when given the correct method name' do
-      it 'matches' do
-        post_office = PostOffice.new
-        matcher = delegate_method(:deliver_mail).to(:mailman).as(:deliver_mail_and_avoid_dogs)
-        post_office.should matcher
+      it 'accepts' do
+        PostOffice.new.
+          should delegate_method(:deliver_mail).to(:mailman).as(:deliver_mail_and_avoid_dogs)
       end
     end
 
     context 'when given an incorrect method name' do
-      it 'does not match' do
+      it 'rejects' do
         post_office = PostOffice.new
         matcher = delegate_method(:deliver_mail).to(:mailman).as(:watch_tv)
         matcher.matches?(post_office).should be_false
@@ -161,8 +182,8 @@ describe Shoulda::Matchers::Independent::DelegateMatcher do
 
         matcher.matches?(post_office)
 
-        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as :watch_tv'
-        matcher.failure_message.should == message
+        message = 'Expected PostOffice#deliver_mail to delegate to PostOffice#mailman as #watch_tv'
+        matcher.failure_message_for_should.should == message
       end
     end
   end