shoulda-matchers 3.1.3 → 4.0.0.rc1

data/lib/shoulda/matchers/active_record/association_matchers/required_matcher.rb

@@ -0,0 +1,51 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      module AssociationMatchers
+        # @private
+        class RequiredMatcher
+          attr_reader :missing_option
+
+          def initialize(attribute_name, required)
+            @required = required
+            @submatcher = ActiveModel::DisallowValueMatcher.new(nil).
+              for(attribute_name).
+              with_message(validation_message_key)
+            @missing_option = ''
+          end
+
+          def description
+            "required: #{required}"
+          end
+
+          def matches?(subject)
+            if submatcher_passes?(subject)
+              true
+            else
+              @missing_option =
+                'the association should have been defined ' +
+                "with `required: #{required}`, but was not"
+              false
+            end
+          end
+
+          private
+
+          attr_reader :required, :submatcher
+
+          def submatcher_passes?(subject)
+            if required
+              submatcher.matches?(subject)
+            else
+              submatcher.does_not_match?(subject)
+            end
+          end
+
+          def validation_message_key
+            RailsShim.validation_message_key_for_association_required_option
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -20,10 +20,10 @@ module Shoulda
       #
       # #### Qualifiers
       #
-      # ##### with
+      # ##### with_values
       #
-      # Use `with` to test that the enum has been defined with a certain set of
-      # known values.
+      # Use `with_values` to test that the attribute has been defined with a
+      # certain set of possible values.
       #
       #     class Process < ActiveRecord::Base
       #       enum status: [:running, :stopped, :suspended]
@@ -33,14 +33,101 @@ module Shoulda
       #     RSpec.describe Process, type: :model do
       #       it do
       #         should define_enum_for(:status).
-      #           with([:running, :stopped, :suspended])
+      #           with_values([:running, :stopped, :suspended])
       #       end
       #     end
       #
       #     # Minitest (Shoulda)
       #     class ProcessTest < ActiveSupport::TestCase
       #       should define_enum_for(:status).
-      #         with([:running, :stopped, :suspended])
+      #         with_values([:running, :stopped, :suspended])
+      #     end
+      #
+      # ##### backed_by_column_of_type
+      #
+      # Use `backed_by_column_of_type` to test that the attribute is of a
+      # certain column type. (The default is `:integer`.)
+      #
+      #     class LoanApplication < ActiveRecord::Base
+      #       enum status: {
+      #         active: "active",
+      #         pending: "pending",
+      #         rejected: "rejected"
+      #       }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe LoanApplication, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with_values(
+      #             active: "active",
+      #             pending: "pending",
+      #             rejected: "rejected"
+      #           ).
+      #           backed_by_column_of_type(:string)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class LoanApplicationTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with_values(
+      #           active: "active",
+      #           pending: "pending",
+      #           rejected: "rejected"
+      #         ).
+      #         backed_by_column_of_type(:string)
+      #     end
+      #
+      ## ##### with_prefix
+      #
+      # Use `with_prefix` to test that the enum is defined with a `_prefix`
+      # option (Rails 5 only). Can take either a boolean or a symbol:
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], _prefix: :old
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with_values([:open, :closed]).
+      #           with_prefix(:old)
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with_values([:open, :closed]).
+      #         with_prefix(:old)
+      #     end
+      #
+      # ##### with_suffix
+      #
+      # Use `with_suffix` to test that the enum is defined with a `_suffix`
+      # option (Rails 5 only). Can take either a boolean or a symbol:
+      #
+      #     class Issue < ActiveRecord::Base
+      #       enum status: [:open, :closed], _suffix: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Issue, type: :model do
+      #       it do
+      #         should define_enum_for(:status).
+      #           with_values([:open, :closed]).
+      #           with_suffix
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class ProcessTest < ActiveSupport::TestCase
+      #       should define_enum_for(:status).
+      #         with_values([:open, :closed]).
+      #         with_suffix
       #     end
       #
       # @return [DefineEnumForMatcher]
@@ -53,51 +140,132 @@ module Shoulda
       class DefineEnumForMatcher
         def initialize(attribute_name)
           @attribute_name = attribute_name
-          @options = {}
+          @options = { expected_enum_values: [] }
         end
 
