servactory 3.1.0.rc2 → 3.1.0.rc4

data/lib/servactory/test_kit/rspec/matchers/submatchers/shared/message_submatcher.rb

@@ -17,16 +17,64 @@ module Servactory
             # ## Usage
             #
             # ```ruby
+            # it { is_expected.to have_service_input(:id).type(Integer).message("ID must be an Integer") }
             # it { is_expected.to have_service_input(:email).inclusion(%w[a b]).message("Invalid email") }
             # it { is_expected.to have_service_input(:data).schema({ key: String }).message("Invalid schema") }
+            # it { is_expected.to have_service_input(:email).inclusion(%w[a b]).message(/Invalid/) }
+            # it { is_expected.to have_service_input(:email).inclusion(%w[a b]).message(be_a(Proc)) }
+            # it { is_expected.to have_service_input(:email).inclusion(%w[a b]).message(:default) }
+            # it { is_expected.to have_service_input(:age).must(:be_adult).message("Must be an adult") }
             # ```
             #
             # ## Note
             #
             # Requires `requires_last_submatcher: true` - must follow another
-            # submatcher. Uses the previous submatcher's OPTION_NAME constant
-            # to find the message field.
+            # submatcher. Uses the previous submatcher's OPTION_NAME constant,
+            # or its `option_name` for options with a configurable name such as
+            # `target`, to find the message field. Chaining it after a submatcher
+            # without such an option raises ArgumentError.
+            #
+            # After `.must`, the must submatcher stores the expected message
+            # itself (see MustSubmatcher).
+            #
+            # Every `.message` in a chain is checked, each against the option
+            # chained right before it:
+            #
+            # ```ruby
+            # it do
+            #   is_expected.to have_service_input(:status)
+            #     .type(Symbol).message("Status must be a Symbol")
+            #     .inclusion(%i[active inactive]).message("Status must be active or inactive")
+            # end
+            # ```
+            #
+            # A String is compared with the message exactly, a Regexp is matched
+            # against it, and an RSpec matcher is applied to the message as
+            # defined, for example to check that it is a Proc.
+            #
+            # A Proc message is called before a String or Regexp comparison with
+            # every keyword argument the library passes to it while the service
+            # runs: `service:`, the attribute (`input:`, `internal:` or
+            # `output:`) and `value:`, plus `expected_type:` and `given_type:`
+            # for `type`, or `code:`, `reason:`, `option_name:` and
+            # `option_value:` for the other options, and `key_name:`,
+            # `expected_type:` and `given_type:` for `schema` as well (see
+            # Concerns::ProcMessage). The library passes the same keywords for
+            # every failure reason of an option. Values known only while the
+            # service runs, such as `value:` and `reason:`, are `nil`.
+            # A Proc message that raises with them, for example because it does
+            # not accept every keyword, or does not return a String does not
+            # match, and the failure message shows the error or the returned
+            # value.
+            #
+            # `:default` checks that the option defines no custom message.
+            # Without a custom message, a String or Regexp does not match:
+            # the default message of these options depends on values known
+            # only while the service runs. Check it with `raise_error` instead.
             class MessageSubmatcher < Base::Submatcher
+              include Concerns::OptionHelperRules
+              include Concerns::ProcMessage
+
               # Option name in attribute data (unused - uses last submatcher's)
               OPTION_NAME = :message
               # Key for the message within the option
@@ -35,18 +83,22 @@ module Servactory
               # Creates a new message submatcher.
               #
               # @param context [Base::SubmatcherContext] The submatcher context
-              # @param custom_message [String] Expected error message
+              # @param custom_message [String, Regexp, Symbol, Object] Expected error message, `:default`
+              #   or an RSpec matcher
               # @return [MessageSubmatcher] New submatcher instance
+              # @raise [ArgumentError] If the previous submatcher checks no option with a message,
+              #   or the expected message is of another kind
               def initialize(context, custom_message)
                 super(context)
-                @custom_message = custom_message
+                ensure_option_with_message!
+                @expectation = Base::MessageExpectation.new(custom_message)
               end
 
               # Returns description for RSpec output.
               #
               # @return [String] Human-readable description with message
               def description
-                "message: #{@attribute_schema_message}"
+                "message: #{expectation.description}"
               end
 
               protected
@@ -55,56 +107,98 @@ module Servactory
               #
               # @return [Boolean] True if messages match
               def passes?
