mcmire-shoulda-matchers 2.5.0

data/spec/shoulda/matchers/active_record/association_matchers/model_reflection_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection do
+  it 'delegates other methods to the given Reflection object' do
+    define_model(:country)
+    person_model = define_model(:person, country_id: :integer) do
+      belongs_to :country
+    end
+    delegate_reflection = person_model.reflect_on_association(:country)
+    delegate_reflection.stubs(foo: 'bar')
+    reflection = described_class.new(delegate_reflection)
+
+    expect(reflection.foo).to eq 'bar'
+  end
+
+  describe '#associated_class' do
+    it 'returns the model that the association refers to' do
+      define_model(:country)
+      person_model = define_model(:person, country_id: :integer) do
+        belongs_to :country
+      end
+      delegate_reflection = person_model.reflect_on_association(:country)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection.associated_class).to be Country
+    end
+  end
+
+  describe '#through?' do
+    it 'returns true if the reflection is for a has_many :through association' do
+      define_model(:city, person_id: :integer)
+      define_model(:person, country_id: :integer) do
+        has_many :cities
+      end
+      country_model = define_model(:country) do
+        has_many :people
+        has_many :cities, through: :people
+      end
+      delegate_reflection = country_model.reflect_on_association(:cities)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection).to be_through
+    end
+
+    it 'returns false if not' do
+      define_model(:person, country_id: :integer)
+      country_model = define_model(:country) do
+        has_many :people
+      end
+      delegate_reflection = country_model.reflect_on_association(:people)
+      reflection = described_class.new(delegate_reflection)
+
+      expect(reflection).not_to be_through
+    end
+  end
+
+  describe '#join_table' do
+    context 'when the association was defined with a :join_table option' do
+      it 'returns the value of the option' do
+        define_model(:person, country_id: :integer)
+        country_model = define_model(:country) do
+          has_and_belongs_to_many :people, join_table: 'foos'
+        end
+        delegate_reflection = country_model.reflect_on_association(:people)
+        reflection = described_class.new(delegate_reflection)
+
+        expect(reflection.join_table).to eq 'foos'
+      end
+    end
+
+    context 'when the association was not defined with :join_table' do
+      it 'returns the default join_table that ActiveRecord generates' do
+        define_model(:person, country_id: :integer)
+        country_model = define_model(:country) do
+          has_and_belongs_to_many :people
+        end
+        delegate_reflection = country_model.reflect_on_association(:people)
+        reflection = described_class.new(delegate_reflection)
+
+        expect(reflection.join_table).to eq 'countries_people'
+      end
+    end
+  end
+
+  describe '#association_relation' do
+    if rails_4_x?
+      context 'when the reflection object has a #scope method' do
+        context 'when the scope is a block' do
+          it 'executes the block in the context of an empty scope' do
+            define_model(:country, mood: :string)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, -> { where(mood: 'nice') }
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.where(mood: 'nice').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the scope is nil' do
+          it 'returns an empty scope' do
+            define_model(:country)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.all.to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+      end
+    end
+
+    if rails_3_x?
+      context 'when the reflection object does not have a #scope method' do
+        context 'when the reflection options contain :conditions' do
+          it 'creates an ActiveRecord::Relation from the conditions' do
+            define_model(:country, mood: :string)
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, conditions: { mood: 'nice' }
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Country.where(mood: 'nice').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :order' do
+          it 'creates an ActiveRecord::Relation from the order' do
+            define_model(:person, country_id: :integer, age: :integer)
+            country_model = define_model(:country) do
+              has_many :people, order: 'age'
+            end
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.order('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :include' do
+          it 'creates an ActiveRecord::Relation from the include' do
+            define_model(:city, country_id: :integer)
+            define_model(:country) do
+              has_many :cities
+            end
+            person_model = define_model(:person, country_id: :integer) do
+              belongs_to :country, include: :cities
+            end
+            delegate_reflection = person_model.reflect_on_association(:country)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_includes = reflection.association_relation.includes_values
+            expected_includes = Country.includes(:cities).includes_values
+            expect(actual_includes).to eq expected_includes
+          end
+        end
+
+        context 'when the reflection options contain :group' do
+          it 'creates an ActiveRecord::Relation from the group' do
+            country_model = define_model(:country, mood: :string) do
+              has_many :people, group: 'age'
+            end
+            define_model(:person, country_id: :integer, age: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.group('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :having' do
+          it 'creates an ActiveRecord::Relation from the having' do
+            country_model = define_model(:country) do
+              has_many :people, having: 'country_id > 1'
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.having('country_id > 1').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :limit' do
+          it 'creates an ActiveRecord::Relation from the limit' do
+            country_model = define_model(:country) do
+              has_many :people, limit: 10
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.limit(10).to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :offset' do
+          it 'creates an ActiveRecord::Relation from the offset' do
+            country_model = define_model(:country) do
+              has_many :people, offset: 5
+            end
+            define_model(:person, country_id: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.offset(5).to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+
+        context 'when the reflection options contain :select' do
+          it 'creates an ActiveRecord::Relation from the select' do
+            country_model = define_model(:country) do
+              has_many :people, select: 'age'
+            end
+            define_model(:person, country_id: :integer, age: :integer)
+            delegate_reflection = country_model.reflect_on_association(:people)
+            reflection = described_class.new(delegate_reflection)
+
+            actual_sql = reflection.association_relation.to_sql
+            expected_sql = Person.select('age').to_sql
+            expect(actual_sql).to eq expected_sql
+          end
+        end
+      end
+    end
+  end
+end

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
+    expect(model(nickname: :string)).to have_db_column(:nickname)
+  end
+
+  it 'rejects a nonexistent database column' do
+    expect(define_model(:employee).new).not_to have_db_column(:nickname)
+  end
+
+  context '#of_type' do
+    it 'accepts a column of correct type' do
+      expect(model(nickname: :string)).
+        to have_db_column(:nickname).of_type(:string)
+    end
+
+    it 'rejects a nonexistent database column' do
+      expect(define_model(:superhero).new).
+        not_to have_db_column(:nickname).of_type(:string)
+    end
+
+    it 'rejects a column of wrong type' do
+      expect(model(nickname: :integer)).
+        not_to have_db_column(:nickname).of_type(:string)
+    end
+  end
+
+  context 'with precision option' do
+    it 'accepts a column of correct precision' do
+      expect(with_table(:salary, :decimal, precision: 5)).
+        to have_db_column(:salary).with_options(precision: 5)
+    end
+
+    it 'rejects a column of wrong precision' do
+      expect(with_table(:salary, :decimal, precision: 6)).
+        not_to have_db_column(:salary).with_options(precision: 5)
+    end
+  end
+
+  context 'with limit option' do
+    it 'accepts a column of correct limit' do
+      expect(with_table(:email, :string, limit: 255)).
+        to have_db_column(:email).with_options(limit: 255)
+    end
+
+    it 'rejects a column of wrong limit' do
+      expect(with_table(:email, :string, limit: 100)).
+        not_to have_db_column(:email).with_options(limit: 255)
+    end
+  end
+
+  context 'with default option' do
+    it 'accepts a column with correct default' do
+      expect(with_table(:admin, :boolean, default: false)).
+        to have_db_column(:admin).with_options(default: false)
+    end
+
+    it 'rejects a column with wrong default' do
+      expect(with_table(:admin, :boolean, default: true)).
+        not_to have_db_column(:admin).with_options(default: false)
+    end
+  end
+
+  context 'with null option' do
+    it 'accepts a column of correct null' do
+      expect(with_table(:admin, :boolean, null: false)).
+        to have_db_column(:admin).with_options(null: false)
+    end
+
+    it 'rejects a column of wrong null' do
+      expect(with_table(:admin, :boolean, null: true)).
+        not_to have_db_column(:admin).with_options(null: false)
+    end
+  end
+
+  context 'with scale option' do
+    it 'accepts a column of correct scale' do
+      expect(with_table(:salary, :decimal, precision: 10, scale: 2)).
+        to have_db_column(:salary).with_options(scale: 2)
+    end
+
+    it 'rejects a column of wrong scale' do
+      expect(with_table(:salary, :decimal, precision: 10, scale: 4)).
+        not_to have_db_column(:salary).with_options(scale: 2)
+    end
+  end
+
+  context 'with primary option' do
+    it 'accepts a column that is primary' do
+      expect(with_table(:custom_id, :integer, primary: true)).
+        to have_db_column(:id).with_options(primary: true)
+    end
+
+    it 'rejects a column that is not primary' do
+      expect(with_table(:whatever, :integer, primary: false)).
+        not_to 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
+      expect(with_index_on(:age)).to have_db_index(:age)
+    end
+
+    it 'rejects a nonexistent index' do
+      expect(define_model(:employee).new).not_to have_db_index(:age)
+    end
+  end
+
+  context 'have_db_index with unique option' do
+    it 'accepts an index of correct unique' do
+      expect(with_index_on(:ssn, unique: true)).
+        to have_db_index(:ssn).unique(true)
+    end
+
+    it 'rejects an index of wrong unique' do
+      expect(with_index_on(:ssn, unique: false)).
+        not_to 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]
+      expect(define_model_class('Geocoding').new).
+        to 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
+      expect(define_model_class('Geocoding').new).
+        not_to have_db_index([:geocodable_type, :geocodable_id])
+    end
+  end
+
+  it 'join columns with and when describing multiple columns' do
+    expect(have_db_index([:user_id, :post_id]).description).to match(/on columns user_id and post_id/)
+  end
+
+  it 'describes a unique index as unique' do
+    expect(have_db_index(:user_id).unique(true).description).to match(/a unique index/)
+  end
+
+  it 'describes a non-unique index as non-unique' do
+    expect(have_db_index(:user_id).unique(false).description).to match(/a non-unique index/)
+  end
+
+  it "does not display an index's uniqueness when it's not important" do
+    expect(have_db_index(:user_id).description).not_to match(/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)
+
+    expect(with_index_on(:age)).to 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
+      expect(with_readonly_attr).to 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
+
+      expect(model).not_to have_readonly_attribute(:other)
+    end
+  end
+
+  context 'an attribute on a class with no readonly attributes' do
+    it 'rejects being read-only' do
+      expect(define_model(:example, attr: :string).new).
+        not_to 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)
+
+      expect(matcher.failure_message).not_to be_nil
+    end
+  end
+
+  def with_readonly_attr
+    define_model :example, attr: :string do
+      attr_readonly :attr
+    end.new
+  end
+end