rspec-twirp 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c2f0ca51df29824ba1c1f2d1944ca94119501b3ec6366d09144f077bd99c92f2
-  data.tar.gz: 513bdae144ce76ecec652954cff14d3f8467037f6ec706ab67181be0ac036d61
+  metadata.gz: 7a9027f86450d9e045705304d1d8e590b51a733269938e83ca5ae098a90018d4
+  data.tar.gz: dca42845c93b814878cf24842320583ddf6dbce3b0d266cd897a58500cf31a31
 SHA512:
-  metadata.gz: 4a4ebdce6d3d96826eca31484d1d4c22dc5b9e07fb109bea659315c5cfc7265f497f8d0a0bb498115e654ee139b232d6c6eb74bfd6da03a325a44411e636486c
-  data.tar.gz: 4342593db5f6e34db3fb0c3829a04ff1b8bc5806960e6b0efb144f650c38b80b08559b7f1f1a616a1c36712e2fb4a1c9cb963e457accd9451ac1ad3a6314096f
+  metadata.gz: 98d362457d71269cf64bffa1fe0b1fe00e173fe68df88e12cf0af20aa1030d518e031415d005050209b070095c36a6eac454e1bdba740661a090ce3be90cfa15
+  data.tar.gz: a0923b782b8568198fb267cd1e3bc6192bb032b0a7e746be478a4e8d66317ccc81652487f6f3b442847c6c2946b2e398f25b60682c0cc6b1c794c556837d0978

data/lib/rspec/twirp/error_matcher.rb

@@ -1,30 +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)
+          @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}"
+        values_match?(matcher.to_h, actual.to_h)
       else
         # match msg
+        @expected[:msg] = matcher
+        @actual[:msg] = actual.msg
 
-        @fail_msg = "Expected #{actual} to have msg: #{matcher.inspect}, found #{actual.msg}"
-        return false unless values_match?(matcher, 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|
@@ -33,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
@@ -44,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

@@ -0,0 +1,2 @@
+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,34 +1,36 @@
-RSpec::Matchers.define :be_a_twirp_response do |type = nil, **attrs|
-  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}"
-    end
-
-    @fail_msg = "Expected a Twirp response, found #{actual}"
-    return false unless actual.is_a?(Google::Protobuf::MessageExts)
+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 expected response type
-    @fail_msg = "Expected a Twirp response of type #{type}, found #{actual.class}"
-    return false if type && actual.class != type
+  match do |actual|
+    @fail_msg = "Expected a Twirp::ClientResp, found #{actual}"
+    return false unless actual.is_a?(Twirp::ClientResp)
 
-    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
-    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.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/rspec/twirp.rb

@@ -1,32 +1,9 @@
-require "rspec/expectations"
-require "rspec/twirp/client_response_matcher"
+require "google/protobuf"
+require "rspec"
+require "rspec/protobuf"
+require "twirp"
+
 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
-
-    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
-        else
-          attr
-        end
-      end.compact
-
-      klass.new(**discrete_attrs)
-    rescue Google::Protobuf::TypeError => e
-      raise TypeError, e.message
-    end
-  end
-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,16 +7,54 @@ 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
     }.to fail_with /to be a Twirp::Error/
   end
 
+  describe "status matches" do
+    it { is_expected.to be_a_twirp_error(404) }
+
+    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 {
+        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) }
 
-    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 {
@@ -35,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
 
@@ -50,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: "")
@@ -64,6 +119,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/) }

data/spec/message_spec.rb

