rspec-twirp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2f0ca51df29824ba1c1f2d1944ca94119501b3ec6366d09144f077bd99c92f2
-  data.tar.gz: 513bdae144ce76ecec652954cff14d3f8467037f6ec706ab67181be0ac036d61
+  metadata.gz: 2634a27685c93991e30afab03cf80cb5fe650047a2b91342eeadff69a7bb920e
+  data.tar.gz: f87529044e688df0b546e65cd527989842e983576bf62a70ea7aabf72d920d09
 SHA512:
-  metadata.gz: 4a4ebdce6d3d96826eca31484d1d4c22dc5b9e07fb109bea659315c5cfc7265f497f8d0a0bb498115e654ee139b232d6c6eb74bfd6da03a325a44411e636486c
-  data.tar.gz: 4342593db5f6e34db3fb0c3829a04ff1b8bc5806960e6b0efb144f650c38b80b08559b7f1f1a616a1c36712e2fb4a1c9cb963e457accd9451ac1ad3a6314096f
+  metadata.gz: 01e6fbab6f8649f6c8dbcc8df72269699e099eb1d924d6ff6656781d5339d060c6138e465a5c43b5ec2a9320614d7924bed1c79eac088c9c10f881d99c6588d7
+  data.tar.gz: ce566d5fd9e1e91cca7a100d205e4a1b0615c743f808383d5180bd007049aeaaaf1298bfe382ad6e0385404dd3c04fadb5980ac53fbc9de54c9aeee335b4834b

data/lib/rspec/twirp/error_matcher.rb

@@ -14,9 +14,22 @@ RSpec::Matchers.define :be_a_twirp_error do |*matchers, **meta_matcher|
 
         @fail_msg = "Expected #{actual} to have code: #{matcher.inspect}, found #{actual.code}"
         return false unless actual.code == matcher
+      when Integer
+        # match http status code
+
+        if code = Twirp::ERROR_CODES_TO_HTTP_STATUS.key(matcher)
+          @fail_msg = "Expected #{actual} to have status: #{matcher}, found #{actual.code}"
+          return false unless actual.code == code
+        else
+          raise ArgumentError, "invalid error status code: #{matcher}"
+        end
+      when Twirp::Error
+        # match instance
+
+        @fail_msg = "Expected #{actual} to equal #{matcher}"
+        return false unless values_match?(matcher.to_h, actual.to_h)
       else
         # match msg
-
         @fail_msg = "Expected #{actual} to have msg: #{matcher.inspect}, found #{actual.msg}"
         return false unless values_match?(matcher, actual.msg)
       end

data/lib/rspec/twirp/helpers.rb

@@ -0,0 +1,16 @@
+require "rspec/twirp/mock_client"
+require "rspec/twirp/mock_connection"
+
+module RSpec
+  module Twirp
+    module Helpers
+      def mock_twirp_connection(...)
+        RSpec::Twirp.mock_connection(...)
+      end
+
+      def mock_twirp_client(...)
+        RSpec::Twirp.mock_client(...)
+      end
+    end
+  end
+end

data/lib/rspec/twirp/make_request_matcher.rb

