twirp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76e48aace902f0cec12c1055dd664f659fb9dcf3
-  data.tar.gz: 792f3fcc5a62cbd2adfd9f3d714b246e96c63bca
+  metadata.gz: 4d21a865d8176ee77a6651aabe59247ae763e1d5
+  data.tar.gz: 8d16237130c4e966f97b98f7f529f6eb82814bf0
 SHA512:
-  metadata.gz: ea48c85b317496979d87015964d714a95db49093d5a81183b50928fbcdb453f4469fdf819b907012b1094f692fc08d3892b89bf55d870791f8607eded50ca06b
-  data.tar.gz: bb59b2e6077814fa06b9b29fee4473155408eb0930ddb4ca00a2e088534e4a32b64450eda3721445c26634d5ed36ead624b35544c2c8988f070ffc066a7bf8ad
+  metadata.gz: 2194339fba1ba02716da045f69f55e4fe7e6631f5d6eb1c1b38d7039ef913bbd08c41c919d0872d0240dae238100bb685c6b40a747133887d7494d23d5d0b3f2
+  data.tar.gz: 595aab3aca050f20139ec2a1f5e8bff184fcfd771cc9fd008fd14056850228c79974d765da76c6c08e0e93e7a9c502ba76acfacdae7acff2020e561fe5f2d8a8

data/README.md

@@ -54,19 +54,21 @@ require_relative 'gen/haberdasher_twirp.rb'
 
 class HaberdasherHandler
     def hello_world(req)
-        return Example::HelloWorldResponse.new(message: "Hello #{req.name}")
+        return {message: "Hello #{req.name}"}
     end
 end
 
 handler = HaberdasherHandler.new()
-Rack::Handler::WEBrick.run Example::HaberdasherService.new(handler)
+service = Example::HaberdasherService.new(handler)
+Rack::Handler::WEBrick.run service
 ```
 
 You can also mount onto a rails service:
 ```ruby
 App::Application.routes.draw do
   handler = HaberdasherHandler.new()
