rspec-twirp 0.2.0 → 0.3.1

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/error_spec.rb

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

@@ -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/message_spec.rb

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