schema_expectations 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18218491d35e976cf13367e3d30d60e952886de6
-  data.tar.gz: fa58281615fdda22fefb031a987f85001c8fe672
+  metadata.gz: bd5eeeafd64927fadc0781314d97e9c104efcc63
+  data.tar.gz: 67ea5f0dec0ac25d66dadc768a233e3446f961a1
 SHA512:
-  metadata.gz: 1eb5dc8161b1b91c08d40225bbd03d58e4153a6ea51af88420afbb91549837ca861849e486bb8e41f703097e5566ff6a344785829ac772a24c5a36995aa3992d
-  data.tar.gz: 8cc5ba8420797a7d5b10e8c25ca2ca309b2b8ecd7204f804296960988d7b835fc99ced2ff607f8b32c384ab5f407de6cf1d37cd3b103cc53fc1c23e0ba2052a9
+  metadata.gz: 746d0312374307e14a451bd7186d6561c99de12d7247728fcdec00e8bda23976ee330046c33b90ef90fdd24ae03c09733a9933d0e62be52e0e79ef18512e20cc
+  data.tar.gz: 1cec0c037a5ea1fbb5dd6fa0b21c5f6914f104b55cb9a38a45dde97895247c501ba3acd269f20a635cfd8b1958819c0a282b9c474e385803ed00641e6ab422bd

data/CHANGELOG.md

@@ -1,6 +1,7 @@
 # Schema Expectations Changelog
 
 ### git master
+- added `validate_schema_uniqueness`
 
 ### 0.2.0 (Febuary 18, 2015)
 

data/README.md

