servactory 2.5.0.rc1 → 2.5.0.rc3

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/must_matcher.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class MustMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, must_names)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @must_names = must_names
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "must: #{must_names.join(', ')}"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :must_names,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              attribute_must = attribute_data.fetch(:must)
+
+              attribute_must.keys.difference(must_names).empty? &&
+                must_names.difference(attribute_must.keys).empty?
+            end
+
+            def build_missing_option
+              "should #{must_names.join(', ')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_attribute_matchers/types_matcher.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class TypesMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, types)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @types = types
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "type"
+              result += types.size > 1 ? "s: " : ": "
+              result + types.join(", ")
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :types,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              option_types = attribute_data.fetch(:types)
+
+              option_types.difference(types).empty? &&
+                types.difference(option_types).empty?
+            end
+
+            def build_missing_option
+              option_types = attribute_data.fetch(:types)
+
+              text_about_types = types.size > 1 ? "with one of the following types" : "type"
+
+              <<~MESSAGE
+                should be a value with #{text_about_types}
+
+                  expected #{types.inspect}
+                       got #{option_types.inspect}
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matcher.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        class HaveServiceInputMatcher # rubocop:disable Metrics/ClassLength
+          attr_reader :described_class, :input_name, :options
+
+          def initialize(described_class, input_name)
+            @described_class = described_class
+            @input_name = input_name
+
+            @options = {}
+            @submatchers = []
+
+            @missing = ""
+          end
+
+          def supports_block_expectations?
+            true
+          end
+
+          def type(type)
+            @option_types = Array(type)
+            add_submatcher(
+              HaveServiceAttributeMatchers::TypesMatcher,
+              described_class,
+              :input,
+              input_name,
+              @option_types
+            )
+            self
+          end
+
+          def types(*types)
+            @option_types = types
+            add_submatcher(
+              HaveServiceAttributeMatchers::TypesMatcher,
+              described_class,
+              :input,
+              input_name,
+              @option_types
+            )
+            self
+          end
+
+          def required(custom_message = nil)
+            remove_submatcher(HaveServiceInputMatchers::OptionalMatcher)
+            add_submatcher(
+              HaveServiceInputMatchers::RequiredMatcher,
+              described_class,
+              :input,
+              input_name,
+              custom_message
+            )
+            self
+          end
+
+          def optional
+            remove_submatcher(HaveServiceInputMatchers::RequiredMatcher)
+            add_submatcher(
+              HaveServiceInputMatchers::OptionalMatcher,
+              described_class,
+              :input,
+              input_name
+            )
+            self
+          end
+
+          def default(value)
+            add_submatcher(
+              HaveServiceInputMatchers::DefaultMatcher,
+              described_class,
+              :input,
+              input_name,
+              value
+            )
+            self
+          end
+
+          def consists_of(*types) # rubocop:disable Metrics/MethodLength
+            message = block_given? ? yield : nil
+
+            add_submatcher(
+              HaveServiceAttributeMatchers::ConsistsOfMatcher,
+              described_class,
+              :input,
+              input_name,
+              @option_types,
+              Array(types),
+              message
+            )
+            self
+          end
+
+          def inclusion(values)
+            add_submatcher(
+              HaveServiceAttributeMatchers::InclusionMatcher,
+              described_class,
+              :input,
+              input_name,
+              Array(values)
+            )
+            self
+          end
+
+          def must(*must_names)
+            add_submatcher(
+              HaveServiceAttributeMatchers::MustMatcher,
+              described_class,
+              :input,
+              input_name,
+              Array(must_names)
+            )
+            self
+          end
+
+          def valid_with(attributes)
+            add_submatcher(
+              HaveServiceInputMatchers::ValidWithMatcher,
+              described_class,
+              :input,
+              input_name,
+              attributes
+            )
+            self
+          end
+
+          # NOTE: Used for delayed chain implementation
+          # def not_implemented_chain(*description)
+          #   Kernel.warn <<-MESSAGE.squish
+          #     This chain has not yet been implemented.
+          #     This message is for informational purposes only.
+          #     Description: #{description}
+          #   MESSAGE
+          #   self
+          # end
+
+          def description
+            "#{input_name} with #{submatchers.map(&:description).join(', ')}"
+          end
+
+          def failure_message
+            "Expected #{expectation}, which #{missing_options}"
+          end
+
+          def failure_message_when_negated
+            "Did not expect #{expectation} with specified options"
+          end
+
+          def matches?(subject)
+            @subject = subject
+
+            submatchers_match?
+          end
+
+          protected
+
+          attr_reader :submatchers, :missing, :subject
+
+          def add_submatcher(matcher_class, *args)
+            remove_submatcher(matcher_class)
+            submatchers << matcher_class.new(*args)
+          end
+
+          def remove_submatcher(matcher_class)
+            submatchers.delete_if do |submatcher|
+              submatcher.is_a?(matcher_class)
+            end
+          end
+
+          def expectation
+            "#{described_class.name} to have a service input attribute named #{input_name}"
+          end
+
+          def missing_options
+            missing_options = [missing, missing_options_for_failing_submatchers]
+            missing_options.flatten.select(&:present?).join(", ")
+          end
+
+          def failing_submatchers
+            @failing_submatchers ||= submatchers.reject do |matcher|
+              matcher.matches?(subject)
+            end
+          end
+
+          def missing_options_for_failing_submatchers
+            if defined?(failing_submatchers)
+              failing_submatchers.map(&:missing_option)
+            else
+              []
+            end
+          end
+
+          def submatchers_match?
+            failing_submatchers.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/default_matcher.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceInputMatchers
+          class DefaultMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, default_value)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @default_value = default_value
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "default: #{default_value.inspect}"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :default_value,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              attribute_default_value = attribute_data.fetch(:default)
+
+              attribute_default_value.casecmp(default_value).zero?
+            end
+
+            def build_missing_option
+              attribute_default_value = attribute_data.fetch(:default)
+
+              <<~MESSAGE
+                should have a default value
+
+                  expected #{default_value.inspect}
+                       got #{attribute_default_value.inspect}
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/optional_matcher.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceInputMatchers
+          class OptionalMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "required: false"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :attribute_data
+
+            def submatcher_passes?(_subject)
+              input_required = attribute_data.fetch(:required).fetch(:is)
+
+              input_required == false
+            end
+
+            def build_missing_option
+              <<~MESSAGE
+                should be optional
+
+                  expected required: false
+                       got required: true
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/servactory/test_kit/rspec/matchers/have_service_input_matchers/required_matcher.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceInputMatchers
+          class RequiredMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, custom_message)
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @custom_message = custom_message
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @missing_option = ""
+            end
+
+            def description
+              "required: true"
+            end
+
+            def matches?(subject)
+              if submatcher_passes?(subject)
+                true
+              else
+                @missing_option = build_missing_option
+
+                false
+              end
+            end
+
+            private
+
+            attr_reader :described_class,
+                        :attribute_type,
+                        :attribute_type_plural,
+                        :attribute_name,
+                        :custom_message,
+                        :attribute_data
+
+            def submatcher_passes?(_subject) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              attribute_required = attribute_data.fetch(:required).fetch(:is)
+              attribute_required_message = attribute_data.fetch(:required).fetch(:message)
+
+              matched = attribute_required == true
+
+              if attribute_required_message.nil?
+                attribute_required_message = I18n.t(
+                  "servactory.#{attribute_type_plural}.validations.required.default_error.default",
+                  service_class_name: described_class.name,
+                  "#{attribute_type}_name": attribute_name
+                )
+              end
+
+              matched &&= attribute_required_message.casecmp(custom_message).zero? if custom_message.present?
+
+              matched
+            end
+
+            def build_missing_option
+              <<~MESSAGE
+                should be required
+
+                  expected required: true
+                       got required: false
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end