@@ -0,0 +1,169 @@
+# expect {
+#   do_the_thing
+# }.to make_twirp_request(client | service | rpc_method).with(request | attrs)
+#
+# expect(client).to make_twirp_request(rpc_method).with(...)
+
+RSpec::Matchers.define :make_twirp_request do |*matchers|
+  chain :with do |input_matcher = nil|
+    @input_matcher = if input_matcher
+      if input_matcher.is_a?(Google::Protobuf::MessageExts)
+        defaults = input_matcher.class.new.to_h
+        hash_form = input_matcher.to_h.reject {|k,v| v == defaults[k] }
+
+        ->(input) do
+          if input.is_a?(Google::Protobuf::MessageExts)
+            values_match?(input_matcher, input)
+          else
+            values_match?(include(**hash_form), input.to_h)
+          end
+        end
+      elsif input_matcher.is_a?(Class) && input_matcher < Google::Protobuf::MessageExts
+        ->(input) { values_match?(be_a(input_matcher), input) }
+      elsif input_matcher.is_a?(Hash)
+        ->(input) { values_match?(include(**input_matcher), input.to_h) }
+      else
+        raise TypeError, "Expected an input_matcher of type `Google::Protobuf::MessageExts`, found #{input_matcher.class}"
+      end
+    end
+  end
+
+  chain(:and_call_original) { @and_call_original = true }
+  chain(:and_return) do |arg|
+    @and_return = case arg
+    when Google::Protobuf::MessageExts
+      Twirp::ClientResp.new(arg, nil)
+    when Twirp::Error
+      Twirp::ClientResp.new(nil, arg)
+    when Class
+      if arg < Google::Protobuf::MessageExts
+        Twirp::ClientResp.new(arg.new, nil)
+      end
+    end
+
+    unless @and_return
+      raise TypeError, "Expected type `Google::Protobuf::MessageExts`, found #{arg}"
+    end
+  end
+
+  supports_block_expectations
+
+  match do |client_or_block|
+    @input_matcher ||= ->(*){ true }
+
+    if @and_call_original && @and_return
+      raise ArgumentError, "use `and_call_original` or `and_return`, but not both"
+    end
+
+    if client_or_block.is_a? Proc
+      RSpec::Mocks.with_temporary_scope do
+        match_block_request(client_or_block, matchers)
+      end
+    elsif client_or_block.is_a?(Twirp::Client)
+      match_client_request(client_or_block, matchers)
+    else
+      raise ArgumentError, "Expected Twirp::Client or block, found: #{client_or_block}"
+    end
+  end
+
+  def match_block_request(block, matchers)
+    expected_client = be_a(Twirp::Client)
+    expected_service = anything
+    expected_rpc_name = anything
+
+    matchers.each do |matcher|
+      case matcher
+      when Twirp::Client
+        expected_client = be(matcher)
+      when Class
+        if matcher <= Twirp::Client
+          expected_client = be_a(matcher)
+        elsif matcher <= Twirp::Service
+          expected_service = matcher.service_full_name
+        else
+          raise TypeError
+        end
+      when String
+        expected_rpc_name = be(matcher.to_sym)
+      when Symbol
+        expected_rpc_name = be(matcher)
+      when Regexp
+        expected_rpc_name = matcher
+      end
+    end
+
+    @twirp_request_made = false
+
+    # stub pre-existing client instances
+    ObjectSpace.each_object(Twirp::Client) do |client|
+      if expected_client === client && (expected_service === client.class.service_full_name)
+        stub_client(client, expected_rpc_name)
+      end
+    end
+
+    # stub future client instances
+    ObjectSpace.each_object(Twirp::Client.singleton_class).select do |obj|
+      obj < Twirp::Client && obj != Twirp::ClientJSON
+    end.each do |client_type|
+      next unless client_type.name && expected_service === client_type.service_full_name
+
+      allow(client_type).to receive(:new).and_wrap_original do |orig, *args, **kwargs|
+        orig.call(*args, **kwargs).tap do |client|
+          if expected_client === client
+            stub_client(client, expected_rpc_name)
+          end
+        end
+      end
+    end
+
+    block.call
+
+    @twirp_request_made
+  end
+
+  def stub_client(client, rpc_matcher)
+    allow(client).to receive(:rpc).and_wrap_original do |orig, rpc_name, input, req_opts|
+      if values_match?(rpc_matcher, rpc_name) && @input_matcher.call(input)
+        @twirp_request_made = true
+      end
+
+      if @and_call_original
+        orig.call(rpc_name, input, req_opts)
+      elsif @and_return
+        @and_return
+      end
+    end
+  end
+
+  def match_client_request(client, matchers)
+    rpc_name = matchers.first.to_sym if matchers.any?
+
+    if rpc_name
+      rpc_info = client.class.rpcs.values.find do |x|
+        x[:rpc_method] == rpc_name || x[:ruby_method] == rpc_name
+      end
+
+      raise ArgumentError, "invalid rpc method: #{rpc_name}" unless rpc_info
+
+      msg = "Expected #{client} to make a twirp request to #{rpc_name}"
+      rpc_matcher = eq(rpc_info[:rpc_method])
+    else
+      rpc_info = nil
+      msg = "Expected #{client} to make a twirp request"
+      rpc_matcher = anything
+    end
+
+    expect(client).to receive(:rpc) do |rpc_name, input, req_opts|
+      expect(rpc_name).to match(rpc_matcher), msg
+      expect(@input_matcher.call(input)).to be(true), msg
+    end
+  end
+
+  description do
+    "make a Twirp request"
+  end
+
+  failure_message { @fail_msg || super() }
+end
+
+RSpec::Matchers.alias_matcher :make_a_twirp_request, :make_twirp_request

