proto_pharm 0.6.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require_relative "../lib/proto_pharm"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/bin/regen_examples

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+grpc_tools_ruby_protoc \
+		-I ./spec/examples/hello \
+		--ruby_out=./spec/examples/hello \
+		--grpc_out=./spec/examples/hello \
+		spec/examples/hello/hello.proto

data/bin/release

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/proto_pharm/version"
+
+current_branch = `git rev-parse --abbrev-ref HEAD`.strip
+
+unless current_branch == "master" || ProtoPharm::VERSION =~ %r{\.pre\d*\z}
+  puts "Can only release from the master branch 😿"
+  exit 1
+end
+
+system "git tag v#{ProtoPharm::VERSION}"
+
+system "git push --tag"
+
+system "git push fury #{current_branch}:master"

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/proto_pharm.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+require "grpc"
+
+require_relative "proto_pharm/version"
+require_relative "proto_pharm/configuration"
+
+require_relative "proto_pharm/introspection"
+require_relative "proto_pharm/stub_components/failure_response"
+
+require_relative "proto_pharm/adapter"
+require_relative "proto_pharm/grpc_stub_adapter"
+require_relative "proto_pharm/grpc_stub_adapter/mock_stub"
+
+require_relative "proto_pharm/stub_registry"
+require_relative "proto_pharm/api"
+
+module ProtoPharm
+  extend ProtoPharm::Api
+
+  class << self
+    delegate :enable!, :disable!, :enabled?, to: :adapter
+
+    def reset!
+      ProtoPharm.stub_registry.reset!
+    end
+
+    def stub_registry
+      @stub_registry ||= ProtoPharm::StubRegistry.new
+    end
+
+    def adapter
+      @adapter ||= Adapter.new
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+  end
+
+  # Hook into GRPC::ClientStub
+  # https://github.com/grpc/grpc/blob/bec3b5ada2c5e5d782dff0b7b5018df646b65cb0/src/ruby/lib/grpc/generic/service.rb#L150-L186
+  GRPC::ClientStub.prepend GrpcStubAdapter::MockStub
+end
+
+GrpcMock = ActiveSupport::Deprecation::DeprecatedConstantProxy.new("GrpcMock", "ProtoPharm")

data/lib/proto_pharm/action_stub.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/blank"
+
+module ProtoPharm
+  class ActionStub < RequestStub
+    include Introspection
+    include StubComponents::FailureResponse
+
+    attr_reader :service, :action
+
+    # @param service [GRPC::GenericService] gRPC service class representing the the service being stubbed
+    # @param action [String, Symbol] name of the endpoint being stubbed
+    def initialize(service, action)
+      @service = service
+      @action = action
+
+      super(grpc_path)
+    end
+
+    # @param proto [Object] request proto object
+    # @param request_kwargs [Hash] parameters for request
+    def with(proto = nil, **request_kwargs)
+      super(endpoint.normalize_request_proto(proto, **request_kwargs))
+    end
+
+    # @param proto [Object] response proto object
+    # @param request_kwargs [Hash] parameters to respond with
+    def to_return(proto = nil, **request_kwargs)
+      super(endpoint.normalize_response_proto(proto, **request_kwargs))
+    end
+
+    def received!(request)
+      @received_requests << request
+    end
+
+    def received_count
+      received_requests.size
+    end
+
+    def match?(match_path, match_request)
+      # If paths don't match, don't try to cast the request object
+      super unless grpc_path == match_path
+
+      # If paths match, cast the given request object to the expected proto
+      super(match_path, endpoint.normalize_request_proto(match_request))
+    end
+
+    private
+
+    delegate :grpc_path, :input_type, :output_type, to: :endpoint
+
+    def endpoint
+      @endpoint ||= inspect_rpc(service, action)
+    end
+  end
+end

data/lib/proto_pharm/adapter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class Adapter
+    delegate :enable!, :disable!, :enabled?, to: :adapter
+
+    private
+
+    def adapter
+      @adapter ||= GrpcStubAdapter.new
+    end
+  end
+end

data/lib/proto_pharm/api.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "proto_pharm/request_stub"
+require "proto_pharm/action_stub"
+require "proto_pharm/matchers/request_including_matcher"
+
+module ProtoPharm
+  module Api
+    # @param path [String]
+    def stub_request(path)
+      ProtoPharm.stub_registry.register_request_stub(ProtoPharm::RequestStub.new(path))
+    end
+
+    def stub_grpc_action(service, rpc_action)
+      ProtoPharm.stub_registry.register_request_stub(ProtoPharm::ActionStub.new(service, rpc_action))
+    end
+
+    # @param values [Hash]
+    def request_including(values)
+      ProtoPharm::Matchers::RequestIncludingMatcher.new(values)
+    end
+
+    def disable_net_connect!
+      ProtoPharm.config.allow_net_connect = false
+    end
+
+    def allow_net_connect!
+      ProtoPharm.config.allow_net_connect = true
+    end
+  end
+end

data/lib/proto_pharm/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class Configuration
+    attr_accessor :allow_net_connect
+
+    def initialize
+      @allow_net_connect = true
+    end
+  end
+end

data/lib/proto_pharm/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class Error < StandardError; end
+
+  class NetConnectNotAllowedError < Error
+    def initialize(sigunature)
+      super("Real gRPC connections are disabled. #{sigunature} is requested")
+    end
+  end
+
+  class NoResponseError < Error
+    def initialize(msg)
+      super("There is no response: #{msg}")
+    end
+  end
+
+  class InvalidProtoType < Error; end
+  class RpcNotFoundError < Error; end
+  class RpcNotStubbedError < Error; end
+end