@@ -4,8 +4,98 @@
 [![Test Coverage](https://codeclimate.com/github/emma-borhanian/schema_expectations/badges/coverage.svg)](https://codeclimate.com/github/emma-borhanian/schema_expectations)
 [![Dependency Status](https://gemnasium.com/emma-borhanian/schema_expectations.svg)](https://gemnasium.com/emma-borhanian/schema_expectations)
 
-# Work in progress
-
 # Schema Expectations
 
 Allows you to test whether your database schema matches the validations in your ActiveRecord models.
+
+# Installation
+
+Add `schema_expectations` to your Gemfile:
+
+```ruby
+group :test do
+  gem 'schema_expectations'
+end
+```
+
+# Usage with RSpec
+
+## Validating uniqueness constraints
+
+The `validate_schema_uniqueness` matcher tests that an ActiveRecord model
+has uniqueness validation on columns with database uniqueness constraints,
+and vice versa.
+
+For example, we can assert that the model and database are consistent
+on whether `record_type` and `record_id` should be unique:
+
+```ruby
+create_table :records do |t|
+  t.integer :record_type
+  t.integer :record_id
+  t.index [:record_type, :record_id], unique: true
+end
+
+class Record < ActiveRecord::Base
+  validates :record_type, uniqueness: { scope: :record_id }
+end
+
+# RSpec
+describe Record do
+  it { should validate_schema_uniqueness }
+end
+```
+
+You can restrict the columns tested:
+
+```ruby
+# RSpec
+describe Record do
+  it { should validate_schema_uniqueness.only(:record_id, :record_type) }
+  it { should validate_schema_uniqueness.except(:record_id, :record_type) }
+end
+```
+
+note: if you exclude a column, then every unique scope which includes it will be completely ignored,
+regardless of whether that scope includes other non-excluded columns. Only works similarly, in
+that it will ignore any scope which contains columns not in the list
+
+## Validating presence constraints
+
+The `validate_schema_nullable` matcher tests that an ActiveRecord model
+has unconditional presence validation on columns with `NOT NULL` constraints,
+and vice versa.
+
+For example, we can assert that the model and database are consistent
+on whether `Record#name` should be present:
+
+```ruby
+create_table :records do |t|
+  t.string :name, null: false
+end
+
+class Record < ActiveRecord::Base
+  validates :name, presence: true
+end
+
+# RSpec
+describe Record do
+  it { should validate_schema_nullable }
+end
+```
+
+You can restrict the columns tested:
+
+```ruby
+# RSpec
+describe Record do
+  it { should validate_schema_nullable.only(:name) }
+  it { should validate_schema_nullable.except(:name) }
+end
+```
+
+The primary key and timestamp columns are automatically skipped.
+
+# License
+
+[MIT License](MIT-LICENSE)

data/lib/schema_expectations/active_record/column_reflector.rb

@@ -24,6 +24,10 @@ module SchemaExpectations
         new_with_columns @columns.reject(&method(:present_default_column?))
       end
 
+      def unique_scopes
+        unique_indexes.map { |index| index.columns.map(&:to_sym).sort }.sort
+      end
+
       private
 
       def new_with_columns(columns)
@@ -87,6 +91,11 @@ module SchemaExpectations
       def all_timestamp_attributes
         @all_timestamp_attributes ||= Record.new.send(:all_timestamp_attributes).map(&:to_sym)
       end
+
+      def unique_indexes
+        indexes = @model.connection.indexes(@model.table_name)
+        indexes.select(&:unique)
+      end
     end
   end
 end

data/lib/schema_expectations/active_record/validation_reflector.rb

@@ -3,7 +3,9 @@ require 'schema_expectations/util'
 module SchemaExpectations
   module ActiveRecord
     class ValidationReflector # :nodoc:
-      CONDITIONAL_OPTIONS = %i(on if unless allow_nil allow_blank)
+      CONDITIONAL_OPTIONS = %i(on if unless)
+      ALLOW_NIL_OPTIONS = %i(allow_nil allow_blank)
+      ALLOW_EMPTY_OPTIONS = %i(allow_blank)
 
       def initialize(model, validators = nil)
         @model = model
@@ -14,10 +16,21 @@ module SchemaExpectations
         @validators.flat_map(&:attributes).uniq
       end
 
+      def unique_scopes
+        validators = validators_with_kind :uniqueness
+        validators.flat_map(&method(:validator_scopes))
+      end
+
       def conditions_for_attribute(attribute)
-        validators = validators_for_attribute(attribute)
-        validators -= validators_without_options CONDITIONAL_OPTIONS
-        Util.slice_hash(validators.first.options, *CONDITIONAL_OPTIONS) if validators.first
+        options_for_attribute attribute, CONDITIONAL_OPTIONS
+      end
+
+      def allow_nil_conditions_for_attribute(attribute)
+        options_for_attribute attribute, ALLOW_NIL_OPTIONS
+      end
+
+      def allow_empty_conditions_for_attribute(attribute)
+        options_for_attribute attribute, ALLOW_EMPTY_OPTIONS
       end
 
       def presence
@@ -28,12 +41,35 @@ module SchemaExpectations
         new_with_validators validators_without_options CONDITIONAL_OPTIONS
       end
 
+      def disallow_nil
+        new_with_validators validators_without_options ALLOW_NIL_OPTIONS
+      end
+
+      def disallow_empty
+        new_with_validators validators_without_options ALLOW_EMPTY_OPTIONS
+      end
+
+      def for_unique_scope(scope)
+        scope = scope.sort
+        validators = validators_with_kind :uniqueness
+        validators.select! do |validator|
+          validator_scopes(validator).include? scope
+        end
+        new_with_validators validators
+      end
+
       private
 
       def new_with_validators(validators)
         ValidationReflector.new(@model, validators)
       end
 
+      def options_for_attribute(attribute, option_keys)
+        validators = validators_for_attribute(attribute)
+        validators -= validators_without_options option_keys
+        Util.slice_hash(validators.first.options, *option_keys) if validators.first
+      end
+
       def validators_with_kind(kind)
         @validators.select do |validator|
           validator.kind == kind
@@ -54,6 +90,14 @@ module SchemaExpectations
           validator.attributes.include? attribute
         end
       end
+
+      def validator_scopes(validator)
+        scopes = validator.attributes.map do |attribute|
+          scope = [attribute] + Array(validator.options[:scope])
+          scope.map(&:to_sym).sort
+        end
+        scopes.sort
+      end
     end
   end
 end

data/lib/schema_expectations/rspec_matchers/validate_schema_nullable.rb

@@ -57,7 +57,9 @@ module SchemaExpectations
         end
 
         (@not_null_column_names - @present_column_names).each do |column_name|
-          if conditions = validator_conditions_for_column_name(column_name)
+          conditions = validator_allow_nil_conditions_for_column_name(column_name) ||
+            validator_conditions_for_column_name(column_name)
+          if conditions
             errors << "#{column_name} is NOT NULL but its presence validator was conditional: #{conditions.inspect}"
           else
             errors << "#{column_name} is NOT NULL but has no presence validation"
@@ -106,7 +108,8 @@ module SchemaExpectations
       end
 
       def present_attributes
-        @validation_reflector.presence.unconditional.attributes
+        @validation_reflector.presence.
+          unconditional.disallow_nil.attributes
       end
 
       def present_column_names
@@ -132,6 +135,10 @@ module SchemaExpectations
         column_names
       end
 
+      def validator_allow_nil_conditions_for_column_name(column_name)
+        @validation_reflector.allow_nil_conditions_for_attribute column_name_to_attribute column_name
+      end
+
       def validator_conditions_for_column_name(column_name)
         @validation_reflector.conditions_for_attribute column_name_to_attribute column_name
       end

data/lib/schema_expectations/rspec_matchers/validate_schema_uniqueness.rb

@@ -0,0 +1,153 @@
+require 'rspec/expectations'
+require 'schema_expectations/active_record/validation_reflector'
+require 'schema_expectations/active_record/column_reflector'
+
+module SchemaExpectations
+  module RSpecMatchers
+    # The `validate_schema_uniqueness` matcher tests that an ActiveRecord model
+    # has uniqueness validation on columns with database uniqueness constraints,
+    # and vice versa.
+    #
+    # For example, we can assert that the model and database are consistent
+    # on whether `record_type` and `record_id` should be unique:
+    #
+    #     create_table :records do |t|
+    #       t.integer :record_type
+    #       t.integer :record_id
+    #       t.index [:record_type, :record_id], unique: true
+    #     end
+
+    #     class Record < ActiveRecord::Base
+    #       validates :record_type, uniqueness: { scope: :record_id }
+    #     end
+    #
+    #     # RSpec
+    #     describe Record do
+    #       it { should validate_schema_uniqueness }
+    #     end
+    #
+    # You can restrict the columns tested:
+    #
+    #     # RSpec
+    #     describe Record do
+    #       it { should validate_schema_uniqueness.only(:record_id, :record_type) }
+    #       it { should validate_schema_uniqueness.except(:record_id, :record_type) }
+    #     end
+    #
+    # note: if you exclude a column, then every unique scope which includes it will be completely ignored,
+    # regardless of whether that scope includes other non-excluded columns. Only works similarly, in
+    # that it will ignore any scope which contains columns not in the list
+    #
+    # @return [ValidateSchemaUniquenessMatcher]
+    def validate_schema_uniqueness
+      ValidateSchemaUniquenessMatcher.new
+    end
+
+    class ValidateSchemaUniquenessMatcher
+      def matches?(model)
+        @model = cast_model model
+        @validation_reflector = ActiveRecord::ValidationReflector.new(@model)
+        @column_reflector = ActiveRecord::ColumnReflector.new(@model)
+        @validator_unique_scopes = filter_scopes(validator_unique_scopes).map(&:sort).sort
+        @schema_unique_scopes = filter_scopes(schema_unique_scopes).map(&:sort).sort
+        @validator_unique_scopes == @schema_unique_scopes
+      end
+
+      def failure_message
+        errors = []
+
+        (@validator_unique_scopes - @schema_unique_scopes).each do |scope|
+          errors << "scope #{scope.inspect} has unconditional uniqueness validation but is missing a unique database index"
+        end
+
+        (@schema_unique_scopes - @validator_unique_scopes).each do |scope|
+          conditions = validator_conditions_for_scope(scope) ||
+            validator_allow_empty_conditions_for_scope(scope)
+          if conditions
+            errors << "scope #{scope.inspect} has a unique index but its uniqueness validator was conditional: #{conditions.inspect}"
+          else
+            errors << "scope #{scope.inspect} has a unique index but no uniqueness validation"
+          end
+        end
+
+        errors.join(', ')
+      end
+
+      def failure_message_when_negated
+        'should not match unique indexes with its uniqueness validation but does'
+      end
+
+      def description
+        'validate unique indexes have uniqueness validation'
+      end
+
+      # Specifies a list of columns to restrict matcher
+      #
+      # Any unique scope which includes a column not in this list will be ignored
+      #
+      # @return [ValidateSchemaUniquenessMatcher] self
+      def only(*args)
+        fail 'cannot use only and except' if @except
+        @only = Array(args)
+        fail 'empty only list' if @only.empty?
+        self
+      end
+
+      # Specifies a list of columns for matcher to ignore
+      #
+      # Any unique scope which includes one of these columns will be ignored
+      #
+      # @return [ValidateSchemaUniquenessMatcher] self
+      def except(*args)
+        fail 'cannot use only and except' if @only
+        @except = Array(args)
+        fail 'empty except list' if @except.empty?
+        self
+      end
+
+      private
+
+      def cast_model(model)
+        model = model.class if model.is_a?(::ActiveRecord::Base)
+        unless model.is_a?(Class) && model.ancestors.include?(::ActiveRecord::Base)
+          fail "#{model.inspect} does not inherit from ActiveRecord::Base"
+        end
+        model
+      end
+
+      def validator_unique_scopes
+        @validation_reflector.unconditional.disallow_empty.unique_scopes
+      end
+
+      def schema_unique_scopes
+        @column_reflector.unique_scopes
+      end
+
+      def filter_scopes(scopes)
+        if @only
+          scopes.select { |scope| (scope - @only).empty? }
+        elsif @except
+          scopes.select { |scope| (scope & @except).empty? }
+        else
+          scopes
+        end
+      end
+
+      def validator_conditions_for_scope(scope)
+        reflector = @validation_reflector.for_unique_scope(scope)
+        conditions = reflector.attributes.map do |attribute|
+          reflector.conditions_for_attribute attribute
+        end
+        conditions.compact.first
+      end
+
+      def validator_allow_empty_conditions_for_scope(scope)
+        reflector = @validation_reflector.for_unique_scope(scope)
+        conditions = reflector.attributes.map do |attribute|
+          reflector.allow_empty_conditions_for_attribute attribute
+        end
+        conditions.compact.first
+      end
+    end
+  end
+end

data/lib/schema_expectations/rspec_matchers.rb

@@ -1 +1,2 @@
 require 'schema_expectations/rspec_matchers/validate_schema_nullable'
+require 'schema_expectations/rspec_matchers/validate_schema_uniqueness'

data/lib/schema_expectations/version.rb

@@ -1,3 +1,3 @@
 module SchemaExpectations
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/lib/schema_expectations/active_record/column_reflector_spec.rb

@@ -145,6 +145,33 @@ module SchemaExpectations
           expect(column_reflector.for_attributes(*%i(record missing other)).column_names).to eq %i(record_id other)
         end
       end
+
+      specify '#unique_scopes' do
+        create_table :records do |t|
+          t.string :a
+          t.string :b
+          t.string :c
+          t.string :d
+          t.string :not_unique
+          t.string :other
+        end
+
+        add_index :records, :not_unique
+        add_index :records, :a, unique: true
+        add_index :records, %i(a b), unique: true
+        add_index :records, %i(c a b), unique: true
+        add_index :records, %i(d b), unique: true
+        add_index :records, %i(a not_unique)
+
+        stub_const('Record', Class.new(::ActiveRecord::Base))
+
+        expect(column_reflector.unique_scopes).to eq [
+          %i(a),
+          %i(a b),
+          %i(a b c),
+          %i(b d)
+        ]
+      end
     end
   end
 end

data/spec/lib/schema_expectations/active_record/validation_reflector_spec.rb

@@ -27,35 +27,97 @@ module SchemaExpectations
           present not_present conditional_1 conditional_2
           conditional_3 conditional_4 conditional_5)
 
-        expect(validation_reflector.unconditional.attributes).to eq %i(present not_present)
+        expect(validation_reflector.unconditional.attributes).to eq %i(present not_present conditional_4 conditional_5)
+
+        expect(validation_reflector.disallow_nil.attributes).to eq %i(present not_present conditional_1 conditional_2 conditional_3)
+
+        expect(validation_reflector.disallow_empty.attributes).to eq %i(present not_present conditional_1 conditional_2 conditional_3 conditional_4)
 
         expect(validation_reflector.presence.attributes).to eq %i(
           present conditional_1 conditional_2
           conditional_3 conditional_4 conditional_5)
 
-        expect(validation_reflector.unconditional.presence.attributes).to eq %i(present)
-        expect(validation_reflector.presence.unconditional.attributes).to eq %i(present)
+        expect(validation_reflector.unconditional.presence.disallow_nil.attributes).to eq %i(present)
+        expect(validation_reflector.presence.unconditional.disallow_nil.attributes).to eq %i(present)
       end
 
-      specify '#conditions_for_attribute' do
+      specify '#for_unique_scope' do
         Record.instance_eval do
-          validates :present, presence: true
-          validates :not_present, length: { minimum: 1 }
-          validates :conditional_1, presence: true, on: :create
-          validates :conditional_2, presence: true, if: ->{ false }
-          validates :conditional_3, presence: true, unless: ->{ false }
-          validates :conditional_4, presence: true, allow_nil: true
-          validates :conditional_5, presence: true, allow_blank: true
+          validates :a, uniqueness: true
+          validates :a, :d, uniqueness: { scope: %i(b) }
+          validates :c, uniqueness: { scope: %i(a b) }
         end
 
-        expect(validation_reflector.conditions_for_attribute(:missing)).to be_nil
-        expect(validation_reflector.conditions_for_attribute(:present)).to be_nil
-        expect(validation_reflector.conditions_for_attribute(:not_present)).to be_nil
-        expect(validation_reflector.conditions_for_attribute(:conditional_1)).to eq(on: :create)
-        expect(validation_reflector.conditions_for_attribute(:conditional_2).keys).to eq [:if]
-        expect(validation_reflector.conditions_for_attribute(:conditional_3).keys).to eq [:unless]
-        expect(validation_reflector.conditions_for_attribute(:conditional_4)).to eq(allow_nil: true)
-        expect(validation_reflector.conditions_for_attribute(:conditional_5)).to eq(allow_blank: true)
+        expect(validation_reflector.for_unique_scope(%i(missing)).attributes).to be_empty
+        expect(validation_reflector.for_unique_scope(%i(a)).attributes).to eq %i(a)
+        expect(validation_reflector.for_unique_scope(%i(a b)).attributes).to eq %i(a d)
+        expect(validation_reflector.for_unique_scope(%i(b a)).attributes).to eq %i(a d)
+        expect(validation_reflector.for_unique_scope(%i(b d)).attributes).to eq %i(a d)
+        expect(validation_reflector.for_unique_scope(%i(a b c)).attributes).to eq %i(c)
+        expect(validation_reflector.for_unique_scope(%i(c b a)).attributes).to eq %i(c)
+      end
+
+      specify '#unique_scopes' do
+        Record.instance_eval do
+          validates :a, uniqueness: true
+          validates :b, uniqueness: { scope: %i(a) }
+          validates :c, uniqueness: { scope: %i(a b) }
+          validates :d, uniqueness: { scope: %i(b) }
+        end
+
+        expect(validation_reflector.unique_scopes).to eq [
+          %i(a),
+          %i(a b),
+          %i(a b c),
+          %i(b d)
+        ]
+      end
+
+      context 'conditions' do
+        before do
+          Record.instance_eval do
+            validates :present, presence: true
+            validates :not_present, length: { minimum: 1 }
+            validates :conditional_1, presence: true, on: :create
+            validates :conditional_2, presence: true, if: ->{ false }
+            validates :conditional_3, presence: true, unless: ->{ false }
+            validates :conditional_4, presence: true, allow_nil: true
+            validates :conditional_5, presence: true, allow_blank: true
+          end
+        end
+
+        specify '#conditions_for_attribute' do
+          expect(validation_reflector.conditions_for_attribute(:missing)).to be_nil
+          expect(validation_reflector.conditions_for_attribute(:present)).to be_nil
+          expect(validation_reflector.conditions_for_attribute(:not_present)).to be_nil
+          expect(validation_reflector.conditions_for_attribute(:conditional_1)).to eq(on: :create)
+          expect(validation_reflector.conditions_for_attribute(:conditional_2).keys).to eq [:if]
+          expect(validation_reflector.conditions_for_attribute(:conditional_3).keys).to eq [:unless]
+          expect(validation_reflector.conditions_for_attribute(:conditional_4)).to be_nil
+          expect(validation_reflector.conditions_for_attribute(:conditional_5)).to be_nil
+        end
+
+        specify '#allow_nil_conditions_for_attribute' do
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:missing)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:present)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:not_present)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:conditional_1)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:conditional_2)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:conditional_3)).to be_nil
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:conditional_4)).to eq(allow_nil: true)
+          expect(validation_reflector.allow_nil_conditions_for_attribute(:conditional_5)).to eq(allow_blank: true)
+        end
+
+        specify '#allow_empty_conditions_for_column_name' do
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:missing)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:present)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:not_present)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:conditional_1)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:conditional_2)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:conditional_3)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:conditional_4)).to be_nil
+          expect(validation_reflector.allow_empty_conditions_for_attribute(:conditional_5)).to eq(allow_blank: true)
+        end
       end
     end
   end

