webmock-twirp 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b68a561786519f4bf91828a3a01e4ae803e36e03af7fd327af7780ba5da4d838
-  data.tar.gz: 151994b76bc7d4494be3f302f20633a19fdb681a092d4f1d489e694f89d43189
+  metadata.gz: 292380b89f2b938b849edb2e4ce46cb84e197b6a39592d16425440446adce9a1
+  data.tar.gz: 64be8b4452a96b256adc5bfe9d08a479392d9cb916f4fe0ab1135cc763728f87
 SHA512:
-  metadata.gz: b764858403de27f0b9cc28a6bddb7c827379308c1619be1b8bcbeff8d1824a3cb1c3f892644ce63c78c2bc4f1331e4fdb4a60eb88713541e0161d899a4ddaa1c
-  data.tar.gz: 43a24c5182e1aab84cbc16897faae7ea54098be328ad07e5754b939c6b89783985c23f1d565db89fa751fb5e1edb719d72a0fef264b64ae1ceadbc877e8b92d0
+  metadata.gz: c4f52185995140dc0d2aa2646227bbd9195a87941a1ab40a20d6e1dfb1b29bf24c9b0a50796db26fecd453f802fecc5bd5003eee284f325ccea3a96bf4f152a6
+  data.tar.gz: fa2e3ed00ed69f960dae3c500979fc8a745cd6e78015c68d6b963ee85ffad842070855abcdd8d50e6f37263f2789ead2f231d50092698c496bd0e4e5b8251970

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+###  v0.4.0  (2022-11-16)
+- .to_return(Twirp::ClientResp)
+- revert client class name filter
+- unqualified client class filter
+- uri matching
+
+###  v0.3.0  (2022-10-28)
+- twirpify all the things
+- improve refinements
+- make_twirp_request rspec matcher
+
 ###  v0.2.1  (2022-10-19)
 - fix client matching
 

data/README.md

