shoulda-matchers 4.0.0.rc1 → 4.0.1

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

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

@@ -1,169 +0,0 @@
-require 'unit_spec_helper'
-
-# rubocop:disable Metrics/BlockLength
-describe Shoulda::Matchers::ActiveRecord::HaveSecureTokenMatcher,
-  type: :model do
-
-  if active_record_supports_has_secure_token?
-    describe '#description' do
-      it 'returns the message including the name of the default column' do
-        matcher = have_secure_token
-        expect(matcher.description).
-          to eq('have :token as a secure token')
-      end
-
-      it 'returns the message including the name of a provided column' do
-        matcher = have_secure_token(:special_token)
-        expect(matcher.description).
-          to eq('have :special_token as a secure token')
-      end
-    end
-
-    it 'matches when the subject configures has_secure_token with the db' do
-      create_table(:users) do |t|
-        t.string :token
-        t.index :token, unique: true
-      end
-
-      valid_model = define_model_class(:User) { has_secure_token }
-
-      expect(valid_model.new).to have_secure_token
-    end
-
-    it 'matches when the subject configures has_secure_token with the db for ' \
-       'a custom attribute' do
-      create_table(:users) do |t|
-        t.string :auth_token
-        t.index :auth_token, unique: true
-      end
-
-      valid_model = define_model_class(:User) { has_secure_token(:auth_token) }
-      expect(valid_model.new).to have_secure_token(:auth_token)
-    end
-
-    it 'does not match when missing an token index' do
-      create_table(:users) do |t|
-        t.string :token
-      end
-
-      invalid_model = define_model_class(:User) { has_secure_token }
-      expected_message =
-        'Expected User to have :token as a secure token but the following ' \
-        'errors were found: missing unique index for users.token'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token
-        expect { expect(invalid_model.new).to have_secure_token }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'does not match when missing a token column' do
-      create_table(:users)
-      invalid_model = define_model_class(:User) { has_secure_token }
-
-      expected_message =
-        'Expected User to have :token as a secure token but the following ' \
-        'errors were found: missing expected class and instance methods, ' \
-        'missing correct column token:string, missing unique index for ' \
-        'users.token'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token
-        expect { expect(invalid_model.new).to have_secure_token }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'does not match when when lacking has_secure_token' do
-      create_table(:users) do |t|
-        t.string :token
-        t.index :token
-      end
-
-      invalid_model = define_model_class(:User)
-
-      expected_message =
-        'Expected User to have :token as a secure token but the following ' \
-        'errors were found: missing expected class and instance methods, ' \
-        'missing unique index for users.token'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token
-        expect { expect(invalid_model.new).to have_secure_token }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'does not match when missing an index for a custom attribute' do
-      create_table(:users) do |t|
-        t.string :auth_token
-      end
-
-      invalid_model = define_model_class(:User) do
-        has_secure_token(:auth_token)
-      end
-
-      expected_message =
-        'Expected User to have :auth_token as a secure token but the ' \
-        'following errors were found: missing unique index for ' \
-        'users.auth_token'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token(:auth_token)
-        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'does not match when missing a column for a custom attribute' do
-      create_table(:users)
-      invalid_model = define_model_class(:User) do
-        has_secure_token(:auth_token)
-      end
-
-      expected_message =
-        'Expected User to have :auth_token as a secure token but the ' \
-        'following errors were found: missing expected class and instance '  \
-        'methods, missing correct column auth_token:string, missing unique ' \
-        'index for users.auth_token'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token(:auth_token)
-        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'does not match when when lacking has_secure_token for the attribute' do
-      create_table(:users) do |t|
-        t.string :auth_token
-        t.index :auth_token, unique: true
-      end
-
-      invalid_model = define_model_class(:User)
-      expected_message =
-        'Expected User to have :auth_token as a secure token but the ' \
-        'following errors were found: missing expected class and instance ' \
-        'methods'
-
-      aggregate_failures do
-        expect(invalid_model.new).not_to have_secure_token(:auth_token)
-        expect { expect(invalid_model.new).to have_secure_token(:auth_token) }.
-          to fail_with_message(expected_message)
-      end
-    end
-
-    it 'fails with the appropriate message when negated' do
-      create_table(:users) do |t|
-        t.string :token
-        t.index :token, unique: true
-      end
-
-      valid_model = define_model_class(:User) { has_secure_token }
-
-      expect { expect(valid_model.new).not_to have_secure_token }.
-        to fail_with_message('Did not expect User to have secure token :token')
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveRecord::SerializeMatcher, type: :model do
-  it 'accepts when the attribute is serialized' do
-    expect(with_serialized_attr).to serialize(:attr)
-  end
-
-  context 'when attribute is not serialized' do
-    it 'rejects' do
-      expect(unserialized_model).not_to serialize(:attr)
-    end
-
-    it 'assigns a helpful failure message' do
-      matcher = serialize(:attr)
-
-      matcher.matches?(unserialized_model)
-
-      expect(matcher.failure_message).to match(/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)
-
-      expect(matcher.failure_message).to match(/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)
-
-      expect(matcher.failure_message).to match(/with an instance of Hash/)
-    end
-
-    def unserialized_model
-      @model ||= define_model(:example, attr: :string).new
-    end
-  end
-
-  context 'an attribute that will end up being serialized as YAML' do
-    it 'accepts when the types match' do
-      expect(with_serialized_attr(Hash)).to serialize(:attr).as(Hash)
-    end
-
-    it 'rejects when the types do not match' do
-      expect(with_serialized_attr(Hash)).not_to serialize(:attr).as(String)
-    end
-
-    it 'rejects when using as_instance_of' do
-      expect(with_serialized_attr(Hash)).not_to 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)
-      expect(with_serialized_attr(ExampleSerializer.new)).
-        to serialize(:attr).as_instance_of(ExampleSerializer)
-    end
-
-    it 'rejects when using #as' do
-      define_serializer(:ExampleSerializer)
-      expect(with_serialized_attr(ExampleSerializer.new)).
-        not_to 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