shoulda-matchers 3.1.0 → 5.2.0

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

@@ -1,251 +0,0 @@
-require 'unit_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)
-    allow(delegate_reflection).to receive(:foo).and_return('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_name' do
-    context 'when the association was defined with a :join_table option' do
-      it 'returns the value of the option' do
-        create_table :foos, id: false do |t|
-          t.integer :person_id
-          t.integer :country_id
-        end
-        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_name).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_name).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/unit/shoulda/matchers/active_record/define_enum_for_matcher_spec.rb

@@ -1,168 +0,0 @@
-require "unit_spec_helper"
-
-describe Shoulda::Matchers::ActiveRecord::DefineEnumForMatcher, type: :model do
-  if active_record_supports_enum?
-    context 'if the attribute is given in plural form accidentally' do
-      it 'rejects' do
-        record = record_with_array_values
-        plural_enum_attribute = enum_attribute.to_s.pluralize
-        message = "Expected #{record.class} to define :#{plural_enum_attribute} as an enum and store the value in a column with an integer type"
-
-        assertion = lambda do
-          expect(record).to define_enum_for(plural_enum_attribute)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'if a method to hold enum values exists on the model but was not created via the enum macro' do
-      it 'rejects' do
-        model = define_model :example do
-          def self.statuses; end
-        end
-
-        message = "Expected #{model} to define :statuses as an enum and store the value in a column with an integer type"
-
-        assertion = lambda do
-          expect(model.new).to define_enum_for(:statuses)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    describe "with only the attribute name specified" do
-      it "accepts a record where the attribute is defined as an enum" do
-        expect(record_with_array_values).to define_enum_for(enum_attribute)
-      end
-
-      it "rejects a record where the attribute is not defined as an enum" do
-        message = "Expected #{record_with_array_values.class} to define :#{non_enum_attribute} as an enum and store the value in a column with an integer type"
-
-        assertion = lambda do
-          expect(record_with_array_values).
-            to define_enum_for(non_enum_attribute)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      it "rejects a record where the attribute is not defined as an enum with should not" do
-        message = "Did not expect #{record_with_array_values.class} to define :#{enum_attribute} as an enum and store the value in a column with an integer type"
-
-        assertion = lambda do
-          expect(record_with_array_values).
-            not_to define_enum_for(enum_attribute)
-        end
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      context 'if the column storing the attribute is not an integer type' do
-        it 'rejects' do
-          record = record_with_array_values(column_type: :string)
-          message = "Expected #{record.class} to define :statuses as an enum and store the value in a column with an integer type"
-
-          assertion = lambda do
-            expect(record).to define_enum_for(:statuses)
-          end
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-    end
-
-    describe "with both attribute name and enum values specified" do
-      context "when the actual enum values are an array" do
-        it "accepts a record where the attribute is defined as an enum and the enum values match" do
-          expect(record_with_array_values).to define_enum_for(enum_attribute).
-            with(["published", "unpublished", "draft"])
-        end
-
-        it "accepts a record where the attribute is not defined as an enum" do
-          message = %{Expected #{record_with_array_values.class} to define :#{non_enum_attribute} as an enum with ["open", "close"] and store the value in a column with an integer type}
-
-          assertion = lambda do
-            expect(record_with_array_values).
-              to define_enum_for(non_enum_attribute).with(['open', 'close'])
-          end
-
-          expect(&assertion).to fail_with_message(message)
-        end
-
-        it "accepts a record where the attribute is defined as an enum but the enum values do not match" do
-          message = %{Expected #{record_with_array_values.class} to define :#{enum_attribute} as an enum with ["open", "close"] and store the value in a column with an integer type}
-
-          assertion = lambda do
-            expect(record_with_array_values).
-              to define_enum_for(enum_attribute).
-              with(["open", "close"])
-          end
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-
-      context "when the actual enum values are a hash" do
-        it "accepts a record where the attribute is defined as an enum and the enum values match" do
-          expect(record_with_hash_values).to define_enum_for(enum_attribute).with(active: 0, archived: 1)
-        end
-
-        it "accepts a record where the enum values match when expected enum values are given as an array" do
-          expect(record_with_hash_values).to define_enum_for(enum_attribute).with(["active", "archived"])
-        end
-
-        it "accepts a record where the attribute is defined as an enum but the enum values do not match" do
-          message = %{Expected #{record_with_hash_values.class} to define :#{enum_attribute} as an enum with {:active=>5, :archived=>10} and store the value in a column with an integer type}
-
-          assertion = lambda do
-            expect(record_with_hash_values).
-              to define_enum_for(enum_attribute).
-              with(active: 5, archived: 10)
-          end
-
-          expect(&assertion).to fail_with_message(message)
-        end
-
-        it "rejects a record where the attribute is not defined as an enum" do
-          message = %{Expected #{record_with_hash_values.class} to define :record_with_hash_values as an enum with {:active=>5, :archived=>10} and store the value in a column with an integer type}
-
-          assertion = lambda do
-            expect(record_with_hash_values).
-              to define_enum_for(:record_with_hash_values).
-              with(active: 5, archived: 10)
-          end
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-    end
-
-    def enum_attribute
-      :status
-    end
-
-    def non_enum_attribute
-      :condition
-    end
-
-    def record_with_array_values(column_type: :integer)
-      model = define_model(
-        :record_with_array_values,
-        enum_attribute => { type: column_type },
-      )
-      model.enum(enum_attribute => ['published', 'unpublished', 'draft'])
-      model.new
-    end
-
-    def record_with_hash_values
-      model = define_model(
-        :record_with_hash_values,
-        enum_attribute => { type: :integer },
-      )
-      model.enum(enum_attribute => { active: 0, archived: 1 })
-      model.new
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher, type: :model 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/unit/shoulda/matchers/active_record/have_db_index_matcher_spec.rb

@@ -1,85 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveDbIndexMatcher, type: :model 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 unique index as unique when no argument is given' do
-    expect(have_db_index(:user_id).unique.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 = double(
-      'ActiveRecord::ConnectionAdapters::IndexDefinition',
-      unique: 7,
-      name: :age
-    )
-    matcher = have_db_index(:age).unique(true)
-    allow(matcher).to receive(:matched_index).and_return(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/unit/shoulda/matchers/active_record/have_readonly_attributes_matcher_spec.rb

@@ -1,41 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::HaveReadonlyAttributeMatcher, type: :model 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