crspec 0.1.2 → 0.1.3

data/lib/crspec/mock/argument_matchers.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Crspec
+  module Mock
+    # RSpec-style argument matchers usable in with(...) and have_received
+    # constraints. Each responds to ===(actual).
+    module ArgumentMatchers
+      class Anything
+        def ===(_other) = true
+        def ==(other) = true
+        def inspect = "anything"
+      end
+
+      class HashIncluding
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(actual)
+          return false unless actual.is_a?(Hash)
+
+          @expected.all? { |k, v| actual.key?(k) && (v == actual[k] || v === actual[k]) }
+        end
+        alias == ===
+
+        def inspect = "hash_including(#{@expected.inspect})"
+      end
+
+      class HashExcluding
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(actual)
+          return false unless actual.is_a?(Hash)
+
+          @expected.none? { |k, v| actual.key?(k) && (v == actual[k] || v === actual[k]) }
+        end
+        alias == ===
+
+        def inspect = "hash_excluding(#{@expected.inspect})"
+      end
+
+      class ArrayIncluding
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ===(actual)
+          return false unless actual.is_a?(Array)
+
+          @expected.all? { |item| actual.any? { |el| item == el || item === el } }
+        end
+        alias == ===
+
+        def inspect = "array_including(#{@expected.inspect})"
+      end
+
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual) = actual.instance_of?(@klass)
+        alias == ===
+
+        def inspect = "an_instance_of(#{@klass})"
+      end
+
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def ===(actual) = actual.is_a?(@klass)
+        alias == ===
+
+        def inspect = "kind_of(#{@klass})"
+      end
+
+      class Duck
+        def initialize(*methods)
+          @methods = methods
+        end
+
+        def ===(actual) = @methods.all? { |m| actual.respond_to?(m) }
+        alias == ===
+
+        def inspect = "duck_type(#{@methods.map(&:inspect).join(", ")})"
+      end
+
+      def anything
+        Anything.new
+      end
+
+      def hash_including(expected = {}, **kwargs)
+        HashIncluding.new(expected.merge(kwargs))
+      end
+
+      def hash_excluding(expected = {}, **kwargs)
+        HashExcluding.new(expected.merge(kwargs))
+      end
+
+      def array_including(*items)
+        ArrayIncluding.new(items.flatten(1))
+      end
+
+      def an_instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      alias instance_of an_instance_of
+
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      alias a_kind_of kind_of
+
+      def duck_type(*methods)
+        Duck.new(*methods)
+      end
+
+      def self.args_match?(expected_args, actual_args, actual_kwargs = nil)
+        return true if expected_args.nil?
+
+        # A trailing hash matcher (hash_including etc.) may target the
+        # call's keyword arguments.
+        if actual_kwargs && !actual_kwargs.empty? &&
+           expected_args.size == actual_args.size + 1 &&
+           (expected_args.last.is_a?(HashIncluding) || expected_args.last.is_a?(HashExcluding) || expected_args.last.is_a?(Hash))
+          positional = expected_args[0...-1]
+          return args_match?(positional, actual_args) &&
+                 (expected_args.last == actual_kwargs || expected_args.last === actual_kwargs)
+        end
+
+        return false unless expected_args.size == actual_args.size
+
+        expected_args.zip(actual_args).all? do |expected, actual|
+          expected == actual || expected === actual
+        end
+      end
+
+      def self.kwargs_match?(expected_kwargs, actual_kwargs)
+        return true if expected_kwargs.nil? || expected_kwargs.empty?
+
+        if expected_kwargs.size == 1 && expected_kwargs.values.first.is_a?(HashIncluding)
+          return expected_kwargs.values.first === actual_kwargs
+        end
+
+        return false unless expected_kwargs.size == actual_kwargs.size
+
+        expected_kwargs.all? do |key, expected|
+          actual_kwargs.key?(key) && (expected == actual_kwargs[key] || expected === actual_kwargs[key])
+        end
+      end
+    end
+  end
+end

data/lib/crspec/mock/double.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "space"
+require_relative "argument_matchers"
 
 module Crspec
   module Mock
@@ -13,10 +14,15 @@ module Crspec
         @name = name || "Double"
         Space.current.register_double(self)
         stubs.each do |method_name, return_value|
+          __crspec_verify_stub!(method_name)
           Space.current.register_stub(self, method_name, proc { return_value })
         end
       end
 
+      def __crspec_verify_stub!(method_name)
+        # Plain doubles accept any stub.
+      end
+
       def verify_expectations!
         # Verified via Space
       end
@@ -26,19 +32,47 @@ module Crspec
       end
     end
 
