proto_pharm 0.6.0

data/lib/proto_pharm/matchers/hash_argument_matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module Matchers
+    # Base class for Hash matchers
+    # https://github.com/rspec/rspec-mocks/blob/master/lib/rspec/mocks/argument_matchers.rb
+    class HashArgumentMatcher
+      def self.stringify_keys!(arg, options = {})
+        case arg
+        when Array
+          arg.map do |elem|
+            options[:deep] ? stringify_keys!(elem, options) : elem
+          end
+        when Hash
+          Hash[
+            *arg.map do |key, value|
+              k = key.is_a?(Symbol) ? key.to_s : key
+              v = (options[:deep] ? stringify_keys!(value, options) : value)
+              [k, v]
+            end.inject([]) { |r, x| r + x }]
+        else
+          arg
+        end
+      end
+
+      def initialize(expected)
+        @expected = Hash[
+          ProtoPharm::Matchers::HashArgumentMatcher.stringify_keys!(expected, deep: true).sort,
+        ]
+      end
+
+      def ==(_actual, &block)
+        @expected.all?(&block)
+      rescue NoMethodError
+        false
+      end
+
+      def self.from_rspec_matcher(matcher)
+        new(matcher.instance_variable_get(:@expected))
+      end
+    end
+  end
+end

data/lib/proto_pharm/matchers/request_including_matcher.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "proto_pharm/matchers/hash_argument_matcher"
+
+module ProtoPharm
+  module Matchers
+    class RequestIncludingMatcher < HashArgumentMatcher
+      def ==(actual)
+        if actual.respond_to?(:to_h)
+          actual = actual.to_h
+        end
+
+        actual = Hash[ProtoPharm::Matchers::HashArgumentMatcher.stringify_keys!(actual, deep: true)]
+        super { |key, value| inner_including(value, key, actual) }
+      rescue NoMethodError
+        false
+      end
+
+      private
+
+      def inner_including(expect, key, actual)
+        if actual.key?(key)
+          actual_value = actual[key]
+          if expect.is_a?(Hash)
+            RequestIncludingMatcher.new(expect) == actual_value
+          else
+            expect === actual_value
+          end
+        else
+          false
+        end
+      end
+
+      def inspect
+        "reqeust_including(#{@expected.inspect})"
+      end
+    end
+  end
+end

data/lib/proto_pharm/operation_stub.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class OperationStub
+    attr_reader :response_proc, :metadata, :trailing_metadata, :deadline
+
+    # @param metadata [Hash] Any metadata passed into the GRPC request
+    # @param deadline [Time] The deadline set on the GRPC request
+    # @yieldreturn [*] The stubbed value or error expected to be returned from the request
+    def initialize(metadata: nil, deadline: nil, &response_proc)
+      @response_proc = response_proc
+      @metadata = metadata
+      @deadline = deadline
+
+      # TODO: support stubbing
+      @trailing_metadata = {}
+    end
+
+    # Calls the block given upon instantiation and returns the result
+    def response
+      response_proc.call
+    end
+    alias_method :execute, :response
+
+    # TODO: support stubbing
+    def cancelled?
+      false
+    end
+  end
+end

data/lib/proto_pharm/request_pattern.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class RequestPattern
+    attr_reader :path, :request, :block
+
+    # @param path [String]
+    def initialize(path)
+      @path = path
+      @block = nil
+      @request = nil
+    end
+
+    def with(request = nil, &block)
+      if request.nil? && !block_given?
+        raise ArgumentError, "#with method invoked with no arguments. Either options request or block must be specified."
+      end
+
+      @request = request
+      @block = block
+    end
+
+    def match?(match_path, match_request)
+      path == match_path &&
+        (request.nil? || request == match_request) &&
+        (block.nil? || block.call(match_path))
+    end
+  end
+end