data/lib/rspec/twirp/message_matcher.rb

@@ -0,0 +1,61 @@
+RSpec::Matchers.define :be_a_twirp_message do |type = nil, **attrs|
+  match do |actual|
+    # ensure type is a valid twirp message type
+    if type && !(type < Google::Protobuf::MessageExts)
+      raise TypeError, "Expected `type` to be a Google::Protobuf::MessageExts, found: #{type}"
+    end
+
+    @fail_msg = "Expected a Twirp message, found #{actual}"
+    return false unless actual.is_a?(Google::Protobuf::MessageExts)
+
+    # match expected message type
+    @fail_msg = "Expected a Twirp message of type #{type}, found #{actual.class}"
+    return false if type && actual.class != type
+
+    return true if attrs.empty?
+
+    # sanity check inputs
+    validate_types(attrs, actual.class)
+
+    # match attributes which are present
+    attrs.each do |attr_name, expected_attr|
+      actual_attr = actual.send(attr_name)
+
+      @fail_msg = "Expected #{actual} to have #{attr_name}: #{expected_attr.inspect}, found #{actual_attr}"
+      return false unless values_match?(expected_attr, actual_attr)
+    end
+
+    true
+  end
+
+  description do
+    type ? "a #{type} Twirp message" : "a Twirp message"
+  end
+
+  failure_message { @fail_msg }
+
+  private
+
+  def validate_types(attrs, klass)
+    # check names and types of attrs by constructing an actual proto object
+    discrete_attrs = attrs.transform_values do |attr|
+      case attr
+      when Regexp
+        attr.inspect
+      when Range
+        attr.first
+      when RSpec::Matchers::BuiltIn::BaseMatcher
+        # no good substitute, so skip attr and hope for the best
+        nil
+      else
+        attr
+      end
+    end.compact
+
+    klass.new(**discrete_attrs)
+  rescue Google::Protobuf::TypeError => e
+    raise TypeError, e.message
+  end
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_message, :be_a_twirp_message

data/lib/rspec/twirp/mock_client.rb

@@ -0,0 +1,59 @@
+# mock_twirp_client(Twirp::Client, { rpc => response } )
+
+module RSpec
+  module Twirp
+    def mock_client(client, **responses)
+      unless client.is_a?(Class) && client < ::Twirp::Client
+        raise ArgumentError, "Expected Twirp::Client, found: #{client.class}"
+      end
+
+      rpcs = client.rpcs.values
+
+      client_instance = client.new(mock_connection)
+
+      unless responses.empty?
+        # validate input
+        responses.transform_keys! do |rpc_name|
+          rpc_info = rpcs.find do |x|
+            x[:rpc_method] == rpc_name || x[:ruby_method] == rpc_name
+          end
+
+          unless rpc_info
+            raise ArgumentError, "invalid rpc method: #{rpc_name}"
+          end
+
+          rpc_info[:rpc_method]
+        end
+
+        # repackage responses
+        client_responses = {}
+        responses.each do |rpc_method, response|
+          if response.is_a?(Hash)
+            response = client.rpcs[rpc_method.to_s][:output_class].new(**response)
+          end
+
+          client_responses[rpc_method] = RSpec::Twirp.generate_client_response(response)
+        end
+
+        # mock
+        rpcs.each do |info|
+          response = client_responses[info[:rpc_method]]
+
+          if response
+            allow(client_instance).to receive(:rpc).with(
+              info[:rpc_method],
+              any_args,
+            ).and_return(response)
+          else
+            allow(client_instance).to receive(:rpc).with(
+              info[:rpc_method],
+              any_args,
+            ).and_raise(::RSpec::Mocks::MockExpectationError)
+          end
+        end
+      end
+
+      client_instance
+    end
+  end
+end