+    # A verifying double: only methods that exist on the doubled class's
+    # instance interface may be stubbed or expected.
+    class InstanceDouble < Double
+      def initialize(doubled_class, name = nil, stubs = {})
+        @doubled_class = doubled_class.is_a?(Module) ? doubled_class : nil
+        @doubled_class_name = doubled_class.is_a?(Module) ? doubled_class.name : doubled_class.to_s
+        super(name || @doubled_class_name, stubs)
+      end
+
+      def __crspec_verify_stub!(method_name)
+        return unless @doubled_class
+
+        method_sym = method_name.to_sym
+        return if @doubled_class.method_defined?(method_sym) ||
+                  @doubled_class.private_method_defined?(method_sym)
+
+        raise MockError,
+              "the #{@doubled_class_name} class does not implement the instance method: #{method_sym}"
+      end
+
+      def inspect
+        "#<InstanceDouble(#{@doubled_class_name}) #{@name.inspect}>"
+      end
+    end
+
     class StubChain
       attr_reader :target, :method_name
 
       def initialize(target, method_name)
         @target = target
         @method_name = method_name.to_sym
+        target.__crspec_verify_stub!(@method_name) if target.respond_to?(:__crspec_verify_stub!)
         @expected_args = nil
+        @expected_kwargs = nil
         @return_proc = proc {}
         register_default_stub
       end
 
-      def with(*args)
+      def with(*args, **kwargs)
         @expected_args = args
+        @expected_kwargs = kwargs
         update_stub
         self
       end
@@ -78,6 +112,23 @@ module Crspec
         self
       end
 
+      def and_call_original
+        target = @target
+        method_name = @method_name
+        original = begin
+          target.method(method_name)
+        rescue NameError
+          raise MockError, "#{target.inspect} has no original implementation of #{method_name}"
+        end
+        # Find the implementation beneath the interceptor.
+        original = original.super_method while original && original.owner == Interceptor
+        raise MockError, "#{target.inspect} has no original implementation of #{method_name}" unless original
+
+        @return_proc = proc { |*args, **kwargs, &block| original.call(*args, **kwargs, &block) }
+        update_stub
+        self
+      end
+
       private
 
       def register_default_stub
@@ -88,13 +139,19 @@ module Crspec
         target = @target
         method_name = @method_name
         expected_args = @expected_args
+        expected_kwargs = @expected_kwargs
         return_proc = @return_proc
 
         implementation = proc do |*args, **kwargs, &block|
-          if expected_args && args != expected_args
+          Space.current.record_call(target, method_name, args, kwargs)
+          if expected_args && !expected_args.empty? && !ArgumentMatchers.args_match?(expected_args, args, kwargs)
             raise MockError, "Expected #{method_name} with #{expected_args.inspect}, got #{args.inspect}"
           end
 
+          if expected_kwargs && !expected_kwargs.empty? && !ArgumentMatchers.kwargs_match?(expected_kwargs, kwargs)
+            raise MockError, "Expected #{method_name} with #{expected_kwargs.inspect}, got #{kwargs.inspect}"
+          end
+
           return_proc.call(*args, **kwargs, &block)
         end
 
@@ -153,14 +210,20 @@ module Crspec
         target = @target
         method_name = @method_name
         expected_args = @expected_args
+        expected_kwargs = @expected_kwargs
         return_proc = @return_proc
 
         implementation = proc do |*args, **kwargs, &block|
           @call_count += 1
-          if expected_args && args != expected_args
+          Space.current.record_call(target, method_name, args, kwargs)
+          if expected_args && !expected_args.empty? && !ArgumentMatchers.args_match?(expected_args, args, kwargs)
             raise MockError, "Expected #{method_name} with #{expected_args.inspect}, got #{args.inspect}"
           end
 
+          if expected_kwargs && !expected_kwargs.empty? && !ArgumentMatchers.kwargs_match?(expected_kwargs, kwargs)
+            raise MockError, "Expected #{method_name} with #{expected_kwargs.inspect}, got #{kwargs.inspect}"
+          end
+
           return_proc.call(*args, **kwargs, &block)
         end
 
@@ -174,6 +237,7 @@ module Crspec
       def initialize(method_name)
         @method_name = method_name.to_sym
         @expected_args = nil
+        @expected_kwargs = nil
         @return_values = nil
         @raise_exception = nil
         @yield_args = nil
@@ -181,8 +245,9 @@ module Crspec
         @count_constraint = :exact
       end
 
-      def with(*args)
+      def with(*args, **kwargs)
         @expected_args = args
+        @expected_kwargs = kwargs
         self
       end
 
@@ -202,6 +267,11 @@ module Crspec
         self
       end
 
