nobrainer-rspec 1.0.1

data/lib/matchers/have_index_for.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    # The `have_index_for` matcher tests that the table that backs your model
+    # has a specific index.
+    #
+    #     class User
+    #       include NoBrainer::Document
+    #
+    #       field :name, index: true
+    #       field :lastname
+    #
+    #       index :lastname
+    #     end
+    #
+    #     # RSpec
+    #     RSpec.describe User, type: :model do
+    #       it { is_expected.to have_index_for(:name) }
+    #       it { is_expected.to have_index_for(:lastname) }
+    #     end
+    #
+    # #### Qualifiers
+    #
+    # ##### with_multi
+    #
+    # Use `with_multi` to assert that an index is defined as multi for a certain
+    # field.
+    #
+    #     class User
+    #       include NoBrainer::Document
+    #
+    #       field :name, index: :multi
+    #       field :lastname
+    #
+    #       index :lastname, multi: true
+    #     end
+    #
+    #     # RSpec
+    #     RSpec.describe User, type: :model do
+    #       it do
+    #         it { is_expected.to have_index_for(:name).with_multi }
+    #         it { is_expected.to have_index_for(:lastname).with_multi }
+    #       end
+    #     end
+    #
+    # ##### named
+    #
+    # Use `named` to assert that an index has a certain name.
+    #
+    #     class User
+    #       include NoBrainer::Document
+    #
+    #       field :firstname
+    #       field :lastname
+    #
+    #       index :full_name_compound, %i[firstname lastname]
+    #     end
+    #
+    #     # RSpec
+    #     RSpec.describe User, type: :model do
+    #       it do
+    #         is_expected.to have_index_for(%i[firstname lastname])
+    #           .named(:full_name_compound)
+    #       end
+    #     end
+    #
+    class HaveIndexFor # :nodoc:
+      def initialize(*attrs)
+        @attributes = attrs.collect do |attributes|
+          if attributes.is_a?(Array)
+            attributes.collect(&:to_sym)
+          else
+            attributes.to_sym
+          end
+        end
+      end
+
+      def with_multi(multi = true)
+        @multi = multi
+        self
+      end
+
+      def named(index_name)
+        @index_name = index_name
+        self
+      end
+
+      def matches?(klass)
+        @klass = klass.is_a?(Class) ? klass : klass.class
+        @errors = []
+        @attributes.each do |attr|
+          if attr.is_a?(Array)
+            missing_fields = attr - @klass.fields.keys
+            if missing_fields.empty?
+              index_key = @index_name || attr.join('_').to_sym
+              if @klass.indexes.include?(index_key)
+                error = ''
+
+                # Checking multi
+                if @multi && (@klass.indexes[index_key][:multi] != @multi)
+                  error += " with multi #{@klass.indexes[index_key][:multi].inspect}"
+                end
+
+                @errors.push("field #{attr.inspect}" + error) unless error.blank?
+              else
+                if @index_name
+                  @errors.push "no compound index named #{@index_name}"
+                else
+                  @errors.push "no compound index for fields #{attr.to_sentence}"
+                end
+              end
+            else
+              @errors.push "the field#{'s' if missing_fields.size > 1} " \
+                           "#{missing_fields.to_sentence} " \
+                           "#{missing_fields.size > 1 ? 'are' : 'is'} missing"
+            end
+          else
+            if @klass.fields.include?(attr)
+              if @klass.indexes.include?(attr)
+                error = ''
+
+                # Checking multi
+                if @multi && (@klass.indexes[attr][:multi] != @multi)
+                  error += " with multi #{@klass.indexes[attr][:multi].inspect}"
+                end
+
+                @errors.push("field #{attr.inspect}" + error) unless error.blank?
+
+              else
+                @errors.push "no index for field #{attr.inspect}"
+              end
+            else
+              @errors.push "no field named #{attr.inspect}"
+            end
+          end
+        end
+        @errors.empty?
+      end
+
+      def failure_message_for_should
+        "Expected #{@klass.inspect} to #{description}, got #{@errors.to_sentence}"
+      end
+
+      def failure_message_for_should_not
+        "Expected #{@klass.inspect} to not #{description}, got #{@klass.inspect} to #{description}"
+      end
+
+      alias failure_message failure_message_for_should
+      alias failure_message_when_negated failure_message_for_should_not
+
+      def description
+        desc = "have index for #{@attributes.collect(&:inspect).to_sentence}"
+        desc += ' to be multi' if @multi
+        desc += " named #{@index_name}" if @index_name
+        desc
+      end
+    end
+
+    def have_index_for(*args)
+      HaveIndexFor.new(*args)
+    end
+  end
+end

