light-services 2.2.1 → 3.0.0

data/lib/light/services/messages.rb

@@ -4,20 +4,32 @@
 module Light
   module Services
     class Messages
+      extend Forwardable
+
+      def_delegators :@messages, :[], :any?, :empty?, :size, :keys, :values, :each, :each_with_index, :key?
+      alias has_key? key?
+
       def initialize(config)
         @break = false
         @config = config
         @messages = {}
       end
 
+      # Returns total count of all messages across all keys
+      def count
+        @messages.values.sum(&:size)
+      end
+
       def add(key, texts, opts = {})
-        raise Light::Services::Error, "Error text can't be blank" if !texts || texts.blank?
+        raise Light::Services::Error, "Error must be a non-empty string" unless texts
 
         message = nil
 
         [*texts].each do |text|
           message = text.is_a?(Message) ? text : Message.new(key, text, opts)
 
+          raise Light::Services::Error, "Error must be a non-empty string" unless valid_error_text?(message.text)
+
           @messages[key] ||= []
           @messages[key] << message
         end
@@ -46,43 +58,19 @@ module Light
           raise Light::Services::Error, "Don't know how to import errors from #{entity}"
         end
       end
-
-      def copy_to(entity)
-        if (defined?(ActiveRecord::Base) && entity.is_a?(ActiveRecord::Base)) || entity.is_a?(Light::Services::Base)
-          each do |key, messages|
-            messages.each do |message|
-              entity.errors.add(key, message.to_s)
-            end
-          end
-        elsif entity.is_a?(Hash)
-          each do |key, messages|
-            entity[key] ||= []
-            entity[key] += messages.map(&:to_s)
-          end
-        else
-          raise Light::Services::Error, "Don't know how to export errors to #{entity}"
-        end
-
-        entity
-      end
+      alias from_record copy_from
 
       def to_h
         @messages.to_h.transform_values { |value| value.map(&:to_s) }
       end
 
-      def method_missing(method, *args, &block)
-        if @messages.respond_to?(method)
-          @messages.public_send(method, *args, &block)
-        else
-          super
-        end
-      end
+      private
 
-      def respond_to_missing?(method, include_private = false)
-        @messages.respond_to?(method, include_private) || super
-      end
+      def valid_error_text?(text)
+        return false unless text.is_a?(String)
 
-      private
+        !text.strip.empty?
+      end
 
       def break!(break_execution)
         return unless break_execution.nil? ? @config[:break_on_add] : break_execution

