servactory 2.5.0.rc2 → 2.5.0.rc4

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

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        module HaveServiceInputMatchers
+          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
+
+              @attribute_data = described_class.info.public_send(attribute_type_plural).fetch(attribute_name)
+
+              @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
+
+            def submatcher_passes?(_subject) # rubocop:disable Metrics/CyclomaticComplexity
+              success_passes? &&
+                failure_type_passes? &&
+                failure_required_passes? &&
+                failure_optional_passes? &&
+                failure_consists_of_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)
+              input_first_type = option_types.first
+              input_required = attribute_data.fetch(:required).fetch(:is)
+              attribute_consists_of_types = Array(attribute_data.fetch(:consists_of).fetch(:type))
+              attribute_consists_of_first_type = attribute_consists_of_types.first
+
+              prepared_attributes = attributes.dup
+              prepared_attributes[attribute_name] = Servactory::TestKit::FakeType.new
+
+              input_required_message =
+                if described_class.config.collection_mode_class_names.include?(input_first_type) &&
+                   attribute_consists_of_first_type != false
+                  if input_required
+                    I18n.t(
+                      "servactory.#{attribute_type_plural}.validations.required.default_error.for_collection",
+                      service_class_name: described_class.name,
+                      "#{attribute_type}_name": attribute_name
+                    )
+                  else
+                    I18n.t(
+                      "servactory.#{attribute_type_plural}.validations.type.default_error.for_collection.wrong_type",
+                      service_class_name: described_class.name,
+                      "#{attribute_type}_name": attribute_name,
+                      expected_type: option_types.join(", "),
+                      given_type: Servactory::TestKit::FakeType.new.class.name
+                    )
+                  end
+                else
+                  I18n.t(
+                    "servactory.#{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
+                  )
+                end
+
+              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(
+                  "servactory.#{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_format_passes?
+              # NOTE: Checking for negative cases is not implemented for `format`
+              true
+            end
+
+            def failure_consists_of_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              option_types = attribute_data.fetch(:types)
+              input_first_type = option_types.first
+
+              return true unless described_class.config.collection_mode_class_names.include?(input_first_type)
+
+              prepared_attributes = attributes.dup
+              prepared_attributes[attribute_name] = input_first_type[Servactory::TestKit::FakeType.new]
+
+              attribute_consists_of_types = Array(attribute_data.fetch(:consists_of).fetch(:type))
+              attribute_consists_of_first_type = attribute_consists_of_types.first
+
+              return true if attribute_consists_of_first_type == false
+
+              attribute_consists_of_message = attribute_data.fetch(:consists_of).fetch(:message)
+
+              if attribute_consists_of_message.nil?
+                attribute_consists_of_message = I18n.t(
+                  "servactory.#{attribute_type_plural}.validations.type.default_error.for_collection.wrong_element_type", # rubocop:disable Layout/LineLength
+                  service_class_name: described_class.name,
+                  "#{attribute_type}_name": attribute_name,
+                  expected_type: attribute_consists_of_types.join(", "),
+                  given_type: prepared_attributes[attribute_name].map { _1.class.name }.join(", ")
+                )
+              end
+
+              expect_failure_with!(prepared_attributes, attribute_consists_of_message)
+            end
+
+            def failure_inclusion_passes? # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+              input_inclusion_in = attribute_data.fetch(:inclusion).fetch(: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(
+                  "servactory.#{attribute_type_plural}.validations.inclusion.default_error",
+                  service_class_name: described_class.name,
+                  "#{attribute_type}_name": attribute_name,
+                  "#{attribute_type}_inclusion": input_inclusion_in,
+                  value: wrong_value
+                )
+              elsif input_required_message.is_a?(Proc)
+                input_work = attribute_data.fetch(:work)
+
+                input_required_message = input_required_message.call(
+                  service_class_name: described_class.name,
+                  input: input_work,
+                  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

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers
+        class HaveServiceInternalMatcher # rubocop:disable Metrics/ClassLength
+          attr_reader :described_class, :internal_name, :options
+
+          def initialize(described_class, internal_name)
+            @described_class = described_class
+            @internal_name = internal_name
+
+            @options = {}
+            @submatchers = []
+
+            @missing = ""
+          end
+
+          def supports_block_expectations?
+            true
+          end
+
+          def type(type)
+            @option_types = Array(type)
+            add_submatcher(
+              HaveServiceAttributeMatchers::TypesMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              @option_types
+            )
+            self
+          end
+
+          def types(*types)
+            @option_types = types
+            add_submatcher(
+              HaveServiceAttributeMatchers::TypesMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              @option_types
+            )
+            self
+          end
+
+          def consists_of(*types) # rubocop:disable Metrics/MethodLength
+            message = block_given? ? yield : nil
+
+            add_submatcher(
+              HaveServiceAttributeMatchers::ConsistsOfMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              @option_types,
+              Array(types),
+              message
+            )
+            self
+          end
+
+          def inclusion(values)
+            add_submatcher(
+              HaveServiceAttributeMatchers::InclusionMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              Array(values)
+            )
+            self
+          end
+
+          def must(*must_names)
+            add_submatcher(
+              HaveServiceAttributeMatchers::MustMatcher,
+              described_class,
+              :internal,
+              internal_name,
+              Array(must_names)
+            )
+            self
+          end
+
+          def description
+            "#{internal_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 internal attribute named #{internal_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.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module Servactory
+  module TestKit
+    module Rspec
+      module Matchers # rubocop:disable Metrics/ModuleLength
+        def have_service_input(input_name) # rubocop:disable Naming/PredicateName
+          HaveServiceInputMatcher.new(described_class, input_name)
+        end
+
+        RSpec::Matchers.alias_matcher :have_input, :have_service_input
+
+        def have_service_internal(internal_name) # rubocop:disable Naming/PredicateName
+          HaveServiceInternalMatcher.new(described_class, internal_name)
+        end
+
+        RSpec::Matchers.alias_matcher :have_internal, :have_service_internal
+
+        ########################################################################
+        ########################################################################
+        ########################################################################
+
+        RSpec::Matchers.define :have_service_output do |output_name| # rubocop:disable Metrics/BlockLength
+          description { "service output" }
+
+          match do |actual|
+            match_for(actual, output_name)
+          end
+
+          chain :instance_of do |class_or_name|
+            @instance_of = Servactory::Utils.constantize_class(class_or_name)
+          end
+
+          chain :nested do |*values|
+            @nested = values
+          end
+
+          chain :with do |value|
+            @value = value
+          end
+
+          failure_message do |actual|
+            match_for(actual, output_name)
+          end
+
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def match_for(actual, output_name)
+            given_value = actual.public_send(output_name)
+
+            if defined?(@nested) && @nested.present?
+              @nested.each do |method_name|
+                next unless given_value.respond_to?(method_name)
+
+                given_value = given_value.public_send(method_name)
+              end
+            end
+
+            expect(given_value).to(
+              if defined?(@instance_of)
+                RSpec::Matchers::BuiltIn::BeAnInstanceOf.new(@instance_of)
+              elsif @value.is_a?(Array)
+                RSpec::Matchers::BuiltIn::ContainExactly.new(@value)
+              elsif @value.is_a?(Hash)
+                RSpec::Matchers::BuiltIn::Match.new(@value)
+              elsif @value.is_a?(TrueClass) || @value.is_a?(FalseClass)
+                RSpec::Matchers::BuiltIn::Equal.new(@value)
+              elsif @value.is_a?(NilClass)
+                RSpec::Matchers::BuiltIn::BeNil.new(@value)
+              else
+                RSpec::Matchers::BuiltIn::Eq.new(@value)
+              end
+            )
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        RSpec::Matchers.alias_matcher :have_output, :have_service_output
+
+        RSpec::Matchers.define :be_success_service do # rubocop:disable Metrics/BlockLength
+          description { "service success" }
+
+          def expected_data
+            @expected_data ||= {}
+          end
+
+          match do |actual|
+            matched = actual.is_a?(Servactory::Result)
+            matched &&= actual.success?
+            matched &&= !actual.failure?
+
+            if defined?(expected_data)
+              matched &&= expected_data.all? do |key, value|
+                if actual.respond_to?(key)
+                  actual.public_send(key) == value
+                else
+                  false
+                end
+              end
+            end
+
+            matched
+          end
+
+          chain :with_output do |key, value|
+            expected_data[key] = value
+          end
+
+          chain :with_outputs do |attributes|
+            attributes.each do |key, value|
+              expected_data[key] = value
+            end
+          end
+
+          failure_message do |actual| # rubocop:disable Metrics/BlockLength
+            unless actual.instance_of?(Servactory::Result)
+              break <<~MESSAGE
+                Incorrect service result:
+
+                  expected Servactory::Result
+                       got #{actual.class.name}
+              MESSAGE
+            end
+
+            if actual.failure?
+              break <<~MESSAGE
+                Incorrect service result:
+
+                  expected success
+                       got failure
+              MESSAGE
+            end
+
+            if defined?(expected_data)
+              message = expected_data.each do |key, value|
+                unless actual.respond_to?(key)
+                  break <<~MESSAGE
+                    Non-existent value key in result:
+
+                    expected #{actual.inspect}
+                         got #{key}
+                  MESSAGE
+                end
+
+                expected_value = actual.public_send(key)
+                next if actual.public_send(key) == value
+
+                break <<~MESSAGE
+                  Incorrect result value for #{key}:
+
+                    expected #{expected_value.inspect}
+                         got #{value.inspect}
+                MESSAGE
+              end
+            end
+
+            break message if message.present?
+
+            <<~MESSAGE
+              Unexpected case when using `be_success_service`.
+
+              Please try to build an example based on the documentation.
+              Or report your problem to us:
+
+                https://github.com/servactory/servactory/issues
+            MESSAGE
+          end
+        end
+
+        RSpec::Matchers.define :be_failure_service do # rubocop:disable Metrics/BlockLength
+          description { "service failure" }
+
+          match do |actual|
+            expected_failure_class =
+              defined?(@expected_failure_class) ? @expected_failure_class : Servactory::Exceptions::Failure
+
+            expected_type = defined?(@expected_type) ? @expected_type : :base
+            expected_message = defined?(@expected_message) ? @expected_message : nil
+            expected_meta = defined?(@expected_meta) ? @expected_meta : nil
+
+            matched = actual.is_a?(Servactory::Result)
+            matched &&= !actual.success?
+            matched &&= actual.failure?
+            matched &&= actual.error.is_a?(Servactory::Exceptions::Failure)
+            matched &&= actual.error.instance_of?(expected_failure_class)
+            matched &&= actual.error.type == expected_type
+            matched &&= actual.error.message == expected_message
+            matched &&= actual.error.meta == expected_meta
+            matched
+          end
+
+          chain :with do |expected_failure_class|
+            @expected_failure_class = expected_failure_class
+          end
+
+          chain :type do |expected_type|
+            @expected_type = expected_type
+          end
+
+          chain :message do |expected_message|
+            @expected_message = expected_message
+          end
+
+          chain :meta do |expected_meta|
+            @expected_meta = expected_meta
+          end
+
+          failure_message do |actual| # rubocop:disable Metrics/BlockLength
+            unless actual.instance_of?(Servactory::Result)
+              break <<~MESSAGE
+                Incorrect service result:
+
+                  expected Servactory::Result
+                       got #{actual.class.name}
+              MESSAGE
+            end
+
+            if actual.success?
+              break <<~MESSAGE
+                Incorrect service result:
+
+                  expected failure
+                       got success
+              MESSAGE
+            end
+
+            unless actual.error.is_a?(Servactory::Exceptions::Failure)
+              break <<~MESSAGE
+                Incorrect error object:
+
+                  expected Servactory::Exceptions::Failure
+                       got #{actual.error.class.name}
+              MESSAGE
+            end
+
+            if defined?(@expected_failure_class)
+              unless actual.error.instance_of?(@expected_failure_class)
+                break <<~MESSAGE
+                  Incorrect instance error:
+
+                    expected #{@expected_failure_class}
+                         got #{actual.error.class.name}
+                MESSAGE
+              end
+            else
+              unless actual.error.instance_of?(Servactory::Exceptions::Failure)
+                break <<~MESSAGE
+                  Incorrect error object:
+
+                    expected Servactory::Exceptions::Failure
+                         got #{actual.error.class.name}
+                MESSAGE
+              end
+            end
+
+            if defined?(@expected_type) && actual.error.type != @expected_type
+              break <<~MESSAGE
+                Incorrect error type:
+
+                  expected #{actual.error.type.inspect}
+                       got #{@expected_type.inspect}
+              MESSAGE
+            end
+
+            if defined?(@expected_message) && actual.error.message != @expected_message
+              break <<~MESSAGE
+                Incorrect error message:
+
+                  expected #{actual.error.message.inspect}
+                       got #{@expected_message.inspect}
+              MESSAGE
+            end
+
+            if defined?(@expected_meta) && actual.error.meta != @expected_meta
+              break <<~MESSAGE
+                Incorrect error meta:
+
+                  expected #{actual.error.meta.inspect}
+                       got #{@expected_meta.inspect}
+              MESSAGE
+            end
+
+            <<~MESSAGE
+              Unexpected case when using `be_failure_service`.
+
+              Please try to build an example based on the documentation.
+              Or report your problem to us:
+
+                https://github.com/servactory/servactory/issues
+            MESSAGE
+          end
+        end
+      end
+    end
+  end
+end