-                last_submatcher = context.last_submatcher
-                attribute_schema = attribute_data.fetch(last_submatcher.class::OPTION_NAME)
-                @attribute_schema_is = attribute_schema.fetch(last_submatcher.class::OPTION_BODY_KEY)
-                @attribute_schema_message = attribute_schema.fetch(:message)
+                attribute_schema = attribute_data[option_name]
+                @mismatch = attribute_schema.is_a?(Hash) ? find_mismatch(attribute_schema) : missing_option_explanation
 
-                schema_message_equal?
+                @mismatch.nil?
               end
 
               # Builds the failure message for message validation.
               #
               # @return [String] Failure message with expected vs actual message
               def build_failure_message
-                return "" if schema_message_equal?
+                "should return expected message in case of problem:\n\n#{@mismatch.indent(2)}"
+              end
 
-                <<~MESSAGE
-                  should return expected message in case of problem:
+              private
 
-                    expected #{@attribute_schema_message.inspect}
-                         got #{custom_message.inspect}
-                MESSAGE
+              attr_reader :expectation
+
+              # Ensures that the previous submatcher checks an option with a message.
+              #
+              # @return [void]
+              # @raise [ArgumentError] If there is no previous submatcher or its option has no message
+              def ensure_option_with_message!
+                last_submatcher = context.last_submatcher
+                return if last_submatcher.respond_to?(:option_name)
+                return if last_submatcher.is_a?(Base::Submatcher) && last_submatcher.class.const_defined?(:OPTION_NAME)
+
+                raise ArgumentError, option_with_message_error_message(last_submatcher)
               end
 
-              private
+              # Builds the error message for a `message` chained without an option with a message.
+              #
+              # @param last_submatcher [Base::Submatcher, nil] The previous submatcher
+              # @return [String] Error message
+              def option_with_message_error_message(last_submatcher)
+                position = last_submatcher.nil? ? "first in the chain" : "after `#{last_submatcher.description}`"
+                required = last_submatcher.is_a?(Input::RequiredSubmatcher)
+                hint = required ? " To check the required message, pass it to `required`." : ""
 
-              attr_reader :custom_message
+                "`message` checks the message of the option chained right before it: chain it after " \
+                  "`type`, `consists_of`, `schema`, `inclusion`, `target` or `must`, not #{position}.#{hint}"
+              end
 
-              # Compares expected and actual messages with type-aware logic.
+              # Compares the option's message with the expected message.
               #
-              # Handles RSpec matchers, Procs, and plain strings.
+              # @param attribute_schema [Hash] The option in attribute data
+              # @return [String, nil] Explanation of the mismatch, or nil if the messages match
+              def find_mismatch(attribute_schema)
+                @attribute_schema_is = attribute_schema[context.last_submatcher.class::OPTION_BODY_KEY]
+                @attribute_schema_message = attribute_schema[:message]
+
+                expectation.mismatch_for(@attribute_schema_message) { |message| call_message(message) }
+              end
+
+              # Explains a mismatch for an attribute without the option.
               #
-              # @return [Boolean] True if messages match
-              def schema_message_equal? # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
-                @schema_message_equal ||= begin
-                  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
-                rescue RSpec::Expectations::ExpectationNotMetError
-                  false
+              # @return [String] Explanation of the mismatch
+              def missing_option_explanation
+                <<~MESSAGE
+                  expected #{expectation.description}
+                       got no `#{option_name}` option
+                MESSAGE
+              end
+
+              # Calls a Proc message with the keyword arguments the library passes to it.
+              #
+              # `code:` is the name of the must rule the option helper generates,
+              # such as `be_inclusion`.
+              #
+              # @param message [Proc] The attribute's message
+              # @return [Object] The message built by the Proc
+              def call_message(message)
+                if option_name == :type
+                  return call_proc_message(message, :type, expected_type: @attribute_schema_is.join(", "))
                 end
+
+                call_proc_message(
+                  message,
+                  option_name == :schema ? :schema : :dynamic_option,
+                  code: option_helper_rule_name(option_name),
+                  option_name:,
+                  option_value: @attribute_schema_is
+                )
+              end
+
+              # Returns the name of the option validated by the previous submatcher.
+              #
+              # @return [Symbol] Option name in attribute data
+              def option_name
+                last_submatcher = context.last_submatcher
+                return last_submatcher.option_name if last_submatcher.respond_to?(:option_name)
+
+                last_submatcher.class::OPTION_NAME
               end
             end
           end