@@ -0,0 +1,69 @@
+describe "be_a_twirp_message" do
+  subject(:request) { HelloRequest.new(**attrs) }
+
+  let(:attrs) { {} }
+
+  it { is_expected.to be_a_twirp_message }
+
+  it "works with responses also" do
+    expect(HelloResponse.new).to be_a_twirp_message
+  end
+
+  it "supports compound matchers" do
+    expect([ request ]).to include(a_twirp_message)
+  end
+
+  it "does not match non-twirp subjects" do
+    expect(Object).not_to be_a_twirp_message
+  end
+
+  it "matches a specific message type" do
+    is_expected.to be_a_twirp_message(HelloRequest)
+  end
+
+  it "catches type mismatches" do
+    is_expected.not_to be_a_twirp_message(GoodbyeRequest)
+  end
+
+  it "catches erroneous message types" do
+    expect {
+      is_expected.to be_a_twirp_message(Object)
+    }.to raise_error(TypeError, /Object/)
+  end
+
+  context "with attributes" do
+    let(:attrs) { { name: "Bob", count: 3 } }
+
+    it "can match attributes" do
+      is_expected.to be_a_twirp_message(HelloRequest, **attrs)
+    end
+
+    it "supports regex matches" do
+      is_expected.to be_a_twirp_message(name: /^B/)
+    end
+
+    it "supports range matches" do
+      is_expected.to be_a_twirp_message(count: 1..5)
+    end
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_message(GoodbyeRequest, name: "Bob")
+      }.to fail_with /message of type/
+
+      is_expected.not_to be_a_twirp_message(name: "nope")
+
+      is_expected.not_to be_a_twirp_message(name: /no/)
+
+      is_expected.not_to be_a_twirp_message(count: 1)
+    end
+
+    it "catches erroneous attribute matches" do
+      is_expected.not_to be_a_twirp_message(namezzz: "Bob")
+    end
+
+    it "handles type mismatches" do
+      is_expected.not_to be_a_twirp_message(name: 123)
+    end
+  end
+end

data/spec/response_spec.rb

@@ -1,56 +1,89 @@
 describe "be_a_twirp_response" do
-  subject { HelloResponse.new(**attrs) }
+  context "with a response" do
+    subject { Twirp::ClientResp.new(response, nil) }
 
-  let(:attrs) { {} }
+    let(:response) { GoodbyeResponse.new }
 
-  it { is_expected.to be_a_twirp_response }
+    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 /Expected a Twirp response, found Object/
-  end
+    it "handles non-twirp response" do
+      expect(Object).not_to be_a_twirp_response
+    end
 
-  it "matches a specific response type" do
-    is_expected.to be_a_twirp_request(HelloResponse)
-  end
+    context "with attributes" do
+      let(:response) { GoodbyeResponse.new(**attrs) }
+      let(:attrs) { { message: "bye", name: "Bob" } }
 
-  it "catches type mismatches" do
-    expect {
-      is_expected.to be_a_twirp_request(GoodbyeResponse)
-    }.to fail_with /request of type GoodbyeResponse/
-  end
+      it "can match attributes" do
+        is_expected.to be_a_twirp_response(**attrs)
+      end
 
-  context "with attributes" do
-    let(:attrs) { { message: msg } }
-    let(:msg) { [ "Hello World" ] }
+      it "supports regex matches" do
+        is_expected.to be_a_twirp_response(name: /^B/)
+      end
 
-    it { is_expected.to be_a_twirp_response(**attrs) }
+      it "catches mismatches" do
+        expect {
+          is_expected.to be_a_twirp_response(name: "nope")
+        }.to fail_including(
+          '-:name => "nope",',
+          '+:name => "Bob",',
+        )
 
-    it "supports regex matches" do
-      is_expected.to be_a_twirp_response(message: include(/Hello/))
+        expect {
+          is_expected.to be_a_twirp_response(name: /no/)
+        }.to fail_including(
+          '-:name => /no/,',
+          '+:name => "Bob",',
+        )
+      end
     end
