twirp 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de95a607dde7addc708877a41f8b0f99453f1653
-  data.tar.gz: 7e84e7a36ad28d2d79c8d1ed793194fb3b549552
+  metadata.gz: 1e62a59d0a5485723751b5d1f15452c79d50a338
+  data.tar.gz: 54444353c6556ad93ac5d3eee42a844f0d9ee106
 SHA512:
-  metadata.gz: 7e553cb895062292854559ece9f472213cd66a4fd61bd81b671f9645d51d65057078692c4c6ef2ebf96697265efd0cd3d212b1d069cb08a588937e4a64770760
-  data.tar.gz: 2ad9fcca77b96fa7e5740be188c18d5f08e514acfb08c91bba1b785a5061f3cd2b325b074466076273ac94ae1b627ca0dd5f9dc247138fb7019205692a6304ed
+  metadata.gz: 0c6a92c2d93ef86c8ecffc4ce1a0581eb9b12bca892e018113ab5e4ac0d0c5bce949b1fe19fe8d14b53887f9273196832a4a3d99ed71d0bde07ccfbab5ca5c5d
+  data.tar.gz: 1ae6b8cb525b577e4b2eeb92114100f0d7b0444d3e5e2226dea24467934d464db92e304b6ed9899cbeff6aace09b1cf4b795448c0d10dac3066567cbfffa0e8f

data/README.md

@@ -1,150 +1,133 @@
 # Twirp
 
