shoulda-matchers 1.4.2 → 1.5.0

data/spec/shoulda/active_record/have_db_column_matcher_spec.rb

@@ -1,185 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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
-
-  it "allows an IndexDefinition to have a truthy value for unique" do
-    db_connection = create_table 'superheros' do |table|
-      table.integer :age
-    end
-    db_connection.add_index :superheros, :age
-    define_model_class 'Superhero'
-
-    @matcher = have_db_index(:age).unique(true)
-
-    index_definition = stub("ActiveRecord::ConnectionAdapters::IndexDefinition",
-                            :unique => 7,
-                            :name => :age)
-    @matcher.stubs(:matched_index => index_definition)
-
-    Superhero.new.should @matcher
-  end
-end

data/spec/shoulda/active_record/have_readonly_attributes_matcher_spec.rb

@@ -1,46 +0,0 @@
-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/serialize_matcher_spec.rb

@@ -1,81 +0,0 @@
-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_class(:ExampleSerializer) 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