data/lib/matchers/have_timestamps.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    def have_timestamps
+      HaveTimestamps.new
+    end
+
+    class HaveTimestamps
+      def initialize
+        @root_module = 'NoBrainer::Document::Timestamps'
+      end
+
+      def matches?(actual)
+        @model = actual.is_a?(Class) ? actual : actual.class
+        @model.included_modules.include?(expected_module)
+      end
+
+      def description
+        'be a NoBrainer document with timestamps'
+      end
+
+      def failure_message
+        "Expected #{@model.inspect} class to #{description}"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@model.inspect} class to not #{description}"
+      end
+
+      private
+
+      def expected_module
+        @root_module.constantize
+      end
+    end
+  end
+end

data/lib/matchers/validations.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      class HaveValidationMatcher
+        def initialize(field, validation_type)
+          @field = field.to_s
+          @type = validation_type.to_s
+          @options = {}
+        end
+
+        def matches?(actual)
+          @klass = actual.is_a?(Class) ? actual : actual.class
+
+          @validator = @klass.validators_on(@field).detect do |v|
+            (v.kind.to_s == @type) && (!v.options[:on] || on_options_matches?(v))
+          end
+
+          if @validator
+            @negative_result_message = "#{@type.inspect} validator on #{@field.inspect}"
+            @positive_result_message = "#{@type.inspect} validator on #{@field.inspect}"
+          else
+            @negative_result_message = "no #{@type.inspect} validator on #{@field.inspect}"
+            return false
+          end
+
+          true
+        end
+
+        def failure_message_for_should
+          "Expected #{@klass.inspect} to #{description}; instead got #{@negative_result_message}"
+        end
+
+        def failure_message_for_should_not
+          "Expected #{@klass.inspect} to not #{description}; instead got #{@positive_result_message}"
+        end
+
+        alias failure_message failure_message_for_should
+        alias failure_message_when_negated failure_message_for_should_not
+
+        def description
+          desc = "have #{@type.inspect} validator on #{@field.inspect}"
+          desc += " on #{@options[:on]}" if @options[:on]
+          desc
+        end
+
+        def on(*on_method)
+          @options[:on] = on_method.flatten
+          self
+        end
+
+        private
+
+        def check_on
+          validator_on_methods = [@validator.options[:on]].flatten
+
+          if validator_on_methods.any?
+            message = " on methods: #{validator_on_methods}"
+
+            if on_options_covered_by?(@validator)
+              @positive_result_message += message
+            else
+              @negative_result_message += message
+              @result = false
+            end
+          end
+        end
+
+        def on_options_matches?(validator)
+          @options[:on] && validator.options[:on] && on_options_covered_by?(validator)
+        end
+
+        def on_options_covered_by?(validator)
+          ([@options[:on]].flatten - [validator.options[:on]].flatten).empty?
+        end
+      end
+    end
+  end
+end

data/lib/matchers/validations/acceptance_of.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      def validate_acceptance_of(field)
+        HaveValidationMatcher.new(field, :acceptance)
+      end
+    end
+  end
+end

