rspec-twirp 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2634a27685c93991e30afab03cf80cb5fe650047a2b91342eeadff69a7bb920e
-  data.tar.gz: f87529044e688df0b546e65cd527989842e983576bf62a70ea7aabf72d920d09
+  metadata.gz: 7a9027f86450d9e045705304d1d8e590b51a733269938e83ca5ae098a90018d4
+  data.tar.gz: dca42845c93b814878cf24842320583ddf6dbce3b0d266cd897a58500cf31a31
 SHA512:
-  metadata.gz: 01e6fbab6f8649f6c8dbcc8df72269699e099eb1d924d6ff6656781d5339d060c6138e465a5c43b5ec2a9320614d7924bed1c79eac088c9c10f881d99c6588d7
-  data.tar.gz: ce566d5fd9e1e91cca7a100d205e4a1b0615c743f808383d5180bd007049aeaaaf1298bfe382ad6e0385404dd3c04fadb5980ac53fbc9de54c9aeee335b4834b
+  metadata.gz: 98d362457d71269cf64bffa1fe0b1fe00e173fe68df88e12cf0af20aa1030d518e031415d005050209b070095c36a6eac454e1bdba740661a090ce3be90cfa15
+  data.tar.gz: a0923b782b8568198fb267cd1e3bc6192bb032b0a7e746be478a4e8d66317ccc81652487f6f3b442847c6c2946b2e398f25b60682c0cc6b1c794c556837d0978

data/lib/rspec/twirp/error_matcher.rb

@@ -1,43 +1,59 @@
 RSpec::Matchers.define :be_a_twirp_error do |*matchers, **meta_matcher|
   match do |actual|
-    @fail_msg = "Expected #{actual} to be a Twirp::Error, found #{actual.class}"
+    @fail_msg = "Expected `#{actual}` to be a Twirp::Error, found: #{actual.class}"
     return false unless actual.is_a?(Twirp::Error)
 
-    matchers.each do |matcher|
+    @expected = {}
+    @actual = {}
+
+    matched = matchers.all? do |matcher|
       case matcher
       when Symbol
         # match code
+        @expected[:code] = matcher
+        @actual[:code] = actual.code
 
         unless Twirp::Error.valid_code?(matcher)
           raise ArgumentError, "invalid error code: #{matcher.inspect}"
         end
 
-        @fail_msg = "Expected #{actual} to have code: #{matcher.inspect}, found #{actual.code}"
-        return false unless actual.code == matcher
+        @fail_msg = "Expected #{actual} to have code `#{matcher.inspect}`, found: #{actual.code.inspect}"
+        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
+          @expected[:code] = code
+          @actual[:code] = actual.code
+
+          actual_status = Twirp::ERROR_CODES_TO_HTTP_STATUS[actual.code]
+
+          @fail_msg = "Expected #{actual} to have status #{matcher} / #{code.inspect}, found: #{actual_status} / #{actual.code.inspect}"
+          actual.code == code
         else
           raise ArgumentError, "invalid error status code: #{matcher}"
         end
       when Twirp::Error
         # match instance
+        @expected = matcher.to_h
+        @actual = actual.to_h
 
         @fail_msg = "Expected #{actual} to equal #{matcher}"
-        return false unless values_match?(matcher.to_h, actual.to_h)
+        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)
+        @expected[:msg] = matcher
+        @actual[:msg] = actual.msg
+
+        @fail_msg = "Expected #{actual} to have msg #{matcher.inspect}, found: #{actual.msg.inspect}"
+        values_match?(matcher, actual.msg)
       end
     end
 
     # match meta
     unless meta_matcher.empty?
-      @cur_match = { meta: meta_matcher }
+      @expected[:meta] = meta_matcher
+      @actual[:meta] = actual.meta
 
       # sanity check...values must be Strings or Regexp
       discrete_attrs = meta_matcher.transform_values do |attr|
@@ -46,10 +62,10 @@ RSpec::Matchers.define :be_a_twirp_error do |*matchers, **meta_matcher|
       actual.send(:validate_meta, discrete_attrs)
 
       @fail_msg = "Expected #{actual} to have meta: #{meta_matcher.inspect}, found #{actual.meta}"
-      return false unless values_match?(meta_matcher, actual.meta)
+      matched &= values_match?(meta_matcher, actual.meta)
     end
 