data/lib/servactory/test_kit/rspec/matchers/submatchers/shared/must_submatcher.rb

@@ -13,33 +13,113 @@ module Servactory
             # Validates that an attribute has the expected custom validation rules
             # defined via the `must` option. Excludes dynamic options that are
             # tested separately (consists_of, schema, be_inclusion, be_target).
+            # Optionally validates the messages of the rules.
             #
             # ## Usage
             #
             # ```ruby
             # it { is_expected.to have_service_input(:email).must([:be_valid_email]) }
             # it { is_expected.to have_service_input(:age).must([:be_positive, :be_adult]) }
+            # it { is_expected.to have_service_input(:age).must(:be_positive, be_adult: "Must be an adult") }
+            # it { is_expected.to have_service_input(:age).must(be_positive: /positive/, be_adult: :default) }
+            # it { is_expected.to have_service_input(:age).must(:be_adult).message("Must be an adult") }
             # ```
             #
             # ## Comparison
             #
             # Uses set difference to compare validation names - order doesn't matter.
+            # Bare names and the keys of expected messages together must name
+            # every rule of the attribute.
+            #
+            # ## Messages
+            #
+            # `.message` chained right after `.must` naming one rule is the same
+            # as the keyed form for that rule. After `.must` naming several
+            # rules, `.message` raises ArgumentError.
+            #
+            # An expected message follows the rules of `.message`: a String is
+            # compared with the message exactly, a Regexp is matched against it,
+            # an RSpec matcher is applied to the message as defined, and
+            # `:default` checks that the rule defines no custom message.
+            #
+            # Without a custom message, the rule uses the default message of
+            # the library, which depends only on the service, the attribute and
+            # the rule name, so a String or Regexp is compared with it.
+            #
+            # A Proc message is called with the keyword arguments the library
+            # passes to it: `service:`, the attribute (`input:`, `internal:` or
+            # `output:`), `value:`, `code:`, `reason:` and `meta:`. Values known
+            # only while the service runs are `nil`. A Proc message that raises
+            # with them, for example because it does not accept all of them,
+            # does not match.
+            #
+            # Rules generated by option helpers, such as `be_in_format` of the
+            # `format` option or `be_greater_than_or_equal_to` of `min`, may be
+            # listed by name, but their messages depend on the validated value:
+            # expecting a message for them raises ArgumentError. Check these
+            # messages with `raise_error` instead.
             class MustSubmatcher < Base::Submatcher
+              include Concerns::OptionHelperRules
+              include Concerns::ProcMessage
+
+              # NOTE: Dynamic options that are also `must` but tested separately
+              BUILT_IN_RULE_NAMES = %i[consists_of schema be_inclusion be_target].freeze
+
+              # Splits the arguments of the `must` chain method.
+              #
+              # A trailing Hash, which Ruby passes for keyword arguments,
+              # maps rule names to their expected messages.
+              #
+              # @param args [Array] The arguments of the chain method
+              # @return [Array(Array<Symbol>, Hash{Symbol => Object})] Rule names and expected messages
+              def self.arguments_from(args)
+                expectations, names = Array(args).flatten.partition { |argument| argument.is_a?(Hash) }
+
+                [names, expectations.reduce({}, :merge)]
+              end
+
               # Creates a new must submatcher.
               #
               # @param context [Base::SubmatcherContext] The submatcher context
               # @param must_names [Array<Symbol>] Expected validation rule names
+              # @param message_expectations [Hash{Symbol => Object}] Expected messages by rule name
               # @return [MustSubmatcher] New submatcher instance
-              def initialize(context, must_names)
+              # @raise [ArgumentError] If an expected message is of an unsupported kind,
+              #   or belongs to a rule generated by an option helper
+              def initialize(context, must_names, message_expectations = {})
                 super(context)
