rspec-twirp 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fd6d0300d49b6797b5e346b3c9091dc946a7dde949aeebe8a188ece2a68ed24
-  data.tar.gz: 634c8748918a04c36a576bcfc377fcfa122d01f3b58d4b5a7576098a11e882d9
+  metadata.gz: 2634a27685c93991e30afab03cf80cb5fe650047a2b91342eeadff69a7bb920e
+  data.tar.gz: f87529044e688df0b546e65cd527989842e983576bf62a70ea7aabf72d920d09
 SHA512:
-  metadata.gz: 7a2cb6d3d9d72219a255d03905f8007dec32263f938067c27986a308542fbe953ff372e8adb6a841b86f498d6d66c32a065a7b550eaf85a771a06792367daca0
-  data.tar.gz: 6f748768287f63658564c30ebff9bc6ef1bbb7965bc3236f9af5dd52c1e1ae01b5e41001f349a7510d763e8f2401824b358f89cdc3fb8c8f6b19688965991d49
+  metadata.gz: 01e6fbab6f8649f6c8dbcc8df72269699e099eb1d924d6ff6656781d5339d060c6138e465a5c43b5ec2a9320614d7924bed1c79eac088c9c10f881d99c6588d7
+  data.tar.gz: ce566d5fd9e1e91cca7a100d205e4a1b0615c743f808383d5180bd007049aeaaaf1298bfe382ad6e0385404dd3c04fadb5980ac53fbc9de54c9aeee335b4834b

data/lib/rspec/twirp/error_matcher.rb

@@ -0,0 +1,62 @@
+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}"
+    return false unless actual.is_a?(Twirp::Error)
+
+    matchers.each do |matcher|
+      case matcher
+      when Symbol
+        # match 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
+      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
+    end
+
+    # match meta
+    unless meta_matcher.empty?
+      @cur_match = { meta: meta_matcher }
+
+      # sanity check...values must be Strings or Regexp
+      discrete_attrs = meta_matcher.transform_values do |attr|
+        attr.is_a?(Regexp) ? attr.inspect : attr
+      end
+      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)
+    end
+
+    true
+  end
+
+  description do
+    "a Twirp::Error"
+  end
+
+  failure_message { @fail_msg }
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_error, :be_a_twirp_error

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

@@ -0,0 +1,57 @@
+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 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"
+      end
+
+      @fail_msg = "Expected #{actual} to have an error, but found none"
+      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, but found none"
+      return false unless actual.data
+
+      expect(actual.data).to be_a_twirp_message(**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_response, :be_a_twirp_response

data/lib/rspec/twirp/version.rb

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

data/lib/rspec/twirp.rb

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

data/lib/rspec-twirp.rb

@@ -1,5 +1 @@
-require "rspec-twirp/version"
-
-module RSpecTwirp
-
-end
+require "rspec/twirp"

data/spec/error_spec.rb

@@ -0,0 +1,116 @@
+describe "be_a_twirp_error" do
+  subject { 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_error }
+
+  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 { 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) }
+
+    it { expect { is_expected.to be_a_twirp_error(:unknown) }.to fail }
+
+    it "catches erroneous codes" do
+      expect {
+        is_expected.to be_a_twirp_error(:not_a_valid_code)
+      }.to raise_error(ArgumentError, /:not_a_valid_code/)
+    end
+  end
+
+  describe "msg matches" do
+    it { is_expected.to be_a_twirp_error("Not Found") }
+
+    it "supports Regex matches" do
+      is_expected.to be_a_twirp_error(/Not/)
+    end
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error("Not")
+      }.to fail_with /to have msg: "Not"/
+
+      expect {
+        is_expected.to be_a_twirp_error(/Nope/)
+      }.to fail_with /to have msg: \/Nope\//
+    end
+  end
+
+  describe "meta matches" do
+    it { is_expected.to be_a_twirp_error(is_meta: "true") }
+    it { is_expected.to be_a_twirp_error(is_meta: /^t/) }
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(is_meta: "false")
+      }.to fail_with /to have meta.*is_meta/
+
+      expect {
+        is_expected.to be_a_twirp_error(not_meta: "")
+      }.to fail_with /to have meta.*not_meta/
+    end
+
+    it "catches type errors" do
+      expect {
+        is_expected.to be_a_twirp_error(is_meta: true)
+      }.to raise_error(ArgumentError, /meta values must be Strings/)
+    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/) }
+    it { is_expected.to be_a_twirp_error(:not_found, is_meta: "true") }
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(:unknown, "Not Found")
+      }.to fail_with /unknown/
+
+      expect {
+        is_expected.to be_a_twirp_error(:not_found, "Nope")
+      }.to fail_with /Nope/
+
+      expect {
+        is_expected.to be_a_twirp_error(:not_found, is_meta: "false")
+      }.to fail_with /false/
+    end
+  end
+end

data/spec/make_request_spec.rb

@@ -0,0 +1,181 @@
+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/message_spec.rb

@@ -0,0 +1,83 @@
+describe "be_a_twirp_message" do
+  subject { 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([ subject ]).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/
+  end
+
+  it "matches a specific message type" do
+    is_expected.to be_a_twirp_message(HelloRequest)
+  end
+
+  it "catches type mismatches" do
+    expect {
+      is_expected.to be_a_twirp_message(GoodbyeRequest)
+    }.to fail_with /message of type 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/
+
+      expect {
+        is_expected.to be_a_twirp_message(name: "nope")
+      }.to fail_with /to have name: "nope"/
+
+      expect {
+        is_expected.to be_a_twirp_message(name: /no/)
+      }.to fail_with /to have name: \/no\//
+
+      expect {
+        is_expected.to be_a_twirp_message(count: 1)
+      }.to fail_with /to have 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/)
+    end
+
+    it "catches type mismatches" do
+      expect {
+        is_expected.to be_a_twirp_message(name: 123)
+      }.to raise_error(TypeError, /string field.*given Integer/)
+    end
+  end
+end

data/spec/mock_connection_spec.rb

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

data/spec/response_spec.rb

@@ -0,0 +1,124 @@
+describe "be_a_twirp_response" do
+  context "with a response" do
+    subject { Twirp::ClientResp.new(response, nil) }
+
+    let(:response) { GoodbyeResponse.new }
+
+    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/)
+    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_response(GoodbyeResponse, **attrs)
+      end
+
+      it "supports regex matches" do
+        is_expected.to be_a_twirp_response(name: /^B/)
+      end
+
+      it "catches mismatches" do
+        expect {
+          is_expected.to be_a_twirp_response(name: "nope")
+        }.to fail_with /to have name: "nope"/
+
+        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/)
+      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.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_response
+      }.to fail_with /to have data/
+    end
+
+    it "fails the error match" do
+      expect {
+        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 "fails" do
+      expect {
+        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,59 @@
 --- !ruby/object:Gem::Specification
 name: rspec-twirp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-25 00:00:00.000000000 Z
+date: 2022-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: google-protobuf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        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: codecov
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  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:
     - - ">="
@@ -39,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -73,7 +101,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/rspec-twirp.rb
-- lib/rspec-twirp/version.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:
 - MIT
@@ -93,8 +134,13 @@ 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: RSpecTwirp
-test_files: []
+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/version.rb

@@ -1,3 +0,0 @@
-module RSpecTwirp
-  VERSION = "0.0.1"
-end