data/lib/proto_pharm/grpc_stub_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "operation_stub"
+
+module ProtoPharm
+  class GrpcStubAdapter
+    delegate :enable!, :disable!, :enabled?, to: :class
+
+    class << self
+      def disable!
+        @enabled = false
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def enabled?
+        @enabled
+      end
+    end
+  end
+end

data/lib/proto_pharm/grpc_stub_adapter/mock_stub.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  class GrpcStubAdapter
+    module MockStub
+      def request_response(method, request, *args, return_op: false, **opts)
+        return super unless ProtoPharm.enabled?
+
+        request_stub = ProtoPharm.stub_registry.find_request_matching(method, request)
+
+        if request_stub
+          operation = OperationStub.new(metadata: opts[:metadata]) do
+            request_stub.received!(request)
+            request_stub.response.evaluate
+          end
+
+          return_op ? operation : operation.execute
+        elsif ProtoPharm.config.allow_net_connect
+          super
+        else
+          raise NetConnectNotAllowedError, method
+        end
+      end
+
+      # TODO
+      def client_streamer(method, requests, *args)
+        return super unless ProtoPharm.enabled?
+
+        r = requests.to_a       # FIXME: this may not work
+        request_stub = ProtoPharm.stub_registry.find_request_matching(method, r)
+
+        if request_stub
+          request_stub.received!(requests)
+          request_stub.response.evaluate
+        elsif ProtoPharm.config.allow_net_connect
+          super
+        else
+          raise NetConnectNotAllowedError, method
+        end
+      end
+
+      def server_streamer(method, request, *args)
+        return super unless ProtoPharm.enabled?
+
+        request_stub = ProtoPharm.stub_registry.find_request_matching(method, request)
+
+        if request_stub
+          request_stub.received!(request)
+          request_stub.response.evaluate
+        elsif ProtoPharm.config.allow_net_connect
+          super
+        else
+          raise NetConnectNotAllowedError, method
+        end
+      end
+
+      def bidi_streamer(method, requests, *args)
+        return super unless ProtoPharm.enabled?
+
+        r = requests.to_a       # FIXME: this may not work
+        request_stub = ProtoPharm.stub_registry.find_request_matching(method, r)
+
+        if request_stub
+          request_stub.received!(requests)
+          request_stub.response.evaluate
+        elsif ProtoPharm.config.allow_net_connect
+          super
+        else
+          raise NetConnectNotAllowedError, method
+        end
+      end
+    end
+  end
+end

data/lib/proto_pharm/introspection.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "introspection/rpc_inspector"
+require_relative "introspection/service_resolver"
+
+module ProtoPharm
+  module Introspection
+    private
+
+    def resolve_service(service)
+      Introspection::ServiceResolver.resolve(service)
+    end
+
+    def inspect_rpc(service, endpoint)
+      Introspection::RpcInspector.new(service, endpoint)
+    end
+  end
+end

data/lib/proto_pharm/introspection/rpc_inspector.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module Introspection
+    class RpcInspector
+      attr_reader :grpc_service, :endpoint_name
+
+      delegate :service_name, :rpc_descs, to: :grpc_service
+
+      def initialize(service, endpoint_name)
+        @grpc_service = ServiceResolver.resolve(service)
+
+        @endpoint_name = endpoint_name
+      end
+
+      def normalize_request_proto(proto = nil, **kwargs)
+        cast_proto(input_type, proto, **kwargs)
+      end
+
+      def normalize_response_proto(proto = nil, **kwargs)
+        cast_proto(output_type, proto, **kwargs)
+      end
+
+      def normalized_rpc_name
+        @normalized_rpc_name ||= endpoint_name.to_s.camelize.to_sym
+      end
+
+      def rpc_desc
+        @rpc_desc ||= rpc_descs[normalized_rpc_name].tap do |endpoint|
+          raise RpcNotFoundError, "Service #{service_name} does not implement '#{normalized_rpc_name}'" if endpoint.blank?
+        end
+      end
+
+      def grpc_path
+        @grpc_path ||= "/#{service_name}/#{normalized_rpc_name}"
+      end
+
+      def input_type
+        rpc_desc.input
+      end
+
+      def output_type
+        rpc_desc.output
+      end
+
+      private
+
+      def cast_proto(proto_class, proto = nil, **kwargs)
+        return proto_class.new(**kwargs) if proto.blank?
+        return proto_class.new(proto) if proto.respond_to?(:to_hash)
+
+        raise InvalidProtoType, "Invalid proto type #{proto.class} for #{grpc_path}, expected #{proto_class}" unless proto.class == proto_class
+
+        proto
+      end
+    end
+  end
+end

data/lib/proto_pharm/introspection/service_resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ProtoPharm
+  module Introspection
+    module ServiceResolver
+      class InvalidGRPCServiceError < StandardError; end
+
+      class << self
+        def resolve(service)
+          raise InvalidGRPCServiceError, "Not a valid gRPC service module: #{service.inspect}" unless service.respond_to?(:const_defined?)
+
+          service.const_defined?(:Service) ? service::Service : service
+        end
+      end
+
+      # We'll need this later
+      # attr_reader :service
+
+      # def initialize(service)
+      #   @service = service
+      # end
+    end
+  end
+end