-                @must_names = must_names
+                @must_names = (must_names + message_expectations.keys).uniq
+                @message_expectations = message_expectations.transform_values do |expected|
+                  Base::MessageExpectation.new(expected)
+                end
+
+                message_expectations.each_key { |name| ensure_message_checkable!(name) }
+              end
+
+              # Stores the message expected by `.message` chained right after `.must`.
+              #
+              # `.must(:rule).message(expected)` is the same as `.must(rule: expected)`.
+              # Each rule accepts one expected message.
+              #
+              # @param expected [String, Regexp, Symbol, Object] Expected message, `:default` or an RSpec matcher
+              # @return [void]
+              # @raise [ArgumentError] If `must` does not name exactly one rule, the rule already has
+              #   an expected message, or the message cannot be checked
+              def expect_message(expected)
+                raise ArgumentError, several_rules_error_message unless must_names.one?
+
+                name = must_names.first
+                raise ArgumentError, "Rule `#{name}` already has an expected message" if message_expectations.key?(name)
+
+                ensure_message_checkable!(name)
+                message_expectations[name] = Base::MessageExpectation.new(expected)
               end
 
               # Returns description for RSpec output.
               #
               # @return [String] Human-readable description with rule names
               def description
-                "must: #{must_names.join(', ')}"
+                "must: #{must_names.map { |name| rule_description(name) }.join(', ')}"
               end
 
               protected
@@ -48,31 +128,126 @@ module Servactory
               #
               # Filters out dynamic options that are tested by other submatchers.
               #
-              # @return [Boolean] True if must rules match (order-independent)
+              # @return [Boolean] True if must rules and their messages match (order-independent)
               def passes?
-                attribute_must = attribute_data.fetch(:must)
-                attribute_must_keys = attribute_must.keys.dup
-
-                # NOTE: Dynamic options that are also `must` but tested separately
-                attribute_must_keys.delete(:consists_of)
-                attribute_must_keys.delete(:schema)
-                attribute_must_keys.delete(:be_inclusion)
-                attribute_must_keys.delete(:be_target)
+                @actual_must_names = actual_must_names
+                @message_mismatches = find_message_mismatches
 
-                attribute_must_keys.difference(must_names).empty? &&
-                  must_names.difference(attribute_must_keys).empty?
+                names_match? && @message_mismatches.empty?
               end
 
               # Builds the failure message for must validation.
               #
-              # @return [String] Simple failure message with expected rules
+              # @return [String] Failure message with expected vs actual rules and messages
               def build_failure_message
-                "should #{must_names.join(', ')}"
+                messages = @message_mismatches.map do |name, mismatch|
+                  "should return expected message for must rule `#{name}`:\n\n#{mismatch.indent(2)}"
+                end
+
+                messages.unshift(names_failure_message) unless names_match?
+                messages.join("\n")
               end
 
               private
 
-              attr_reader :must_names
+              attr_reader :must_names, :message_expectations
+
+              # Ensures that the message of a rule does not depend on the validated value.
+              #
+              # @param name [Symbol] Rule name
+              # @return [void]
+              # @raise [ArgumentError] If an option helper generated the rule
+              def ensure_message_checkable!(name)
+                return if BUILT_IN_RULE_NAMES.include?(name) || !option_helper_rule?(name)
+
+                raise ArgumentError,
+                      "The message of must rule `#{name}` cannot be checked: an option helper generated the rule, " \
+                      "and its message depends on the validated value. List the rule by name, as in " \
+                      "`must(:#{name})`, and check the error message with `raise_error`."
+              end
+
+              # Builds the error message for `.message` after `.must` naming several rules.
+              #
+              # @return [String] Error message
+              def several_rules_error_message
+                return "`message` after `must` needs a rule name, e.g. `must(:rule).message(...)`." if must_names.empty?
+
+                keyed = must_names.map { |name| "#{name}: ..." }.join(", ")
+
+                "`message` after `must` needs exactly one rule, got #{must_names.size}. " \
+                  "Use the keyed form to expect a message for each rule, as in `must(#{keyed})`."
+              end
+
+              # Describes a rule name with its expected message.
+              #
+              # @param name [Symbol] Rule name
+              # @return [String] Rule description
+              def rule_description(name)
+                expectation = message_expectations[name]
+                return name.to_s if expectation.nil?
+
+                "#{name} with message #{expectation.description}"
+              end
+
+              # Returns the attribute's must rules.
+              #
+              # @return [Hash{Symbol => Hash, Proc}] Rules by name
+              def attribute_must
+                attribute_data[:must] || {}
+              end
+
+              # Returns the names of the attribute's rules checked by this submatcher.
+              #
+              # @return [Array<Symbol>] Rule names
+              def actual_must_names
+                attribute_must.keys - BUILT_IN_RULE_NAMES
+              end
+
+              # Compares the expected rule names with the attribute's rule names.
+              #
+              # @return [Boolean] True if both name the same rules
+              def names_match?
+                @actual_must_names.difference(must_names).empty? &&
+                  must_names.difference(@actual_must_names).empty?
+              end
+
+              # Builds the failure message for mismatching rule names.
+              #
+              # @return [String] Failure message with expected vs actual rules
+              def names_failure_message
+                <<~MESSAGE
+                  should #{must_names.join(', ')}
+
+                    expected must rules: #{build_list_message(must_names)}
+                         got must rules: #{build_list_message(@actual_must_names)}
+                MESSAGE
+              end
+
+              # Compares the messages of the attribute's rules with the expected messages.
+              #
+              # Rules missing from the attribute are reported by the name comparison.
+              #
+              # @return [Hash{Symbol => String}] Explanations of the mismatches by rule name
+              def find_message_mismatches
+                message_expectations.filter_map do |name, expectation|
+                  next unless attribute_must.key?(name)
+
+                  mismatch = expectation.mismatch_for(
+                    rule_message(attribute_must.fetch(name)),
+                    default_message: Servactory::Maintenance::Validations::Translator::Must.default_message
+                  ) { |message| call_proc_message(message, :must, code: name) }
+
+                  [name, mismatch] unless mismatch.nil?
+                end.to_h
+              end
+
+              # Returns the custom message of a rule.
+              #
+              # @param rule [Hash, Proc] The rule in advanced or simple mode
+              # @return [String, Proc, nil] The custom message
+              def rule_message(rule)
+                rule.is_a?(Hash) ? rule[:message] : nil
+              end
             end
           end
         end