+      def and_call_original
+        @call_original = true
+        self
+      end
+
       def once
         @expected_count = 1
         @count_constraint = :exact
@@ -243,10 +313,32 @@ module Crspec
       private
 
       def apply_chain_options(chain)
-        chain.with(*@expected_args) if @expected_args
+        if @expected_args || @expected_kwargs
+          chain.with(*(@expected_args || []), **(@expected_kwargs || {}))
+        end
         chain.and_return(*@return_values) if @return_values
         chain.and_raise(@raise_exception, @raise_message) if @raise_exception
         chain.and_yield(*@yield_args) if @yield_args
+        chain.and_call_original if @call_original
+      end
+    end
+
+    # allow(target).to receive_messages(a: 1, b: 2)
+    class ReceiveMessagesMatcher
+      def initialize(messages)
+        @messages = messages
+      end
+
+      def setup_allow(target)
+        @messages.map do |method_name, value|
+          StubChain.new(target, method_name).and_return(value)
+        end
+      end
+
+      def setup_expect(target)
+        @messages.map do |method_name, value|
+          ExpectationChain.new(target, method_name).and_return(value)
+        end
       end
     end
 
@@ -264,20 +356,131 @@ module Crspec
       end
     end
 
+    # expect(target).to have_received(:method).with(...).once
+    class HaveReceivedMatcher
+      def initialize(method_name)
+        @method_name = method_name.to_sym
+        @expected_args = nil
+        @expected_kwargs = nil
+        @expected_count = nil
+        @count_constraint = :at_least_once
+      end
+
+      def with(*args, **kwargs)
+        @expected_args = args
+        @expected_kwargs = kwargs
+        self
+      end
+
+      def once
+        @expected_count = 1
+        @count_constraint = :exact
+        self
+      end
+
+      def twice
+        @expected_count = 2
+        @count_constraint = :exact
+        self
+      end
+
+      def exactly(n)
+        @expected_count = n
+        @count_constraint = :exact
+        self
+      end
+
+      def times
+        self
+      end
+
+      def at_least(n)
+        @expected_count = n
+        @count_constraint = :at_least
+        self
+      end
+
+      def matches?(target)
+        @target = target
+        calls = Space.current.calls_for(target, @method_name)
+        if @expected_args || @expected_kwargs
+          calls = calls.select do |args, kwargs|
+            ArgumentMatchers.args_match?(@expected_args, args, kwargs) &&
+              ArgumentMatchers.kwargs_match?(@expected_kwargs, kwargs)
+          end
+        end
+        @actual_count = calls.size
+
+        case @count_constraint
+        when :exact then @actual_count == @expected_count
+        when :at_least then @actual_count >= @expected_count
+        else @actual_count.positive?
+        end
+      end
+
+      def failure_message
+        expectation = case @count_constraint
+                      when :exact then "exactly #{@expected_count} time(s)"
+                      when :at_least then "at least #{@expected_count} time(s)"
+                      else "at least once"
+                      end
+        with_clause = @expected_args ? " with #{@expected_args.inspect}" : ""
+        "Expected #{@target.inspect} to have received #{@method_name.inspect}#{with_clause} #{expectation}, " \
+          "but received it #{@actual_count} time(s)"
+      end
+
+      def failure_message_when_negated
+        "Expected #{@target.inspect} not to have received #{@method_name.inspect}, " \
+          "but received it #{@actual_count} time(s)"
+      end
+    end
+
+    # A spy: a double that accepts any message and records calls for
+    # have_received verification.
+    class Spy < Double
+      def method_missing(method_name, *args, **kwargs, &block)
+        space = Fiber[Space::STORAGE_KEY]
+        if space
+          if (stub = space.fetch_stub(self, method_name))
+            return stub.call(*args, **kwargs, &block)
+          end
+
+          space.record_call(self, method_name, args, kwargs)
+        end
+        nil
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+
+      def inspect
+        "#<Spy #{@name.inspect}>"
+      end
+    end
+
     module DSL
+      include ArgumentMatchers
+
       def double(name = nil, stubs = {})
         Double.new(name, stubs)
       end
 
       def instance_double(target_class, name = nil, stubs = {})
-        double_name = if target_class.is_a?(String) || target_class.is_a?(Symbol)
-                        target_class.to_s
-                      elsif target_class.respond_to?(:name)
-                        target_class.name
-                      else
-                        target_class.to_s
-                      end
-        Double.new(name || double_name, stubs)
+        if name.is_a?(Hash) && stubs.empty?
+          stubs = name
+          name = nil
+        end
+        resolved = if target_class.is_a?(String) || target_class.is_a?(Symbol)
+                     begin
+                       Object.const_get(target_class.to_s)
+                     rescue NameError
+                       target_class.to_s
+                     end
+                   else
+                     target_class
+                   end
+        InstanceDouble.new(resolved, name, stubs)
       end
 
       def allow(target)