@@ -97,6 +97,45 @@ stub_twirp_request.to_return do |request|
 end
 ```
 
+## Improved WebMock Errors
+Before
+```ruby
+> client = EchoClient.new("http://example.com/twirp")
+...
+> client.echo(msg: "Hi")
+/lib/webmock/http_lib_adapters/net_http.rb:104:in `request': Real HTTP connections are disabled. Unregistered request: 
+POST http://example.com/twirp/Echo/Echo with body ' (WebMock::NetConnectNotAllowedError)
+Hi' with headers {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type'=>'application/protobuf', 'User-Agent'=>'Faraday v1.10.2'}
+
+You can stub this request with the following snippet:
+
+stub_request(:post, "http://example.com/twirp/Echo/Echo").
+  with(
+    body: "\n\x02Hi",
+    headers: {
+       'Accept'=>'*/*',
+       'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+       'Content-Type'=>'application/protobuf',
+       'User-Agent'=>'Faraday v1.10.2'
+    }).
+  to_return(status: 200, body: "", headers: {})
+```
+
+After
+```ruby
+> require "webmock-twirp"
+> client = EchoClient.new("http://example.com/twirp")
+...
+> client.echo(msg: "Hi")
+/lib/webmock/http_lib_adapters/net_http.rb:104:in `request': Real Twirp connections are disabled. Unregistered request: 
+EchoClient(http://example.com/twirp/Echo/Echo).echo(msg: "Hi") (WebMock::NetConnectNotAllowedError)
+
+You can stub this request with the following snippet:
+
+stub_twirp_request(:echo).with(
+  msg: "Hi",
+).to_return(...)
+```
 
 ----
 ## Contributing

data/lib/webmock/twirp/error.rb

@@ -0,0 +1,37 @@
+module WebMock
+  module Twirp
+    module NetConnectNotAllowedError
+      def initialize(request_signature)
+        @request_signature = request_signature
+      end
+
+      def message
+        snippet = WebMock::RequestSignatureSnippet.new(@request_signature)
+
+        text = [
+          "Real Twirp connections are disabled. Unregistered request:",
+          @request_signature,
+          snippet.stubbing_instructions,
+          snippet.request_stubs,
+          "="*60
+        ].compact.join("\n\n")
+      end
+    end
+  end
+end
+
+# hijack creation of Twirp errors
+module WebMock
+  class NetConnectNotAllowedError
+    def self.new(request_signature)
+      allocate.tap do |instance|
+        if request_signature.is_a?(WebMock::Twirp::RequestSignature)
+          instance.extend(WebMock::Twirp::NetConnectNotAllowedError)
+        end
+
+        instance.send(:initialize, request_signature)
+      end
+    end
+  end
+end
+

data/lib/webmock/twirp/matchers/make_twirp_request.rb

@@ -0,0 +1,46 @@
+module WebMock
+  module Twirp
+    module Matchers
+      class MakeTwirpRequest
+        def initialize(*matchers)
+          @stub = WebMock::Twirp::RequestStub.new(*matchers)
+        end
+
+        def method_missing(name, *args, **kwargs, &block)
+          super unless respond_to?(name)
+          @stub.send(name, *args, **kwargs, &block)
+
+          self
+        end
+
+        def respond_to?(method_name, include_private = false)
+          super || @stub.respond_to?(method_name)
+        end
+
+        def matches?(block)
+          unless block.is_a?(Proc)
+            raise ArgumentError, "expected block, found: #{block}"
+          end
+
+          WebMock::StubRegistry.instance.register_request_stub(@stub)
+          block.call
+          WebMock::StubRegistry.instance.remove_request_stub(@stub)
+
+          RequestRegistry.instance.times_executed(@stub) > 0
+        end
+
+        def failure_message
+          "expected a Twirp request but received none"
+        end
+
+        def failure_message_when_negated
+          "did not expect a Twirp request, but received one"
+        end
+
+        def supports_block_expectations?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/webmock/twirp/matchers.rb

@@ -0,0 +1,13 @@
+require "webmock/twirp/matchers/make_twirp_request"
+
+module WebMock
+  module Twirp
+    module Matchers
+      def make_twirp_request(...)
+        MakeTwirpRequest.new(...)
+      end
+
+      alias_method :make_a_twirp_request, :make_twirp_request
+    end
+  end
+end

data/lib/webmock/twirp/refinements.rb

@@ -8,16 +8,16 @@ module WebMock
       end
 
       refine Google::Protobuf::MessageExts do
-        def normalized_hash(symbolize_keys: true)
+        def normalized_hash
           res = {}
 
           self.class.descriptor.each do |field|
-            key = symbolize_keys ? field.name.to_sym : field.name
+            key = field.name.to_sym
             value = field.get(self)
 
             if value.is_a?(Google::Protobuf::MessageExts)
               # recursively serialize sub-message
-              value = value.normalized_hash(symbolize_keys: symbolize_keys)
+              value = value.normalized_hash
             end
 
             res[key] = value unless field.default == value
@@ -71,6 +71,12 @@ module WebMock
           end
         end
       end
+
+      refine ::WebMock::RequestSignature do
+        def proto_headers?
+          !!(headers&.fetch("Content-Type", nil)&.start_with?(::Twirp::Encoding::PROTO))
+        end
+      end
     end
   end
 end

data/lib/webmock/twirp/request_body_diff.rb

@@ -0,0 +1,39 @@
+using WebMock::Twirp::Refinements
+
+module WebMock
+  module Twirp
+    module RequestBodyDiff
+
+      private
+
+      def request_signature_diffable?
+        !!request_signature.twirp_request
+      end
+
+      def request_stub_diffable?
+        !!request_stub.with_attrs && !request_stub.with_attrs.is_a?(Proc)
+      end
+
+      def request_signature_body_hash
+        request_signature.twirp_request.normalized_hash
+      end
+
+      def request_stub_body_hash
+        request_stub.with_attrs
+      end
+    end
+  end
+end
+
+# hijack creation of Twirp snippets
+module WebMock
+  class RequestBodyDiff
+    def self.new(request_signature, request_stub)
+      super.tap do |instance|
+        if request_signature.proto_headers? && request_stub.is_a?(WebMock::Twirp::RequestStub)
+          instance.extend(WebMock::Twirp::RequestBodyDiff)
+        end
+      end
+    end
+  end
+end

data/lib/webmock/twirp/request_signature.rb

@@ -0,0 +1,55 @@
+using WebMock::Twirp::Refinements
+
+module WebMock
+  module Twirp
+    module RequestSignature
+      def twirp_client
+        @twirp_client ||= begin
+          service_full_name, rpc_name = uri.path.split("/").last(2)
+
+          # find matching client
+          client = ObjectSpace.each_object(::Twirp::Client.singleton_class).find do |obj|
+            next unless obj < ::Twirp::Client && obj.name
+            obj.service_full_name == service_full_name && obj.rpcs.key?(rpc_name)
+          end
+        end
+      end
+
+      def twirp_rpc
+        @twirp_rpc ||= begin
+          rpc_name = uri.path.split("/").last
+          client = twirp_client.rpcs[rpc_name] if twirp_client
+        end
+      end
+
+      def twirp_request
+        twirp_rpc[:input_class].decode(body) if twirp_rpc
+      end
+
+      def to_s
+        return super unless twirp_rpc
+
+        uri = WebMock::Util::URI.strip_default_port_from_uri_string(self.uri.to_s)
+        params = twirp_request.normalized_hash.map do |k, v|
+          "#{k}: #{v.inspect}"
+        end.join(", ")
+
+        string = "#{twirp_client}(#{uri})"
+        string << ".#{twirp_rpc[:ruby_method]}"
+        string << "(#{params.empty? ? "{}" : params})"
+
+        string
+      end
+    end
+  end
+end
+
+module WebMock
+  class RequestSignature
+    def self.new(...)
+      super(...).tap do |instance|
+        instance.extend(WebMock::Twirp::RequestSignature) if instance.proto_headers?
+      end
+    end
+  end
+end

data/lib/webmock/twirp/request_signature_snippet.rb

@@ -0,0 +1,40 @@
+using WebMock::Twirp::Refinements
+
+module WebMock
+  module Twirp
+    module RequestSignatureSnippet
+      def stubbing_instructions
+        return unless WebMock.show_stubbing_instructions?
+
+        client = @request_signature.twirp_client
+        rpc = @request_signature.twirp_rpc
+
+        return super unless client
+
+        string = "You can stub this request with the following snippet:\n\n"
+        string << "stub_twirp_request(#{rpc[:ruby_method].inspect})"
+
+        if request = @request_signature.twirp_request
+          params = request.normalized_hash.map do |k, v|
+            "  #{k}: #{v.inspect},"
+          end.join("\n")
+
+          string << ".with(\n#{params}\n)" unless params.empty?
+        end
+
+        string << ".to_return(...)"
+      end
+    end
+  end
+end
+
+# hijack creation of Twirp snippets
+module WebMock
+  class RequestSignatureSnippet
+    def self.new(request_signature)
+      super.tap do |instance|
+        instance.extend(WebMock::Twirp::RequestSignatureSnippet) if request_signature.proto_headers?
+      end
+    end
+  end
+end

data/lib/webmock/twirp/request_stub.rb

@@ -1,11 +1,11 @@
+require "uri"
+
 module WebMock
   module Twirp
     class RequestStub < WebMock::RequestStub
       using Refinements
 
       def initialize(*filters)
-        rpc_name = filters.snag { |x| x.is_a?(Symbol) }
-
         client = filters.snag { |x| x.is_a?(::Twirp::Client) }
 
         klass = client&.class
@@ -13,11 +13,21 @@ module WebMock
           x.is_a?(Class) && (x < ::Twirp::Client || x < ::Twirp::Service)
         end
 
+        rpc_name = filters.snag { |x| x.is_a?(Symbol) }
+
+        uri = filters.snag do |x|
+          x.is_a?(String) && x.start_with?("http") && x =~ URI::regexp
+        end
+
+        if client && uri
+          raise ArgumentError, "specify uri or client instance, but not both"
+        end
+
         unless filters.empty?
           raise ArgumentError, "unexpected arguments: #{filters}"
         end
 
-        uri = ""
+        uri ||= ""
 
         if client
           conn = client.instance_variable_get(:@conn)
@@ -25,15 +35,11 @@ module WebMock
         end
 
         if klass
-          @rpcs = klass.rpcs
+          @twirp_client = klass
           uri += "/#{klass.service_full_name}"
-        else
-          uri += "/[^/]+"
-        end
 
-        if rpc_name
-          if klass
-            # kindly convert ruby method to rpc method name
+          if rpc_name
+            # type check and kindly convert ruby method to rpc method name
             rpc_info = klass.rpcs.values.find do |x|
               x[:rpc_method] == rpc_name || x[:ruby_method] == rpc_name
             end
@@ -41,19 +47,29 @@ module WebMock
             raise ArgumentError, "invalid rpc method: #{rpc_name}" unless rpc_info
 
             uri += "/#{rpc_info[:rpc_method]}"
-          else
-            uri += "/#{rpc_name}"
           end
-        else
-          uri += "/[^/]+"
         end
 
-        super(:post, /#{uri}$/)
+        super(:post, /#{uri}/)
 
         # filter on Twirp header
         @request_pattern.with(
           headers: { "Content-Type" => ::Twirp::Encoding::PROTO },
         )
+
+        if rpc_name
+          # match rpc dynamically after client resolves
+          @rpc_name = rpc_name
+
+          @request_pattern.with do |request|
+            rpc_info = request.twirp_rpc
+
+            !!rpc_info && (
+              rpc_info[:rpc_method] == rpc_name ||
+              rpc_info[:ruby_method] == rpc_name
+            )
+          end
+        end
       end
 
       def with(request = nil, **attrs, &block)
@@ -69,16 +85,31 @@ module WebMock
           { body: request.to_proto }
         end
 
-        decoder = ->(request) do
-          input_class = rpc_from_request(request)[:input_class]
-          decoded_request = input_class.decode(request.body)
+        # save for diffing
+        @with_attrs = if block_given?
+          block
+        elsif request
+          request
+        elsif attrs.any?
+          attrs
+        end
 
+        decoder = ->(request_signature) do
           matched = true
-          matched &= decoded_request.include?(attrs) if attrs.any?
-          matched &= block.call(decoded_request) if block
+
+          request = request_signature.twirp_request
+          matched &&= !!request
+
+          # match request attributes
+          if attrs.any?
+            matched &&= request.include?(attrs)
+          end
+
+          # match block
+          matched &&= block.call(request) if block_given?
 
           matched
-        end if attrs.any? || block_given?
+        end
 
         super(request_matcher || {}, &decoder)
       end
@@ -93,17 +124,15 @@ module WebMock
 
         response_hashes = responses.map do |response|
           ->(request) do
-            # determine msg type and package response
-            output_class = rpc_from_request(request)[:output_class]
-            generate_http_response(output_class, response)
+            generate_http_response(request, response)
           end
         end
 
         decoder = ->(request) do
-          # determine msg type and call provided block
-          rpc = rpc_from_request(request)
-          res = block.call(rpc[:input_class].decode(request.body))
-          generate_http_response(rpc[:output_class], res)
+          generate_http_response(
+            request,
+            block.call(request.twirp_request),
+          )
         end if block_given?
 
         super(*response_hashes, &decoder)
@@ -114,29 +143,18 @@ module WebMock
         raise NotImplementedError
       end
 
-      private
-
-      def rpc_from_request(request_signature)
-        service_full_name, rpc_name = request_signature.uri.path.split("/").last(2)
+      # for internal, package use only
+      attr_reader :twirp_client, :rpc_name, :with_attrs
 
-        rpcs = @rpcs || begin
-          # find matching client instance
-          client = ObjectSpace.each_object(::Twirp::Client).find do |client|
-            service_full_name == client.class.service_full_name && \
-              client.class.rpcs.key?(rpc_name)
-          end
+      private
 
-          unless client
-            raise "could not determine Twirp::Client for call to: #{service_full_name}/#{rpc_name}"
-          end
+      def generate_http_response(request, obj)
+        msg_class = request.twirp_rpc&.fetch(:output_class)
 
-          client.class.rpcs
+        if msg_class.nil?
+          raise "could not determine Twirp::Client for request: #{request}"
         end
 
-        rpcs[rpc_name]
-      end
-
-      def generate_http_response(msg_class, obj)
         res = case obj
         when nil
           msg_class.new
@@ -148,6 +166,8 @@ module WebMock
           end
 
           obj
+        when ::Twirp::ClientResp
+          obj.error || obj.data
         when ::Twirp::Error
           obj
         when Symbol

data/lib/webmock/twirp/stub_request_snippet.rb

@@ -0,0 +1,46 @@
+module WebMock
+  module Twirp
+    module StubRequestSnippet
+      def to_s(with_response = true)
+        string = "stub_twirp_request"
+
+        filters = [
+          @request_stub.twirp_client,
+          @request_stub.rpc_name&.inspect,
+        ].compact.join(", ")
+        string << "(#{filters})" unless filters.empty?
+
+        if attrs = @request_stub.with_attrs
+          string << ".with(\n"
+
+          if attrs.is_a?(Hash)
+            string << attrs.map do |k, v|
+              "  #{k}: #{v.inspect},"
+            end.join("\n")
+          elsif attrs.is_a?(Proc)
+            string << "  { ... }"
+          else
+            string << "  #{attrs}"
+          end
+
+          string << "\n)"
+        end
+
+        string
+      end
+    end
+  end
+end
+
+# hijack creation of Twirp snippets
+module WebMock
+  class StubRequestSnippet
+    def self.new(request_stub)
+      super.tap do |instance|
+        if request_stub.is_a?(WebMock::Twirp::RequestStub)
+          instance.extend(WebMock::Twirp::StubRequestSnippet)
+        end
+      end
+    end
+  end
+end

data/lib/webmock/twirp/version.rb

@@ -1,5 +1,5 @@
 module WebMock
   module Twirp
-    VERSION = "0.2.1"
+    VERSION = "0.4.0"
   end
 end

data/lib/webmock/twirp.rb

@@ -1,11 +1,16 @@
 require "google/protobuf"
 require "twirp"
 require "webmock"
+require "webmock/twirp/error"
+require "webmock/twirp/matchers"
 require "webmock/twirp/refinements"
+require "webmock/twirp/request_body_diff"
+require "webmock/twirp/request_signature"
+require "webmock/twirp/request_signature_snippet"
 require "webmock/twirp/request_stub"
+require "webmock/twirp/stub_request_snippet"
 require "webmock/twirp/version"
 
-
 module WebMock
   module Twirp
     extend self
@@ -26,15 +31,22 @@ module WebMock
   end
 end
 
+# patch WebMock to export Twirp helpers
+module WebMock
+  module API
+    include WebMock::Twirp::API
+  end
 
-if $LOADED_FEATURES.find { |x| x =~ %r{/webmock/rspec.rb} }
-  # require "webmock/rspec"
-  RSpec.configure { |c| c.include WebMock::Twirp::API }
-else
-  # patch WebMock to also export stub_twirp_request
-  module WebMock
-    module API
-      include WebMock::Twirp::API
-    end
+  module Matchers
+    include WebMock::Twirp::Matchers
+  end
+end
+
+if $LOADED_FEATURES.find { |x| x =~ %r{/webmock/rspec.rb$} }
+  # require "webmock/rspec" was already called, so load helpers
+
+  RSpec.configure do |conf|
+    conf.include WebMock::Twirp::API
+    conf.include WebMock::Twirp::Matchers
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: webmock-twirp
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-20 00:00:00.000000000 Z
+date: 2022-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: webmock
@@ -133,8 +133,15 @@ files:
 - README.md
 - lib/webmock-twirp.rb
 - lib/webmock/twirp.rb
+- lib/webmock/twirp/error.rb
+- lib/webmock/twirp/matchers.rb
+- lib/webmock/twirp/matchers/make_twirp_request.rb
 - lib/webmock/twirp/refinements.rb
+- lib/webmock/twirp/request_body_diff.rb
+- lib/webmock/twirp/request_signature.rb
+- lib/webmock/twirp/request_signature_snippet.rb
 - lib/webmock/twirp/request_stub.rb
+- lib/webmock/twirp/stub_request_snippet.rb
 - lib/webmock/twirp/version.rb
 - webmock-twirp.gemspec
 homepage: https://github.com/dpep/webmock-twirp