-  mount Example::HaberdasherService.new(handler), at: HaberdasherService::PATH_PREFIX
+  service = Example::HaberdasherService.new(handler)
+  mount service, at: HaberdasherService::PATH_PREFIX
 end
 ```
 

data/example/main.rb

@@ -4,7 +4,7 @@ require_relative 'gen/haberdasher_twirp.rb'
 
 class HaberdasherHandler
     def hello_world(req)
-        return Example::HelloWorldResponse.new(message: "Hello #{req.name}")
+        return {message: "Hello #{req.name}"}
     end
 end
 

data/lib/twirp.rb

@@ -1,3 +1,4 @@
 require_relative 'twirp/version'
 require_relative 'twirp/error'
-require_relative 'twirp/service'
+require_relative 'twirp/exception'
+require_relative 'twirp/service'

data/lib/twirp/error.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Twirp
 
   # Valid Twirp error codes and their mapping to related HTTP status.
@@ -29,6 +31,11 @@ module Twirp
   # Twirp::Error represents a valid error from a Twirp service
 	class Error
 
+    # Wrap an arbitrary error as a Twirp :internal
+    def self.InternalWith(err)
+      self.new :internal, err.message, "cause" => err.class.name
+    end
+
     # Initialize a Twirp::Error
     # The code MUST be one of the valid ERROR_CODES Symbols (e.g. :internal, :not_found, :permission_denied ...).
     # The msg is a String with the error message.
@@ -69,7 +76,11 @@ module Twirp
     end
 
     def to_json
-      JSON.encode(as_json)
+      JSON.generate(as_json)
+    end
+
+    def to_s
+      "Twirp::Error code:#{code} msg:#{msg.inspect} meta:#{meta.inspect}"
     end
 
     private
@@ -97,7 +108,7 @@ module Twirp
 
     def validate_meta_key_value(key, value)
       if !key.is_a?(String) || !value.is_a?(String)
-        raise ArgumentError.new("Twirp::Error meta must be a Hash with String keys and values")
+        raise ArgumentError.new("Twirp::Error meta must be a Hash with String keys and values. Invalid key<#{key.class}>: #{key.inspect}, value<#{value.class}>: #{value.inspect}")
       end
     end
 

data/lib/twirp/exception.rb

@@ -0,0 +1,21 @@
+require_relative "./error"
+
+module Twirp
+
+  class Exception < StandardError
+
+    def initialize(code, msg, meta=nil)
+      @twerr = Twirp::Error.new(code, msg, meta)
+    end
+
+    def message
+      "#{code}: #{msg}"
+    end
+
+    def code; @twerr.code; end
+    def msg; @twerr.msg; end
+    def meta; @twerr.meta; end
+    def to_json; @twerr.to_json; end
+    def as_json; @twerr.as_json; end
+  end
+end

data/lib/twirp/service.rb

@@ -1,5 +1,4 @@
 module Twirp
-
   class Service
 
     class << self
@@ -9,7 +8,7 @@ module Twirp
         @package_name = package_name.to_s
       end
 
-      # Configure service name
+      # Configure service name.
       def service(service_name)
         @service_name = service_name.to_s
       end
@@ -35,107 +34,129 @@ module Twirp
       end
 
       # Get configured package name as String.
-      # And empty value means that there's no package
+      # And empty value means that there's no package.
       def package_name
         @package_name.to_s
       end
 
       # Get configured service name as String.
-      # If not configured, it defaults to the class name
+      # If not configured, it defaults to the class name.
       def service_name
         sname = @service_name.to_s
         sname.empty? ? self.name : sname
       end
 
-      # Get configured metadata for rpc methods
+      # Get configured metadata for rpc methods.
       def rpcs
         @rpcs || {}
       end
 
       # Path prefix that should be used to route requests to this service.
       # It is based on the package and service name, in the expected Twirp URL format.
-      # The full URL would be: {BaseURL}/path_prefix/{MethodName}
+      # The full URL would be: {BaseURL}/path_prefix/{MethodName}.
       def path_prefix
-        if package_name.empty?
-          service_name # e.g. "Haberdasher"
-        else
-          "#{package_name}.#{service_name}" # e.g. "the.haberdasher.pkg.Haberdasher"
-        end
+        "/twirp/#{service_full_name}" # e.g. "twirp/Haberdasher"
+      end
+
+      # Service full name uniquelly identifies the service.
+      # It is the service name prefixed by the package name,
+      # for example "my.package.Haberdasher", or "Haberdasher" (if no package).
+      def service_full_name
+        package_name.empty? ? service_name : "#{package_name}.#{service_name}"
       end
-    end
+
+    end # class << self
+
 
     # Instantiate a new service with a handler.
-    # A handler implements each rpc method as a regular object method call.
+    # The handler must implemnt all rpc methods required by this service.
     def initialize(handler)
-      # validate that the handler reponds to all expected methods
       self.class.rpcs.each do |method_name, rpc|
         if !handler.respond_to? rpc[:handler_method]
-          raise ArgumentError.new("Handler must respond to .#{rpc[:handler_method]}(req) in order to handle the message #{method_name}.")
+          raise ArgumentError.new("Handler must respond to .#{rpc[:handler_method]}(input) in order to handle the message #{method_name}.")
         end
       end
-
       @handler = handler
     end
-
     # Register a before hook (not implemented)
     def before(&block)
       # TODO... and also after hooks
     end
 
-    # A service instance is a Rack middleware block.
+    # Rack app handler.
     def call(env)
       req = Rack::Request.new(env)
+      rpc, content_type, bad_route = parse_rack_request(req)
+      if bad_route
+        return error_response(bad_route)
+      end
+        
+      proto_req = decode_request(rpc[:request_class], content_type, req.body.read)
+      begin
+        resp = @handler.send(rpc[:handler_method], proto_req)
+        return rack_response_from_handler(rpc, content_type, resp)
+      rescue Twirp::Exception => twerr
+        error_response(twerr)
+      end
+    end
+
+    def path_prefix
+      self.class.path_prefix
+    end
+
+    def service_full_name
+      self.class.service_full_name
+    end
 
+  private
+
+    def parse_rack_request(req)
       if req.request_method != "POST"
-        return error_response(bad_route_error("Only POST method is allowed", req))
+        return nil, nil, bad_route_error("HTTP request method must be POST", req)
+      end
+
+      content_type = req.env["CONTENT_TYPE"]
+      if content_type != "application/json" && content_type != "application/protobuf"
+        return nil, nil, bad_route_error("unexpected Content-Type: #{content_type.inspect}. Content-Type header must be one of \"application/json\" or \"application/protobuf\"", req)
       end
       
-      method_name = req.fullpath.split("/").last
-      rpc_method = self.class.rpcs[method_name]
-      if !rpc_method
-        return error_response(bad_route_error("rpc method not found: #{method_name.inspect}", req))
+      path_parts = req.fullpath.split("/")
+      if path_parts.size < 4 || path_parts[-2] != self.service_full_name || path_parts[-3] != "twirp"
+        return nil, nil, bad_route_error("Invalid route. Expected format: POST {BaseURL}/twirp/(package.)?{Service}/{Method}", req)
       end
+      method_name = path_parts[-1]
 
-      request_class = rpc_method[:request_class]
-      response_class = rpc_method[:response_class]
-
-      content_type = req.env["CONTENT_TYPE"]
-      req_msg = decode_request(rpc_method[:request_class], content_type, req.body.read)
-      if !req_msg
-        return error_response(bad_route_error("unexpected Content-Type: #{content_type.inspect}", req))
+      rpc = self.class.rpcs[method_name]
+      if !rpc
+        return nil, nil, bad_route_error("rpc method not found: #{method_name.inspect}", req)
       end
 
-      # Handle Twirp request
-      # TODO: wrap with begin-rescue block
-      resp_msg = @handler.send(rpc_method[:handler_method], req_msg)
+      return rpc, content_type, nil
+    end
 
-      if resp_msg.is_a? Twirp::Error
-        return error_response(resp_msg)
+    def rack_response_from_handler(rpc, content_type, resp)
+      if resp.is_a? Twirp::Error
+        return error_response(resp)
       end
 
-      if resp_msg.is_a? Hash # allow handlers to respond with just the attributes
-        resp_msg = response_class.new(resp_msg)
+      if resp.is_a? Hash # allow handlers to return just the attributes
+        resp = rpc[:response_class].new(resp)
       end
-      encoded_resp = encode_response(response_class, content_type, resp_msg)
-
-      return [200, {'Content-Type' => content_type}, [encoded_resp]]
 
-      # TODO: add recue for any error in the method, wrap with Twith error
-    end
+      if !resp # allow handlers to return nil or false as a reponse with zero-values
+        resp = rpc[:response_class].new
+      end
 
-    # path prefix that can be used to mount this service
-    def path_prefix
-      self.class.path_prefix
+      encoded_resp = encode_response(rpc[:response_class], content_type, resp)
+      success_response(content_type, encoded_resp)
     end
 
-  private
-
     def decode_request(request_class, content_type, body)
       case content_type
       when "application/json"
         request_class.decode_json(body)
       when "application/protobuf"
-        request_type.decode(body)
+        request_class.decode(body)
       end
     end
 
@@ -148,6 +169,10 @@ module Twirp
       end
     end
 
+    def success_response(content_type, encoded_resp)
+      [200, {'Content-Type' => content_type}, [encoded_resp]]
+    end
+
     def error_response(twirp_error)
       status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twirp_error.code]
       headers = {'Content-Type' => 'application/json'} 

data/lib/twirp/version.rb

@@ -1,3 +1,3 @@
 module Twirp
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/test/fake_services.rb

@@ -0,0 +1,58 @@
+# Fake messages, services and hadndlers for tests.
+
+require 'google/protobuf'
+require_relative '../lib/twirp'
+
+# Protobuf messages.
+# An example of the result of the protoc ruby code generator.
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_message "example.Size" do
+    optional :inches, :int32, 1
+  end
+  add_message "example.Hat" do
+    optional :inches, :int32, 1
+    optional :color, :string, 2
+  end
+  add_message "example.Empty" do
+  end
+end
+
+module Example
+  Size = Google::Protobuf::DescriptorPool.generated_pool.lookup("example.Size").msgclass
+  Hat = Google::Protobuf::DescriptorPool.generated_pool.lookup("example.Hat").msgclass
+  Empty = Google::Protobuf::DescriptorPool.generated_pool.lookup("example.Empty").msgclass
+end
+
+# Twirp Service.
+# An example of the result of the protoc twirp_ruby plugin code generator.
+module Example
+  class Haberdasher < Twirp::Service
+    package "example"
+    service "Haberdasher"
+
+    rpc "MakeHat", Size, Hat, handler_method: :make_hat
+  end
+end
+
+# Example service handler.
+# It would be provided by the developer as implementation for the service.
+class HaberdasherHandler
+  # This fake can optionally be initialized with a block for the make_hat implementation.
+  def initialize(&block)
+    if block_given?
+      @make_hat_block = block
+    else # default implementation
+      @make_hat_block = Proc.new do |size|
+        {inches: size.inches, color: "white"}
+      end
+    end
+  end
+
+  def make_hat(size)
+    @make_hat_block.call(size)
+  end
+end
+
+# Twirp Service with no package and no rpc methods.
+class EmptyService < Twirp::Service
+end

data/test/service_test.rb

@@ -1,105 +1,235 @@
 require 'minitest/autorun'
 require 'rack/mock'
-
 require 'google/protobuf'
-require_relative '../lib/twirp'
-
-# Protobuf messages.
-# This is what the protoc code generator would produce.
-Google::Protobuf::DescriptorPool.generated_pool.build do
-  add_message "foopkg.DoFooRequest" do
-    optional :foo, :string, 1
-  end
-  add_message "foopkg.DoFooResponse" do
-    optional :bar, :string, 1
-  end
-end
-module FooPkg
-  DoFooRequest = Google::Protobuf::DescriptorPool.generated_pool.lookup("foopkg.DoFooRequest").msgclass
-  DoFooResponse = Google::Protobuf::DescriptorPool.generated_pool.lookup("foopkg.DoFooResponse").msgclass
-end
-
-# Twirp Service.
-# This is wha the twirp_ruby protoc plugin code generator would produce.
-module FooPkg
-  class FooService < Twirp::Service
-    package "foopkg"
-    service "FooService"
-
-    rpc "DoFoo", DoFooRequest, DoFooResponse, handler_method: :do_foo
-  end
-end
+require 'json'
 
-# Example service handler.
-# This would be provided by the developer as implementation for the service.
-class FooHandler
-  def do_foo(req)
-    {bar: "Hello #{req.foo}"}
-  end
-end
-
-# Twirp Service with no package and no rpc methods.
-class EmptyService < Twirp::Service
-end
+require_relative '../lib/twirp'
+require_relative './fake_services'
 
 class ServiceTest < Minitest::Test
 
+  # DSL rpc builds the proper rpc data on the service
   def test_rpc_methods
-    # make sure that rpcs have been properly setup by the `rpc` DSL constructor
-    assert_equal 1, FooPkg::FooService.rpcs.size
+    assert_equal 1, Example::Haberdasher.rpcs.size
     assert_equal({
-      request_class: FooPkg::DoFooRequest,
-      response_class: FooPkg::DoFooResponse,
-      handler_method: :do_foo,
-    }, FooPkg::FooService.rpcs["DoFoo"])
+      request_class: Example::Size,
+      response_class: Example::Hat,
+      handler_method: :make_hat,
+    }, Example::Haberdasher.rpcs["MakeHat"])
   end
 
+  # DSL package and service define the proper data on the service
   def test_package_service_getters
-    assert_equal "foopkg", FooPkg::FooService.package_name
-    assert_equal "FooService", FooPkg::FooService.service_name
-    assert_equal "foopkg.FooService", FooPkg::FooService.path_prefix
+    assert_equal "example", Example::Haberdasher.package_name
+    assert_equal "Haberdasher", Example::Haberdasher.service_name
+    assert_equal "example.Haberdasher", Example::Haberdasher.service_full_name
+    assert_equal "/twirp/example.Haberdasher", Example::Haberdasher.path_prefix
 
     assert_equal "", EmptyService.package_name # defaults to empty string
     assert_equal "EmptyService", EmptyService.service_name # defaults to class name
-    assert_equal "EmptyService", EmptyService.path_prefix # with no package is just the service name
+    assert_equal "EmptyService", EmptyService.service_full_name # with no package is just the service name
+    assert_equal "/twirp/EmptyService", EmptyService.path_prefix
   end
   
-  def test_initialize_service
-    # simple initialization
-    svc = FooPkg::FooService.new(FooHandler.new)
+  def test_init_service
+    svc = Example::Haberdasher.new(HaberdasherHandler.new)
     assert svc.respond_to?(:call) # so it is a Proc that can be used as Rack middleware
-
-    empty_svc = EmptyService.new(nil) # an empty service does not need a handler
-    assert svc.respond_to?(:call)
+    assert_equal "example.Haberdasher", svc.service_full_name
+    assert_equal "/twirp/example.Haberdasher", svc.path_prefix
   end
 
-  def test_path_prefix
-    svc = FooPkg::FooService.new(FooHandler.new)
-    assert_equal "foopkg.FooService", svc.path_prefix
+  def test_init_empty_service
+    empty_svc = EmptyService.new(nil) # an empty service does not need a handler
+    assert empty_svc.respond_to?(:call)
+    assert_equal "EmptyService", empty_svc.service_full_name
+    assert_equal "/twirp/EmptyService", empty_svc.path_prefix
   end
 
-  def test_initialize_fails_on_invalid_handlers
+  def test_init_failures
     assert_raises ArgumentError do 
-      FooPkg::FooService.new() # handler is mandatory
+      Example::Haberdasher.new() # handler is mandatory
     end
 
-    # verify that handler implements required methods
     err = assert_raises ArgumentError do 
-      FooPkg::FooService.new("fake handler")
+      Example::Haberdasher.new("fake handler")
     end
-    assert_equal "Handler must respond to .do_foo(req) in order to handle the message DoFoo.", err.message
+    assert_equal "Handler must respond to .make_hat(input) in order to handle the message MakeHat.", err.message
   end
 
-  def test_successful_simple_request
-    env = Rack::MockRequest.env_for("/twirp/foopkg.FooService/DoFoo", method: "POST", 
-      input: '{"foo": "World"}', "CONTENT_TYPE" => "application/json")
+  def test_successful_json_request
+    env = json_req "/twirp/example.Haberdasher/MakeHat", inches: 10
+    status, headers, body = haberdasher_service.call(env)
 
-    svc = FooPkg::FooService.new(FooHandler.new)
-    status, headers, body = svc.call(env)
+    assert_equal 200, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({"inches" => 10, "color" => "white"}, JSON.parse(body[0]))
+  end
+
+  def test_successful_proto_request
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new(inches: 10)
+    status, headers, body = haberdasher_service.call(env)
 
     assert_equal 200, status
+    assert_equal 'application/protobuf', headers['Content-Type']
+    assert_equal Example::Hat.new(inches: 10, color: "white"), Example::Hat.decode(body[0])
+  end
+
+  def test_bad_route_with_wrong_rpc_method
+    env = json_req "/twirp/example.Haberdasher/MakeUnicorns", and_rainbows: true
+    status, headers, body = haberdasher_service.call(env)
+
+    assert_equal 404, status
     assert_equal 'application/json', headers['Content-Type']
-    assert_equal body[0], '{"bar":"Hello World"}'
+    assert_equal({
+      "code" => 'bad_route', 
+      "msg" => 'rpc method not found: "MakeUnicorns"',
+      "meta"=> {"twirp_invalid_route" => "POST /twirp/example.Haberdasher/MakeUnicorns"},
+    }, JSON.parse(body[0]))    
   end
 
+  def test_bad_route_with_wrong_http_method
+    env = Rack::MockRequest.env_for "/twirp/example.Haberdasher/MakeHat", 
+      method: "GET", input: '{"inches": 10}', "CONTENT_TYPE" => "application/json"
+    status, headers, body = haberdasher_service.call(env)
+
+    assert_equal 404, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({
+      "code" => 'bad_route', 
+      "msg" => 'HTTP request method must be POST',
+      "meta"=> {"twirp_invalid_route" => "GET /twirp/example.Haberdasher/MakeHat"},
+    }, JSON.parse(body[0]))
+  end
+
+  def test_bad_route_with_wrong_content_type
+    env = Rack::MockRequest.env_for "/twirp/example.Haberdasher/MakeHat", 
+      method: "POST", input: 'free text', "CONTENT_TYPE" => "text/plain"
+    status, headers, body = haberdasher_service.call(env)
+
+    assert_equal 404, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({
+      "code" => 'bad_route', 
+      "msg" => 'unexpected Content-Type: "text/plain". Content-Type header must be one of "application/json" or "application/protobuf"',
+      "meta"=> {"twirp_invalid_route" => "POST /twirp/example.Haberdasher/MakeHat"},
+    }, JSON.parse(body[0]))
+  end
+
+  def test_bad_route_with_wrong_path_json
+    env = json_req "/wrongpath", {}
+    status, headers, body = haberdasher_service.call(env)
+
+    assert_equal 404, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({
+      "code" => 'bad_route', 
+      "msg" => 'Invalid route. Expected format: POST {BaseURL}/twirp/(package.)?{Service}/{Method}',
+      "meta"=> {"twirp_invalid_route" => "POST /wrongpath"},
+    }, JSON.parse(body[0]))
+  end
+
+  def test_bad_route_with_wrong_path_protobuf
+    env = proto_req "/another/wrong.Path/MakeHat", Example::Empty.new()
+    status, headers, body = haberdasher_service.call(env)
+
+    assert_equal 404, status
+    assert_equal 'application/json', headers['Content-Type'] # error responses are always JSON, even for Protobuf requests
+    assert_equal({
+      "code" => 'bad_route', 
+      "msg" => 'Invalid route. Expected format: POST {BaseURL}/twirp/(package.)?{Service}/{Method}',
+      "meta"=> {"twirp_invalid_route" => "POST /another/wrong.Path/MakeHat"},
+    }, JSON.parse(body[0]))
+  end
+
+  # Handler should be able to return an instance of the proto message
+  def test_handler_returns_a_proto_message
+    svc = Example::Haberdasher.new(HaberdasherHandler.new do |size|
+      Example::Hat.new(inches: 11)
+    end)
+
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new
+    status, headers, body = svc.call(env)
+
+    assert_equal 200, status
+    assert_equal Example::Hat.new(inches: 11, color: ""), Example::Hat.decode(body[0])
+  end
+
+  # Handler should be able to return a hash with attributes
+  def test_handler_returns_hash_attributes
+    svc = Example::Haberdasher.new(HaberdasherHandler.new do |size|
+      {inches: 11}
+    end)
+
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new
+    status, headers, body = svc.call(env)
+
+    assert_equal 200, status
+    assert_equal Example::Hat.new(inches: 11, color: ""), Example::Hat.decode(body[0])
+  end
+
+  # Handler should be able to return nil, as a message with all zero-values
+  def test_handler_returns_nil
+    svc = Example::Haberdasher.new(HaberdasherHandler.new do |size|
+      nil
+    end)
+
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new
+    status, headers, body = svc.call(env)
+
+    assert_equal 200, status
+    assert_equal Example::Hat.new(inches: 0, color: ""), Example::Hat.decode(body[0])
+  end
+
+  # Handler should be able to return Twirp::Error values, that will trigger error responses
+  def test_handler_returns_twirp_error
+    svc = Example::Haberdasher.new(HaberdasherHandler.new do |size|
+      return Twirp::Error.new(:invalid_argument, "I don't like that size")
+    end)
+
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new(inches: 666)
+    status, headers, body = svc.call(env)
+    assert_equal 400, status
+    assert_equal 'application/json', headers['Content-Type'] # error responses are always JSON, even for Protobuf requests
+    assert_equal({
+      "code" => 'invalid_argument', 
+      "msg" => "I don't like that size",
+    }, JSON.parse(body[0]))
+  end
+
+  # Handler should be able to raise a Twirp::Exception, that will trigger error responses
+  def test_handler_raises_twirp_exception
+    svc = Example::Haberdasher.new(HaberdasherHandler.new do |size|
+      raise Twirp::Exception.new(:invalid_argument, "I don't like that size")
+    end)
+
+    env = proto_req "/twirp/example.Haberdasher/MakeHat", Example::Size.new(inches: 666)
+    status, headers, body = svc.call(env)
+    assert_equal 400, status
+    assert_equal 'application/json', headers['Content-Type'] # error responses are always JSON, even for Protobuf requests
+    assert_equal({
+      "code" => 'invalid_argument', 
+      "msg" => "I don't like that size",
+    }, JSON.parse(body[0]))
+  end
+
+
+  # Test Helpers
+  # ------------
+
+  def json_req(path, attrs)
+    Rack::MockRequest.env_for path, method: "POST", 
+      input: JSON.generate(attrs),
+      "CONTENT_TYPE" => "application/json"
+  end
+
+  def proto_req(path, proto_message)
+    Rack::MockRequest.env_for path, method: "POST", 
+      input: proto_message.class.encode(proto_message),
+      "CONTENT_TYPE" => "application/protobuf"
+  end
+
+  def haberdasher_service
+    Example::Haberdasher.new(HaberdasherHandler.new)
+  end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twirp
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Cyrus A. Forbes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-16 00:00:00.000000000 Z
+date: 2018-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -61,10 +61,12 @@ files:
 - example/main.rb
 - lib/twirp.rb
 - lib/twirp/error.rb
+- lib/twirp/exception.rb
 - lib/twirp/service.rb
 - lib/twirp/version.rb
 - protoc-gen-twirp_ruby/main.go
 - test/error_test.rb
+- test/fake_services.rb
 - test/service_test.rb
 - twirp.gemspec
 homepage: https://github.com/cyrusaf/ruby-twirp
@@ -93,4 +95,5 @@ specification_version: 4
 summary: Twirp services in Ruby.
 test_files:
 - test/error_test.rb
+- test/fake_services.rb
 - test/service_test.rb