shoulda-matchers 1.0.0 → 1.1.0

data/spec/shoulda/active_record/have_db_column_matcher_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher do
+  context "have_db_column" do
+    before do
+      @matcher = have_db_column(:nickname)
+    end
+
+    it "should accept an existing database column" do
+      create_table 'superheros' do |table|
+        table.string :nickname
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a nonexistent database column" do
+      define_model :superhero
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column of type string" do
+    before do
+      @matcher = have_db_column(:nickname).of_type(:string)
+    end
+
+    it "should accept a column of correct type" do
+      create_table 'superheros' do |table|
+        table.string :nickname
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a nonexistent database column" do
+      define_model :superhero
+      Superhero.new.should_not @matcher
+    end
+
+    it "should reject a column of wrong type" do
+      create_table 'superheros' do |table|
+        table.integer :nickname
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with precision option" do
+    before do
+      @matcher = have_db_column(:salary).with_options(:precision => 5)
+    end
+
+    it "should accept a column of correct precision" do
+      create_table 'superheros' do |table|
+        table.decimal :salary, :precision => 5
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a column of wrong precision" do
+      create_table 'superheros' do |table|
+        table.decimal :salary, :precision => 15
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with limit option" do
+    before do
+      @matcher = have_db_column(:email).
+                   of_type(:string).
+                   with_options(:limit => 255)
+    end
+
+    it "should accept a column of correct limit" do
+      create_table 'superheros' do |table|
+        table.string :email, :limit => 255
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a column of wrong limit" do
+      create_table 'superheros' do |table|
+        table.string :email, :limit => 500
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with default option" do
+    before do
+      @matcher = have_db_column(:admin).
+                   of_type(:boolean).
+                   with_options(:default => false)
+    end
+
+    it "should accept a column of correct default" do
+      create_table 'superheros' do |table|
+        table.boolean :admin, :default => false
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a column of wrong default" do
+      create_table 'superheros' do |table|
+        table.boolean :admin, :default => true
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with null option" do
+    before do
+      @matcher = have_db_column(:admin).
+                   of_type(:boolean).
+                   with_options(:null => false)
+    end
+
+    it "should accept a column of correct null" do
+      create_table 'superheros' do |table|
+        table.boolean :admin, :null => false
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a column of wrong null" do
+      create_table 'superheros' do |table|
+        table.boolean :admin, :null => true
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with scale option" do
+    before do
+      @matcher = have_db_column(:salary).
+                   of_type(:decimal).
+                   with_options(:scale => 2)
+    end
+
+    it "should accept a column of correct scale" do
+      create_table 'superheros' do |table|
+        table.decimal :salary, :precision => 10, :scale => 2
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a column of wrong scale" do
+      create_table 'superheros' do |table|
+        table.decimal :salary, :precision => 10, :scale => 4
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_column with primary option" do
+    it "should accept a column that is primary" do
+      create_table 'superheros' do |table|
+        table.integer :id, :primary => true
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should have_db_column(:id).with_options(:primary => true)
+    end
+
+    it "should reject a column that is not primary" do
+      create_table 'superheros' do |table|
+        table.integer :primary
+      end
+      define_model_class 'Superhero'
+      Superhero.new.should_not have_db_column(:primary).with_options(:primary => true)
+    end
+  end
+end

data/spec/shoulda/active_record/have_db_index_matcher_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher do
+  context "have_db_index" do
+    before do
+      @matcher = have_db_index(:age)
+    end
+
+    it "should accept an existing index" do
+      db_connection = create_table 'superheros' do |table|
+        table.integer :age
+      end
+      db_connection.add_index :superheros, :age
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject a nonexistent index" do
+      define_model :superhero
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_index with unique option" do
+    before do
+      @matcher = have_db_index(:ssn).unique(true)
+    end
+
+    it "should accept an index of correct unique" do
+      db_connection = create_table 'superheros' do |table|
+        table.integer :ssn
+      end
+      db_connection.add_index :superheros, :ssn, :unique => true
+      define_model_class 'Superhero'
+      Superhero.new.should @matcher
+    end
+
+    it "should reject an index of wrong unique" do
+      db_connection = create_table 'superheros' do |table|
+        table.integer :ssn
+      end
+      db_connection.add_index :superheros, :ssn, :unique => false
+      define_model_class 'Superhero'
+      Superhero.new.should_not @matcher
+    end
+  end
+
+  context "have_db_index on multiple columns" do
+    before do
+      @matcher = have_db_index([:geocodable_type, :geocodable_id])
+    end
+
+    it "should accept 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'
+      Geocoding.new.should @matcher
+    end
+
+    it "should reject a nonexistant index" do
+      db_connection = create_table 'geocodings' do |table|
+        table.integer :geocodable_id
+        table.string  :geocodable_type
+      end
+      define_model_class 'Geocoding'
+      Geocoding.new.should_not @matcher
+    end
+  end
+
+  it "should join columns with and describing multiple columns" do
+    have_db_index([:user_id, :post_id]).description.should =~ /on columns user_id and post_id/
+  end
+
+  it "should context a unique index as unique" do
+    have_db_index(:user_id).unique(true).description.should =~ /a unique index/
+  end
+
+  it "should context a non-unique index as non-unique" do
+    have_db_index(:user_id).unique(false).description.should =~ /a non-unique index/
+  end
+
+  it "should not context an index's uniqueness when it isn't important" do
+    have_db_index(:user_id).description.should_not =~ /unique/
+  end
+end