-    true
+    matched
   end
 
   description do
@@ -57,6 +73,12 @@ RSpec::Matchers.define :be_a_twirp_error do |*matchers, **meta_matcher|
   end
 
   failure_message { @fail_msg }
+
+  diffable
+
+  def expected
+    @expected
+  end
 end
 
 RSpec::Matchers.alias_matcher :a_twirp_error, :be_a_twirp_error

data/lib/rspec/twirp/message_matcher.rb

@@ -1,61 +1,2 @@
-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
+RSpec::Matchers.alias_matcher :be_a_twirp_message, :be_a_protobuf
+RSpec::Matchers.alias_matcher :a_twirp_message, :a_protobuf

data/lib/rspec/twirp/response_matcher.rb

@@ -1,31 +1,13 @@
-RSpec::Matchers.define :be_a_twirp_response do |type = nil, **attrs|
+RSpec::Matchers.define :be_a_twirp_response do |**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 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::ClientResp, found #{actual}"
     return false unless actual.is_a?(Twirp::ClientResp)
 
-    # match expected response type
-    @fail_msg = "Expected a Twirp::ClientResp of type #{type}, found #{actual.data&.class}"
-    return false if type && actual.data&.class != type
-
     if @with_error
       unless attrs.empty?
         raise ArgumentError, "match data attributes or error, but not both"
@@ -48,7 +30,7 @@ RSpec::Matchers.define :be_a_twirp_response do |type = nil, **attrs|
   end
 
   description do
-    type ? "a #{type} Twirp response" : "a Twirp response"
+    "a Twirp response"
   end
 
   failure_message { @fail_msg }

data/lib/rspec/twirp/version.rb

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

data/lib/rspec/twirp.rb

@@ -1,54 +1,9 @@
 require "google/protobuf"
 require "rspec"
+require "rspec/protobuf"
 require "twirp"
 
-require "rspec/twirp/helpers"
-require "rspec/twirp/make_request_matcher"
 require "rspec/twirp/error_matcher"
 require "rspec/twirp/message_matcher"
 require "rspec/twirp/response_matcher"
-
-module RSpec
-  module Twirp
-    extend RSpec::Mocks::ExampleMethods
-
-    # private
-
-    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
-          raise ArgumentError, "invalid error code: #{arg}"
-        end
-      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
-
-      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
+require "rspec/twirp/version"

data/spec/error_spec.rb

@@ -1,5 +1,5 @@
 describe "be_a_twirp_error" do
-  subject { Twirp::Error.new(code, msg, meta) }
+  subject(:error) { Twirp::Error.new(code, msg, meta) }
 
   let(:code) { :not_found }
   let(:msg) { "Not Found" }
@@ -7,6 +7,10 @@ describe "be_a_twirp_error" do
 
   it { is_expected.to be_a_twirp_error }
 
+  it "is composable" do
+    expect(e: error).to include(e: a_twirp_error)
+  end
+
   it "catches type mismatches" do
     expect {
       expect(Object).to be_a_twirp_error
@@ -16,7 +20,18 @@ describe "be_a_twirp_error" do
   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 mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(400)
+      }.to fail_including(
+        "to have status 400",
+        "found: 404",
+
+        # diff
+        "-:code => :invalid_argument,",
+        "+:code => :not_found,",
+      )
+    end
 
     it "catches erroneous codes" do
       expect {
@@ -28,7 +43,18 @@ describe "be_a_twirp_error" do
   describe "code matches" do
     it { is_expected.to be_a_twirp_error(:not_found) }
 
-    it { expect { is_expected.to be_a_twirp_error(:unknown) }.to fail }
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(:unknown)
+      }.to fail_including(
+        "to have code `:unknown`",
+        "found: :not_found",
+
+        # diff
+        "-:code => :unknown,",
+        "+:code => :not_found,",
+      )
+    end
 
     it "catches erroneous codes" do
       expect {
@@ -47,11 +73,22 @@ describe "be_a_twirp_error" do
     it "catches mismatches" do
       expect {
         is_expected.to be_a_twirp_error("Not")
-      }.to fail_with /to have msg: "Not"/
+      }.to fail_including(
+        'to have msg "Not"',
+        'found: "Not Found"',
+
+        # diff
+        '-:msg => "Not",',
+        '+:msg => "Not Found",',
+      )
 
       expect {
         is_expected.to be_a_twirp_error(/Nope/)
-      }.to fail_with /to have msg: \/Nope\//
+      }.to fail_including(
+        # diff
+        '-:msg => /Nope/,',
+        '+:msg => "Not Found",',
+      )
     end
   end
 