+  end
+
+  context "with error" do
+    subject { Twirp::ClientResp.new(nil, error) }
+
+    let(:error) { Twirp::Error.new(code, msg, meta) }
+    let(:code) { :not_found }
+    let(:msg) { "Not Found" }
+    let(:meta) { { is_meta: "true" } }
+
+    it { is_expected.to be_a_twirp_response.with_error }
+    it { is_expected.to be_a_twirp_response.with_error(code) }
+    it { is_expected.to be_a_twirp_response.with_error(msg) }
+    it { is_expected.to be_a_twirp_response.with_error(**meta) }
+    it { is_expected.to be_a_twirp_response.with_error(/Not/) }
 
     it "catches mismatches" do
       expect {
-        is_expected.to be_a_twirp_response(message: [ "" ])
-      }.to fail_with /to have message/
+        is_expected.to be_a_twirp_response.with_error(:internal)
+      }.to fail_with /to have code `:internal`/
+    end
+  end
 
+  context "with neither response nor error" do
+    subject { Twirp::ClientResp.new(nil, nil) }
+
+    it "fails the response match" do
       expect {
-        is_expected.to be_a_twirp_response(message: [ "Hello" ])
-      }.to fail_with /to have message/
+        is_expected.to be_a_twirp_response
+      }.to fail_with /to have data/
     end
 
-    it "catches the erroneous attributes" do
+    it "fails the error match" do
       expect {
-        is_expected.to be_a_twirp_response(msg: [])
-      }.to raise_error(ArgumentError, /msg/)
+        is_expected.to be_a_twirp_response.with_error
+      }.to fail_with /to have an error/
     end
+  end
+
+  context "with both response and error" do
+    subject { Twirp::ClientResp.new(GoodbyeResponse.new, Twirp::Error.not_found("Not Found")) }
 
-    it "catches type mismatches" do
+    it "does not permit both attr and error matching" do
       expect {
-        is_expected.to be_a_twirp_response(message: "Hello World")
-      }.to raise_error(ArgumentError, /Expected array/)
+        is_expected.to be_a_twirp_response(name: "Bob").with_error
+      }.to raise_error(ArgumentError, /but not both/)
     end
   end
 end

metadata

@@ -1,31 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: rspec-twirp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-25 00:00:00.000000000 Z
+date: 2022-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: twirp
+  name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: rspec-expectations
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,21 +39,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: rspec-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '0.2'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: codecov
+  name: twirp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,7 +108,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "..."
+description: Twirp RSpec matchers
 email:
 executables: []
 extensions: []
@@ -102,14 +116,12 @@ extra_rdoc_files: []
 files:
 - lib/rspec-twirp.rb
 - lib/rspec/twirp.rb
-- lib/rspec/twirp/client_response_matcher.rb
 - lib/rspec/twirp/error_matcher.rb
-- lib/rspec/twirp/request_matcher.rb
+- lib/rspec/twirp/message_matcher.rb
 - lib/rspec/twirp/response_matcher.rb
 - lib/rspec/twirp/version.rb
-- spec/client_response_spec.rb
 - spec/error_spec.rb
-- spec/request_spec.rb
+- spec/message_spec.rb
 - spec/response_spec.rb
 homepage: https://github.com/dpep/rspec-twirp_rb
 licenses:
@@ -130,12 +142,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Gem::Specification::RSpec::Twirp
 test_files:
 - spec/error_spec.rb
-- spec/request_spec.rb
+- spec/message_spec.rb
 - spec/response_spec.rb
-- spec/client_response_spec.rb

data/lib/rspec/twirp/client_response_matcher.rb

@@ -1,48 +0,0 @@
-RSpec::Matchers.define :be_a_twirp_client_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 request type
-    if type && !(type < Google::Protobuf::MessageExts)
-      raise ArgumentError, "Expected `type` to be a Twirp response, found: #{type}"
-    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"
-      end
-
-      @fail_msg = "Expected #{actual} to have an error"
-      return false unless actual.error
-
-      matchers, meta_matchers = @with_error
-      expect(actual.error).to be_a_twirp_error(*matchers, **meta_matchers)
-    else
-      @fail_msg = "Expected #{actual} to have data"
-      return false unless actual.data
-
-      expect(actual.data).to be_a_twirp_response(**attrs)
-    end
-  rescue RSpec::Expectations::ExpectationNotMetError => err
-    @fail_msg = err.message
-    false
-  end
-
-  description do
-    type ? "a #{type} Twirp response" : "a Twirp response"
-  end
-
-  failure_message { @fail_msg }
-end
-
-RSpec::Matchers.alias_matcher :a_twirp_client_response, :be_a_twirp_client_response