data/lib/proto_pharm/request_stub.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "proto_pharm/request_pattern"
+require "proto_pharm/response"
+require "proto_pharm/response_sequence"
+require "proto_pharm/errors"
+
+module ProtoPharm
+  class RequestStub
+    attr_reader :received_requests, :request_pattern, :response_sequence
+
+    delegate :path, to: :request_pattern, allow_nil: true
+
+    # @param path [String] gRPC path like /${service_name}/${method_name}
+    def initialize(path)
+      @request_pattern = RequestPattern.new(path)
+      @response_sequence = []
+      @received_requests = []
+    end
+
+    def with(request = nil, &block)
+      @request_pattern.with(request, &block)
+      self
+    end
+
+    def to_return(*values)
+      responses = [*values].flatten.map { |v| Response::Value.new(v) }
+      @response_sequence << ProtoPharm::ResponsesSequence.new(responses)
+      self
+    end
+
+    def to_raise(*exceptions)
+      responses = [*exceptions].flatten.map { |e| Response::ExceptionValue.new(e) }
+      @response_sequence << ProtoPharm::ResponsesSequence.new(responses)
+      self
+    end
+
+    def response
+      if @response_sequence.empty?
+        raise ProtoPharm::NoResponseError, "Must be set some values by using ProtoPharm::RequestStub#to_run"
+      elsif @response_sequence.size == 1
+        @response_sequence.first.next
+      else
+        if @response_sequence.first.end?
+          @response_sequence.shift
+        end
+
+        @response_sequence.first.next
+      end
+    end
+
+    def received!(request)
+      @received_requests << request
+    end
+
+    def received_count
+      received_requests.size
+    end
+
+    # @param path [String]
+    # @param request [Object]
+    # @return [Bool]
+    def match?(path, request)
+      @request_pattern.match?(path, request)
+    end
+  end
+end

data/lib/proto_pharm/response.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module Response
+    class ExceptionValue
+      attr_reader :exception
+
+      def initialize(exception)
+        @exception = case exception
+                     when String
+                       StandardError.new(exception)
+                     when Class
+                       exception.new("Exception from ProtoPharm")
+                     when Exception
+                       exception
+                     else
+                       raise ArgumentError.new(message: "Invalid exception class: #{exception.class}")
+                     end
+      end
+
+      def evaluate
+        raise @exception.dup
+      end
+    end
+
+    class Value
+      def initialize(value)
+        @value = value
+      end
+
+      def evaluate
+        @value.dup
+      end
+    end
+  end
+end

data/lib/proto_pharm/response_sequence.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class ResponsesSequence
+    attr_accessor :repeat
+    attr_reader :responses
+
+    def initialize(responses)
+      @repeat = 1
+      @responses = responses
+      @current = 0
+      @last = @responses.length - 1
+    end
+
+    def end?
+      @repeat == 0
+    end
+
+    def next
+      if @repeat > 0
+        response = @responses[@current]
+        next_pos
+        response
+      else
+        @responses.last
+      end
+    end
+
+    private
+
+    def next_pos
+      if @last == @current
+        @current = 0
+        @repeat -= 1
+      else
+        @current += 1
+      end
+    end
+  end
+end

data/lib/proto_pharm/rspec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "rspec"
+
+require_relative "../proto_pharm"
+
+require_relative "rspec/action_stub_proxy"
+require_relative "rspec/action_stub_builder"
+
+require_relative "rspec/dsl"
+require_relative "rspec/matchers/have_received_rpc"
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ProtoPharm.enable!
+  end
+
+  config.after(:suite) do
+    ProtoPharm.disable!
+  end
+
+  config.after(:each) do
+    ProtoPharm.reset!
+  end
+
+  config.include ProtoPharm::RSpec::DSL
+  config.include ProtoPharm::RSpec::Matchers
+end