@@ -62,7 +99,13 @@ describe "be_a_twirp_error" do
     it "catches mismatches" do
       expect {
         is_expected.to be_a_twirp_error(is_meta: "false")
-      }.to fail_with /to have meta.*is_meta/
+      }.to fail_including(
+        "to have meta",
+
+        # diff
+        '-:meta => {:is_meta=>"false"},',
+        '+:meta => {:is_meta=>"true"},',
+      )
 
       expect {
         is_expected.to be_a_twirp_error(not_meta: "")

data/spec/message_spec.rb

@@ -1,5 +1,5 @@
 describe "be_a_twirp_message" do
-  subject { HelloRequest.new(**attrs) }
+  subject(:request) { HelloRequest.new(**attrs) }
 
   let(:attrs) { {} }
 
@@ -10,13 +10,11 @@ describe "be_a_twirp_message" do
   end
 
   it "supports compound matchers" do
-    expect([ subject ]).to include(a_twirp_message)
+    expect([ request ]).to include(a_twirp_message)
   end
 
-  it "catches non-twirp subjects" do
-    expect {
-      expect(Object).to be_a_twirp_message
-    }.to fail_with /Expected a Twirp message, found Object/
+  it "does not match non-twirp subjects" do
+    expect(Object).not_to be_a_twirp_message
   end
 
   it "matches a specific message type" do
@@ -24,9 +22,7 @@ describe "be_a_twirp_message" do
   end
 
   it "catches type mismatches" do
-    expect {
-      is_expected.to be_a_twirp_message(GoodbyeRequest)
-    }.to fail_with /message of type GoodbyeRequest/
+    is_expected.not_to be_a_twirp_message(GoodbyeRequest)
   end
 
   it "catches erroneous message types" do
@@ -55,29 +51,19 @@ describe "be_a_twirp_message" do
         is_expected.to be_a_twirp_message(GoodbyeRequest, name: "Bob")
       }.to fail_with /message of type/
 
-      expect {
-        is_expected.to be_a_twirp_message(name: "nope")
-      }.to fail_with /to have name: "nope"/
+      is_expected.not_to be_a_twirp_message(name: "nope")
 
-      expect {
-        is_expected.to be_a_twirp_message(name: /no/)
-      }.to fail_with /to have name: \/no\//
+      is_expected.not_to be_a_twirp_message(name: /no/)
 
-      expect {
-        is_expected.to be_a_twirp_message(count: 1)
-      }.to fail_with /to have count: 1/
+      is_expected.not_to be_a_twirp_message(count: 1)
     end
 
-    it "catches the erroneous attribute matches" do
-      expect {
-        is_expected.to be_a_twirp_message(namezzz: "Bob")
-      }.to raise_error(ArgumentError, /namezzz/)
+    it "catches erroneous attribute matches" do
+      is_expected.not_to be_a_twirp_message(namezzz: "Bob")
     end
 
-    it "catches type mismatches" do
-      expect {
-        is_expected.to be_a_twirp_message(name: 123)
-      }.to raise_error(TypeError, /string field.*given Integer/)
+    it "handles type mismatches" do
+      is_expected.not_to be_a_twirp_message(name: 123)
     end
   end
 end

data/spec/response_spec.rb

@@ -6,39 +6,16 @@ describe "be_a_twirp_response" do
 
     it { is_expected.to be_a_twirp_response }
 
-    it "catches non-twirp response" do
-      expect {
-        expect(Object).to be_a_twirp_response
-      }.to fail_with /found Object/
-    end
-
-    it "matches a specific response type" do
-      is_expected.to be_a_twirp_response(GoodbyeResponse)
-    end
-
-    it "matches a specific response" do
-      is_expected.to be_a_twirp_response(response)
-    end
-
-    it "catches type mismatches" do
-      expect {
-        is_expected.to be_a_twirp_response(HelloResponse)
-      }.to fail_with /of type HelloResponse/
-    end
-
-    it "catches erroneous response types" do
-      expect {
-        is_expected.to be_a_twirp_response(Object)
-      }.to raise_error(ArgumentError, /Object/)
+    it "handles non-twirp response" do
+      expect(Object).not_to be_a_twirp_response
     end
 
     context "with attributes" do
