servactory 2.12.0.rc2 → 2.12.0.rc3

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

@@ -6,15 +6,17 @@ module Servactory
       module Matchers
         module HaveServiceAttributeMatchers
           class InclusionMatcher
+            OPTION_NAME = :inclusion
+            OPTION_BODY_KEY = :in
+
             attr_reader :missing_option
 
-            def initialize(described_class, attribute_type, attribute_name, values, custom_message)
+            def initialize(described_class, attribute_type, attribute_name, values)
               @described_class = described_class
               @attribute_type = attribute_type
               @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
               @attribute_name = attribute_name
               @values = values
-              @custom_message = custom_message
 
               @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
 
@@ -42,37 +44,19 @@ module Servactory
                         :attribute_type_plural,
                         :attribute_name,
                         :values,
-                        :custom_message,
                         :attribute_data
 
-            def submatcher_passes?(_subject) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity
-              attribute_inclusion = attribute_data.fetch(:inclusion)
-              attribute_inclusion_in = attribute_inclusion.fetch(:in)
-              attribute_inclusion_message = attribute_inclusion.fetch(:message)
-
-              matched = attribute_inclusion_in.difference(values).empty? &&
-                        values.difference(attribute_inclusion_in).empty?
-
-              if custom_message.present? && !attribute_inclusion_message.nil?
-                if custom_message.is_a?(RSpec::Matchers::BuiltIn::BaseMatcher)
-                  RSpec::Expectations::ValueExpectationTarget
-                    .new(attribute_inclusion_message)
-                    .to(custom_message)
-                else
-                  matched &&= if attribute_inclusion_message.is_a?(Proc)
-                                attribute_inclusion_message.call.casecmp(custom_message).zero?
-                              else
-                                attribute_inclusion_message.casecmp(custom_message).zero?
-                              end
-                end
-              end
+            def submatcher_passes?(_subject)
+              attribute_inclusion = attribute_data.fetch(OPTION_NAME)
+              attribute_inclusion_in = attribute_inclusion.fetch(OPTION_BODY_KEY)
 
-              matched
+              attribute_inclusion_in.difference(values).empty? &&
+                values.difference(attribute_inclusion_in).empty?
             end
 
             def build_missing_option
-              attribute_inclusion = attribute_data.fetch(:inclusion)
-              attribute_inclusion_in = attribute_inclusion.fetch(:in)
+              attribute_inclusion = attribute_data.fetch(OPTION_NAME)
+              attribute_inclusion_in = attribute_inclusion.fetch(OPTION_BODY_KEY)
 
               <<~MESSAGE
                 should include the expected values

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class MessageMatcher
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, submatcher, 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)
+
+              attribute_schema = attribute_data.fetch(submatcher.class::OPTION_NAME)
+              @attribute_schema_is = attribute_schema.fetch(submatcher.class::OPTION_BODY_KEY)
+              @attribute_schema_message = attribute_schema.fetch(:message)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "message: "
+              result + attribute_schema_message
+            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,
+                        :option_types,
+                        :custom_message,
+                        :attribute_schema_is,
+                        :attribute_schema_message
+
+            def submatcher_passes?(_subject)
+              schema_message_equal?
+            end
+
+            def schema_message_equal? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              @schema_message_equal ||=
+                if custom_message.present? && !attribute_schema_message.nil?
+                  if custom_message.is_a?(RSpec::Matchers::BuiltIn::BaseMatcher)
+                    RSpec::Expectations::ValueExpectationTarget
+                      .new(attribute_schema_message)
+                      .to(custom_message)
+
+                    true
+                  elsif attribute_schema_message.is_a?(Proc)
+                    attribute_schema_message.call.casecmp(custom_message).zero?
+                  else
+                    attribute_schema_message.casecmp(custom_message).zero?
+                  end
+                else
+                  true
+                end
+            end
+
+            def build_missing_option
+              unless schema_message_equal? # rubocop:disable Style/GuardClause
+                <<~MESSAGE
+                  should return expected message in case of problem:
+
+                    expected #{attribute_schema_message.inspect}
+                         got #{custom_message.inspect}
+                MESSAGE
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,12 @@ module Servactory
               # NOTE: Even though the dynamic option `consists_of` is a `must`, here we are testing explicit `must`.
               attribute_must_keys.delete(:consists_of)
 
