shoulda-matchers 5.3.0 → 6.1.0

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

@@ -0,0 +1,174 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `encrypt` matcher tests usage of the
+      # `encrypts` macro (Rails 7+ only).
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code)
+      #     end
+      #
+      # #### Qualifiers
+      #
+      # ##### deterministic
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, deterministic: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).deterministic(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).deterministic(true)
+      #     end
+      #
+      # ##### downcase
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, downcase: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).downcase(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).downcase(true)
+      #     end
+      #
+      # ##### ignore_case
+      #
+      #     class Survey < ActiveRecord::Base
+      #       encrypts :access_code, deterministic: true, ignore_case: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Survey, type: :model do
+      #       it { should encrypt(:access_code).ignore_case(true) }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class SurveyTest < ActiveSupport::TestCase
+      #       should encrypt(:access_code).ignore_case(true)
+      #     end
+      #
+      # @return [EncryptMatcher]
+      #
+      def encrypt(value)
+        EncryptMatcher.new(value)
+      end
+
+      # @private
+      class EncryptMatcher
+        def initialize(attribute)
+          @attribute = attribute.to_sym
+          @options = {}
+        end
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        def deterministic(deterministic)
+          with_option(:deterministic, deterministic)
+        end
+
+        def downcase(downcase)
+          with_option(:downcase, downcase)
+        end
+
+        def ignore_case(ignore_case)
+          with_option(:ignore_case, ignore_case)
+        end
+
+        def matches?(subject)
+          @subject = subject
+          result = encrypted_attributes_included? &&
+                   options_correct?(
+                     :deterministic,
+                     :downcase,
+                     :ignore_case,
+                   )
+
+          if result
+            @failure_message_when_negated = "Did not expect to #{description} of #{class_name}"
+            if @options.present?
+              @failure_message_when_negated += "
+using "
+              @failure_message_when_negated += @options.map { |opt, expected|
+                ":#{opt} option as ‹#{expected}›"
+              }.join(' and
+')
+            end
+
+            @failure_message_when_negated += ",
+but it did"
+          end
+
+          result
+        end
+
+        def description
+          "encrypt :#{@attribute}"
+        end
+
+        private
+
+        def encrypted_attributes_included?
+          if encrypted_attributes.include?(@attribute)
+            true
+          else
+            @failure_message = "Expected to #{description} of #{class_name}, but it did not"
+            false
+          end
+        end
+
+        def with_option(option_name, value)
+          @options[option_name] = value
+          self
+        end
+
+        def options_correct?(*opts)
+          opts.all? do |opt|
+            next true unless @options.key?(opt)
+
+            expected = @options[opt]
+            actual = encrypted_attribute_scheme.send("#{opt}?")
+            next true if expected == actual
+
+            @failure_message = "Expected to #{description} of #{class_name} using :#{opt} option
+as ‹#{expected}›, but got ‹#{actual}›"
+
+            false
+          end
+        end
+
+        def encrypted_attributes
+          @_encrypted_attributes ||= @subject.class.encrypted_attributes || []
+        end
+
+        def encrypted_attribute_scheme
+          @subject.class.type_for_attribute(@attribute).scheme
+        end
+
+        def class_name
+          @subject.class.name
+        end
+      end
+    end
+  end
+end

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

@@ -48,6 +48,30 @@ module Shoulda
       #       should have_db_column(:camera_aperture).of_type(:decimal)
       #     end
       #
+      # ##### of_sql_type
+      #
+      # Use `of_sql_type` to assert that a column is defined as a certain sql_type.
+      #
+      #     class CreatePhones < ActiveRecord::Migration
+      #       def change
+      #         create_table :phones do |t|
+      #           t.string :camera_aperture, limit: 36
+      #         end
+      #       end
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe Phone, type: :model do
+      #       it do
+      #         should have_db_column(:camera_aperture).of_sql_type('varchar(36)')
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class PhoneTest < ActiveSupport::TestCase
+      #       should have_db_column(:camera_aperture).of_sql_type('varchar(36)')
+      #     end
+      #
       # ##### with_options
       #
       # Use `with_options` to assert that a column has been defined with
@@ -96,6 +120,11 @@ module Shoulda
           self
         end
 
+        def of_sql_type(sql_column_type)
+          @options[:sql_column_type] = sql_column_type
+          self
+        end
+
         def with_options(opts = {})
           validate_options(opts)
           OPTIONS.each do |attribute|
@@ -110,6 +139,7 @@ module Shoulda
           @subject = subject
           column_exists? &&
             correct_column_type? &&
+            correct_sql_column_type? &&
             correct_precision? &&
             correct_limit? &&
             correct_default? &&
@@ -129,12 +159,9 @@ module Shoulda
 
         def description
           desc = "have db column named #{@column}"
-          if @options.key?(:column_type)
-            desc << " of type #{@options[:column_type]}"
-          end
-          if @options.key?(:precision)
-            desc << " of precision #{@options[:precision]}"
-          end
+          desc << " of type #{@options[:column_type]}" if @options.key?(:column_type)
+          desc << " of sql_type #{@options[:sql_column_type]}" if @options.key?(:sql_column_type)
+          desc << " of precision #{@options[:precision]}" if @options.key?(:precision)
           desc << " of limit #{@options[:limit]}" if @options.key?(:limit)
           desc << " of default #{@options[:default]}" if @options.key?(:default)
           desc << " of null #{@options[:null]}" if @options.key?(:null)
@@ -178,6 +205,19 @@ module Shoulda
           end
         end
 
+        def correct_sql_column_type?
+          return true unless @options.key?(:sql_column_type)
+
+          if matched_column.sql_type.to_s == @options[:sql_column_type].to_s
+            true
+          else
+            @missing =
+              "#{model_class} has a db column named #{@column} " <<
+              "of sql type #{matched_column.sql_type}, not #{@options[:sql_column_type]}."
+            false
+          end
+        end
+
         def correct_precision?
           return true unless @options.key?(:precision)
 

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

@@ -152,18 +152,18 @@ module Shoulda
         end
 
         def description
-          description = 'have '
-
-          description <<
-            if qualifiers.include?(:unique)
-              "#{Shoulda::Matchers::Util.a_or_an(index_type)} "
-            else
-              'an '
-            end
+          String.new('have ').tap do |description|
+            description <<
+              if qualifiers.include?(:unique)
+                "#{Shoulda::Matchers::Util.a_or_an(index_type)} "
+              else
+                'an '
+              end
 
-          description << 'index on '
+            description << 'index on '
 
-          description << inspected_expected_columns
+            description << inspected_expected_columns
+          end
         end
 
         private
@@ -197,17 +197,28 @@ module Shoulda
         def matched_index
           @_matched_index ||=
             if expected_columns.one?
-              actual_indexes.detect do |index|
+              sorted_indexes.detect do |index|
                 Array.wrap(index.columns) == expected_columns
               end
             else
-              actual_indexes.detect do |index|
+              sorted_indexes.detect do |index|
                 index.columns == expected_columns
               end
             end
         end
 
-        def actual_indexes
+        def sorted_indexes
+          if qualifiers.include?(:unique)
+            # return indexes with unique matching the qualifier first
+            unsorted_indexes.sort_by do |index|
+              index.unique == qualifiers[:unique] ? 0 : 1
+            end
+          else
+            unsorted_indexes
+          end
+        end
+
+        def unsorted_indexes
           model.connection.indexes(table_name)
         end
 

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

@@ -2,7 +2,7 @@ module Shoulda
   module Matchers
     module ActiveRecord
       # The `have_implicit_order_column` matcher tests that the model has `implicit_order_column`
-      # assigned to one of the table columns. (Rails 6+ only)
+      # assigned to one of the table columns.
       #
       #     class Product < ApplicationRecord
       #       self.implicit_order_column = :created_at
@@ -20,10 +20,8 @@ module Shoulda
       #
       # @return [HaveImplicitOrderColumnMatcher]
       #
-      if RailsShim.active_record_gte_6?
-        def have_implicit_order_column(column_name)
-          HaveImplicitOrderColumnMatcher.new(column_name)
-        end
+      def have_implicit_order_column(column_name)
+        HaveImplicitOrderColumnMatcher.new(column_name)
       end
 
       # @private

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

@@ -59,7 +59,7 @@ module Shoulda
         private
 
         def readonly_attributes
-          @_readonly_attributes ||= (@subject.class.readonly_attributes || [])
+          @_readonly_attributes ||= @subject.class.readonly_attributes || []
         end
 
         def class_name

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

@@ -0,0 +1,151 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      # The `normalize` matcher is used to ensure attribute normalizations
+      # are transforming attribute values as expected.
+      #
+      # Take this model for example:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, with: -> email { email.strip.downcase }
+      #     end
+      #
+      # You can use `normalize` providing an input and defining the expected
+      # normalization output:
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email).from(" ME@XYZ.COM\n").to("me@xyz.com")
+      #     end
+      #
+      # You can use `normalize` to test multiple attributes at once:
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :email, :handle, with: -> value { value.strip.downcase }
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it do
+      #         should normalize(:email, :handle).from(" Example\n").to("example")
+      #       end
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:email, handle).from(" Example\n").to("example")
+      #     end
+      #
+      # If the normalization accepts nil values with the `apply_to_nil` option,
+      # you just need to use `.from(nil).to("Your expected value here")`.
+      #
+      #     class User < ActiveRecord::Base
+      #       normalizes :name, with: -> name { name&.titleize || 'Untitled' },
+      #         apply_to_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     RSpec.describe User, type: :model do
+      #       it { should normalize(:name).from("jane doe").to("Jane Doe") }
+      #       it { should normalize(:name).from(nil).to("Untitled") }
+      #     end
+      #
+      #     # Minitest (Shoulda)
+      #     class User < ActiveSupport::TestCase
+      #       should normalize(:name).from("jane doe").to("Jane Doe")
+      #       should normalize(:name).from(nil).to("Untitled")
+      #     end
+      #
+      # @return [NormalizeMatcher]
+      #
+      def normalize(*attributes)
+        if attributes.empty?
+          raise ArgumentError, 'need at least one attribute'
+        else
+          NormalizeMatcher.new(*attributes)
+        end
+      end
+
+      # @private
+      class NormalizeMatcher
+        attr_reader :attributes, :from_value, :to_value, :failure_message,
+          :failure_message_when_negated
+
+        def initialize(*attributes)
+          @attributes = attributes
+        end
+
+        def description
+          %(
+            normalize #{attributes.to_sentence(last_word_connector: ' and ')} from
+            ‹#{from_value.inspect}› to ‹#{to_value.inspect}›
+          ).squish
+        end
+
+        def from(value)
+          @from_value = value
+
+          self
+        end
+
+        def to(value)
+          @to_value = value
+
+          self
+        end
+
+        def matches?(subject)
+          attributes.all? { |attribute| attribute_matches?(subject, attribute) }
+        end
+
+        def does_not_match?(subject)
+          attributes.all? { |attribute| attribute_does_not_match?(subject, attribute) }
+        end
+
+        private
+
+        def attribute_matches?(subject, attribute)
+          return true if normalize_attribute?(subject, attribute)
+
+          @failure_message = build_failure_message(
+            attribute,
+            subject.class.normalize_value_for(attribute, from_value),
+          )
+          false
+        end
+
+        def attribute_does_not_match?(subject, attribute)
+          return true unless normalize_attribute?(subject, attribute)
+
+          @failure_message_when_negated = build_failure_message_when_negated(attribute)
+          false
+        end
+
+        def normalize_attribute?(subject, attribute)
+          subject.class.normalize_value_for(attribute, from_value) == to_value
+        end
+
+        def build_failure_message(attribute, attribute_value)
+          %(
+            Expected to normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized to ‹#{attribute_value.inspect}›
+          ).squish
+        end
+
+        def build_failure_message_when_negated(attribute)
+          %(
+            Expected to not normalize #{attribute.inspect} from ‹#{from_value.inspect}› to
+            ‹#{to_value.inspect}› but it was normalized
+          ).squish
+        end
+      end
+    end
+  end
+end