shoulda-matchers 4.0.1 → 4.1.0

data/lib/shoulda/matchers/active_record/association_matcher.rb

@@ -272,7 +272,7 @@ module Shoulda
       #       should belong_to(:organization).required
       #     end
       #
-      # #### without_validating_presence
+      # ##### without_validating_presence
       #
       # Use `without_validating_presence` with `belong_to` to prevent the
       # matcher from checking whether the association disallows nil (Rails 5+
@@ -1362,13 +1362,11 @@ module Shoulda
         def class_has_foreign_key?(klass)
           if options.key?(:foreign_key)
             option_verifier.correct_for_string?(:foreign_key, options[:foreign_key])
+          elsif column_names_for(klass).include?(foreign_key)
+            true
           else
-            if klass.column_names.include?(foreign_key)
-              true
-            else
-              @missing = "#{klass} does not have a #{foreign_key} foreign key."
-              false
-            end
+            @missing = "#{klass} does not have a #{foreign_key} foreign key."
+            false
           end
         end
 
@@ -1407,6 +1405,12 @@ module Shoulda
           failing_submatchers.empty?
         end
 
+        def column_names_for(klass)
+          klass.column_names
+        rescue ::ActiveRecord::StatementInvalid
+          []
+        end
+
         def belongs_to_required_by_default?
           ::ActiveRecord::Base.belongs_to_required_by_default
         end

data/lib/shoulda/matchers/active_record/define_enum_for_matcher.rb

@@ -144,31 +144,22 @@ module Shoulda
         end
 
         def description
-          description = "define :#{attribute_name} as an enum, backed by "
+          description = "#{simple_description} backed by "
           description << Shoulda::Matchers::Util.a_or_an(expected_column_type)
 
-          if options[:expected_prefix]
-            description << ', using a prefix of '
-            description << "#{options[:expected_prefix].inspect}"
+          if expected_enum_values.any?
+            description << ' with values '
+            description << Shoulda::Matchers::Util.inspect_value(
+              expected_enum_values,
+            )
           end
 
-          if options[:expected_suffix]
-            if options[:expected_prefix]
-              description << ' and'
-            else
-              description << ', using'
-            end
-
-            description << ' a suffix of '
-
-            description << "#{options[:expected_suffix].inspect}"
+          if options[:prefix]
+            description << ", prefix: #{options[:prefix].inspect}"
           end
 
-          if presented_expected_enum_values.any?
-            description << ', with possible values '
-            description << Shoulda::Matchers::Util.inspect_value(
-              presented_expected_enum_values,
-            )
+          if options[:suffix]
+            description << ", suffix: #{options[:suffix].inspect}"
           end
 
           description
@@ -187,13 +178,13 @@ module Shoulda
           with_values(expected_enum_values)
         end
 
-        def with_prefix(expected_prefix = attribute_name)
-          options[:expected_prefix] = expected_prefix
+        def with_prefix(expected_prefix = true)
+          options[:prefix] = expected_prefix
           self
         end
 
-        def with_suffix(expected_suffix = attribute_name)
-          options[:expected_suffix] = expected_suffix
+        def with_suffix(expected_suffix = true)
+          options[:suffix] = expected_suffix
           self
         end
 
@@ -212,13 +203,14 @@ module Shoulda
         end
 
         def failure_message
-          message = "Expected #{model} to #{expectation}"
-
-          if failure_reason
-            message << ". However, #{failure_reason}"
-          end
+          message =
+            if enum_defined?
+              "Expected #{model} to #{expectation}. "
+            else
+              "Expected #{model} to #{expectation}, but "
+            end
 
-          message << '.'
+          message << failure_message_continuation + '.'
 
           Shoulda::Matchers.word_wrap(message)
         end
@@ -230,20 +222,65 @@ module Shoulda
 
         private
 
-        attr_reader :attribute_name, :options, :record, :failure_reason
+        attr_reader :attribute_name, :options, :record,
+          :failure_message_continuation
 
         def expectation