data/lib/matchers/validations/confirmation_of.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      class ValidateConfirmationOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :confirmation)
+        end
+      end
+
+      def validate_confirmation_of(field)
+        ValidateConfirmationOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/exclusion_of.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      class ValidateExclusionOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :exclusion)
+        end
+
+        def to_not_allow(*values)
+          @not_allowed_values = [values].flatten
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @not_allowed_values
+            raw_validator_not_allowed_values = @validator.options[:in]
+
+            validator_not_allowed_values = case raw_validator_not_allowed_values
+                                           when Range then raw_validator_not_allowed_values.to_a
+                                           when Proc then raw_validator_not_allowed_values.call(actual)
+                                           else raw_validator_not_allowed_values end
+
+            allowed_values = @not_allowed_values - validator_not_allowed_values
+            if allowed_values.empty?
+              @positive_result_message = @positive_result_message += ' not allowing all values mentioned'
+            else
+              @negative_result_message = @negative_result_message += " allowing the following the ff. values: #{allowed_values.inspect}"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " not allowing the ff. values: #{@not_allowed_values}" if @not_allowed_values
+          "#{super}#{options_desc.to_sentence}"
+        end
+      end
+
+      def validate_exclusion_of(field)
+        ValidateExclusionOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/format_of.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      class ValidateFormatOfMatcher < HaveValidationMatcher
+        def initialize(field)
+          super(field, :format)
+        end
+
+        def with_format(format)
+          @format = format
+          self
+        end
+
+        def to_allow(valid_value)
+          @valid_value = valid_value
+          self
+        end
+
+        def not_to_allow(invalid_value)
+          @invalid_value = invalid_value
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @format
+            if @validator.options[:with] == @format
+              @positive_result_message = @positive_result_message += " with format #{@validator.options[:format].inspect}"
+            else
+              @negative_result_message = @negative_result_message += " with format #{@validator.options[:format].inspect}"
+              result = false
+            end
+          end
+
+          if @valid_value
+            if @validator.options[:with] =~ @valid_value
+              @positive_result_message = @positive_result_message += " with #{@valid_value.inspect} as a valid value"
+            else
+              @negative_result_message = @negative_result_message += " with #{@valid_value.inspect} as an invalid value"
+              result = false
+            end
+          end
+
+          if @invalid_value
+            if @invalid_value !~ @validator.options[:with]
+              @positive_result_message = @positive_result_message += " with #{@invalid_value.inspect} as an invalid value"
+            else
+              @negative_result_message = @negative_result_message += " with #{@invalid_value.inspect} as a valid value"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " with format #{@format.inspect}" if @format
+          options_desc << " allowing the value #{@valid_value.inspect}" if @valid_value
+          options_desc << " not allowing the value #{@invalid_value.inspect}" if @invalid_value
+          "#{super}#{options_desc.to_sentence}"
+        end
+      end
+
+      def validate_format_of(field)
+        ValidateFormatOfMatcher.new(field)
+      end
+    end
+  end
+end

data/lib/matchers/validations/inclusion_of.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module NoBrainer
+  module Matchers
+    module Validations
+      class ValidateInclusionOfMatcher < HaveValidationMatcher
+        def initialize(name)
+          super(name, :inclusion)
+        end
+
+        def to_allow(*values)
+          @allowed_values = values.map { |v| v.respond_to?(:to_a) ? v.to_a : v }.flatten
+          self
+        end
+
+        def matches?(actual)
+          return false unless result = super(actual)
+
+          if @allowed_values
+            raw_validator_allowed_values = @validator.options[:in]
+
+            validator_allowed_values = case raw_validator_allowed_values
+                                       when Range then raw_validator_allowed_values.to_a
+                                       when Proc then raw_validator_allowed_values.call(actual)
+                                       else raw_validator_allowed_values end
+
+            not_allowed_values = @allowed_values - validator_allowed_values
+            if not_allowed_values.empty?
+              @positive_result_message = @positive_result_message += ' allowing all values mentioned'
+            else
+              @negative_result_message = @negative_result_message += " not allowing these values: #{not_allowed_values.inspect}"
+              result = false
+            end
+          end
+
+          result
+        end
+
+        def description
+          options_desc = []
+          options_desc << " allowing these values: #{@allowed_values}" if @allowed_values
+          "#{super}#{options_desc.to_sentence}"
+        end
+      end
+
+      def validate_inclusion_of(field)
+        ValidateInclusionOfMatcher.new(field)
+      end
+    end
+  end
+end