-        def with(expected_enum_values)
+        def description
+          description = "define :#{attribute_name} as an enum, 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}"
+          end
+
+          if options[:expected_suffix]
+            if options[:expected_prefix]
+              description << ' and'
+            else
+              description << ', using'
+            end
+
+            description << ' a suffix of '
+
+            description << "#{options[:expected_suffix].inspect}"
+          end
+
+          if presented_expected_enum_values.any?
+            description << ', with possible values '
+            description << Shoulda::Matchers::Util.inspect_value(
+              presented_expected_enum_values,
+            )
+          end
+
+          description
+        end
+
+        def with_values(expected_enum_values)
           options[:expected_enum_values] = expected_enum_values
           self
         end
 
+        def with(expected_enum_values)
+          Shoulda::Matchers.warn_about_deprecated_method(
+            'The `with` qualifier on `define_enum_for`',
+            '`with_values`',
+          )
+          with_values(expected_enum_values)
+        end
+
+        def with_prefix(expected_prefix = attribute_name)
+          options[:expected_prefix] = expected_prefix
+          self
+        end
+
+        def with_suffix(expected_suffix = attribute_name)
+          options[:expected_suffix] = expected_suffix
+          self
+        end
+
+        def backed_by_column_of_type(expected_column_type)
+          options[:expected_column_type] = expected_column_type
+          self
+        end
+
         def matches?(subject)
           @record = subject
-          enum_defined? && enum_values_match? && column_type_is_integer?
+
+          enum_defined? &&
+            enum_values_match? &&
+            column_type_matches? &&
+            enum_value_methods_exist?
         end
 
         def failure_message
-          "Expected #{expectation}"
+          message = "Expected #{model} to #{expectation}"
+
+          if failure_reason
+            message << ". However, #{failure_reason}"
+          end
+
+          message << '.'
+
+          Shoulda::Matchers.word_wrap(message)
         end
-        alias :failure_message_for_should :failure_message
 
         def failure_message_when_negated
-          "Did not expect #{expectation}"
+          message = "Expected #{model} not to #{expectation}, but it did."
+          Shoulda::Matchers.word_wrap(message)
         end
-        alias :failure_message_for_should_not :failure_message_when_negated
-
-        def description
-          desc = "define :#{attribute_name} as an enum"
 
-          if options[:expected_enum_values]
-            desc << " with #{options[:expected_enum_values]}"
-          end
+        private
 
-          desc << " and store the value in a column with an integer type"
+        attr_reader :attribute_name, :options, :record, :failure_reason
 
-          desc
+        def expectation
+          description
         end
 
-        protected
+        def presented_expected_enum_values
+          if expected_enum_values.is_a?(Hash)
+            expected_enum_values.symbolize_keys
+          else
+            expected_enum_values
+          end
+        end
 
-        attr_reader :record, :attribute_name, :options
+        def normalized_expected_enum_values
+          to_hash(expected_enum_values)
+        end
 
-        def expectation
-          "#{model.name} to #{description}"
+        def expected_enum_value_names
+          to_array(expected_enum_values)
         end
 
         def expected_enum_values
-          hashify(options[:expected_enum_values]).with_indifferent_access
+          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
 
         def actual_enum_values
@@ -105,15 +273,45 @@ module Shoulda
         end
 
         def enum_defined?
-          model.defined_enums.include?(attribute_name.to_s)
+          if model.defined_enums.include?(attribute_name.to_s)
+            true
+          else
+            @failure_reason = "no such enum exists in #{model}"
+            false
+          end
         end
 
         def enum_values_match?
-          expected_enum_values.empty? || actual_enum_values == expected_enum_values
+          passed =
+            expected_enum_values.empty? ||
+            normalized_actual_enum_values == normalized_expected_enum_values
+
+          if passed
+            true
+          else
+            @failure_reason =
+              "the actual enum values for #{attribute_name.inspect} are " +
+              Shoulda::Matchers::Util.inspect_value(
+                presented_actual_enum_values,
+              )
+            false
+          end
         end
 
-        def column_type_is_integer?
-          column.type == :integer
+        def column_type_matches?
+          if column.type == expected_column_type.to_sym
+            true
+          else
+            @failure_reason =
+              "#{attribute_name.inspect} is " +
+              Shoulda::Matchers::Util.a_or_an(column.type) +
+              ' column'
+            false
+          end
+        end
+
+        def expected_column_type
+          options[:expected_column_type] || :integer
         end
 
         def column
