twirp 1.2.0 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 83302ec929694b2ac96f016518ad5585de1fa65e
-  data.tar.gz: c79097cde99163118952b003b1402332f83b8c7f
+SHA256:
+  metadata.gz: 3f17d89c29073da7ebffa780c9e8577e10f2537e28900344d8a055e098aa5f3d
+  data.tar.gz: 2932fb1abec1db6b14c3b39e8b7d2f81e318c0bdc02639d83a99bdfacd26001f
 SHA512:
-  metadata.gz: ba357830275b3b4af11bc6f7319118a17a4405c338592ccb26293a0fed95622612b7f6d167214254eb6b0c05664d91f2ca5c847aeceb171e7c3dd0395f73d7ec
-  data.tar.gz: '05581b8cb43081e0e0103f6e3c50af6dfa0280b67355307418d287086e0c109e335bd0708f84eed4561eca7c288f1aa98884e71524a797ad07fe081a737efa3f'
+  metadata.gz: aca9edc089a15abfe4426880e8db8a8e2cac3f47ff056703e686dc14a3fe879a952a2b96c2de8bb06301b7406262601102c29fe48af6f9ead8775e9e2c76e35b
+  data.tar.gz: 10fc31c496e2fa4020ff9a643e08aa9ba333b0baa2324d1a42444ca6916d672a449eeef7ab22e674de81cc7a3e906d82fc97736714dfab29a999bfb4dd191f75

data/README.md

