servactory 2.16.1 → 3.0.0.rc1

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

@@ -1,72 +0,0 @@
-# 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 = attribute_must.keys
-
-              # 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
-
-            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/schema_matcher.rb

@@ -1,92 +0,0 @@
-# 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
-              "schema: #{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? # rubocop:disable Metrics/MethodLength
-              matcher_result =
-                RSpec::Expectations::ExpectationHelper
-                .with_matcher(
-                  RSpec::Expectations::PositiveExpectationHandler,
-                  RSpec::Matchers::BuiltIn::Match.new(schema_data),
-                  nil
-                ) do |matcher|
-                  matcher.matches?(attribute_schema_is)
-                end
-
-              @schema_data_equal ||=
-                (
-                  schema_data.present? && matcher_result
-                ) || 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_attribute_matchers/types_matcher.rb

@@ -1,72 +0,0 @@
-# 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_matchers/default_matcher.rb

@@ -1,69 +0,0 @@
-# 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)
-
-              return default_value.nil? if attribute_default_value.is_a?(NilClass)
-
-              attribute_default_value.to_s.casecmp(default_value.to_s).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

@@ -1,63 +0,0 @@
-# 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

@@ -1,81 +0,0 @@
-# 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)
-
-              @i18n_root_key = described_class.config.i18n_root_key
-
-              @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,
-                        :i18n_root_key
-
-            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(
-                  "#{i18n_root_key}.#{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

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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-module Servactory
-  module TestKit
-    module Rspec
-      module Matchers
-        module HaveServiceInputMatchers
-          # DEPRECATED: This chain is planned to be decommissioned.
-          class ValidWithMatcher # rubocop:disable Metrics/ClassLength
-            attr_reader :missing_option
-
-            def initialize(described_class, attribute_type, attribute_name, attributes)
-              @described_class = described_class
-              @attribute_type = attribute_type
-              @attribute_type_plural = attribute_type.to_s.pluralize.to_sym
-              @attribute_name = attribute_name
-              @attributes = attributes.is_a?(FalseClass) ? attributes : Servactory::Utils.adapt(attributes)
-
-              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
-
-              @i18n_root_key = described_class.config.i18n_root_key
-
-              @missing_option = ""
-            end
-
-            def description
-              "valid_with attribute checking"
-            end
-
-            def matches?(subject)
-              if attributes.is_a?(FalseClass) || 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,
-                        :attributes,
-                        :attribute_data,
-                        :i18n_root_key
-
-            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?
-            end
-
-            def success_passes?
-              expect_success_with!(attributes)
-            end
-
-            def failure_type_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              option_types = attribute_data.fetch(:types)
-
-              prepared_attributes = attributes.dup
-              prepared_attributes[attribute_name] = Servactory::TestKit::FakeType.new
-
-              input_required_message =
-                I18n.t(
-                  "#{i18n_root_key}.#{attribute_type_plural}.validations.type.default_error.default",
-                  service_class_name: described_class.name,
-                  "#{attribute_type}_name": attribute_name,
-                  expected_type: option_types.join(", "),
-                  given_type: Servactory::TestKit::FakeType.new.class.name
-                )
-
-              expect_failure_with!(prepared_attributes, input_required_message)
-            end
-
-            def failure_required_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              input_required = attribute_data.fetch(:required).fetch(:is)
-
-              return true unless input_required
-
-              prepared_attributes = attributes.dup
-              prepared_attributes[attribute_name] = nil
-
-              input_required_message = attribute_data.fetch(:required).fetch(:message)
-
-              if input_required_message.nil?
-                input_required_message = I18n.t(
-                  "#{i18n_root_key}.#{attribute_type_plural}.validations.required.default_error.default",
-                  service_class_name: described_class.name,
-                  "#{attribute_type}_name": attribute_name
-                )
-              end
-
-              expect_failure_with!(prepared_attributes, input_required_message)
-            end
-
-            def failure_optional_passes?
-              input_required = attribute_data.fetch(:required).fetch(:is)
-
-              return true if input_required
-
-              prepared_attributes = attributes.dup
-              prepared_attributes[attribute_name] = nil
-
-              expect_failure_with!(prepared_attributes, nil)
-            end
-
-            def failure_consists_of_passes?
-              # NOTE: Checking for negative cases is not implemented for `consists_of`
-              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
-            end
-
-            def failure_inclusion_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-              input_inclusion_in = attribute_data.dig(:inclusion, :in)
-
-              return true if input_inclusion_in.blank?
-
-              wrong_value = Servactory::TestKit::Utils::Faker.fetch_value_for(input_inclusion_in.first.class)
-
-              prepared_attributes = attributes.dup
-              prepared_attributes[attribute_name] = wrong_value
-
-              input_required_message = attribute_data.fetch(:inclusion).fetch(:message)
-
-              if input_required_message.nil?
-                input_required_message = I18n.t(
-                  "#{i18n_root_key}.#{attribute_type_plural}.validations.must.dynamic_options.inclusion.default",
-                  service_class_name: described_class.name,
-                  "#{attribute_type}_name": attribute_name,
-                  "#{attribute_type}_inclusion": input_inclusion_in.inspect,
-                  value: wrong_value.inspect
-                )
-              elsif input_required_message.is_a?(Proc)
-                service_class = Struct.new(:class_name, keyword_init: true)
-                service = service_class.new(class_name: described_class.name)
-
-                input_actor = attribute_data.fetch(:actor)
-
-                input_required_message = input_required_message.call(
-                  service:,
-                  input: input_actor,
-                  value: wrong_value
-                )
-              end
-
-              expect_failure_with!(prepared_attributes, input_required_message)
-            end
-
-            def failure_must_passes?
-              # NOTE: Checking for negative cases is not implemented for `must`
-              true
-            end
-
-            def expect_success_with!(prepared_attributes)
-              described_class.call!(prepared_attributes).success?
-            rescue Servactory::Exceptions::Input
-              false
-            rescue StandardError
-              true
-            end
-
-            def expect_failure_with!(prepared_attributes, expected_message)
-              described_class.call!(prepared_attributes).success?
-            rescue Servactory::Exceptions::Input => e
-              return false if expected_message.blank?
-
-              expected_message.casecmp(e.message).zero?
-            rescue Servactory::Exceptions::Internal, Servactory::Exceptions::Output
-              # NOTE: Skips the fall of validations inside the service, which are not important in this place.
-              true
-            end
-
-            def build_missing_option
-              "should work as expected on the specified attributes based on its options"
-            end
-          end
-        end
-      end
-    end
-  end
-end