data/spec/lib/schema_expectations/rspec_matchers/validate_schema_uniqueness_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+describe SchemaExpectations::RSpecMatchers::ValidateSchemaUniquenessMatcher, :active_record do
+  shared_examples_for 'Record' do
+    def validates(*args)
+      Record.instance_eval do
+        validates *args
+      end
+    end
+
+    let(:unique_scope) { [:unique_1_of_1] }
+
+    before do
+      create_table :records do |t|
+        t.string :no_index
+        t.string :index_not_unique
+
+        unique_scope.each do |column_name|
+          t.string column_name
+        end
+      end
+
+      add_index :records, :index_not_unique
+      add_index :records, unique_scope, unique: true
+
+      stub_const('Record', Class.new(ActiveRecord::Base))
+    end
+
+    subject(:record) { Record }
+
+    context 'with no validations' do
+      it { is_expected.to_not validate_schema_uniqueness }
+
+      specify 'error messages' do
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            "scope #{unique_scope.inspect} has a unique index but no uniqueness validation")
+        )
+      end
+
+      specify '#only' do
+        is_expected.to validate_schema_uniqueness.only(unique_scope.first) if unique_scope.size > 1
+        is_expected.to_not validate_schema_uniqueness.only(*unique_scope)
+        is_expected.to validate_schema_uniqueness.only(:no_index, :index_not_unique)
+        is_expected.to_not validate_schema_uniqueness.only(*unique_scope, :no_index, :index_not_unique)
+      end
+
+      specify '#except' do
+        is_expected.to validate_schema_uniqueness.except(unique_scope.first)
+        is_expected.to validate_schema_uniqueness.except(*unique_scope)
+        is_expected.to_not validate_schema_uniqueness.except(:no_index, :index_not_unique)
+        is_expected.to validate_schema_uniqueness.except(*unique_scope, :no_index, :index_not_unique)
+      end
+    end
+
+    context 'validating uniqueness on unique index' do
+      before { validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) } }
+
+      it { is_expected.to validate_schema_uniqueness }
+
+      specify '#only' do
+        is_expected.to validate_schema_uniqueness.only(*unique_scope)
+        is_expected.to validate_schema_uniqueness.only(:no_index, :index_not_unique)
+        is_expected.to validate_schema_uniqueness.only(*unique_scope, :no_index, :index_not_unique)
+      end
+
+      specify '#except' do
+        is_expected.to validate_schema_uniqueness.except(*unique_scope)
+        is_expected.to validate_schema_uniqueness.except(:no_index, :index_not_unique)
+      end
+    end
+
+    context 'validating uniqueness on not-unique index' do
+      before do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }
+        validates :index_not_unique, uniqueness: true
+      end
+
+      it { is_expected.to_not validate_schema_uniqueness }
+
+      specify 'error messages' do
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            "scope [:index_not_unique] has unconditional uniqueness validation but is missing a unique database index")
+        )
+      end
+
+      specify '#only' do
+        is_expected.to_not validate_schema_uniqueness.only(:index_not_unique)
+        is_expected.to validate_schema_uniqueness.only(*unique_scope, :no_index)
+      end
+
+      specify '#except' do
+        is_expected.to_not validate_schema_uniqueness.except(*unique_scope, :no_index)
+        is_expected.to validate_schema_uniqueness.except(:index_not_unique)
+      end
+    end
+
+    context 'validating uniqueness on column without index' do
+      before do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }
+        validates :no_index, uniqueness: true
+      end
+
+      it { is_expected.to_not validate_schema_uniqueness }
+
+      specify 'error messages' do
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            "scope [:no_index] has unconditional uniqueness validation but is missing a unique database index")
+        )
+      end
+
+      specify '#only' do
+        is_expected.to_not validate_schema_uniqueness.only(:no_index)
+        is_expected.to validate_schema_uniqueness.only(*unique_scope, :index_not_unique)
+      end
+
+      specify '#except' do
+        is_expected.to_not validate_schema_uniqueness.except(*unique_scope, :index_not_unique)
+        is_expected.to validate_schema_uniqueness.except(:no_index)
+      end
+    end
+
+    specify '#failure_message_when_negated' do
+      validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }
+
+      expect do
+        is_expected.to_not validate_schema_uniqueness
+      end.to raise_error 'should not match unique indexes with its uniqueness validation but does'
+    end
+
+    specify 'allows validators with allow_nil: true' do
+      validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }, allow_nil: true
+
+      is_expected.to validate_schema_uniqueness
+    end
+
+    context 'ignores validators with' do
+      specify 'on: :create' do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }, on: :create
+
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            "scope #{unique_scope.inspect} has a unique index but its uniqueness validator was conditional: {:on=>:create}")
+        )
+      end
+
+      specify 'if: proc' do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }, if: ->{ false }
+
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            /\Ascope #{Regexp.escape(unique_scope.inspect)} has a unique index but its uniqueness validator was conditional: {:if=>\#<Proc:.*>}\z/)
+        )
+      end
+
+      specify 'unless: proc' do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }, unless: ->{ false }
+
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            /\Ascope #{Regexp.escape(unique_scope.inspect)} has a unique index but its uniqueness validator was conditional: {:unless=>\#<Proc:.*>}\z/)
+        )
+      end
+
+      specify 'allow_blank: true' do
+        validates unique_scope.first, uniqueness: { scope: unique_scope.drop(1) }, allow_blank: true
+
+        expect { is_expected.to validate_schema_uniqueness }.to(
+          raise_error(RSpec::Expectations::ExpectationNotMetError,
+            "scope #{unique_scope.inspect} has a unique index but its uniqueness validator was conditional: {:allow_blank=>true}")
+        )
+      end
+    end
+  end
+
+  context 'called on class' do
+    include_examples 'Record' do
+      subject(:record) { Record }
+    end
+  end
+
+  context 'called on instance' do
+    include_examples 'Record' do
+      subject(:record) { Record.new }
+    end
+  end
+
+  context 'with two columns' do
+    include_examples 'Record' do
+      let(:unique_scope) { [:unique_1_of_2, :unique_2_of_2] }
+    end
+  end
+  specify 'called on unrecognized object' do
+    expect { expect(double('object')).to validate_schema_uniqueness }.
+      to raise_error /#<RSpec::Mocks::Double:0x\h* @name="object"> does not inherit from ActiveRecord::Base/
+  end
+end