data/lib/rspec/twirp/request_matcher.rb

@@ -1,37 +0,0 @@
-RSpec::Matchers.define :be_a_twirp_request do |type = nil, **attrs|
-  match do |actual|
-    # ensure type is a valid twirp request type
-    if type && !(type < Google::Protobuf::MessageExts)
-      raise ArgumentError, "Expected `type` to be a Twirp request, found: #{type}"
-    end
-
-    @fail_msg = "Expected a Twirp request, found #{actual}"
-    return false unless actual.is_a?(Google::Protobuf::MessageExts)
-
-    # match expected request type
-    @fail_msg = "Expected a Twirp request of type #{type}, found #{actual.class}"
-    return false if type && actual.class != type
-
-    return true if attrs.empty?
-
-    RSpec::Twirp.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 request" : "a Twirp request"
-  end
-
-  failure_message { @fail_msg }
-end
-
-RSpec::Matchers.alias_matcher :a_twirp_request, :be_a_twirp_request

data/spec/client_response_spec.rb

@@ -1,112 +0,0 @@
-describe "be_a_twirp_client_response" do
-  context "with a response" do
-    subject { Twirp::ClientResp.new(GoodbyeResponse.new, nil) }
-
-    it { is_expected.to be_a_twirp_client_response }
-
-    it "catches non-twirp response" do
-      expect {
-        expect(Object).to be_a_twirp_client_response
-      }.to fail_with /found Object/
-    end
-
-    it "matches a specific response type" do
-      is_expected.to be_a_twirp_client_response(GoodbyeResponse)
-    end
-
-    it "catches type mismatches" do
-      expect {
-        is_expected.to be_a_twirp_client_response(HelloResponse)
-      }.to fail_with /of type HelloResponse/
-    end
-
-    it "catches erroneous response types" do
-      expect {
-        is_expected.to be_a_twirp_client_response(Object)
-      }.to raise_error(ArgumentError, /Object/)
-    end
-
-    context "with attributes" do
-      subject { Twirp::ClientResp.new(GoodbyeResponse.new(**attrs), nil) }
-
-      let(:attrs) { { message: "bye", name: "Bob" } }
-
-      it "can match attributes" do
-        is_expected.to be_a_twirp_client_response(GoodbyeResponse, **attrs)
-      end
-
-      it "supports regex matches" do
-        is_expected.to be_a_twirp_client_response(name: /^B/)
-      end
-
-      it "catches mismatches" do
-        expect {
-          is_expected.to be_a_twirp_client_response(name: "nope")
-        }.to fail_with /to have name: "nope"/
-
-        expect {
-          is_expected.to be_a_twirp_client_response(name: /no/)
-        }.to fail_with /to have name: \/no\//
-      end
-
-      it "catches the erroneous attributes" do
-        expect {
-          is_expected.to be_a_twirp_client_response(namezzz: "Bob")
-        }.to raise_error(ArgumentError, /namezzz/)
-      end
-
-      it "catches type mismatches" do
-        expect {
-          is_expected.to be_a_twirp_client_response(name: 123)
-        }.to raise_error(TypeError, /string field.*given Integer/)
-      end
-    end
-  end
-
-  context "with error" do
-    subject { Twirp::ClientResp.new(nil, error) }
-
-    let(:error) { Twirp::Error.new(code, msg, meta) }
-    let(:code) { :not_found }
-    let(:msg) { "Not Found" }
-    let(:meta) { { is_meta: "true" } }
-
-    it { is_expected.to be_a_twirp_client_response.with_error }
-    it { is_expected.to be_a_twirp_client_response.with_error(code) }
-    it { is_expected.to be_a_twirp_client_response.with_error(msg) }
-    it { is_expected.to be_a_twirp_client_response.with_error(**meta) }
-    it { is_expected.to be_a_twirp_client_response.with_error(/Not/) }
-
-    it "catches mismatches" do
-      expect {
-        is_expected.to be_a_twirp_client_response.with_error(:internal)
-      }.to fail_with /code: :internal/
-    end
-  end
-
-  context "with neither response nor error" do
-    subject { Twirp::ClientResp.new(nil, nil) }
-
-    it "fails the response match" do
-      expect {
-        is_expected.to be_a_twirp_client_response
-      }.to fail_with /to have data/
-    end
-
-    it "fails the error match" do
-      expect {
-        is_expected.to be_a_twirp_client_response.with_error
-      }.to fail_with /to have an error/
-    end
-  end
-
-  context "with both response and error" do
-    subject { Twirp::ClientResp.new(GoodbyeResponse.new, Twirp::Error.not_found("Not Found")) }
-
-    it "fails" do
-      expect {
-        is_expected.to be_a_twirp_client_response(name: "Bob").with_error
-      }.to raise_error(ArgumentError, /but not both/)
-    end
-  end
-end