-          description
-        end
+          if enum_defined?
+            expectation = "#{simple_description} backed by "
+            expectation << Shoulda::Matchers::Util.a_or_an(expected_column_type)
+
+            if expected_enum_values.any?
+              expectation << ', mapping '
+              expectation << presented_enum_mapping(
+                normalized_expected_enum_values,
+              )
+            end
+
+            if expected_prefix
+              expectation <<
+                if expected_suffix
+                  ', '
+                else
+                  ' and '
+                end
+
+              expectation << 'prefixing accessor methods with '
+              expectation << "#{expected_prefix}_".inspect
+            end
+
+            if expected_suffix
+              expectation <<
+                if expected_prefix
+                  ', and '
+                else
+                  ' and '
+                end
+
+              expectation << 'suffixing accessor methods with '
+              expectation << "_#{expected_suffix}".inspect
+            end
 
-        def presented_expected_enum_values
-          if expected_enum_values.is_a?(Hash)
-            expected_enum_values.symbolize_keys
+            expectation
           else
-            expected_enum_values
+            simple_description
           end
         end
 
+        def simple_description
+          "define :#{attribute_name} as an enum"
+        end
+
+        def presented_enum_mapping(enum_values)
+          enum_values.
+            map { |output_to_input|
+              output_to_input.
+                map(&Shoulda::Matchers::Util.method(:inspect_value)).
+                join(' to ')
+            }.
+            to_sentence
+        end
+
         def normalized_expected_enum_values
           to_hash(expected_enum_values)
         end
@@ -256,14 +293,6 @@ module Shoulda
           options[:expected_enum_values]
         end
 
-        def presented_actual_enum_values
-          if expected_enum_values.is_a?(Array)
-            to_array(actual_enum_values)
-          else
-            to_hash(actual_enum_values).symbolize_keys
-          end
-        end
-
         def normalized_actual_enum_values
           to_hash(actual_enum_values)
         end
@@ -276,7 +305,8 @@ module Shoulda
           if model.defined_enums.include?(attribute_name.to_s)
             true
           else
-            @failure_reason = "no such enum exists in #{model}"
+            @failure_message_continuation =
+              "no such enum exists on #{model}"
             false
           end
         end
@@ -289,11 +319,9 @@ module Shoulda
           if passed
             true
           else
-            @failure_reason =
-              "the actual enum values for #{attribute_name.inspect} are " +
-              Shoulda::Matchers::Util.inspect_value(
-                presented_actual_enum_values,
-              )
+            @failure_message_continuation =
+              "However, #{attribute_name.inspect} actually maps " +
+              presented_enum_mapping(normalized_actual_enum_values)
             false
           end
         end
@@ -302,8 +330,8 @@ module Shoulda
           if column.type == expected_column_type.to_sym
             true
           else
-            @failure_reason =
-              "#{attribute_name.inspect} is " +
+            @failure_message_continuation =
+              "However, #{attribute_name.inspect} is " +
               Shoulda::Matchers::Util.a_or_an(column.type) +
               ' column'
             false
@@ -330,30 +358,59 @@ module Shoulda
           if passed
             true
           else
-            @failure_reason =
-              if options[:expected_prefix]
-                if options[:expected_suffix]
-                  'it was defined with either a different prefix, a ' +
-                  'different suffix, or neither one at all'
-                else
-                  'it was defined with either a different prefix or none at all'
-                end
-              elsif options[:expected_suffix]
-                'it was defined with either a different suffix or none at all'
+            message = "#{attribute_name.inspect} does map to these "
+            message << 'values, but the enum is '
+
+            if expected_prefix
+              if expected_suffix
+                message << 'configured with either a different prefix or '
+                message << 'suffix, or no prefix or suffix at all'
+              else
+                message << 'configured with either a different prefix or no '
+                message << 'prefix at all'
               end
+            elsif expected_suffix
+              message << 'configured with either a different suffix or no '
+              message << 'suffix at all'
+            end
+
+            message << " (we can't tell which)"
+
+            @failure_message_continuation = message
+
             false
           end
         end
 
         def expected_singleton_methods
           expected_enum_value_names.map do |name|
-            [options[:expected_prefix], name, options[:expected_suffix]].
+            [expected_prefix, name, expected_suffix].
               select(&:present?).
               join('_').
               to_sym
           end
         end
 