-      subject { Twirp::ClientResp.new(GoodbyeResponse.new(**attrs), nil) }
-
+      let(:response) { GoodbyeResponse.new(**attrs) }
       let(:attrs) { { message: "bye", name: "Bob" } }
 
       it "can match attributes" do
-        is_expected.to be_a_twirp_response(GoodbyeResponse, **attrs)
+        is_expected.to be_a_twirp_response(**attrs)
       end
 
       it "supports regex matches" do
@@ -48,29 +25,17 @@ describe "be_a_twirp_response" do
       it "catches mismatches" do
         expect {
           is_expected.to be_a_twirp_response(name: "nope")
-        }.to fail_with /to have name: "nope"/
+        }.to fail_including(
+          '-:name => "nope",',
+          '+:name => "Bob",',
+        )
 
         expect {
           is_expected.to be_a_twirp_response(name: /no/)
-        }.to fail_with /to have name: \/no\//
-      end
-
-      it "catches the erroneous attributes" do
-        expect {
-          is_expected.to be_a_twirp_response(namezzz: "Bob")
-        }.to raise_error(ArgumentError, /namezzz/)
-      end
-
-      it "catches type mismatches" do
-        expect {
-          is_expected.to be_a_twirp_response(name: 123)
-        }.to raise_error(TypeError, /string field.*given Integer/)
-      end
-
-      it "can't also match a specific response" do
-        expect {
-          is_expected.to be_a_twirp_response(response, name: "Bob")
-        }.to raise_error(ArgumentError, /but not both/)
+        }.to fail_including(
+          '-:name => /no/,',
+          '+:name => "Bob",',
+        )
       end
     end
   end
@@ -92,7 +57,7 @@ describe "be_a_twirp_response" do
     it "catches mismatches" do
       expect {
         is_expected.to be_a_twirp_response.with_error(:internal)
-      }.to fail_with /code: :internal/
+      }.to fail_with /to have code `:internal`/
     end
   end
 
@@ -115,7 +80,7 @@ describe "be_a_twirp_response" do
   context "with both response and error" do
     subject { Twirp::ClientResp.new(GoodbyeResponse.new, Twirp::Error.not_found("Not Found")) }
 
-    it "fails" do
+    it "does not permit both attr and error matching" do
       expect {
         is_expected.to be_a_twirp_response(name: "Bob").with_error
       }.to raise_error(ArgumentError, /but not both/)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-twirp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-06 00:00:00.000000000 Z
+date: 2022-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: twirp
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +108,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "..."
+description: Twirp RSpec matchers
 email:
 executables: []
 extensions: []
@@ -103,17 +117,11 @@ files:
 - lib/rspec-twirp.rb
 - lib/rspec/twirp.rb
 - lib/rspec/twirp/error_matcher.rb
-- lib/rspec/twirp/helpers.rb
-- lib/rspec/twirp/make_request_matcher.rb
 - lib/rspec/twirp/message_matcher.rb
-- lib/rspec/twirp/mock_client.rb
-- lib/rspec/twirp/mock_connection.rb
 - lib/rspec/twirp/response_matcher.rb
 - lib/rspec/twirp/version.rb
 - spec/error_spec.rb
-- spec/make_request_spec.rb
 - spec/message_spec.rb
-- spec/mock_connection_spec.rb
 - spec/response_spec.rb
 homepage: https://github.com/dpep/rspec-twirp_rb
 licenses:
@@ -140,7 +148,5 @@ specification_version: 4
 summary: Gem::Specification::RSpec::Twirp
 test_files:
 - spec/error_spec.rb
-- spec/make_request_spec.rb
 - spec/message_spec.rb
-- spec/mock_connection_spec.rb
 - spec/response_spec.rb

data/lib/rspec/twirp/helpers.rb

@@ -1,16 +0,0 @@
-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

@@ -1,169 +0,0 @@
-# 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/mock_client.rb

@@ -1,59 +0,0 @@
-# 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