data/lib/servactory/test_kit/rspec/matchers/submatchers/shared/target_submatcher.rb

@@ -29,6 +29,9 @@ module Servactory
               # Key for the target values within the option
               OPTION_BODY_KEY = :in
 
+              # @return [Symbol] The name of the target option
+              attr_reader :option_name
+
               # Creates a new target submatcher.
               #
               # @param context [Base::SubmatcherContext] The submatcher context
@@ -77,8 +80,7 @@ module Servactory
 
               private
 
-              attr_reader :option_name,
-                          :values
+              attr_reader :values
 
               # Formats values for human-readable description.
               #

data/lib/servactory/test_kit/rspec/matchers/submatchers/shared/types_submatcher.rb

@@ -19,6 +19,7 @@ module Servactory
             # it { is_expected.to have_service_input(:user_id).type(Integer) }
             # it { is_expected.to have_service_input(:data).types(String, Hash) }
             # it { is_expected.to have_service_internal(:result).type(Array) }
+            # it { is_expected.to have_service_input(:user_id).type(Integer).message("User ID must be an Integer") }
             # ```
             #
             # ## Comparison
@@ -26,6 +27,11 @@ module Servactory
             # Types are compared by name, sorted alphabetically. Order of types
             # in the definition doesn't matter - only the set of types must match.
             class TypesSubmatcher < Base::Submatcher
+              # Option name in attribute data
+              OPTION_NAME = :type
+              # Key for the types within the option
+              OPTION_BODY_KEY = :is
+
               # Creates a new types submatcher.
               #
               # @param context [Base::SubmatcherContext] The submatcher context

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

@@ -44,8 +44,12 @@
 require_relative "matchers/concerns/attribute_data_access"
 require_relative "matchers/concerns/error_message_builder"
 require_relative "matchers/concerns/value_comparison"
+require_relative "matchers/concerns/option_helper_rules"
+require_relative "matchers/concerns/proc_message"
+require_relative "matchers/concerns/required_message"
 
 # Base classes (loaded after concerns)
+require_relative "matchers/base/message_expectation"
 require_relative "matchers/base/submatcher_context"
 require_relative "matchers/base/submatcher"
 require_relative "matchers/base/submatcher_registry"
@@ -89,6 +93,12 @@ module Servactory
         #   expect(MyService).to have_service_input(:user_id)
         #     .type(Integer)
         #     .required
+        #
+        # @example With messages
+        #   expect(MyService).to have_service_input(:age)
+        #     .type(Integer).message("Age must be an Integer")
+        #     .required(/is required/)
+        #     .must(:be_adult, be_positive: :default)
         def have_service_input(input_name) # rubocop:disable Naming/PredicatePrefix
           HaveServiceInputMatcher.new(described_class, input_name)
         end
@@ -101,6 +111,11 @@ module Servactory
         # @example
         #   expect(MyService).to have_service_internal(:processed_data)
         #     .type(Hash)