+        def expected_prefix
+          if options.include?(:prefix)
+            if options[:prefix] == true
+              attribute_name#.to_sym
+            else
+              options[:prefix]#.to_sym
+            end
+          end
+        end
+
+        def expected_suffix
+          if options.include?(:suffix)
+            if options[:suffix] == true
+              attribute_name#.to_sym
+            else
+              options[:suffix]#.to_sym
+            end
+          end
+        end
+
         def to_hash(value)
           if value.is_a?(Array)
             value.each_with_index.inject({}) do |hash, (item, index)|

data/lib/shoulda/matchers/active_record/have_db_index_matcher.rb

@@ -2,7 +2,9 @@ module Shoulda
   module Matchers
     module ActiveRecord
       # The `have_db_index` matcher tests that the table that backs your model
-      # has a index on a specific column.
+      # has a specific index.
+      #
+      # You can specify one column:
       #
       #     class CreateBlogs < ActiveRecord::Migration
       #       def change
@@ -24,43 +26,83 @@ module Shoulda
       #       should have_db_index(:user_id)
       #     end
       #
-      # #### Qualifiers
-      #
-      # ##### unique
-      #
-      # Use `unique` to assert that the index is unique.
+      # Or you can specify a group of columns:
       #
       #     class CreateBlogs < ActiveRecord::Migration
       #       def change
       #         create_table :blogs do |t|
+      #           t.integer :user_id
       #           t.string :name
       #         end
       #
-      #         add_index :blogs, :name, unique: true
+      #         add_index :blogs, :user_id, :name
       #       end
       #     end
       #
       #     # RSpec
       #     RSpec.describe Blog, type: :model do
-      #       it { should have_db_index(:name).unique(true) }
+      #       it { should have_db_index([:user_id, :name]) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class BlogTest < ActiveSupport::TestCase
-      #       should have_db_index(:name).unique(true)
+      #       should have_db_index([:user_id, :name])
+      #     end
+      #
+      # Finally, if you're using Rails 5 and PostgreSQL, you can also specify an
+      # expression:
+      #
+      #     class CreateLoggedErrors < ActiveRecord::Migration
+      #       def change
+      #         create_table :logged_errors do |t|
+      #           t.string :code
+      #           t.jsonb :content
+      #         end
+      #
+      #         add_index :logged_errors, 'lower(code)::text'
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe LoggedError, type: :model do
+      #       it { should have_db_index('lower(code)::text') }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class LoggedErrorTest < ActiveSupport::TestCase
+      #       should have_db_index('lower(code)::text')
       #     end
       #
-      # Since it only ever makes sense for `unique` to be `true`, you can also
-      # leave off the argument to save some keystrokes:
+      # #### Qualifiers
+      #
+      # ##### unique
+      #
+      # Use `unique` to assert that the index is either unique or non-unique:
+      #
+      #     class CreateBlogs < ActiveRecord::Migration
+      #       def change
+      #         create_table :blogs do |t|
+      #           t.string :domain
+      #           t.integer :user_id
+      #         end
+      #
+      #         add_index :blogs, :domain, unique: true
+      #         add_index :blogs, :user_id
+      #       end
+      #     end
       #
       #     # RSpec
       #     RSpec.describe Blog, type: :model do
       #       it { should have_db_index(:name).unique }
+      #       it { should have_db_index(:name).unique(true) }   # if you want to be explicit
+      #       it { should have_db_index(:user_id).unique(false) }
       #     end
       #
       #     # Minitest (Shoulda)
       #     class BlogTest < ActiveSupport::TestCase
       #       should have_db_index(:name).unique
+      #       should have_db_index(:name).unique(true)   # if you want to be explicit
+      #       should have_db_index(:user_id).unique(false)
       #     end
       #
       # @return [HaveDbIndexMatcher]
@@ -72,12 +114,12 @@ module Shoulda
       # @private
       class HaveDbIndexMatcher
         def initialize(columns)
-          @columns = normalize_columns_to_array(columns)
-          @options = {}
+          @expected_columns = normalize_columns_to_array(columns)
+          @qualifiers = {}
         end
 
         def unique(unique = true)