data/lib/light/services/rspec/matchers/define_argument.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module RSpec
+      module Matchers
+        # Matcher for testing argument definitions on a service class
+        #
+        # @example Basic usage
+        #   expect(MyService).to define_argument(:name)
+        #
+        # @example With type constraint
+        #   expect(MyService).to define_argument(:name).with_type(String)
+        #
+        # @example With optional flag
+        #   expect(MyService).to define_argument(:email).optional
+        #
+        # @example With default value
+        #   expect(MyService).to define_argument(:status).with_default("pending")
+        #
+        # @example With context flag
+        #   expect(MyService).to define_argument(:current_user).with_context
+        #
+        # @example Combined
+        #   expect(MyService).to define_argument(:count).with_type(Integer).optional.with_default(0)
+        def define_argument(name)
+          DefineArgumentMatcher.new(name)
+        end
+
+        class DefineArgumentMatcher
+          def initialize(name)
+            @name = name
+            @expected_type = nil
+            @expected_optional = nil
+            @expected_default = nil
+            @check_default = false
+            @expected_context = nil
+          end
+
+          def with_type(type)
+            @expected_type = type
+            self
+          end
+
+          def optional(value = true)
+            @expected_optional = value
+            self
+          end
+
+          def required
+            @expected_optional = false
+            self
+          end
+
+          def with_default(default)
+            @check_default = true
+            @expected_default = default
+            self
+          end
+
+          def with_context(value = true)
+            @expected_context = value
+            self
+          end
+
+          def matches?(service_class)
+            @service_class = service_class
+            @actual_class = service_class.is_a?(Class) ? service_class : service_class.class
+
+            return false unless argument_defined?
+            return false unless type_matches?
+            return false unless optional_matches?
+            return false unless default_matches?
+            return false unless context_matches?
+
+            true
+          end
+
+          def failure_message
+            return "expected #{@actual_class} to define argument :#{@name}" unless argument_defined?
+            return type_failure_message unless type_matches?
+            return optional_failure_message unless optional_matches?
+            return default_failure_message unless default_matches?
+            return context_failure_message unless context_matches?
+
+            ""
+          end
+
+          def failure_message_when_negated
+            "expected #{@actual_class} not to define argument :#{@name}"
+          end
+
+          def description
+            desc = "define argument :#{@name}"
+            desc += " with type #{@expected_type}" if @expected_type
+            desc += " as optional" if @expected_optional == true
+            desc += " as required" if @expected_optional == false
+            desc += " with default #{@expected_default.inspect}" if @check_default
+            desc += " with context" if @expected_context
+            desc
+          end
+
+          private
+
+          def argument_defined?
+            @actual_class.respond_to?(:arguments) && @actual_class.arguments.key?(@name)
+          end
+
+          def argument
+            @argument ||= @actual_class.arguments[@name]
+          end
+
+          def type_matches?
+            return true if @expected_type.nil?
+
+            # Access the type via instance variable since there's no public getter
+            actual_type = argument.instance_variable_get(:@type)
+            actual_type == @expected_type
+          end
+
+          def optional_matches?
+            return true if @expected_optional.nil?
+
+            argument.optional == @expected_optional
+          end
+
+          def default_matches?
+            return true unless @check_default
+
+            argument.default_exists && argument.default == @expected_default
+          end
+
+          def context_matches?
+            return true if @expected_context.nil?
+
+            argument.context == @expected_context
+          end
+
+          def type_failure_message
+            actual_type = argument.instance_variable_get(:@type)
+            "expected #{@actual_class} argument :#{@name} to have type #{@expected_type}, " \
+              "but it has type #{actual_type.inspect}"
+          end
+
+          def optional_failure_message
+            if @expected_optional
+              "expected #{@actual_class} argument :#{@name} to be optional, but it is required"
+            else
+              "expected #{@actual_class} argument :#{@name} to be required, but it is optional"
+            end
+          end
+
+          def default_failure_message
+            if argument.default_exists
+              "expected #{@actual_class} argument :#{@name} to have default #{@expected_default.inspect}, " \
+                "but it has default #{argument.default.inspect}"
+            else
+              "expected #{@actual_class} argument :#{@name} to have default #{@expected_default.inspect}, " \
+                "but no default is defined"
+            end
+          end
+
+          def context_failure_message
+            if @expected_context
+              "expected #{@actual_class} argument :#{@name} to have context flag, but it doesn't"
+            else
+              "expected #{@actual_class} argument :#{@name} not to have context flag, but it does"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/light/services/rspec/matchers/define_output.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module RSpec
+      module Matchers
+        # Matcher for testing output definitions on a service class
+        #
+        # @example Basic usage
+        #   expect(MyService).to define_output(:result)
+        #
+        # @example With type constraint
+        #   expect(MyService).to define_output(:product).with_type(Product)
+        #
+        # @example With optional flag
+        #   expect(MyService).to define_output(:message).optional
+        #
+        # @example With default value
+        #   expect(MyService).to define_output(:count).with_default(0)
+        #
+        # @example Combined
+        #   expect(MyService).to define_output(:data).with_type(Hash).optional.with_default({})
+        def define_output(name)
+          DefineOutputMatcher.new(name)
+        end
+
+        class DefineOutputMatcher
+          def initialize(name)
+            @name = name
+            @expected_type = nil
+            @expected_optional = nil
+            @expected_default = nil
+            @check_default = false
+          end
+
+          def with_type(type)
+            @expected_type = type
+            self
+          end
+
+          def optional(value = true)
+            @expected_optional = value
+            self
+          end
+
+          def required
+            @expected_optional = false
+            self
+          end
+
+          def with_default(default)
+            @check_default = true
+            @expected_default = default
+            self
+          end
+
+          def matches?(service_class)
+            @service_class = service_class
+            @actual_class = service_class.is_a?(Class) ? service_class : service_class.class
+
+            return false unless output_defined?
+            return false unless type_matches?
+            return false unless optional_matches?
+            return false unless default_matches?
+
+            true
+          end
+
+          def failure_message
+            return "expected #{@actual_class} to define output :#{@name}" unless output_defined?
+            return type_failure_message unless type_matches?
+            return optional_failure_message unless optional_matches?
+            return default_failure_message unless default_matches?
+
+            ""
+          end
+
+          def failure_message_when_negated
+            "expected #{@actual_class} not to define output :#{@name}"
+          end
+
+          def description
+            desc = "define output :#{@name}"
+            desc += " with type #{@expected_type}" if @expected_type
+            desc += " as optional" if @expected_optional == true
+            desc += " as required" if @expected_optional == false
+            desc += " with default #{@expected_default.inspect}" if @check_default
+            desc
+          end
+
+          private
+
+          def output_defined?
+            @actual_class.respond_to?(:outputs) && @actual_class.outputs.key?(@name)
+          end
+
+          def output
+            @output ||= @actual_class.outputs[@name]
+          end
+
+          def type_matches?
+            return true if @expected_type.nil?
+
+            actual_type = output.instance_variable_get(:@type)
+            actual_type == @expected_type
+          end
+
+          def optional_matches?
+            return true if @expected_optional.nil?
+
+            output.optional == @expected_optional
+          end
+
+          def default_matches?
+            return true unless @check_default
+
+            output.default_exists && output.default == @expected_default
+          end
+
+          def type_failure_message
+            actual_type = output.instance_variable_get(:@type)
+            "expected #{@actual_class} output :#{@name} to have type #{@expected_type}, " \
+              "but it has type #{actual_type.inspect}"
+          end
+
+          def optional_failure_message
+            if @expected_optional
+              "expected #{@actual_class} output :#{@name} to be optional, but it is required"
+            else
+              "expected #{@actual_class} output :#{@name} to be required, but it is optional"
+            end
+          end
+
+          def default_failure_message
+            if output.default_exists
+              "expected #{@actual_class} output :#{@name} to have default #{@expected_default.inspect}, " \
+                "but it has default #{output.default.inspect}"
+            else
+              "expected #{@actual_class} output :#{@name} to have default #{@expected_default.inspect}, " \
+                "but no default is defined"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/light/services/rspec/matchers/define_step.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Light
+  module Services
+    module RSpec
+      module Matchers
+        # Matcher for testing step definitions on a service class
+        #
+        # @example Basic usage
+        #   expect(MyService).to define_step(:validate)
+        #
+        # @example With always flag
+        #   expect(MyService).to define_step(:cleanup).with_always(true)
+        #
+        # @example With if condition
+        #   expect(MyService).to define_step(:notify).with_if(:should_notify?)
+        #
+        # @example With unless condition
+        #   expect(MyService).to define_step(:skip_validation).with_unless(:production?)
+        #
+        # @example Check multiple steps
+        #   expect(MyService).to define_steps(:validate, :process, :save)
+        #
+        # @example Check step order
+        #   expect(MyService).to define_steps_in_order(:validate, :process, :save)
+        def define_step(name)
+          DefineStepMatcher.new(name)
+        end
+
+        def define_steps(*names)
+          DefineStepsMatcher.new(names, ordered: false)
+        end
+
+        def define_steps_in_order(*names)
+          DefineStepsMatcher.new(names, ordered: true)
+        end
+
+        class DefineStepMatcher
+          def initialize(name)
+            @name = name
+            @expected_always = nil
+            @expected_if = nil
+            @expected_unless = nil
+          end
+
+          def with_always(value = true)
+            @expected_always = value
+            self
+          end
+
+          def with_if(condition)
+            @expected_if = condition
+            self
+          end
+
+          def with_unless(condition)
+            @expected_unless = condition
+            self
+          end
+
+          def matches?(service_class)
+            @service_class = service_class
+            @actual_class = service_class.is_a?(Class) ? service_class : service_class.class
+
+            return false unless step_defined?
+            return false unless always_matches?
+            return false unless if_matches?
+            return false unless unless_matches?
+
+            true
+          end
+
+          def failure_message
+            return "expected #{@actual_class} to define step :#{@name}" unless step_defined?
+            return always_failure_message unless always_matches?
+            return if_failure_message unless if_matches?
+            return unless_failure_message unless unless_matches?
+
+            ""
+          end
+
+          def failure_message_when_negated
+            "expected #{@actual_class} not to define step :#{@name}"
+          end
+
+          def description
+            desc = "define step :#{@name}"
+            desc += " with always: #{@expected_always}" unless @expected_always.nil?
+            desc += " with if: #{@expected_if.inspect}" if @expected_if
+            desc += " with unless: #{@expected_unless.inspect}" if @expected_unless
+            desc
+          end
+
+          private
+
+          def step_defined?
+            @actual_class.respond_to?(:steps) && @actual_class.steps.key?(@name)
+          end
+
+          def step
+            @step ||= @actual_class.steps[@name]
+          end
+
+          def always_matches?
+            return true if @expected_always.nil?
+
+            step.always == @expected_always
+          end
+
+          def if_matches?
+            return true if @expected_if.nil?
+
+            actual_if = step.instance_variable_get(:@if)
+            actual_if == @expected_if
+          end
+
+          def unless_matches?
+            return true if @expected_unless.nil?
+
+            actual_unless = step.instance_variable_get(:@unless)
+            actual_unless == @expected_unless
+          end
+
+          def always_failure_message
+            "expected #{@actual_class} step :#{@name} to have always: #{@expected_always}, " \
+              "but it has always: #{step.always.inspect}"
+          end
+
+          def if_failure_message
+            actual_if = step.instance_variable_get(:@if)
+            "expected #{@actual_class} step :#{@name} to have if: #{@expected_if.inspect}, " \
+              "but it has if: #{actual_if.inspect}"
+          end
+
+          def unless_failure_message
+            actual_unless = step.instance_variable_get(:@unless)
+            "expected #{@actual_class} step :#{@name} to have unless: #{@expected_unless.inspect}, " \
+              "but it has unless: #{actual_unless.inspect}"
+          end
+        end
+
+        class DefineStepsMatcher
+          def initialize(names, ordered:)
+            @names = names
+            @ordered = ordered
+          end
+
+          def matches?(service_class)
+            @service_class = service_class
+            @actual_class = service_class.is_a?(Class) ? service_class : service_class.class
+            @missing_steps = []
+            @actual_order = []
+
+            return false unless all_steps_defined?
+            return false unless order_matches?
+
+            true
+          end
+
+          def failure_message
+            return missing_steps_failure_message unless all_steps_defined?
+            return order_failure_message unless order_matches?
+
+            ""
+          end
+
+          def failure_message_when_negated
+            if @ordered
+              "expected #{@actual_class} not to define steps #{@names.inspect} in that order"
+            else
+              "expected #{@actual_class} not to define steps #{@names.inspect}"
+            end
+          end
+
+          def description
+            if @ordered
+              "define steps #{@names.inspect} in order"
+            else
+              "define steps #{@names.inspect}"
+            end
+          end
+
+          private
+
+          def all_steps_defined?
+            return false unless @actual_class.respond_to?(:steps)
+
+            actual_step_names = @actual_class.steps.keys
+            @missing_steps = @names - actual_step_names
+            @missing_steps.empty?
+          end
+
+          def order_matches?
+            return true unless @ordered
+
+            actual_step_names = @actual_class.steps.keys
+            @actual_order = @names.select { |name| actual_step_names.include?(name) }
+
+            # Check if the expected steps appear in the same order in actual steps
+            last_index = -1
+            @names.all? do |name|
+              current_index = actual_step_names.index(name)
+              return false unless current_index
+              return false unless current_index > last_index
+
+              last_index = current_index
+              true
+            end
+          end
+
+          def missing_steps_failure_message
+            "expected #{@actual_class} to define steps #{@names.inspect}, " \
+              "but missing: #{@missing_steps.inspect}"
+          end
+
+          def order_failure_message
+            actual_step_names = @actual_class.steps.keys
+            "expected #{@actual_class} to define steps #{@names.inspect} in that order, " \
+              "but actual order is: #{actual_step_names.inspect}"
+          end
+        end
+      end
+    end
+  end
+end