@@ -1,54 +0,0 @@
-# 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/spec/make_request_spec.rb

@@ -1,181 +0,0 @@
-describe "make_twirp_request" do
-  let(:client) { HelloWorldClient.new(conn) }
-  let(:conn) { mock_twirp_connection(response) }
-  let!(:other_client) { HelloWorldClient.new(conn) }
-  let(:request) { HelloRequest.new(name: "World", count: 3) }
-  let(:response) { HelloResponse.new(message: ["Hello", "Hello", "Hello World"]) }
-
-  def hello
-    client.hello(request)
-  end
-
-  describe "block mode" do
-    it { expect { hello }.to make_twirp_request }
-
-    it "returns nil" do
-      expect {
-        expect(hello).to be_nil
-      }.to make_twirp_request
-    end
-
-    context "with client instance matcher" do
-      it "matches a client instance" do
-        expect { hello }.to make_twirp_request(client)
-      end
-
-      it "matches a pre-existing client instance" do
-        expect {
-          other_client.hello(HelloRequest.new)
-        }.to make_twirp_request(other_client)
-      end
-
-      it "catches client mismaches" do
-        expect {
-          expect { hello }.to make_twirp_request(other_client)
-        }.to fail
-      end
-    end
-
-    context "with client class matcher" do
-      it "matches a client class" do
-        expect { hello }.to make_twirp_request(HelloWorldClient)
-      end
-
-      it "matches subclasses" do
-        expect { hello }.to make_twirp_request(Twirp::Client)
-      end
-
-      it "catches mismatches" do
-        expect {
-          expect { hello }.to make_twirp_request(GoodbyeClient)
-        }.to fail
-      end
-
-      it "catches type errors" do
-        expect {
-          expect { hello }.to make_twirp_request(Object)
-        }.to raise_error(TypeError)
-      end
-    end
-
-    context "with rpc name matcher" do
-      it { expect { hello }.to make_twirp_request(:Hello) }
-      it { expect { hello }.to make_twirp_request("Hello") }
-      it { expect { hello }.to make_twirp_request(/^He/) }
-
-      it "catches mismatches" do
-        expect {
-          expect { hello }.to make_twirp_request(:Bye)
-        }.to fail
-
-        expect {
-          expect { hello }.to make_twirp_request(/B/)
-        }.to fail
-      end
-    end
-
-    context "with input matcher" do
-      it "matches messages" do
-        expect { hello }.to make_twirp_request.with(request)
-      end
-
-      it "matches message type" do
-        expect { hello }.to make_twirp_request.with(HelloRequest)
-      end
-
-      it "matches with attrs" do
-        expect { hello }.to make_twirp_request.with(count: 3)
-      end
-
-      context "with json request" do
-        it "matches messages" do
-          expect {
-            client.hello(name: "World")
-          }.to make_twirp_request.with(HelloRequest.new(name: "World"))
-        end
-
-        it "matches attrs" do
-          expect {
-            client.hello(name: "World")
-          }.to make_twirp_request.with(name: "World")
-        end
-      end
-
-      it "catches mismatches" do
-        expect {
-          expect { hello }.to make_twirp_request.with(count: 1)
-        }.to fail
-      end
-    end
-
-    context "with service matcher" do
-      it { expect { hello }.to make_twirp_request(HelloWorldService) }
-
-      it "catches mismatches" do
-        expect {
-          expect { hello }.to make_twirp_request(GoodbyeService)
-        }.to fail
-      end
-    end
-
-    describe ".and_call_original" do
-      it "calls original" do
-        expect {
-          expect(hello).to be_a_twirp_response(response)
-        }.to make_twirp_request.and_call_original
-      end
-    end
-
-    describe ".and_return" do
-      it "returns the specified value" do
-        expect {
-          expect(hello).to be_a_twirp_response(HelloRequest.new)
-        }.to make_twirp_request.and_return(HelloRequest.new)
-      end
-
-      it "returns the specified value" do
-        expect {
-          expect(hello).to be_a_twirp_response(HelloRequest.new)
-        }.to make_twirp_request.and_return(HelloRequest)
-      end
-    end
-  end
-
-  describe "inline mode" do
-    after { hello }
-
-    it { expect(client).to make_twirp_request }
-
-    it "matches a specific rpc method" do
-      expect(client).to make_twirp_request(:hello)
-    end
-
-    it "matches a specific rpc method by rpc name" do
-      expect(client).to make_twirp_request(:Hello)
-    end
-
-    it "fails when client is not called within scope" do
-      expect_expectation_failure {
-        expect(client).to make_twirp_request
-      }
-    end
-
-    describe ".with" do
-      let(:request) { HelloRequest.new(name: "Daniel") }
-
-      it "matches the request message" do
-        expect(client).to make_twirp_request(:hello).with(request)
-      end
-
-      it "matches the request arguments" do
-        expect(client).to make_twirp_request(:hello).with(name: "Daniel")
-      end
-
-      it "fails when params don't match" do
-        expect_expectation_failure {
-          expect(client).to make_twirp_request.with(name: "Bob")
-        }
-      end
-    end
-  end
-end