data/spec/shoulda/active_record/have_readonly_attributes_matcher_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher do
+  context "an attribute that cannot be set after being saved" do
+    before do
+      define_model :example, :attr => :string do
+        attr_readonly :attr
+      end
+      @model = Example.new
+    end
+
+    it "should accept being read-only" do
+      @model.should have_readonly_attribute(:attr)
+    end
+  end
+
+  context "an attribute not included in the readonly set" do
+    before do
+      define_model :example, :attr => :string, :other => :string do
+        attr_readonly :other
+      end
+      @model = Example.new
+    end
+
+    it "should not accept being read-only" do
+      @model.should_not have_readonly_attribute(:attr)
+    end
+  end
+
+  context "an attribute on a class with no readonly attributes" do
+    before do
+      define_model :example, :attr => :string
+      @model = Example.new
+    end
+
+    it "should not accept being read-only" do
+      @model.should_not have_readonly_attribute(:attr)
+    end
+
+    it "should assign a failure message" do
+      matcher = have_readonly_attribute(:attr)
+      matcher.matches?(@model).should == false
+      matcher.failure_message.should_not be_nil
+    end
+  end
+end

data/spec/shoulda/active_record/query_the_database_matcher_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::QueryTheDatabaseMatcher do
+  before do
+    @parent = define_model :litter do
+      has_many :kittens
+    end
+    @child = define_model :kitten, :litter_id => :integer do
+      belongs_to :litter
+    end
+  end
+
+  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
+    @parent.should query_the_database.when_calling(:count)
+  end
+
+  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
+    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
+    @parent.should_not query_the_database(10.times).when_calling(:count)
+  end
+
+  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")
+  end
+end

data/spec/shoulda/active_record/serialize_matcher_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::SerializeMatcher do
+  context "an attribute that should be serialized" do
+    let(:model) do
+      define_model(:example, :attr => :string) do
+        serialize :attr
+      end.new
+    end
+
+    it "should be serialized" do
+      model.should serialize(:attr)
+    end
+  end
+
+  context "an attribute that should be serialized with a type of Hash" do
+    let(:model) do
+      define_model(:example, :attr => :string) do
+        serialize :attr, Hash
+      end.new
+    end
+
+    it "should be serialized" do
+      model.should serialize(:attr).as(Hash)
+    end
+
+    it "should not match when using as_instance_of" do
+      model.should_not serialize(:attr).as_instance_of(Hash)
+    end
+  end
+
+  context "an attribute that should be serialized with a type of Array" do
+    let(:model) do
+      define_model(:example, :attr => :string, :attr2 => :string) do
+        serialize :attr, Array
+        serialize :attr2, Array
+      end.new
+    end
+
+    it "should be serialized" do
+      model.should serialize(:attr).as(Array)
+    end
+  end
+
+  context "an attribute that should be serialized but isn't" do
+    let(:model) { define_model(:example, :attr => :string).new }
+
+    it "should assign a failure message" do
+      matcher = serialize(:attr)
+      matcher.matches?(model).should == false
+      matcher.failure_message.should_not be_nil
+    end
+
+    it "should assign a failure message with 'as'" do
+      matcher = serialize(:attr).as(Hash)
+      matcher.matches?(model).should == false
+      matcher.failure_message.should_not be_nil
+    end
+
+    context "a serializer that is an instance of a class" do
+      before do
+        define_constant(:ExampleSerializer, Object) do
+          def load(*); end
+          def dump(*); end
+        end
+        define_model :example, :attr => :string do
+          serialize :attr, ExampleSerializer.new
+        end
+        @model = Example.new
+      end
+
+      it "should match when using as_instance_of" do
+        @model.should serialize(:attr).as_instance_of(ExampleSerializer)
+      end
+
+      it "should not match when using as" do
+        @model.should_not serialize(:attr).as(ExampleSerializer)
+      end
+    end
+  end
+end