data/spec/support/active_record_helpers.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext/hash/keys'
 module ActiveRecordHelpers
   extend Forwardable
 
-  CONNECTION_DELEGATES = %i(create_table execute)
+  CONNECTION_DELEGATES = %i(create_table add_index execute)
 
   def connection
     ActiveRecord::Base.connection

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: schema_expectations
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Emma Borhanian
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-19 00:00:00.000000000 Z
+date: 2015-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -259,7 +259,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - Guardfile
-- LICENSE
+- MIT-LICENSE
 - README.md
 - Rakefile
 - gemfiles/activerecord_3.1.gemfile
@@ -278,6 +278,7 @@ files:
 - lib/schema_expectations/rspec.rb
 - lib/schema_expectations/rspec_matchers.rb
 - lib/schema_expectations/rspec_matchers/validate_schema_nullable.rb
+- lib/schema_expectations/rspec_matchers/validate_schema_uniqueness.rb
 - lib/schema_expectations/util.rb
 - lib/schema_expectations/version.rb
 - schema_expectations.gemspec
@@ -286,6 +287,7 @@ files:
 - spec/lib/schema_expectations/active_record/validation_reflector_spec.rb
 - spec/lib/schema_expectations/config_spec.rb
 - spec/lib/schema_expectations/rspec_matchers/validate_schema_nullable_spec.rb
+- spec/lib/schema_expectations/rspec_matchers/validate_schema_uniqueness_spec.rb
 - spec/lib/schema_expectations/util_spec.rb
 - spec/meta_spec.rb
 - spec/spec_helper.rb
@@ -322,6 +324,7 @@ test_files:
 - spec/lib/schema_expectations/active_record/validation_reflector_spec.rb
 - spec/lib/schema_expectations/config_spec.rb
 - spec/lib/schema_expectations/rspec_matchers/validate_schema_nullable_spec.rb
+- spec/lib/schema_expectations/rspec_matchers/validate_schema_uniqueness_spec.rb
 - spec/lib/schema_expectations/util_spec.rb
 - spec/meta_spec.rb
 - spec/spec_helper.rb