@@ -287,6 +490,36 @@ module Crspec
       def receive(method_name)
         ReceiveMatcher.new(method_name)
       end
+
+      def receive_messages(messages)
+        ReceiveMessagesMatcher.new(messages)
+      end
+
+      def spy(name = nil, stubs = {})
+        Spy.new(name || "Spy", stubs)
+      end
+
+      def have_received(method_name)
+        HaveReceivedMatcher.new(method_name)
+      end
+
+      def allow_any_instance_of(_klass)
+        raise Crspec::MigrationError, <<~MSG
+          allow_any_instance_of is not supported by Crspec: it mutates shared
+          class hierarchies at runtime, which is unsafe under concurrent
+          threads/fibers. Inject a double or stub the specific instance.
+          Run `crspec-transpile --analyze` to find all occurrences.
+        MSG
+      end
+
+      def expect_any_instance_of(_klass)
+        raise Crspec::MigrationError, <<~MSG
+          expect_any_instance_of is not supported by Crspec: it mutates shared
+          class hierarchies at runtime, which is unsafe under concurrent
+          threads/fibers. Inject a double or stub the specific instance.
+          Run `crspec-transpile --analyze` to find all occurrences.
+        MSG
+      end
     end
   end
 end

data/lib/crspec/mock/interceptor.rb

@@ -3,6 +3,9 @@
 module Crspec
   module Mock
     module Interceptor
+      @intercepted_methods = {}
+      @mutex = Mutex.new
+
       def method_missing(method_name, *args, **kwargs, &block)
         space = Fiber[Space::STORAGE_KEY]
         if space && (stub = space.fetch_stub(self, method_name))
@@ -17,16 +20,36 @@ module Crspec
         space&.fetch_stub(self, method_name) || super
       end
 
-      def self.add_intercept_method(method_name)
-        method_sym = method_name.to_sym
-        return if instance_methods(false).include?(method_sym) || private_instance_methods(false).include?(method_sym)
+      class << self
+        def add_intercept_method(method_name)
+          method_sym = method_name.to_sym
+          @mutex.synchronize do
+            return if @intercepted_methods.key?(method_sym)
+            return if instance_methods(false).include?(method_sym) ||
+                      private_instance_methods(false).include?(method_sym)
+
+            define_method(method_sym) do |*args, **kwargs, &block|
+              space = Fiber[Space::STORAGE_KEY]
+              if space && (stub = space.fetch_stub(self, method_sym))
+                stub.call(*args, **kwargs, &block)
+              else
+                super(*args, **kwargs, &block)
+              end
+            end
+            @intercepted_methods[method_sym] = true
+          end
+        end
 
-        define_method(method_sym) do |*args, **kwargs, &block|
-          space = Fiber[Space::STORAGE_KEY]
-          if space && (stub = space.fetch_stub(self, method_sym))
-            stub.call(*args, **kwargs, &block)
-          else
-            super(*args, **kwargs, &block)
+        # Removes all dynamically-defined intercept methods so they do not
+        # accumulate for the lifetime of the process (e.g. across multiple
+        # embedded runner invocations). Stub lookups fall back to
+        # method_missing until re-added.
+        def cleanup!
+          @mutex.synchronize do
+            @intercepted_methods.each_key do |method_sym|
+              remove_method(method_sym) if instance_methods(false).include?(method_sym)
+            end
+            @intercepted_methods.clear
           end
         end
       end

data/lib/crspec/mock/space.rb

@@ -27,9 +27,22 @@ module Crspec
         @doubles = []
         @stubs = Hash.new { |h, k| h[k] = {} }
         @expectations = []
+        @calls = Hash.new { |h, k| h[k] = [] }
         @mutex = Mutex.new
       end
 
+      def record_call(target, method_name, args, kwargs)
+        @mutex.synchronize do
+          @calls[[target.object_id, method_name.to_sym]] << [args, kwargs]
+        end
+      end
+
+      def calls_for(target, method_name)
+        @mutex.synchronize do
+          @calls[[target.object_id, method_name.to_sym]].dup
+        end
+      end
+
       def register_stub(target, method_name, implementation)
         method_sym = method_name.to_sym
         ensure_interceptor_prepended(target, method_sym)
@@ -66,6 +79,7 @@ module Crspec
           @stubs.clear
           @doubles.clear
           @expectations.clear
+          @calls.clear
         end
       end