+        #
+        # @example With messages
+        #   expect(MyService).to have_service_internal(:total)
+        #     .type(Integer).message(:default)
+        #     .must(:be_positive).message("Total must be positive")
         def have_service_internal(internal_name) # rubocop:disable Naming/PredicatePrefix
           HaveServiceInternalMatcher.new(described_class, internal_name)
         end

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

@@ -31,7 +31,7 @@ module Servactory
       # Specify type directly as the option value:
       #
       # ```ruby
-      # class ProcessUsersService < ApplicationService::Base
+      # class Users::Process < ApplicationService::Base
       #   input :user_ids, type: Array, consists_of: Integer
       #   input :tags, type: Array, consists_of: [String, Symbol]
       #   input :scores, type: Array, consists_of: Float
@@ -88,8 +88,9 @@ module Servactory
         # Creates a ConsistsOf validator instance.
         #
         # @param option_name [Symbol] The option name (default: :consists_of)
-        # @param collection_mode_class_names [Array<Class>] Valid collection types
-        # @return [Servactory::Maintenance::Attributes::OptionHelper]
+        # @param collection_mode_class_names [Servactory::Configuration::CollectionMode::ClassNamesCollection]
+        #   Valid collection types
+        # @return [Servactory::Maintenance::Options::Helper]
         def self.use(option_name = :consists_of, collection_mode_class_names:)
           instance = new(option_name, :type, false)
           instance.assign(collection_mode_class_names)
@@ -98,7 +99,8 @@ module Servactory
 
         # Assigns the list of valid collection class names.
         #
-        # @param collection_mode_class_names [Array<Class>] Collection types to accept
+        # @param collection_mode_class_names [Servactory::Configuration::CollectionMode::ClassNamesCollection]
+        #   Collection types to accept
         # @return [void]
         def assign(collection_mode_class_names)
           @collection_mode_class_names = collection_mode_class_names
@@ -160,7 +162,7 @@ module Servactory
         # @param option [WorkOption] Type configuration
         # @return [Boolean, Array] true if valid, or [false, reason]
         def validate_for!(attribute:, values:, option:)
-          consists_of_types = Array(option.value).uniq
+          consists_of_types = Array(option.value)
 
           # Check presence requirements.
           return [false, :required] if fails_presence_validation?(attribute:, values:, consists_of_types:)
@@ -215,8 +217,7 @@ module Servactory
             service_class_name: service.class_name,
             input_name: input.name,
             option_name:,
-            expected_type: Array(option_value).uniq.join(", "),
-            given_type: given_type_for(values: value, option_value:)
+            **type_names_for(attribute: input, values: value, option_value:, reason:)
           )
         end
 
@@ -238,8 +239,7 @@ module Servactory
             service_class_name: service.class_name,
             internal_name: internal.name,
             option_name:,
-            expected_type: Array(option_value).uniq.join(", "),
-            given_type: given_type_for(values: value, option_value:)
+            **type_names_for(attribute: internal, values: value, option_value:, reason:)
           )
         end
 
@@ -261,11 +261,34 @@ module Servactory
             service_class_name: service.class_name,
             output_name: output.name,
             option_name:,
-            expected_type: Array(option_value).uniq.join(", "),
-            given_type: given_type_for(values: value, option_value:)
+            **type_names_for(attribute: output, values: value, option_value:, reason:)
           )
         end
 
+        # Builds the expected and given type names for a failure message.
+        #
+        # For `:wrong_type` the attribute itself is not of a collection type,
+        # so the configured collection types are expected and the declared
+        # attribute types are given. For other reasons the element types
+        # are compared.
+        #
+        # @param attribute [Object] The attribute being validated
+        # @param values [Object] Failed value
+        # @param option_value [Object] Expected element types
+        # @param reason [Symbol] Failure reason
+        # @return [Hash] Hash with :expected_type and :given_type keys
+        def type_names_for(attribute:, values:, option_value:, reason:)
+          if reason == :wrong_type
+            expected_type = @collection_mode_class_names.to_a.join(", ")
+            given_type = attribute.types.join(", ")
+          else
+            expected_type = Array(option_value).uniq.join(", ")
+            given_type = given_type_for(values:, option_value:)
+          end
+
+          { expected_type:, given_type: }
+        end
+
         # Extracts type names of elements that don't match expected types.
         #
         # @param values [Array, nil] Collection elements