data/lib/proto_pharm/rspec/action_stub_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module RSpec
+    class ActionStubBuilder
+      attr_accessor :grpc_service, :action_stub_proxy
+
+      delegate :rpc_action, :expectations, to: :action_stub_proxy
+
+      def initialize(grpc_service)
+        @grpc_service = grpc_service
+      end
+
+      def to(action_stub_proxy)
+        @action_stub_proxy = action_stub_proxy
+
+        ProtoPharm.stub_registry.register_request_stub(action_stub)
+      end
+
+      private
+
+      def action_stub
+        @action_stub ||= ActionStub.new(grpc_service, rpc_action).tap do |stub|
+          expectations.each do |ex|
+            if ex.kwargs.blank?
+              stub.public_send(ex.method, *ex.args)
+            elsif ex.args.blank?
+              stub.public_send(ex.method, **ex.kwargs)
+            else
+              stub.public_send(ex.method, *ex.args, **ex.kwargs)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/proto_pharm/rspec/action_stub_proxy.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module RSpec
+    class ActionStubProxy
+      attr_reader :rpc_action, :expectations
+
+      def initialize(rpc_action)
+        @rpc_action = rpc_action
+        @expectations = []
+      end
+
+      # Proxies ActionStub#with
+      def with(*args, **kwargs)
+        expectations << Expectation.new(:with, args, kwargs)
+
+        self
+      end
+
+      # Proxies ActionStub#to_return
+      def and_return(*args, **kwargs)
+        expectations << Expectation.new(:to_return, args, kwargs)
+
+        self
+      end
+
+      # Proxies ActionStub#to_raise
+      def and_raise(*args, **kwargs)
+        expectations << Expectation.new(:to_raise, args, kwargs)
+
+        self
+      end
+
+      # Proxies ActionStub#to_fail_with
+      def and_fail_with(*args, **kwargs)
+        expectations << Expectation.new(:to_fail_with, args, kwargs)
+
+        self
+      end
+
+      def and_fail
+        expectations << Expectation.new(:to_fail, [], {})
+
+        self
+      end
+
+      class Expectation
+        attr_reader :method, :args, :kwargs
+
+        def initialize(method, args, kwargs)
+          @method = method
+          @args = args
+          @kwargs = kwargs
+        end
+      end
+    end
+  end
+end

data/lib/proto_pharm/rspec/dsl.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module RSpec
+    module DSL
+      def allow_grpc_service(service)
+        ActionStubBuilder.new(service)
+      end
+
+      def receive_rpc(rpc_action)
+        ActionStubProxy.new(rpc_action)
+      end
+    end
+  end
+end

data/lib/proto_pharm/rspec/matchers/have_received_rpc.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module RSpec
+    module Matchers
+        extend ::RSpec::Matchers::DSL
+
+      matcher :have_received_rpc do |endpoint_reference| # rubocop:disable Metrics/BlockLength
+        include Introspection
+
+        attr_reader :service_reference, :endpoint_reference, :expected_proto, :expected_kwargs
+
+        description { "receive rpc #{endpoint_reference.inspect}#{with_parameters_description}" }
+
+        match do |service_reference|
+          @service_reference = service_reference
+          @endpoint_reference = endpoint_reference
+
+          raise RpcNotStubbedError, "RPC '#{grpc_path}' has not been stubbed. Stub it with stub_grpc_action before asserting." unless matching_request_stubs.any?
+
+          if expected_request_proto.blank?
+            expect(received_request_stubs.size).to be > 0
+          else
+            expect(received_request_stubs.flat_map(&:received_requests)).to include expected_request_proto
+          end
+        end
+
+        chain :with do |expected_proto = nil, **expected_kwargs|
+          raise ArgumentError, "assert only with proto or keyword arguments, not both" if expected_proto.present? && expected_kwargs.present?
+          raise ArgumentError, "cannot assert expected arguments multiple times in the same expectation" if (@expected_proto || @expected_kwargs).present?
+
+          @expected_proto = expected_proto
+          @expected_kwargs = expected_kwargs
+        end
+
+        private
+
+        delegate :grpc_path, :input_type, to: :endpoint
+
+        def endpoint
+          @endpoint ||= inspect_rpc(service_reference, endpoint_reference)
+        end
+
+        def received_request_stubs
+          matching_request_stubs.select { |stub| stub.received_count > 0 }
+        end
+
+        def matching_request_stubs
+          @matching_request_stubs ||= ProtoPharm.stub_registry.all_requests_matching(grpc_path, expected_request_proto)
+        end
+
+        def expected_request_proto
+          return if expected_proto.nil? && expected_kwargs.nil?
+
+          ensure_valid_proto_type!(expected_proto)
+
+          @expected_request_proto ||= expected_proto.presence || input_type.new(**expected_kwargs)
+        end
+
+        def ensure_valid_proto_type!(expected_proto)
+          raise InvalidProtoType, "Invalid proto type #{expected_proto.class} for #{grpc_path}, expected #{input_type}" if expected_proto.present? && expected_proto.class != input_type
+        end
+
+        def with_parameters_description
+          return if expected_request_proto.blank?
+
+          " with request #{expected_request_proto.inspect}"
+        end
+      end
+    end
+  end
+end