data/lib/rspec/twirp/mock_connection.rb

@@ -0,0 +1,54 @@
+# GoodbyeClient.new(mock_twirp_connection)
+
+module RSpec
+  module Twirp
+    extend self
+
+    def mock_connection(response = nil)
+      if block_given? && response
+        raise ArgumentError, "can not specify both block and response"
+      end
+
+      Faraday.new do |conn|
+        conn.adapter :test do |stub|
+          stub.post(/.*/) do |env|
+            response = yield(env) if block_given?
+            response ||= {}
+
+            if response.is_a?(Hash)
+              # create default response
+
+              # determine which client would make this rpc call
+              service_full_name, rpc_method = env.url.path.split("/").last(2)
+              client = ObjectSpace.each_object(::Twirp::Client.singleton_class).find do |client|
+                next unless client.name
+
+                client.service_full_name == service_full_name && client.rpcs.key?(rpc_method)
+              end
+
+              unless client
+                raise TypeError, "could not determine Twirp::Client for: #{env.url.path}"
+              end
+
+              response = client.rpcs[rpc_method][:output_class].new(**response)
+            end
+
+            res = RSpec::Twirp.generate_client_response(response)
+
+            if res.data
+              status = 200
+              headers = { "Content-Type" => ::Twirp::Encoding::PROTO }
+              body = res.data.to_proto
+            else
+              status = ::Twirp::ERROR_CODES_TO_HTTP_STATUS[res.error.code]
+              headers = { "Content-Type" => ::Twirp::Encoding::JSON } # errors are always JSON
+              body = ::Twirp::Encoding.encode_json(res.error.to_h)
+            end
+
+            [ status, headers, body ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/twirp/response_matcher.rb

@@ -1,30 +1,50 @@
 RSpec::Matchers.define :be_a_twirp_response do |type = nil, **attrs|
+  chain :with_error do |*matchers, **meta_matchers|
+    # code, msg, meta
+    @with_error = [ matchers, meta_matchers ]
+  end
+
   match do |actual|
-    # ensure type is a valid twirp response type
-    if type && !(type < Google::Protobuf::MessageExts)
-      raise ArgumentError, "Expected `type` to be a Twirp response, found: #{type}"
+    # ensure type is a valid twirp request type
+    if type
+      if type.is_a?(Google::Protobuf::MessageExts)
+        unless attrs.empty?
+          raise ArgumentError, "Expected Google::Protobuf::MessageExts instance or attrs, but not both"
+        end
+
+        attrs = type.to_h
+        type = type.class
+      elsif !(type < Google::Protobuf::MessageExts)
+        raise ArgumentError, "Expected `type` to be a Google::Protobuf::MessageExts, found: #{type}"
+      end
     end
 
-    @fail_msg = "Expected a Twirp response, found #{actual}"
-    return false unless actual.is_a?(Google::Protobuf::MessageExts)
+    @fail_msg = "Expected a Twirp::ClientResp, found #{actual}"
+    return false unless actual.is_a?(Twirp::ClientResp)
 
     # match expected response type
-    @fail_msg = "Expected a Twirp response of type #{type}, found #{actual.class}"
-    return false if type && actual.class != type
+    @fail_msg = "Expected a Twirp::ClientResp of type #{type}, found #{actual.data&.class}"
+    return false if type && actual.data&.class != type
 
-    return true if attrs.empty?
+    if @with_error
+      unless attrs.empty?
+        raise ArgumentError, "match data attributes or error, but not both"
+      end
 
-    RSpec::Twirp.validate_types(attrs, actual.class)
+      @fail_msg = "Expected #{actual} to have an error, but found none"
+      return false unless actual.error
 
-    # match attributes which are present
-    attrs.each do |attr_name, expected_attr|
-      actual_attr = actual.send(attr_name)
+      matchers, meta_matchers = @with_error
+      expect(actual.error).to be_a_twirp_error(*matchers, **meta_matchers)
+    else
+      @fail_msg = "Expected #{actual} to have data, but found none"
+      return false unless actual.data
 
-      @fail_msg = "Expected #{actual} to have #{attr_name}: #{expected_attr.inspect}, found #{actual_attr}"
-      return false unless values_match?(expected_attr, actual_attr)
+      expect(actual.data).to be_a_twirp_message(**attrs)
     end
-
-    true
+  rescue RSpec::Expectations::ExpectationNotMetError => err
+    @fail_msg = err.message
+    false
   end
 
   description do

data/lib/rspec/twirp/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Twirp
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/rspec/twirp.rb

@@ -1,32 +1,54 @@
-require "rspec/expectations"
-require "rspec/twirp/client_response_matcher"
+require "google/protobuf"
+require "rspec"
+require "twirp"
+
+require "rspec/twirp/helpers"
+require "rspec/twirp/make_request_matcher"
 require "rspec/twirp/error_matcher"
-require "rspec/twirp/request_matcher"
+require "rspec/twirp/message_matcher"
 require "rspec/twirp/response_matcher"
 
 module RSpec
   module Twirp
-    extend self
+    extend RSpec::Mocks::ExampleMethods
+
+    # private
 
-    def validate_types(attrs, klass)
-      # sanity check type and names of attrs by constructing an actual
-      # proto object
-      discrete_attrs = attrs.transform_values do |attr|
-        case attr
-        when Regexp
-          attr.inspect
-        when Range
-          attr.first
-        when RSpec::Matchers::BuiltIn::BaseMatcher
-          nil
+    def generate_client_response(arg)
+      res = case arg
+      when Google::Protobuf::MessageExts, ::Twirp::Error
+        arg
+      when Class
+        if arg < Google::Protobuf::MessageExts
+          arg.new
+        else
+          raise TypeError, "Expected type `Google::Protobuf::MessageExts`, found: #{arg}"
+        end
+      when Symbol
+        if ::Twirp::Error.valid_code?(arg)
+          ::Twirp::Error.new(arg, arg)
         else
-          attr
+          raise ArgumentError, "invalid error code: #{arg}"
         end
-      end.compact
+      when Integer
+        if code = ::Twirp::ERROR_CODES_TO_HTTP_STATUS.key(arg)
+          ::Twirp::Error.new(code, code)
+        else
+          raise ArgumentError, "invalid error code: #{arg}"
+        end
+      else
+        raise NotImplementedError
+      end
 
-      klass.new(**discrete_attrs)
-    rescue Google::Protobuf::TypeError => e
-      raise TypeError, e.message
+      if res.is_a?(Google::Protobuf::MessageExts)
+        ::Twirp::ClientResp.new(res, nil)
+      else
+        ::Twirp::ClientResp.new(nil, res)
+      end
     end
   end
 end
+
+RSpec.configure do |config|
+  config.include(RSpec::Twirp::Helpers)
+end

data/spec/error_spec.rb

@@ -13,6 +13,18 @@ describe "be_a_twirp_error" do
     }.to fail_with /to be a Twirp::Error/
   end
 
+  describe "status matches" do
+    it { is_expected.to be_a_twirp_error(404) }
+
+    it { expect { is_expected.to be_a_twirp_error(400) }.to fail }
+
+    it "catches erroneous codes" do
+      expect {
+        is_expected.to be_a_twirp_error(123)
+      }.to raise_error(ArgumentError, /invalid error/)
+    end
+  end
+
   describe "code matches" do
     it { is_expected.to be_a_twirp_error(:not_found) }
 
@@ -64,6 +76,24 @@ describe "be_a_twirp_error" do
     end
   end
 
+  describe "instance matches" do
+    it "matches similar looking instances" do
+      error = Twirp::Error.new(code, msg, meta)
+      is_expected.to be_a_twirp_error(error)
+    end
+
+    it "catches mismatches" do
+      # no meta
+      expect {
+        is_expected.to be_a_twirp_error(Twirp::Error.not_found("Not Found"))
+      }.to fail
+
+      expect {
+        is_expected.to be_a_twirp_error(Twirp::Error.internal("boom"))
+      }.to fail
+    end
+  end
+
   describe "multi matches" do
     it { is_expected.to be_a_twirp_error(:not_found, "Not Found") }
     it { is_expected.to be_a_twirp_error(:not_found, /Not/) }