-Ruby implementation for for [Twirp](https://github.com/twitchtv/twirp). It includes:
+Twirp allows to easily define RPC services and clients that communicate using Protobuf or JSON over HTTP.
 
-  * [twirp gem](https://rubygems.org/gems/twirp) with classes for:
-    * Twirp::Error
-    * Twirp::Service
-    * Twirp::Client
-  * `protoc-gen-twirp_ruby` protoc plugin for code generation.
+The [Twirp protocol](https://twitchtv.github.io/twirp/docs/spec_v5.html) is implemented in multiple languages. This means that you can write your service in one language and automatically generate clients in other languages. Refer to the [Golang implementation](https://github.com/twitchtv/twirp) for more details on the project.
 
+## Install
 
-## Installation
+Add `gem "twirp"` to your Gemfile, or install with `gem install twirp`.
 
-Add `gem "twirp"` to your Gemfile, or install with:
+For code generation, you also need [protoc](https://github.com/golang/protobuf) (version 3+).
 
-```sh
-➜ gem install twirp
-```
-
-For code generation, Make sure that you have the [protobuf compiler](https://github.com/golang/protobuf) (install version 3+).
-And then use `go get` to install the ruby_twirp protoc plugin:
+## Service DSL
 
-```sh
-➜ go get -u github.com/cyrusaf/ruby-twirp/protoc-gen-twirp_ruby
-```
+A Twirp service defines RPC methods to send and receive Protobuf messages. For example, a `HelloWorld` service:
 
+```ruby
+require 'twirp'
 
-## Usage
+module Example
+  class HelloWorldService < Twirp::Service
+    package "example"
+    service "HelloWorld"
+    rpc :Hello, HelloRequest, HelloResponse, :ruby_method => :hello
+  end
 
-Let's make a `HelloWorld` service in Twirp.
+  class HelloWorldClient < Twirp::Client
+    client_for HelloWorldService
+  end
+end
+```
 
-### Code Generation
+The `HelloRequest` and `HelloResponse` messages are expected to be [google-protobuf](https://github.com/google/protobuf/tree/master/ruby) messages, which can also be defined from their DSL or auto-generated.
 
-Starting with a [Protobuf](https://developers.google.com/protocol-buffers/docs/proto3) file:
 
-```protobuf
-// hello_world/service.proto
+## Code Generation
 
-syntax = "proto3";
-package example;
+RPC messages and the service definition can be auto-generated form a `.proto` file.
 
-service HelloWorld {
-    rpc Hello(HelloRequest) returns (HelloResponse);
-}
+Code generation works with [protoc](https://github.com/golang/protobuf) (the protobuf compiler)
+using the `--ruby_out` option to generate messages and `--twirp_ruby_out` to generate services and clients.
 
-message HelloRequest {
-    string name = 1;
-}
+Make sure to install `protoc` (version 3+). Then use `go get` (Golang) to install the ruby_twirp protoc plugin:
 
-message HelloResponse {
-    string message = 1;
-}
+```sh
+go get -u github.com/cyrusaf/ruby-twirp/protoc-gen-twirp_ruby
 ```
 
-Run the `protoc` binary with the `twirp_ruby` plugin to auto-generate code:
+Given a [Protobuf](https://developers.google.com/protocol-buffers/docs/proto3) file like [example/hello_world/service.proto](example/hello_world/service.proto), you can auto-generate proto and twirp files with the command:
 
 ```sh
-➜ protoc --proto_path=. ./hello_world/service.proto --ruby_out=. --twirp_ruby_out=.
+protoc --proto_path=. --ruby_out=. --twirp_ruby_out=. ./example/hello_world/service.proto
 ```
 
-This will generate `/hello_world/service_pb.rb` and `hello_world/service_twirp.rb`. The generated code looks something like this:
+
+## Twirp Service
+
+A Twirp service delegates into a service handler to implement each rpc method. For example a handler for `HelloWorld`:
 
 ```ruby
-# Code generated by protoc-gen-twirp_ruby, DO NOT EDIT.
-require 'twirp'
+class HelloWorldHandler
 
-module Example
-  class HelloWorldService < Twirp::Service
-    package "example"
-    service "HelloWorld"
-    rpc :Hello, HelloRequest, HelloResponse, :ruby_method => :hello
+  def hello(req, env)
+    if req.name.empty?
+      Twirp::Error.invalid_argument("name is mandatory")
+    else
+      {message: "Hello #{req.name}"}
+    end
   end
 
-  class HelloWorldClient < Twirp::Client
-    client_for HelloWorldService
-  end
 end
 ```
 
-If you don't have Proto files, or don't like the code-generation step, you can always define your service and/or client using the DSL.
+The `req` argument is the request message (input), and the returned value is expected to be the response message, or a `Twirp::Error`.
 
+The `env` argument contains metadata related to the request (e.g. `env[:output_class]`), and other fields that could have been set from before-hooks (e.g. `env[:user_id]` from authentication).
 
-#### Implement the Service Handler
+### Unit Tests
 
-The Service Handler is a simple class that has one method to handle each rpc call.
-For each method, the `intput` is an instance of the protobuf request message. The Twirp `env`
-contains metadata related to the request, and other fields that could have been set from before
-hooks (e.g. `env[:user_id]` from authentication).
+Twirp already takes care of HTTP routing and serialization, you don't really need to test that part, insteadof that, focus on testing the handler using the method `.call_rpc(rpc_method, attrs={}, env={})` on the service:
 
 ```ruby
-class HelloWorldHandler
-  def hello(input, env)
-    {message: "Hello #{input.name}"}
+require 'minitest/autorun'
+
+class HelloWorldHandlerTest < Minitest::Test
+
+  def test_hello_responds_with_name
+    resp = service.call_rpc :Hello, name: "World"
+    assert_equal "Hello World", resp.message
+  end
+
+  def test_hello_name_is_mandatory
+    twerr = service.call_rpc :Hello, name: ""
+    assert_equal :invalid_argument, twerr.code
+  end
+
+  def service
+    handler = HelloWorldHandler.new()
+    Example::HelloWorldService.new(handler)
   end
 end
 ```
 
-### Mount the service to receive HTTP requests
 
-The service is a Rack app instantiated with your handler impementation.
+### Start the Service
 
-```ruby
-require 'rack'
+The service is a [Rack app](https://rack.github.io/) instantiated with your handler impementation. For example:
 
-handler = HelloWorldHandler.new() # your implementation
-service = Example::HelloWorldService.new(handler) # twirp-generated
+```ruby
+handler = HelloWorldHandler.new()
+service = Example::HelloWorldService.new(handler)
 
+require 'rack'
 Rack::Handler::WEBrick.run service
 ```
 
-Since it is a Rack app, it can easily be mounted onto a Rails route with `mount service, at: service.full_name`.
+Rack apps can also be mounted as Rails routes (e.g. `mount service, at: service.full_name`) and are compatible with many other HTTP frameworks.
 
-Now you can start the server and `curl` with JSON to test if everything works:
 
-```sh
-➜ curl --request POST \
-  --url http://localhost:8080/example.HelloWorld/Hello \
-  --header 'Content-Type: application/json' \
-  --data '{"name": "World"}'
-```
+## Twirp Clients
 
-### Unit testing the Service Handler
-
-Twirp already takes care of HTTP routing and serialization, you don't really need to build fake HTTP requests in your tests.
-Instead, you should focus on testing your Service Handler. For convenience, the Twirp Service has the method
-`.call_rpc(rpc_method, attrs={}, env={})` to call the handler with a fake Twirp env and making sure that the handler output is valid.
+Instantiate the client with the base_url:
 
 ```ruby
-require 'minitest/autorun'
-
-class HelloWorldHandlerTest < Minitest::Test
-  def test_hello_responds_with_name
-    service = Example::HelloWorld.new(HelloWorldHandler.new())
-    out = service.call_rpc :Hello, name: "World"
-    assert_equal "Hello World", out.message
-  end
-end
+c = Example::HelloWorldClient.new("http://localhost:3000")
 ```
 
-
-## Clients
-
-Generated clients implement the methods defined in the proto file. The response object contains `data` with an instance of the response class if successfull,
-or an `error` with an instance of `Twirp::Error` if there was a problem. For example, with the HelloWorld generated client:
+Clients implement the same methods as in the service and return a response object with `data` or `error`:
 
 ```ruby
-c = Example::HelloWorldClient.new("http://localhost:3000")
 resp = c.hello(name: "World")
 if resp.error
   puts resp.error #=> <Twirp::Error code:... msg:"..." meta:{...}>
@@ -153,33 +136,27 @@ else
 end
 ```
 
-You can also use the DSL to define your own client if you don't have easy access to the proto file or generated code:
+### Protobuf or JSON
 
-```ruby
-class MyClient < Twirp::Client
-  package "example"
-  service "MyService"
-  rpc :MyMethod, ReqClass, RespClass, :ruby_method => :my_method
-end
+Clients use Protobuf by default. To use JSON, set the `content_type` option:
 
-c = MyClient.new("http://localhost:3000")
-resp = c.my_method(ReqClass.new())
+```ruby
+c = Example::HelloWorldClient.new("http://localhost:3000", content_type: "application/json")
 ```
 
+### Configure Clients with Faraday
 
-### Configure client with Faraday
-
-A Twirp client takes care of routing, serialization and error handling.
-
-Other advanced HTTP options can be configured with [Faraday](https://github.com/lostisland/faraday) middleware. For example:
+While Twirp takes care of routing, serialization and error handling, other advanced HTTP options can be configured with [Faraday](https://github.com/lostisland/faraday) middleware. For example:
 
 ```ruby
-c = MyClient.new(Faraday.new(:url => 'http://localhost:3000') do |c|
-  c.use Faraday::Request::Retry # configure retries
+conn = Faraday.new(:url => 'http://localhost:3000') do |c|
+  c.use Faraday::Request::Retry
   c.use Faraday::Request::BasicAuthentication, 'login', 'pass'
   c.use Faraday::Response::Logger # log to STDOUT
-  c.use Faraday::Adapter::NetHttp # multiple adapters for different HTTP libraries
-end)
+  c.use Faraday::Adapter::NetHttp # can use different HTTP libraries
+end
+
+c = Example::HelloWorldClient.new(conn)
 ```
 
 ## Server Hooks

data/lib/twirp/client.rb

@@ -1,8 +1,9 @@
 require 'faraday'
 require 'json'
 
-require_relative "error"
-require_relative "service_dsl"
+require_relative 'encoding'
+require_relative 'error'
+require_relative 'service_dsl'
 
 module Twirp
 
@@ -23,37 +24,49 @@ module Twirp
     # Hook for ServiceDSL#rpc to define a new method client.<ruby_method>(input, opts).
     def self.rpc_define_method(rpcdef)
       define_method rpcdef[:ruby_method] do |input|
-        call_rpc(rpcdef[:rpc_method], input)
+        rpc(rpcdef[:rpc_method], input)
       end
     end
 
-    # Init with a Faraday connection.
-    def initialize(conn)
+    # Init with a Faraday connection, or a base_url that is used in a default connection.
+    # Clients use Content-Type="application/protobuf" by default. For JSON clinets use :content_type => "application/json".
+    def initialize(conn, opts={})
       @conn = case conn
-      when String then Faraday.new(url: conn) # init with hostname
-      when Faraday::Connection then conn # inith with connection
-      else raise ArgumentError.new("Expected hostname String or Faraday::Connection")
+        when String then Faraday.new(url: conn) # init with hostname
+        when Faraday::Connection then conn      # init with connection
+        else raise ArgumentError.new("Invalid conn #{conn.inspect}. Expected String hostname or Faraday::Connection")
+      end
+
+      @content_type = (opts[:content_type] || Encoding::PROTO)
+      if !Encoding.valid_content_type?(@content_type)
+        raise ArgumentError.new("Invalid content_type #{@content_type.inspect}. Expected one of #{Encoding.valid_content_types.inspect}")
       end
     end
 
-    def service_full_name; self.class.service_full_name; end
+    def service_full_name
+      self.class.service_full_name
+    end
 
     def rpc_path(rpc_method)
       "/#{service_full_name}/#{rpc_method}"
     end
 
-    def call_rpc(rpc_method, input)
+    # Make a remote procedure call to a defined rpc_method. The input can be a Proto message instance,
+    # or the attributes (Hash) to instantiate it. Returns a ClientResp instance with an instance of
+    # output_class, or a Twirp::Error. The input and output classes are the ones configued with the rpc DSL.
+    # If rpc_method was not defined with the rpc DSL then a response with a bad_route error is returned instead.
+    def rpc(rpc_method, input)
       rpcdef = self.class.rpcs[rpc_method.to_s]
       if !rpcdef
         return ClientResp.new(nil, Twirp::Error.bad_route("rpc not defined on this client"))
       end
 
       input = rpcdef[:input_class].new(input) if input.is_a? Hash
-      body = rpcdef[:input_class].encode(input)
+      body = Encoding.encode(input, rpcdef[:input_class], @content_type)
 
       resp = @conn.post do |r|
         r.url rpc_path(rpc_method)
-        r.headers['Content-Type'] = 'application/protobuf'
+        r.headers['Content-Type'] = @content_type
         r.body = body
       end
 
@@ -61,11 +74,11 @@ module Twirp
         return ClientResp.new(nil, error_from_response(resp))
       end
 
-      if resp.headers['Content-Type'] != 'application/protobuf'
-        return ClientResp.new(nil, Twirp::Error.internal("Expected response Content-Type \"application/protobuf\" but found #{resp.headers['Content-Type'].inspect}"))
+      if resp.headers['Content-Type'] != @content_type
+        return ClientResp.new(nil, Twirp::Error.internal("Expected response Content-Type #{@content_type.inspect} but found #{resp.headers['Content-Type'].inspect}"))
       end
 
-      data = rpcdef[:output_class].decode(resp.body)
+      data = Encoding.decode(resp.body, rpcdef[:output_class], @content_type)
       return ClientResp.new(data, nil)
     end
 
@@ -79,7 +92,7 @@ module Twirp
       err_attrs = nil
       begin
         err_attrs = JSON.parse(resp.body)
-      rescue JSON::ParserError => e
+      rescue JSON::ParserError
         return twirp_error_from_intermediary(status, "Response is not JSON", resp.body)
       end
 
@@ -109,7 +122,7 @@ module Twirp
         else :unknown
       end
 
-      twerr = Twirp::Error.new(code, code.to_s, {
+      Twirp::Error.new(code, code.to_s, {
         http_error_from_intermediary: "true",
         not_a_twirp_error_because: reason,
         status_code: status.to_s,

data/lib/twirp/encoding.rb

@@ -0,0 +1,32 @@
+module Twirp
+
+  module Encoding
+    JSON = "application/json"
+    PROTO = "application/protobuf"
+
+    def self.decode(bytes, msg_class, content_type)
+      case content_type
+      when JSON  then msg_class.decode_json(bytes)
+      when PROTO then msg_class.decode(bytes)
+      else raise ArgumentError.new("Invalid content_type")
+      end
+    end
+
+    def self.encode(msg_obj, msg_class, content_type)
+      case content_type
+      when JSON  then msg_class.encode_json(msg_obj)
+      when PROTO then msg_class.encode(msg_obj)
+      else raise ArgumentError.new("Invalid content_type")
+      end
+    end
+
+    def self.valid_content_type?(content_type)
+      content_type == Encoding::JSON || content_type == Encoding::PROTO
+    end
+
+    def self.valid_content_types
+      [Encoding::JSON, Encoding::PROTO]
+    end
+  end
+
+end

data/lib/twirp/service.rb

@@ -1,7 +1,8 @@
-require "json"
+require 'json'
 
-require_relative "error"
-require_relative "service_dsl"
+require_relative 'encoding'
+require_relative 'error'
+require_relative 'service_dsl'
 
 module Twirp
 
@@ -42,12 +43,12 @@ module Twirp
         env = {}
         bad_route = route_request(rack_env, env)
         return error_response(bad_route, env) if bad_route
-      
+
         @before.each do |hook|
           result = hook.call(rack_env, env)
           return error_response(result, env) if result.is_a? Twirp::Error
         end
-          
+
         output = call_handler(env)
         return error_response(output, env) if output.is_a? Twirp::Error
         return success_response(output, env)
@@ -59,7 +60,7 @@ module Twirp
         rescue => hook_e
           e = hook_e
         end
-        
+
         twerr = Twirp::Error.internal_with(e)
         return error_response(twerr, env)
       end
@@ -77,7 +78,7 @@ module Twirp
       env = env.merge(base_env)
       input = env[:input_class].new(input) if input.is_a? Hash
       env[:input] = input
-      env[:content_type] ||= "application/protobuf"
+      env[:content_type] ||= Encoding::PROTO
       env[:http_response_headers] = {}
       call_handler(env)
     end
@@ -95,11 +96,11 @@ module Twirp
       end
 
       content_type = rack_request.get_header("CONTENT_TYPE")
-      if content_type != "application/json" && content_type != "application/protobuf"
-        return bad_route_error("unexpected Content-Type: #{content_type.inspect}. Content-Type header must be one of application/json or application/protobuf", rack_request)
+      if !Encoding.valid_content_type?(content_type)
+        return bad_route_error("Unexpected Content-Type: #{content_type.inspect}. Content-Type header must be one of #{Encoding.valid_content_types.inspect}", rack_request)
       end
       env[:content_type] = content_type
-      
+
       path_parts = rack_request.fullpath.split("/")
       if path_parts.size < 3 || path_parts[-2] != self.full_name
         return bad_route_error("Invalid route. Expected format: POST {BaseURL}/#{self.full_name}/{Method}", rack_request)
@@ -114,8 +115,8 @@ module Twirp
 
       input = nil
       begin
-        input = decode_input(rack_request.body.read, env[:input_class], content_type)
-      rescue => e
+        input = Encoding.decode(rack_request.body.read, env[:input_class], content_type)
+      rescue
         return bad_route_error("Invalid request body for rpc method #{method_name.inspect} with Content-Type=#{content_type}", rack_request)
       end
 
@@ -128,19 +129,7 @@ module Twirp
       Twirp::Error.bad_route msg, twirp_invalid_route: "#{req.request_method} #{req.fullpath}"
     end
 
-    def decode_input(bytes, input_class, content_type)
-      case content_type
-      when "application/protobuf" then input_class.decode(bytes)
-      when "application/json"     then input_class.decode_json(bytes)
-      end
-    end
 
-    def encode_output(obj, output_class, content_type)
-      case content_type
-      when "application/protobuf" then output_class.encode(obj)
-      when "application/json"     then output_class.encode_json(obj)
-      end
-    end
 
     # Call handler method and return a Protobuf Message or a Twirp::Error.
     def call_handler(env)
@@ -166,7 +155,7 @@ module Twirp
         @on_success.each{|hook| hook.call(env) }
 
         headers = env[:http_response_headers].merge('Content-Type' => env[:content_type])
-        resp_body = encode_output(output, env[:output_class], env[:content_type])
+        resp_body = Encoding.encode(output, env[:output_class], env[:content_type])
         [200, headers, [resp_body]]
 
       rescue => e
@@ -201,7 +190,8 @@ module Twirp
     end
 
     def error_response_headers
-      {'Content-Type' => 'application/json'}
+      # Twirp errors are always JSON, even if the request was protobuf
+      {'Content-Type' => Encoding::JSON}
     end
 
   end

data/lib/twirp/service_dsl.rb

@@ -4,12 +4,12 @@ module Twirp
 
     # Configure service package name.
     def package(name)
-      @package = name
+      @package = name.to_s
     end
 
     # Configure service name.
     def service(name)
-      @service = name
+      @service = name.to_s
     end
 
     # Configure service rpc methods.

data/lib/twirp/version.rb

@@ -1,3 +1,3 @@
 module Twirp
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/client_test.rb

@@ -27,39 +27,39 @@ class ClientTest < Minitest::Test
     end
   end
 
-  def test_call_rpc_success
+  def test_rpc_success
     c = FooClient.new(conn_stub("/Foo/Foo") {|req|
       [200, protoheader, proto(Foo, foo: "out")]
     })
-    resp = c.call_rpc(:Foo, foo: "in")
+    resp = c.rpc :Foo, foo: "in"
     assert_nil resp.error
     refute_nil resp.data
     assert_equal "out", resp.data.foo
   end
 
-  def test_call_rpc_error
+  def test_rpc_error
     c = FooClient.new(conn_stub("/Foo/Foo") {|req|
       [400, {}, json(code: "invalid_argument", msg: "dont like empty")]
     })
-    resp = c.call_rpc(:Foo, foo: "")
+    resp = c.rpc :Foo, foo: ""
     assert_nil resp.data
     refute_nil resp.error
     assert_equal :invalid_argument, resp.error.code
     assert_equal "dont like empty", resp.error.msg
   end
 
-  def test_call_rpc_serialization_exception
+  def test_rpc_serialization_exception
     c = FooClient.new(conn_stub("/Foo/Foo") {|req|
       [200, protoheader, "badstuff"]
     })
     assert_raises Google::Protobuf::ParseError do
-      resp = c.call_rpc(:Foo, foo: "in")
+      c.rpc :Foo, foo: "in"
     end
   end
 
-  def test_call_rpc_invalid_method
+  def test_rpc_invalid_method
     c = FooClient.new("http://localhost")
-    resp = c.call_rpc(:OtherStuff, foo: "noo")
+    resp = c.rpc :OtherStuff, foo: "noo"
     assert_nil resp.data
     refute_nil resp.error
     assert_equal :bad_route, resp.error.code
@@ -174,6 +174,64 @@ class ClientTest < Minitest::Test
     assert_equal '{"msg":"I have no code of honor"}', resp.error.meta[:body]
   end
 
+  def test_json_success
+    c = Example::HaberdasherClient.new(conn_stub("/example.Haberdasher/MakeHat") {|req|
+      [200, jsonheader, '{"inches": 99, "color": "red"}']
+    }, content_type: "application/json")
+
+    resp = c.make_hat({})
+    assert_nil resp.error
+    assert_equal 99, resp.data.inches
+    assert_equal "red", resp.data.color
+  end
+
+  def test_json_serialized_request_body_attrs
+    c = Example::HaberdasherClient.new(conn_stub("/example.Haberdasher/MakeHat") {|req|
+      assert_equal "application/json", req.request_headers['Content-Type']
+      assert_equal '{"inches":666}', req.body # body is valid json
+      [200, jsonheader, '{}']
+    }, content_type: "application/json")
+
+    resp = c.make_hat(inches: 666)
+    assert_nil resp.error
+    refute_nil resp.data
+  end
+
+  def test_json_serialized_request_body_object
+    c = Example::HaberdasherClient.new(conn_stub("/example.Haberdasher/MakeHat") {|req|
+      assert_equal "application/json", req.request_headers['Content-Type']
+      assert_equal '{"inches":666}', req.body # body is valid json
+      [200, jsonheader, '{}']
+    }, content_type: "application/json")
+
+    resp = c.make_hat(Example::Size.new(inches: 666))
+    assert_nil resp.error
+    refute_nil resp.data
+  end
+
+  def test_json_error
+    c = Example::HaberdasherClient.new(conn_stub("/example.Haberdasher/MakeHat") {|req|
+      [500, {}, json(code: "internal", msg: "something went wrong")]
+    }, content_type: "application/json")
+
+    resp = c.make_hat(inches: 1)
+    assert_nil resp.data
+    refute_nil resp.error
+    assert_equal :internal, resp.error.code
+    assert_equal "something went wrong", resp.error.msg
+  end
+
+  def test_json_missing_response_header
+    c = Example::HaberdasherClient.new(conn_stub("/example.Haberdasher/MakeHat") {|req|
+      [200, {}, json(inches: 99, color: "red")]
+    }, content_type: "application/json")
+
+    resp = c.make_hat({})
+    refute_nil resp.error
+    assert_equal :internal, resp.error.code
+    assert_equal 'Expected response Content-Type "application/json" but found nil', resp.error.msg
+  end
+
 
   # Test Helpers
   # ------------
@@ -182,6 +240,10 @@ class ClientTest < Minitest::Test
     {'Content-Type' => 'application/protobuf'}
   end
 
+  def jsonheader
+    {'Content-Type' => 'application/json'}
+  end
+
   def proto(clss, attrs={})
     clss.encode(clss.new(attrs))
   end

data/test/service_test.rb

@@ -100,7 +100,7 @@ class ServiceTest < Minitest::Test
     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',
+      "msg"  => 'Unexpected Content-Type: "text/plain". Content-Type header must be one of ["application/json", "application/protobuf"]',
       "meta" => {"twirp_invalid_route" => "POST /example.Haberdasher/MakeHat"},
     }, JSON.parse(body[0]))
   end
@@ -178,7 +178,7 @@ class ServiceTest < Minitest::Test
     end
 
     rack_env = json_req "/example.Haberdasher/BadRouteMethod", inches: 10
-    status, headers, body = svc.call(rack_env)
+    status, _, body = svc.call(rack_env)
 
     assert_equal 404, status
     refute before_called
@@ -188,7 +188,7 @@ class ServiceTest < Minitest::Test
 
   def test_long_base_url
     rack_env = json_req "long-ass/base/url/twirp/example.Haberdasher/MakeHat", {inches: 10}
-    status, headers, body = haberdasher_service.call(rack_env)
+    status, _, body = haberdasher_service.call(rack_env)
 
     assert_equal 200, status
   end
@@ -200,7 +200,7 @@ class ServiceTest < Minitest::Test
     end)
 
     rack_env = proto_req "/example.Haberdasher/MakeHat", Example::Size.new
-    status, headers, body = svc.call(rack_env)
+    status, _, body = svc.call(rack_env)
 
     assert_equal 200, status
     assert_equal Example::Hat.new(inches: 11, color: ""), Example::Hat.decode(body[0])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twirp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Cyrus A. Forbes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-07 00:00:00.000000000 Z
+date: 2018-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -73,6 +73,7 @@ files:
 - README.md
 - lib/twirp.rb
 - lib/twirp/client.rb
+- lib/twirp/encoding.rb
 - lib/twirp/error.rb
 - lib/twirp/service.rb
 - lib/twirp/service_dsl.rb