+              # NOTE: Even though the dynamic option `schema` is a `must`, here we are testing explicit `must`.
+              attribute_must_keys.delete(:schema)
+
+              # NOTE: Even though the dynamic option `inclusion` is a `must`, here we are testing explicit `must`.
+              attribute_must_keys.delete(:inclusion)
+
               attribute_must_keys.difference(must_names).empty? &&
                 must_names.difference(attribute_must_keys).empty?
             end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceAttributeMatchers
+          class SchemaMatcher
+            OPTION_NAME = :schema
+            OPTION_BODY_KEY = :is
+
+            attr_reader :missing_option
+
+            def initialize(described_class, attribute_type, attribute_name, option_types, schema_data) # rubocop:disable Metrics/MethodLength
+              @described_class = described_class
+              @attribute_type = attribute_type
+              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
+              @attribute_name = attribute_name
+              @option_types = option_types
+              @schema_data = schema_data
+
+              attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              attribute_schema = attribute_data.fetch(OPTION_NAME)
+              @attribute_schema_is = attribute_schema.fetch(OPTION_BODY_KEY)
+              @attribute_schema_message = attribute_schema.fetch(:message)
+
+              @missing_option = ""
+            end
+
+            def description
+              result = "schema: "
+              result + schema_data
+            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,
+                        :option_types,
+                        :schema_data,
+                        :attribute_schema_is,
+                        :attribute_schema_message
+
+            def submatcher_passes?(_subject)
+              schema_data_equal?
+            end
+
+            def schema_data_equal?
+              @schema_data_equal ||=
+                (
+                  schema_data.present? && schema_data == attribute_schema_is
+                ) || schema_data.blank?
+            end
+
+            def build_missing_option
+              return if schema_data_equal?
+
+              <<~MESSAGE
+                should be schema with corresponding template
+
+                  expected #{attribute_schema_is.inspect}
+                       got #{schema_data.inspect}
+              MESSAGE
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -84,31 +84,37 @@ module Servactory
             self
           end
 
-          def consists_of(*types) # rubocop:disable Metrics/MethodLength
-            message = block_given? ? yield : nil
-
+          def consists_of(*types)
             add_submatcher(
               HaveServiceAttributeMatchers::ConsistsOfMatcher,
               described_class,
               :input,
               input_name,
               @option_types,
-              Array(types),
-              message
+              Array(types)
             )
             self
           end
 
-          def inclusion(values)
-            message = block_given? ? yield : nil
+          def schema(data = {})
+            add_submatcher(
+              HaveServiceAttributeMatchers::SchemaMatcher,
+              described_class,
+              :input,
+              input_name,
+              @option_types,
+              data
+            )
+            self
+          end
 
+          def inclusion(values)
             add_submatcher(
               HaveServiceAttributeMatchers::InclusionMatcher,
               described_class,
               :input,
               input_name,
-              Array(values),
-              message
+              Array(values)
             )
             self
           end
@@ -135,6 +141,18 @@ module Servactory
             self
           end
 
+          def message(message)
+            add_submatcher(
+              HaveServiceAttributeMatchers::MessageMatcher,
+              described_class,
+              :input,
+              input_name,
+              @last_submatcher,
+              message
+            )
+            self
+          end
+
           # NOTE: Used for delayed chain implementation
           # def not_implemented_chain(*description)
           #   Kernel.warn <<-MESSAGE.squish
@@ -165,11 +183,12 @@ module Servactory
 
           protected
 
-          attr_reader :submatchers, :missing, :subject
+          attr_reader :last_submatcher, :submatchers, :missing, :subject
 
           def add_submatcher(matcher_class, *args)
             remove_submatcher(matcher_class)
-            submatchers << matcher_class.new(*args)
+            @last_submatcher = matcher_class.new(*args)
+            submatchers << @last_submatcher
           end
 
           def remove_submatcher(matcher_class)

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

@@ -47,12 +47,13 @@ module Servactory
                         :attribute_data,
                         :i18n_root_key
 
-            def submatcher_passes?(_subject) # rubocop:disable Metrics/CyclomaticComplexity
+            def submatcher_passes?(_subject) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
               success_passes? &&
                 failure_type_passes? &&
                 failure_required_passes? &&
                 failure_optional_passes? &&
                 failure_consists_of_passes? &&
+                failure_schema_passes? &&
                 failure_format_passes? &&
                 failure_inclusion_passes? &&
                 failure_must_passes?
@@ -117,6 +118,11 @@ module Servactory
               true
             end
 