@@ -124,21 +322,53 @@ module Shoulda
           record.class
         end
 
-        def hashify(value)
-          if value.nil?
-            return {}
+        def enum_value_methods_exist?
+          passed = expected_singleton_methods.all? do |method|
+            model.singleton_methods.include?(method)
           end
 
-          if value.is_a?(Array)
-            new_value = {}
+          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'
+              end
+            false
+          end
+        end
 
-            value.each_with_index do |v, i|
-              new_value[v] = i
+        def expected_singleton_methods
+          expected_enum_value_names.map do |name|
+            [options[:expected_prefix], name, options[:expected_suffix]].
+              select(&:present?).
+              join('_').
+              to_sym
+          end
+        end
+
+        def to_hash(value)
+          if value.is_a?(Array)
+            value.each_with_index.inject({}) do |hash, (item, index)|
+              hash.merge(item.to_s => index)
             end
+          else
+            value.stringify_keys
+          end
+        end
 
-            new_value
+        def to_array(value)
+          if value.is_a?(Array)
+            value.map(&:to_s)
           else
-            value
+            value.keys.map(&:to_s)
           end
         end
       end

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

@@ -50,7 +50,7 @@ module Shoulda
       #       should have_db_index(:name).unique(true)
       #     end
       #
-      # Since it only ever makes since for `unique` to be `true`, you can also
+      # Since it only ever makes sense for `unique` to be `true`, you can also
       # leave off the argument to save some keystrokes:
       #
       #     # RSpec

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

@@ -0,0 +1,111 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `have_secure_token` matcher tests usage of the
+      # `has_secure_token` macro.
+      #
+      # #### Example
+      #
+      #     class User < ActiveRecord
+      #       attr_accessor :token
+      #       attr_accessor :auth_token
+      #
+      #       has_secure_token
+      #       has_secure_token :auth_token
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should have_secure_token }
+      #       it { should have_secure_token(:auth_token) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class UserTest < ActiveSupport::TestCase
+      #       should have_secure_token
+      #       should have_secure_token(:auth_token)
+      #     end
+      #
+      # @return [HaveSecureToken]
+      #
+
+      # rubocop:disable Style/PredicateName
+      def have_secure_token(token_attribute = :token)
+        HaveSecureTokenMatcher.new(token_attribute)
+      end
+      # rubocop:enable Style/PredicateName
+
+      # @private
+      class HaveSecureTokenMatcher
+        attr_reader :token_attribute
+
+        def initialize(token_attribute)
+          @token_attribute = token_attribute
+        end
+
+        def description
+          "have :#{token_attribute} as a secure token"
+        end
+
+        def failure_message
+          return if !@errors
+          "Expected #{@subject.class} to #{description} but the following " \
+          "errors were found: #{@errors.join(', ')}"
+        end
+
+        def failure_message_when_negated
+          return if !@errors
+          "Did not expect #{@subject.class} to have secure token " \
+          ":#{token_attribute}"
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @errors = run_checks
+          @errors.empty?
+        end
+
+        private
+
+        def run_checks
+          @errors = []
+          if !has_expected_instance_methods?
+            @errors << 'missing expected class and instance methods'
+          end
+          if !has_expected_db_column?
+            @errors << "missing correct column #{token_attribute}:string"
+          end
+          if !has_expected_db_index?
+            @errors << "missing unique index for #{table_and_column}"
+          end
+          @errors
+        end
+
+        def has_expected_instance_methods?
+          @subject.respond_to?(token_attribute.to_s) &&
+            @subject.respond_to?("#{token_attribute}=") &&
+            @subject.respond_to?("regenerate_#{token_attribute}") &&
+            @subject.class.respond_to?(:generate_unique_secure_token)
+        end
+
+        def has_expected_db_column?
+          matcher = HaveDbColumnMatcher.new(token_attribute).of_type(:string)
+          matcher.matches?(@subject)
+        end
+
+        def has_expected_db_index?
+          matcher = HaveDbIndexMatcher.new(token_attribute).unique(true)
+          matcher.matches?(@subject)
+        end
+
+        def table_and_column
+          "#{table_name}.#{token_attribute}"
+        end
+
+        def table_name
+          @subject.class.table_name
+        end
+      end
+    end
+  end
+end