data/spec/mock_connection_spec.rb

@@ -1,103 +0,0 @@
-describe :mock_twirp_connection do
-  subject { client.bye(request) }
-
-  let(:client) { GoodbyeClient.new(conn) }
-  let(:request) { GoodbyeRequest.new }
-  let(:response) { GoodbyeResponse.new(**response_attrs) }
-  let(:response_attrs) { { message: "bye" } }
-
-  context "without a mock" do
-    let(:conn) { "http://localhost:3000/twirp/Goodbye/Bye" }
-
-    it { expect { subject }.to raise_error(Faraday::Error) }
-  end
-
-  describe "with a response instance" do
-    let(:conn) { mock_twirp_connection(response) }
-
-    it { is_expected.to be_a(Twirp::ClientResp) }
-    it { is_expected.to be_a_twirp_response }
-    it { is_expected.to be_a_twirp_response(response) }
-    it { is_expected.to be_a_twirp_response(message: "bye") }
-
-    it "catches mismatches" do
-      expect {
-        is_expected.to be_a_twirp_response(message: "nope")
-      }.to fail
-    end
-  end
-
-  describe "with a response type" do
-    let(:conn) { mock_twirp_connection(GoodbyeResponse) }
-
-    it { is_expected.to be_a_twirp_response(GoodbyeResponse) }
-
-    it "catches mismatches" do
-      expect {
-        is_expected.to be_a_twirp_response(HelloResponse)
-      }.to fail
-    end
-  end
-
-  describe "with default response" do
-    let(:conn) { mock_twirp_connection }
-
-    it { is_expected.to be_a_twirp_response(GoodbyeResponse) }
-
-    context "and with attrs" do
-      let(:conn) { mock_twirp_connection(message: "adios") }
-
-      it { is_expected.to be_a_twirp_response(message: "adios") }
-    end
-  end
-
-  describe "with an error" do
-    let(:conn) { mock_twirp_connection(error) }
-    let(:error) { Twirp::Error.not_found("nope") }
-
-    it { is_expected.to be_a_twirp_response.with_error(error) }
-
-    context "when error is symbol" do
-      let(:error) { :not_found }
-
-      it { is_expected.to be_a_twirp_response.with_error(404) }
-      it { is_expected.to be_a_twirp_response.with_error(:not_found) }
-    end
-
-    context "when error is integer" do
-      let(:error) { 500 }
-
-      it { is_expected.to be_a_twirp_response.with_error(500) }
-      it { is_expected.to be_a_twirp_response.with_error(:internal) }
-    end
-  end
-
-  describe "with a block" do
-    context "with a response object" do
-      let(:conn) { mock_twirp_connection { response } }
-
-      it { is_expected.to be_a_twirp_response(response) }
-    end
-
-    context "with response attrs" do
-      let(:conn) { mock_twirp_connection { response_attrs } }
-
-      it "determines the correct response type and incorporates the attrs" do
-        is_expected.to be_a_twirp_response(GoodbyeResponse, **response_attrs)
-      end
-    end
-
-    context "with error" do
-      let(:conn) { mock_twirp_connection { error } }
-      let(:error) { Twirp::Error.not_found("nope") }
-
-      it { is_expected.to be_a_twirp_response.with_error(error) }
-    end
-
-    context "with error code" do
-      let(:conn) { mock_twirp_connection { :not_found } }
-
-      it { is_expected.to be_a_twirp_response.with_error(:not_found) }
-    end
-  end
-end