+            def failure_schema_passes?
+              # NOTE: Checking for negative cases is not implemented for `schema`
+              true
+            end
+
             def failure_format_passes?
               # NOTE: Checking for negative cases is not implemented for `format`
               true

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

@@ -2,8 +2,10 @@
 
 require_relative "have_service_attribute_matchers/types_matcher"
 require_relative "have_service_attribute_matchers/consists_of_matcher"
+require_relative "have_service_attribute_matchers/schema_matcher"
 require_relative "have_service_attribute_matchers/inclusion_matcher"
 require_relative "have_service_attribute_matchers/must_matcher"
+require_relative "have_service_attribute_matchers/message_matcher"
 
 module Servactory
   module TestKit
@@ -50,31 +52,37 @@ module Servactory
             self
           end
 
-          def consists_of(*types) # rubocop:disable Metrics/MethodLength
-            message = block_given? ? yield : nil
-
+          def consists_of(*types)
             add_submatcher(
               HaveServiceAttributeMatchers::ConsistsOfMatcher,
               described_class,
               :internal,
               internal_name,
               @option_types,
-              Array(types),
-              message
+              Array(types)
             )
             self
           end
 
-          def inclusion(values)
-            message = block_given? ? yield : nil
+          def schema(data = {})
+            add_submatcher(
+              HaveServiceAttributeMatchers::SchemaMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              @option_types,
+              data
+            )
+            self
+          end
 
+          def inclusion(values)
             add_submatcher(
               HaveServiceAttributeMatchers::InclusionMatcher,
               described_class,
               :internal,
               internal_name,
-              Array(values),
-              message
+              Array(values)
             )
             self
           end
@@ -90,6 +98,18 @@ module Servactory
             self
           end
 
+          def message(message)
+            add_submatcher(
+              HaveServiceAttributeMatchers::MessageMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              @last_submatcher,
+              message
+            )
+            self
+          end
+
           def description
             "#{internal_name} with #{submatchers.map(&:description).join(', ')}"
           end
@@ -110,11 +130,12 @@ module Servactory
 
           protected
 
-          attr_reader :submatchers, :missing, :subject
+          attr_reader :last_submatcher, :submatchers, :missing, :subject
 
           def add_submatcher(matcher_class, *args)
             remove_submatcher(matcher_class)
-            submatchers << matcher_class.new(*args)
+            @last_submatcher = matcher_class.new(*args)
+            submatchers << @last_submatcher
           end
 
           def remove_submatcher(matcher_class)

data/lib/servactory/tool_kit/dynamic_options/must.rb

@@ -3,7 +3,7 @@
 module Servactory
   module ToolKit
     module DynamicOptions
-      class Must
+      class Must # rubocop:disable Metrics/ClassLength
         class WorkOption
           attr_reader :name,
                       :value,
@@ -80,24 +80,48 @@ module Servactory
           is_option_message_present = option.message.present?
           is_option_message_proc = option.message.is_a?(Proc) if is_option_message_present
 
-          lambda do |input: nil, internal: nil, output: nil, **attributes|
+          lambda do |input: nil, internal: nil, output: nil, **attributes| # rubocop:disable Metrics/BlockLength
             default_attributes = { **attributes, option_name: option.name, option_value: option.value }
 
             if Servactory::Utils.really_input?(input)
               if is_option_message_present
-                is_option_message_proc ? option.message.call(**default_attributes, input:) : option.message
+                if is_option_message_proc
+                  option.message.call(
+                    input:,
+                    **default_attributes.delete(:meta) || {},
+                    **default_attributes
+                  )
+                else
+                  option.message
+                end
               else
                 message_for_input_with(**default_attributes, input:)
               end
             elsif Servactory::Utils.really_internal?(internal)
               if is_option_message_present
-                is_option_message_proc ? option.message.call(**default_attributes, internal:) : option.message
+                if is_option_message_proc
+                  option.message.call(
+                    internal:,
+                    **default_attributes.delete(:meta) || {},
+                    **default_attributes
+                  )
+                else
+                  option.message
+                end
               else
                 message_for_internal_with(**default_attributes, internal:)
               end
             elsif Servactory::Utils.really_output?(output)
               if is_option_message_present
-                is_option_message_proc ? option.message.call(**default_attributes, output:) : option.message
+                if is_option_message_proc
+                  option.message.call(
+                    output:,
+                    **default_attributes.delete(:meta) || {},
+                    **default_attributes
+                  )
+                else
+                  option.message
+                end
               else
                 message_for_output_with(**default_attributes, output:)
               end