-          @options[:unique] = unique
+          @qualifiers[:unique] = unique
           self
         end
 
@@ -87,72 +129,146 @@ module Shoulda
         end
 
         def failure_message
-          "Expected #{expectation} (#{@missing})"
+          message =
+            "Expected #{described_table_name} to #{positive_expectation}"
+
+          message <<
+            if index_exists?
+              ". The index does exist, but #{reason}."
+            elsif reason
+              ", but #{reason}."
+            else
+              ', but it does not.'
+            end
+
+          Shoulda::Matchers.word_wrap(message)
         end
 
         def failure_message_when_negated
-          "Did not expect #{expectation}"
+          Shoulda::Matchers.word_wrap(
+            "Expected #{described_table_name} not to " +
+            "#{negative_expectation}, but it does.",
+          )
         end
 
         def description
-          if @options.key?(:unique)
-            "have a #{index_type} index on columns #{@columns.join(' and ')}"
-          else
-            "have an index on columns #{@columns.join(' and ')}"
-          end
-        end
+          description = 'have '
 
-        protected
+          description <<
+            if qualifiers.include?(:unique)
+              Shoulda::Matchers::Util.a_or_an(index_type) + ' '
+            else
+              'an '
+            end
 
-        def index_exists?
-          ! matched_index.nil?
+          description << 'index on '
+
+          description << inspected_expected_columns
         end
 
-        def correct_unique?
-          return true unless @options.key?(:unique)
+        private
 
-          is_unique = matched_index.unique
+        attr_reader :expected_columns, :qualifiers, :subject, :reason
 
-          is_unique = !is_unique unless @options[:unique]
+        def normalize_columns_to_array(columns)
+          Array.wrap(columns).map(&:to_s)
+        end
 
-          unless is_unique
-            @missing = "#{table_name} has an index named #{matched_index.name} " <<
-            "of unique #{matched_index.unique}, not #{@options[:unique]}."
-          end
+        def index_exists?
+          !matched_index.nil?
+        end
 
-          is_unique
+        def correct_unique?
+          if qualifiers.include?(:unique)
+            if qualifiers[:unique] && !matched_index.unique
+              @reason = 'it is not unique'
+              false
+            elsif !qualifiers[:unique] && matched_index.unique
+              @reason = 'it is unique'
+              false
+            else
+              true
+            end
+          else
+            true
+          end
         end
 
         def matched_index
-          indexes.detect { |each| each.columns == @columns }
+          @_matched_index ||=
+            if expected_columns.one?
+              actual_indexes.detect do |index|
+                Array.wrap(index.columns) == expected_columns
+              end
+            else
+              actual_indexes.detect do |index|
+                index.columns == expected_columns
+              end
+            end
         end
 
-        def model_class
-          @subject.class
+        def actual_indexes
+          model.connection.indexes(table_name)
+        end
+
+        def described_table_name
+          if model
+            "the #{table_name} table"
+          else
+            'a table'
+          end
         end
 
         def table_name
-          model_class.table_name
+          model.table_name
+        end
+
+        def positive_expectation
+          if index_exists?
+            expectation = "have an index on #{inspected_expected_columns}"
+
+            if qualifiers.include?(:unique)
+              expectation << " and for it to be #{index_type}"
+            end
+
+            expectation
+          else
+            description
+          end
         end
 
-        def indexes
-          ::ActiveRecord::Base.connection.indexes(table_name)
+        def negative_expectation
+          description
         end
 
-        def expectation
-          "#{model_class.name} to #{description}"
+        def inspected_expected_columns
+          if formatted_expected_columns.one?
+            formatted_expected_columns.first.inspect
+          else
+            formatted_expected_columns.inspect
+          end
         end
 
         def index_type
-          if @options[:unique]
+          if qualifiers[:unique]
             'unique'
           else
             'non-unique'
           end
         end
 
-        def normalize_columns_to_array(columns)
-          Array.wrap(columns).map(&:to_s)
+        def formatted_expected_columns
+          expected_columns.map do |column|
+            if column.match?(/^\w+$/)
+              column.to_sym
+            else
+              column
+            end
+          end
+        end
+
+        def model
+          subject&.class
         end
       end
     end