data/spec/request_spec.rb

@@ -1,75 +0,0 @@
-describe "be_a_twirp_request" do
-  subject { HelloRequest.new(**attrs) }
-
-  let(:attrs) { {} }
-
-  it { is_expected.to be_a_twirp_request }
-
-  it "catches non-twirp requests" do
-    expect {
-      expect(Object).to be_a_twirp_request
-    }.to fail_with /Expected a Twirp request, found Object/
-  end
-
-  it "matches a specific request type" do
-    is_expected.to be_a_twirp_request(HelloRequest)
-  end
-
-  it "catches type mismatches" do
-    expect {
-      is_expected.to be_a_twirp_request(GoodbyeRequest)
-    }.to fail_with /request of type GoodbyeRequest/
-  end
-
-  it "catches erroneous request types" do
-    expect {
-      is_expected.to be_a_twirp_request(Object)
-    }.to raise_error(ArgumentError, /Object/)
-  end
-
-  context "with attributes" do
-    let(:attrs) { { name: "Bob", count: 3 } }
-
-    it "can match attributes" do
-      is_expected.to be_a_twirp_request(HelloRequest, **attrs)
-    end
-
-    it "supports regex matches" do
-      is_expected.to be_a_twirp_request(name: /^B/)
-    end
-
-    it "supports range matches" do
-      is_expected.to be_a_twirp_request(count: 1..5)
-    end
-
-    it "catches mismatches" do
-      expect {
-        is_expected.to be_a_twirp_request(GoodbyeRequest, name: "Bob")
-      }.to fail_with /request of type/
-
-      expect {
-        is_expected.to be_a_twirp_request(name: "nope")
-      }.to fail_with /to have name: "nope"/
-
-      expect {
-        is_expected.to be_a_twirp_request(name: /no/)
-      }.to fail_with /to have name: \/no\//
-
-      expect {
-        is_expected.to be_a_twirp_request(count: 1)
-      }.to fail_with /to have count: 1/
-    end
-
-    it "catches the erroneous attribute matches" do
-      expect {
-        is_expected.to be_a_twirp_request(namezzz: "Bob")
-      }.to raise_error(ArgumentError, /namezzz/)
-    end
-
-    it "catches type mismatches" do
-      expect {
-        is_expected.to be_a_twirp_request(name: 123)
-      }.to raise_error(TypeError, /string field.*given Integer/)
-    end
-  end
-end