@@ -2,19 +2,21 @@
 
 [Twirp is a protocol](https://twitchtv.github.io/twirp/docs/spec_v5.html) for routing and serialization of services defined in a [.proto file](https://developers.google.com/protocol-buffers/docs/proto3), allowing easy implementation of RPC services with auto-generated clients in different languages.
 
-The [canonical implementation](https://github.com/twitchtv/twirp) is in Golang. The Twirp-Ruby project in this repository is the Ruby implementation.
+The [canonical implementation](https://github.com/twitchtv/twirp) is in Golang. The Twirp-Ruby project is the official implementation in Ruby for both server and clients.
 
 
 ## Install
 
 Add `gem "twirp"` to your Gemfile, or install with `gem install twirp`.
 
+To auto-generate Ruby code from a proto file, use the `protoc` plugin and the `--ruby_out` option ([see Wiki page](https://github.com/twitchtv/twirp-ruby/wiki/Code-Generation)).
+
 
 ## Documentation
 
-[Go to the Wiki](https://github.com/twitchtv/twirp-ruby/wiki).
+[On the wiki](https://github.com/twitchtv/twirp-ruby/wiki).
 
 
 ## Contributing
 
-[Go to the CONTRIBUTING file](CONTRIBUTING.md).
+[On the CONTRIBUTING file](CONTRIBUTING.md).

data/lib/twirp/client_json.rb

@@ -24,6 +24,7 @@ module Twirp
 
       package = opts[:package].to_s
       service = opts[:service].to_s
+      @strict = opts.fetch( :strict, false )
       raise ArgumentError.new("Missing option :service") if service.empty?
       @service_full_name = package.empty? ? service : "#{package}.#{service}"
     end
@@ -33,7 +34,8 @@ module Twirp
     def rpc(rpc_method, attrs={}, req_opts=nil)
       body = Encoding.encode_json(attrs)
 
-      resp = self.class.make_http_request(@conn, @service_full_name, rpc_method, Encoding::JSON, req_opts, body)
+      encoding = @strict ? Encoding::JSON_STRICT : Encoding::JSON
+      resp = self.class.make_http_request(@conn, @service_full_name, rpc_method, encoding, req_opts, body)
       if resp.status != 200
         return ClientResp.new(nil, self.class.error_from_response(resp))
       end

data/lib/twirp/encoding.rb

@@ -17,13 +17,18 @@ module Twirp
 
   module Encoding
     JSON = "application/json"
+    # An opt-in content type useful when curling or manually testing a twirp
+    # service.  This will fail if unknown fields are encountered. The return
+    # content type will be application/json.
+    JSON_STRICT = "application/json; strict=true"
     PROTO = "application/protobuf"
 
     class << self
 
       def decode(bytes, msg_class, content_type)
         case content_type
-        when JSON  then msg_class.decode_json(bytes)
+        when JSON then msg_class.decode_json(bytes, ignore_unknown_fields: true)
+        when JSON_STRICT then msg_class.decode_json(bytes, ignore_unknown_fields: false)
         when PROTO then msg_class.decode(bytes)
         else raise ArgumentError.new("Invalid content_type")
         end
@@ -31,7 +36,7 @@ module Twirp
 
       def encode(msg_obj, msg_class, content_type)
         case content_type
-        when JSON  then msg_class.encode_json(msg_obj)
+        when JSON, JSON_STRICT then msg_class.encode_json(msg_obj, emit_defaults: true)
         when PROTO then msg_class.encode(msg_obj)
         else raise ArgumentError.new("Invalid content_type")
         end
@@ -46,7 +51,7 @@ module Twirp
       end
 
       def valid_content_type?(content_type)
-        content_type == JSON || content_type == PROTO
+        content_type == JSON || content_type == PROTO || content_type == JSON_STRICT
       end
 
       def valid_content_types

data/lib/twirp/error.rb

@@ -16,15 +16,16 @@ module Twirp
   # Valid Twirp error codes and their mapping to related HTTP status.
   # This can also be used to check if a code is valid (check if not nil).
   ERROR_CODES_TO_HTTP_STATUS = {
-    canceled:             408, # RequestTimeout
-    invalid_argument:     400, # BadRequest
-    deadline_exceeded:    408, # RequestTimeout
+    canceled:             408, # Request Timeout
+    invalid_argument:     400, # Bad Request
+    malformed:            400, # Bad Request
+    deadline_exceeded:    408, # Request Timeout
     not_found:            404, # Not Found
     bad_route:            404, # Not Found
     already_exists:       409, # Conflict
     permission_denied:    403, # Forbidden
     unauthenticated:      401, # Unauthorized
-    resource_exhausted:   403, # Forbidden
+    resource_exhausted:   429, # Too Many Requests
     failed_precondition:  412, # Precondition Failed
     aborted:              409, # Conflict
     out_of_range:         400, # Bad Request
@@ -49,10 +50,10 @@ module Twirp
       ERROR_CODES_TO_HTTP_STATUS.key? code # one of the valid symbols
     end
 
-    # Use this constructors to ensure the errors have valid error codes. Example:
+    # Code constructors to ensure valid error codes. Example:
     #     Twirp::Error.internal("boom")
-    #     Twirp::Error.invalid_argument("foo is mandatory", argument: "foo")
-    #     Twirp::Error.permission_denied("thou shall not pass!", target: "Balrog")
+    #     Twirp::Error.invalid_argument("foo is mandatory", mymeta: "foobar")
+    #     Twirp::Error.permission_denied("Thou shall not pass!", target: "Balrog")
     ERROR_CODES.each do |code|
       define_singleton_method code do |msg, meta=nil|
         new(code, msg, meta)
@@ -62,7 +63,7 @@ module Twirp
     # Wrap another error as a Twirp::Error :internal.
     def self.internal_with(err)
       twerr = internal err.message, cause: err.class.name
-      twerr.cause = err
+      twerr.cause = err # availabe in error hook for inspection, but not in the response
       twerr
     end
 
@@ -80,6 +81,7 @@ module Twirp
       @meta = validate_meta(meta)
     end
 
+    # Key-value representation of the error. Can be directly serialized into JSON.
     def to_h
       h = {
         code: @code,

data/lib/twirp/service.rb

@@ -23,10 +23,19 @@ module Twirp
     extend ServiceDSL
 
     class << self
-      # Raise exceptions instead of handling them with exception_raised hooks.
+
+      # Whether to raise exceptions instead of handling them with exception_raised hooks.
       # Useful during tests to easily debug and catch unexpected exceptions.
-      # Default false.
-      attr_accessor :raise_exceptions
+      attr_accessor :raise_exceptions # Default: false
+
+      # Rack response with a Twirp::Error
+      def error_response(twerr)
+        status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twerr.code]
+        headers = {'Content-Type' => Encoding::JSON} # Twirp errors are always JSON, even if the request was protobuf
+        resp_body = Encoding.encode_json(twerr.to_h)
+        [status, headers, [resp_body]]
+      end
+
     end
 
     def initialize(handler)
@@ -98,29 +107,30 @@ module Twirp
   private
 
     # Parse request and fill env with rpc data.
-    # Returns a bad_route error if something went wrong.
+    # Returns a bad_route error if could not be properly routed to a Twirp method.
+    # Returns a malformed error if could not decode the body (either bad JSON or bad Protobuf)
     def route_request(rack_env, env)
       rack_request = Rack::Request.new(rack_env)
 
       if rack_request.request_method != "POST"
-        return bad_route_error("HTTP request method must be POST", rack_request)
+        return route_err(:bad_route, "HTTP request method must be POST", rack_request)
       end
 
       content_type = rack_request.get_header("CONTENT_TYPE")
       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)
+        return route_err(:bad_route, "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)
+        return route_err(:bad_route, "Invalid route. Expected format: POST {BaseURL}/#{self.full_name}/{Method}", rack_request)
       end
       method_name = path_parts[-1]
 
       base_env = self.class.rpcs[method_name]
       if !base_env
-        return bad_route_error("Invalid rpc method #{method_name.inspect}", rack_request)
+        return route_err(:bad_route, "Invalid rpc method #{method_name.inspect}", rack_request)
       end
       env.merge!(base_env) # :rpc_method, :input_class, :output_class
 
@@ -132,7 +142,7 @@ module Twirp
         if e.is_a?(Google::Protobuf::ParseError)
           error_msg += ": #{e.message.strip}"
         end
-        return bad_route_error(error_msg, rack_request)
+        return route_err(:malformed, error_msg, rack_request)
       end
 
       env[:input] = input
@@ -140,12 +150,11 @@ module Twirp
       return
     end
 
-    def bad_route_error(msg, req)
-      Twirp::Error.bad_route msg, twirp_invalid_route: "#{req.request_method} #{req.fullpath}"
+    def route_err(code, msg, req)
+      Twirp::Error.new code, msg, twirp_invalid_route: "#{req.request_method} #{req.fullpath}"
     end
 
 
-
     # Call handler method and return a Protobuf Message or a Twirp::Error.
     def call_handler(env)
       m = env[:ruby_method]
@@ -181,11 +190,7 @@ module Twirp
     def error_response(twerr, env)
       begin
         @on_error.each{|hook| hook.call(twerr, env) }
-
-        status = Twirp::ERROR_CODES_TO_HTTP_STATUS[twerr.code]
-        resp_body = Encoding.encode_json(twerr.to_h)
-        [status, error_response_headers, [resp_body]]
-
+        self.class.error_response(twerr)
       rescue => e
         return exception_response(e, env)
       end
@@ -193,6 +198,7 @@ module Twirp
 
     def exception_response(e, env)
       raise e if self.class.raise_exceptions
+
       begin
         @exception_raised.each{|hook| hook.call(e, env) }
       rescue => hook_e
@@ -200,13 +206,7 @@ module Twirp
       end
 
       twerr = Twirp::Error.internal_with(e)
-      resp_body = Encoding.encode_json(twerr.to_h)
-      [500, error_response_headers, [resp_body]]
-    end
-
-    def error_response_headers
-      # Twirp errors are always JSON, even if the request was protobuf
-      {'Content-Type' => Encoding::JSON}
+      self.class.error_response(twerr)
     end
 
   end

data/lib/twirp/version.rb

@@ -12,5 +12,5 @@
 # permissions and limitations under the License.
 
 module Twirp
-  VERSION = "1.2.0"
+  VERSION = "1.7.2"
 end

data/test/client_json_test.rb

@@ -29,6 +29,20 @@ class ClientJSONTest < Minitest::Test
     assert_equal 3, resp.data["blah_resp"]
   end
 
+  def test_client_json_strict_encoding
+    c = Twirp::ClientJSON.new(conn_stub("/my.pkg.Talking/Blah") {|req|
+      assert_equal "application/json; strict=true", req.request_headers['Content-Type']
+      assert_equal '{"blah1":1,"blah2":2}', req.body # body is json
+
+      [200, {}, '{"blah_resp": 3}']
+    }, package: "my.pkg", service: "Talking", strict: true)
+
+    resp = c.rpc :Blah, blah1: 1, blah2: 2
+    assert_nil resp.error
+    refute_nil resp.data
+    assert_equal 3, resp.data["blah_resp"]
+  end
+
   def test_client_json_error
     c = Twirp::ClientJSON.new(conn_stub("/Foo/Foomo") {|req|
       [400, {}, '{"code": "invalid_argument", "msg": "dont like empty"}']

data/test/error_test.rb

@@ -3,9 +3,9 @@ require 'minitest/autorun'
 require_relative '../lib/twirp/error'
 
 class TestErrorCodes < Minitest::Test
-  
+
   def test_error_codes
-    assert_equal 17, Twirp::ERROR_CODES.size
+    assert_equal 18, Twirp::ERROR_CODES.size
 
     # all codes should be symbols
     Twirp::ERROR_CODES.each do |code|
@@ -13,13 +13,13 @@ class TestErrorCodes < Minitest::Test
     end
 
     # check some codes
-    assert_includes Twirp::ERROR_CODES, :internal 
+    assert_includes Twirp::ERROR_CODES, :internal
     assert_includes Twirp::ERROR_CODES, :not_found
     assert_includes Twirp::ERROR_CODES, :invalid_argument
   end
 
   def test_codes_to_http_status
-    assert_equal 17, Twirp::ERROR_CODES_TO_HTTP_STATUS.size
+    assert_equal 18, Twirp::ERROR_CODES_TO_HTTP_STATUS.size
 
     assert_equal 404, Twirp::ERROR_CODES_TO_HTTP_STATUS[:not_found]
     assert_equal 500, Twirp::ERROR_CODES_TO_HTTP_STATUS[:internal]
@@ -52,7 +52,7 @@ class TestTwirpError < Minitest::Test
   end
 
   def test_invalid_constructor # Make sure that only supported codes are implemented (prevent bad metaprogramming)
-    assert_raises NoMethodError do 
+    assert_raises NoMethodError do
       Twirp::invalid_code_error "should fail"
     end
   end
@@ -67,7 +67,7 @@ class TestTwirpError < Minitest::Test
   def test_new_with_valid_metadata
     err = Twirp::Error.new(:internal, "woops", "meta" => "data", "for this" => "error")
     assert_equal "data", err.meta["meta"]
-    assert_equal "error", err.meta["for this"] 
+    assert_equal "error", err.meta["for this"]
     assert_nil err.meta["something else"]
 
     err = Twirp::Error.new(:internal, "woops", meta: "data")
@@ -78,11 +78,11 @@ class TestTwirpError < Minitest::Test
   def test_invalid_metadata
     Twirp::Error.new(:internal, "woops") # ensure the base case doesn't error
 
-    assert_raises ArgumentError do 
+    assert_raises ArgumentError do
       Twirp::Error.new(:internal, "woops", "string key" => :non_string_value)
     end
 
-    assert_raises ArgumentError do 
+    assert_raises ArgumentError do
       Twirp::Error.new(:internal, "woops", "valid key" => "valid val", "bad_one" => 666)
     end
   end
@@ -91,8 +91,8 @@ class TestTwirpError < Minitest::Test
     # returns a hash with attributes
     err = Twirp::Error.new(:internal, "err msg", "key" => "val")
     assert_equal({code: :internal, msg: "err msg", meta: {"key" => "val"}}, err.to_h)
-  
-    # skips meta if not included 
+
+    # skips meta if not included
     err = Twirp::Error.new(:internal, "err msg")
     assert_equal({code: :internal, msg: "err msg"}, err.to_h)
   end

data/test/service_test.rb

@@ -12,6 +12,15 @@ class ServiceTest < Minitest::Test
     Example::Haberdasher.raise_exceptions = true # configure for testing to make debugging easier
   end
 
+  # Class method to make a Rack response with a Twirp errpr
+  def test_service_error_response
+    twerr = Twirp::Error.invalid_argument('foo')
+    resp = Twirp::Service.error_response(twerr)
+    assert_equal 400, resp[0]
+    assert_equal 'application/json', resp[1]['Content-Type']
+    assert_equal '{"code":"invalid_argument","msg":"foo"}', resp[2][0]
+  end
+
   # The rpc DSL should properly build the base Twirp environment for each rpc method.
   def test_rpcs_accessor
     assert_equal 1, Example::Haberdasher.rpcs.size
@@ -55,6 +64,24 @@ class ServiceTest < Minitest::Test
     assert_equal({"inches" => 10, "color" => "white"}, JSON.parse(body[0]))
   end
 
+  def test_successful_json_strict_request_emit_defaults
+    rack_env = json_strict_req "/example.Haberdasher/MakeHat", inches: 0 # default int value
+    status, headers, body = haberdasher_service.call(rack_env)
+
+    assert_equal 200, status
+    assert_equal 'application/json; strict=true', headers['Content-Type']
+    assert_equal({"inches" => 0, "color" => "white"}, JSON.parse(body[0]))
+  end
+
+  def test_successful_json_request_emit_defaults
+    rack_env = json_req "/example.Haberdasher/MakeHat", inches: 0 # default int value
+    status, headers, body = haberdasher_service.call(rack_env)
+
+    assert_equal 200, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({"inches" => 0, "color" => "white"}, JSON.parse(body[0]))
+  end
+
   def test_successful_proto_request
     rack_env = proto_req "/example.Haberdasher/MakeHat", Example::Size.new(inches: 10)
     status, headers, body = haberdasher_service.call(rack_env)
@@ -136,10 +163,10 @@ class ServiceTest < Minitest::Test
       method: "POST", input: 'bad json', "CONTENT_TYPE" => "application/json"
     status, headers, body = haberdasher_service.call(rack_env)
 
-    assert_equal 404, status
+    assert_equal 400, status
     assert_equal 'application/json', headers['Content-Type']
     assert_equal({
-      "code" => 'bad_route',
+      "code" => 'malformed',
       "msg"  => 'Invalid request body for rpc method "MakeHat" with Content-Type=application/json: ' +
                 "Error occurred during parsing: Parse error at 'bad json'",
       "meta" => {"twirp_invalid_route" => "POST /example.Haberdasher/MakeHat"},
@@ -151,16 +178,39 @@ class ServiceTest < Minitest::Test
       method: "POST", input: 'bad protobuf', "CONTENT_TYPE" => "application/protobuf"
     status, headers, body = haberdasher_service.call(rack_env)
 
-    assert_equal 404, status
+    assert_equal 400, status
     assert_equal 'application/json', headers['Content-Type']
     assert_equal({
-      "code" => 'bad_route',
+      "code" => 'malformed',
       "msg"  => 'Invalid request body for rpc method "MakeHat" with Content-Type=application/protobuf: ' +
                 'Error occurred during parsing: Unexpected EOF inside skipped data',
       "meta" => {"twirp_invalid_route" => "POST /example.Haberdasher/MakeHat"},
     }, JSON.parse(body[0]))
   end
 
+  def test_json_request_ignores_unknown_fields
+    rack_env = json_req "/example.Haberdasher/MakeHat", inches: 10, fake: 3
+    status, headers, body = haberdasher_service.call(rack_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_json_strict_request_fails_unknown_fields
+    rack_env = json_strict_req "/example.Haberdasher/MakeHat", inches: 10, fake: 3
+    status, headers, body = haberdasher_service.call(rack_env)
+
+    assert_equal 400, status
+    assert_equal 'application/json', headers['Content-Type']
+    assert_equal({
+      "code" => 'malformed',
+      "msg"  => 'Invalid request body for rpc method "MakeHat" with Content-Type=application/json; strict=true: ' +
+                "Error occurred during parsing: No such field: fake",
+      "meta" => {"twirp_invalid_route" => "POST /example.Haberdasher/MakeHat"},
+    }, JSON.parse(body[0]))
+  end
+
   def test_bad_route_triggers_on_error_hooks
     svc = haberdasher_service
 
@@ -782,6 +832,12 @@ class ServiceTest < Minitest::Test
       "CONTENT_TYPE" => "application/json"
   end
 
+  def json_strict_req(path, attrs)
+    Rack::MockRequest.env_for path, method: "POST",
+      input: JSON.generate(attrs),
+      "CONTENT_TYPE" => "application/json; strict=true"
+  end
+
   def proto_req(path, proto_message)
     Rack::MockRequest.env_for path, method: "POST",
       input: proto_message.class.encode(proto_message),

data/twirp.gemspec

@@ -19,10 +19,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 1.9'
-  spec.add_runtime_dependency 'google-protobuf', '~> 3.0', '>= 3.0.0'
-  spec.add_runtime_dependency 'faraday', '~> 0' # for clients
+  spec.add_runtime_dependency 'google-protobuf', '~> 3.0', '>= 3.7.0'
+  spec.add_runtime_dependency 'faraday', '< 2' # for clients
 
   spec.add_development_dependency 'bundler', '~> 1'
   spec.add_development_dependency 'minitest', '>= 5'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rack', '>= 2.2.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: twirp
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.7.2
 platform: ruby
 authors:
 - Cyrus A. Forbes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-11 00:00:00.000000000 Z
+date: 2020-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -20,7 +20,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -30,21 +30,21 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.7.0
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -87,6 +87,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
 description: Twirp is a simple RPC framework with protobuf service definitions. The
   Twirp gem provides native support for Ruby.
 email:
@@ -134,15 +148,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Twirp services in Ruby.
 test_files:
-- test/client_json_test.rb
 - test/client_test.rb
 - test/error_test.rb
-- test/fake_services.rb
 - test/license_header_test.rb
+- test/fake_services.rb
 - test/service_test.rb
+- test/client_json_test.rb