restify 1.15.2 → 2.0.1

data/lib/restify/relation.rb

@@ -19,32 +19,35 @@ module Restify
       @template = Addressable::Template.new template
     end
 
-    def request(method, data, params, opts = {})
-      context.request method, expand(params), **opts, data: data
+    def request(method:, params: {}, **opts)
+      context.request(method, expand(params), **opts)
     end
 
-    def get(params = {}, opts = {})
-      request :get, nil, params, opts
+    def get(data = {}, params: {}, **opts)
+      request(**opts, method: :get, params: data.merge(params))
     end
 
-    def head(params = {}, opts = {})
-      request :head, nil, params, opts
+    def head(data = {}, params: {}, **opts)
+      request(**opts, method: :head, params: data.merge(params))
     end
 
-    def delete(params = {}, opts = {})
-      request :delete, nil, params, opts
+    def delete(data = {}, params: {}, **opts)
+      request(**opts, method: :delete, params: data.merge(params))
     end
 
-    def post(data = {}, params = {}, opts = {})
-      request :post, data, params, opts
+    def post(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :post)
     end
 
-    def put(data = {}, params = {}, opts = {})
-      request :put, data, params, opts
+    def put(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :put)
     end
 
-    def patch(data = {}, params = {}, opts = {})
-      request :patch, data, params, opts
+    def patch(data = nil, **opts)
+      opts[:data] = data unless opts.key?(:data)
+      request(**opts, method: :patch)
     end
 
     def ==(other)
@@ -72,14 +75,39 @@ module Restify
     private
 
     def convert(params)
-      params.each_pair.each_with_object({}) do |param, hash|
+      params.each_pair.with_object({}) do |param, hash|
         hash[param[0]] = convert_param param[1]
       end
     end
 
-    def convert_param(value)
-      return value.to_param.to_s if value.respond_to?(:to_param)
+    def convert_param(value, nesting: true)
+      # Convert parameters into values acceptable in a
+      # Addressable::Template, with some support for #to_param, but not
+      # for basic types.
+      if value == nil || # rubocop:disable Style/NilComparison
+         value.is_a?(Numeric) ||
+         value.is_a?(Symbol) ||
+         value.is_a?(Hash) ||
+         value == true ||
+         value == false ||
+         value.respond_to?(:to_str)
+        return value
+      end
+
+      # Handle array-link things first to *not* call #to_params on them,
+      # as that will concatenation any Array to "a/b/c". Instead, we
+      # want to check one level of basic types only.
+      if value.respond_to?(:to_ary)
+        return nesting ? value.to_ary.map {|val| convert_param(val, nesting: false) } : value
+      end
+
+      # Handle Rails' #to_param for non-basic types
+      if value.respond_to?(:to_param)
+        return value.to_param
+      end
 
+      # Otherwise, pass raw value to Addressable::Template and let it
+      # explode.
       value
     end
 

data/lib/restify/request.rb

@@ -29,12 +29,12 @@ module Restify
     #
     attr_reader :timeout
 
-    def initialize(opts = {})
-      @method  = opts.fetch(:method, :get).downcase
-      @uri     = opts.fetch(:uri) { raise ArgumentError.new ':uri required.' }
-      @data    = opts.fetch(:data, nil)
-      @timeout = opts.fetch(:timeout, 300)
-      @headers = opts.fetch(:headers, {})
+    def initialize(uri:, method: :get, data: nil, timeout: 300, headers: {})
+      @uri     = uri
+      @method  = method.to_s.downcase
+      @data    = data
+      @timeout = timeout
+      @headers = headers
 
       @headers['Content-Type'] ||= 'application/json' if json?
     end

data/lib/restify/timeout.rb

@@ -71,9 +71,9 @@ module Restify
         @target = target
 
         if @target
-          super "Operation on #{@target} timed out"
+          super("Operation on #{@target} timed out")
         else
-          super 'Operation timed out'
+          super('Operation timed out')
         end
       end
     end

data/lib/restify/version.rb

@@ -2,9 +2,9 @@
 
 module Restify
   module VERSION
-    MAJOR = 1
-    MINOR = 15
-    PATCH = 2
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 1
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 

data/lib/restify.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 require 'restify/version'
 
-require 'hashie'
 require 'concurrent'
 require 'addressable/uri'
 require 'addressable/template'

data/spec/restify/cache_spec.rb

@@ -1,36 +1,40 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'active_support'
+require 'active_support/cache'
 
 describe Restify::Cache do
-  subject { cache }
+  subject(:cache) { described_class.new(store) }
 
-  let(:store) { double 'store' }
-  let(:cache) { described_class.new store }
+  let(:store) { instance_double(ActiveSupport::Cache::Store) }
 
   describe '#call' do
-    let(:request) { double 'request' }
-    let(:promise0) { double 'promise0' }
-    let(:promise1) { double 'promise1' }
-    let(:response) { double 'response' }
+    let(:request) { instance_double(Restify::Request) }
+    let(:promise0) { instance_double(Restify::Promise, 'promise0') } # rubocop:disable RSpec/IndexedLet
+    let(:promise1) { instance_double(Restify::Promise, 'promise1') } # rubocop:disable RSpec/IndexedLet
+    let(:response) { instance_double(Restify::Response) }
 
     it 'yields with promises' do
-      expect(promise0).to receive(:then).and_yield(response).and_return(promise1)
+      allow(promise0).to receive(:then).and_yield(response).and_return(promise1)
 
-      expect(subject.call(request) { promise0 }).to eq promise1
+      expect(cache.call(request) { promise0 }).to eq promise1
     end
 
     it 'caches new responses' do
-      expect(promise0).to receive(:then).and_yield(response)
+      allow(promise0).to receive(:then).and_yield(response)
+
+      # TODO: Do not stub inside tested object
       expect(cache).to receive(:cache).with(response)
 
-      subject.call(request) { promise0 }
+      cache.call(request) { promise0 }
     end
 
     it 'returns with match' do
+      # TODO: Do not stub inside tested object
       expect(cache).to receive(:match).with(request).and_return(response)
 
-      expect(subject.call(request)).to eq response
+      expect(cache.call(request)).to eq response
     end
   end
 end

data/spec/restify/context_spec.rb

@@ -20,7 +20,7 @@ describe Restify::Context do
       describe '#adapter' do
         subject { super().options[:adapter] }
 
-        let(:kwargs) { {adapter: double('adapter')} }
+        let(:kwargs) { {adapter: instance_double(Restify::Adapter::Base)} }
 
         it 'adapter is not serialized' do
           expect(subject).to equal nil
@@ -30,7 +30,7 @@ describe Restify::Context do
       describe '#cache' do
         subject { super().options[:cache] }
 
-        let(:kwargs) { {adapter: double('cache')} }
+        let(:kwargs) { {cache: Object.new} }
 
         it 'cache is not serialized' do
           expect(subject).to equal nil
@@ -52,7 +52,12 @@ describe Restify::Context do
       subject { load }
 
       let(:dump) { YAML.dump(context) }
-      let(:load) { YAML.load(dump) } # rubocop:disable Security/YAMLLoad
+
+      if RUBY_VERSION >= '3.1'
+        let(:load) { YAML.safe_load(dump, permitted_classes: [Restify::Context, Symbol]) }
+      else
+        let(:load) { YAML.load(dump) }
+      end
 
       include_examples 'serialization'
     end

data/spec/restify/error_spec.rb

@@ -2,16 +2,13 @@
 
 require 'spec_helper'
 
-describe Restify::ResponseError do
-  let(:response) { double 'response' }
+describe Restify::ResponseError do # rubocop:disable RSpec/SpecFilePathFormat
+  let(:response) { instance_double(Restify::Response) }
   let(:message) { 'Error' }
   let(:uri) { 'http://localhost' }
 
   before do
-    allow(response).to receive(:uri).and_return(uri)
-    allow(response).to receive(:code).and_return(code)
-    allow(response).to receive(:message).and_return(message)
-    allow(response).to receive(:decoded_body).and_return({})
+    allow(response).to receive_messages(uri: uri, code: code, message: message, decoded_body: {})
   end
 
   describe '.from_code' do
@@ -20,61 +17,61 @@ describe Restify::ResponseError do
     context 'with 400 Bad Request' do
       let(:code) { 400 }
 
-      it { is_expected.to be_a ::Restify::BadRequest }
+      it { is_expected.to be_a Restify::BadRequest }
     end
 
     context 'with 401 Unauthorized' do
       let(:code) { 401 }
 
-      it { is_expected.to be_a ::Restify::Unauthorized }
+      it { is_expected.to be_a Restify::Unauthorized }
     end
 
     context 'with 404 Unauthorized' do
       let(:code) { 404 }
 
-      it { is_expected.to be_a ::Restify::NotFound }
+      it { is_expected.to be_a Restify::NotFound }
     end
 
     context 'with 406 Not Acceptable' do
       let(:code) { 406 }
 
-      it { is_expected.to be_a ::Restify::NotAcceptable }
+      it { is_expected.to be_a Restify::NotAcceptable }
     end
 
     context 'with 410 Gone' do
       let(:code) { 410 }
 
-      it { is_expected.to be_a ::Restify::Gone }
+      it { is_expected.to be_a Restify::Gone }
     end
 
     context 'with 422 Unprocessable Entity' do
       let(:code) { 422 }
 
-      it { is_expected.to be_a ::Restify::UnprocessableEntity }
+      it { is_expected.to be_a Restify::UnprocessableEntity }
     end
 
     context 'with 500 Internal Server Error' do
       let(:code) { 500 }
 
-      it { is_expected.to be_a ::Restify::InternalServerError }
+      it { is_expected.to be_a Restify::InternalServerError }
     end
 
     context 'with 502 Bad Gateway' do
       let(:code) { 502 }
 
-      it { is_expected.to be_a ::Restify::BadGateway }
+      it { is_expected.to be_a Restify::BadGateway }
     end
 
     context 'with 503 Service Unavailable' do
       let(:code) { 503 }
 
-      it { is_expected.to be_a ::Restify::ServiceUnavailable }
+      it { is_expected.to be_a Restify::ServiceUnavailable }
     end
 
     context 'with 504 Gateway Timeout' do
       let(:code) { 504 }
 
-      it { is_expected.to be_a ::Restify::GatewayTimeout }
+      it { is_expected.to be_a Restify::GatewayTimeout }
     end
   end
 end

data/spec/restify/features/head_requests_spec.rb

@@ -16,23 +16,24 @@ describe Restify do
   end
 
   describe 'HEAD requests' do
-    subject { Restify.new('http://localhost:9292/base').head(params).value! }
+    subject(:value) { Restify.new('http://localhost:9292/base').head(params:).value! }
 
     let(:params) { {} }
 
     it 'returns a resource with access to headers' do
-      expect(subject.response.headers).to include('CONTENT_LENGTH' => '333')
+      expect(value.response.headers).to include('CONTENT_LENGTH' => '333')
     end
 
     it 'parses Link headers into relations' do
-      expect(subject).to have_relation :neat
+      expect(value).to have_relation :neat
     end
 
     context 'with params' do
       let(:params) { {foo: 'bar'} }
 
       it 'adds them to the query string' do
-        subject
+        value
+
         expect(
           request_stub.with(query: {foo: 'bar'}),
         ).to have_been_requested

data/spec/restify/features/opentelemetry_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  subject(:echo) { resource.data }
+
+  let(:resource) { Restify.new('http://localhost:9292/echo').get.value! }
+
+  before do
+    expect(OTLE_EXPORTER.finished_spans).to be_empty
+  end
+
+  describe 'OpenTelemetry' do
+    it 'adds propagation header' do
+      expect(echo).to have_key('HTTP_TRACEPARENT')
+    end
+
+    it 'adds spans' do
+      resource
+
+      spans = OTLE_EXPORTER.finished_spans
+      expect(spans.size).to eq 2
+
+      spans[1].tap do |span|
+        expect(span.instrumentation_scope.name).to eq 'restify'
+        expect(span.instrumentation_scope.version).to eq Restify::VERSION.to_s
+        expect(span.attributes).to eq({
+          'http.request.method' => 'GET',
+          'http.response.status_code' => 200,
+          'server.address' => 'localhost',
+          'server.port' => 9292,
+          'url.full' => 'http://localhost:9292/echo',
+          'url.scheme' => 'http',
+        })
+      end
+
+      # Latest span has to be from the Ethon instrumentation and must
+      # have the Restify span as a parent.
+      spans[0].tap do |span|
+        expect(span.instrumentation_scope.name).to match(/Ethon/)
+        expect(span.parent_span_id).to eq spans[1].span_id
+      end
+    end
+  end
+end

data/spec/restify/features/request_bodies_spec.rb

@@ -13,7 +13,7 @@ describe Restify do
   end
 
   describe 'Request body' do
-    subject { Restify.new('http://localhost:9292/base').post(body, {}, {headers: headers}).value! }
+    subject(:value) { Restify.new('http://localhost:9292/base').post(body, headers:).value! }
 
     let(:headers) { {} }
 
@@ -21,7 +21,7 @@ describe Restify do
       let(:body) { {a: 'b', c: 'd'} }
 
       it 'is serialized as JSON' do
-        subject
+        value
 
         expect(
           request_stub.with(body: '{"a":"b","c":"d"}'),
@@ -29,7 +29,7 @@ describe Restify do
       end
 
       it 'gets a JSON media type for free' do
-        subject
+        value
 
         expect(
           request_stub.with(headers: {'Content-Type' => 'application/json'}),
@@ -40,7 +40,7 @@ describe Restify do
         let(:headers) { {'Content-Type' => 'application/vnd.api+json'} }
 
         it 'respects the override' do
-          subject
+          value
 
           expect(
             request_stub.with(headers: {'Content-Type' => 'application/vnd.api+json'}),
@@ -53,7 +53,7 @@ describe Restify do
       let(:body) { 'a=b&c=d' }
 
       it 'is sent as provided' do
-        subject
+        value
 
         expect(
           request_stub.with(body: 'a=b&c=d'),
@@ -61,10 +61,10 @@ describe Restify do
       end
 
       it 'does not get a JSON media type' do
-        subject
+        value
 
         expect(
-          request_stub.with {|req| req.headers['Content-Type'] !~ /json/ },
+          request_stub.with {|req| !req.headers['Content-Type'].include?('json') },
         ).to have_been_requested
       end
 
@@ -72,7 +72,7 @@ describe Restify do
         let(:headers) { {'Content-Type' => 'application/text'} }
 
         it 'respects the override' do
-          subject
+          value
 
           expect(
             request_stub.with(headers: {'Content-Type' => 'application/text'}),

data/spec/restify/features/request_errors_spec.rb

@@ -2,13 +2,13 @@
 
 require 'spec_helper'
 
-describe Restify, adapter: ::Restify::Adapter::Typhoeus do
+describe Restify, adapter: 'Restify::Adapter::Typhoeus' do
   before do
     stub_request(:get, 'http://stubserver/base').to_timeout
   end
 
   describe 'Timeout' do
-    subject(:request) { Restify.new('http://localhost:9292/base').get({}, timeout: 0.1).value! }
+    subject(:request) { Restify.new('http://localhost:9292/base').get(timeout: 0.1).value! }
 
     it 'throws a network error' do
       expect { request }.to raise_error Restify::NetworkError do |error|

data/spec/restify/features/request_headers_spec.rb

@@ -20,8 +20,7 @@ describe Restify do
 
     it 'sends the headers only for that request' do
       root = context.get(
-        {},
-        {headers: {'Accept' => 'application/msgpack, application/json'}},
+        headers: {'Accept' => 'application/msgpack, application/json'},
       ).value!
 
       root.rel(:self).get.value!
@@ -53,8 +52,7 @@ describe Restify do
 
     it 'can overwrite headers for single requests' do
       root = context.get(
-        {},
-        {headers: {'Accept' => 'application/xml'}},
+        headers: {'Accept' => 'application/xml'},
       ).value!
 
       root.rel(:self).get.value!
@@ -69,8 +67,7 @@ describe Restify do
 
     it 'can add additional headers for single requests' do
       root = context.get(
-        {},
-        {headers: {'X-Custom' => 'foobar'}},
+        headers: {'X-Custom' => 'foobar'},
       ).value!
 
       root.rel(:self).get.value!

data/spec/restify/features/response_errors_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Restify do
   before do
     stub_request(:get, 'http://stubserver/base')
-      .to_return(status: http_status, headers: headers)
+      .to_return(status: http_status, headers:)
   end
 
   let(:http_status) { '200 OK' }

data/spec/restify/features/webmock_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify do
+  before do
+    WebMock.enable!
+  end
+
+  after do
+    WebMock.disable!(except: %i[net_http])
+  end
+
+  describe 'WebMock' do
+    subject(:resource) { Restify.new('http://www.example.com/base').get.value! }
+
+    it 'can stub requests' do
+      stub_request(:any, 'http://www.example.com/base')
+
+      expect(resource.response.status).to eq(:ok)
+    end
+
+    it 'raises error for not stubbed requests' do
+      expect { resource }.to raise_error WebMock::NetConnectNotAllowedError
+    end
+  end
+end

data/spec/restify/global_spec.rb

@@ -7,21 +7,21 @@ describe Restify::Global do
 
   describe '#new' do
     context 'with string URI' do
-      subject { global.new uri, **options }
+      subject(:restify) { global.new(uri, **options) }
 
       let(:uri)     { 'http://api.github.com/' }
       let(:options) { {accept: 'application.vnd.github.v3+json'} }
 
       it 'returns relation for URI' do
-        expect(subject).to be_a Restify::Relation
-        expect(subject.pattern).to eq uri
-        expect(subject.context.uri.to_s).to eq uri
-        expect(subject.context.options).to eq options
+        expect(restify).to be_a Restify::Relation
+        expect(restify.pattern).to eq uri
+        expect(restify.context.uri.to_s).to eq uri
+        expect(restify.context.options).to eq options
       end
     end
 
     context 'with registry symbol' do
-      subject { global.new(name, **options) }
+      subject(:restify) { global.new(uri, **options) }
 
       let(:name) { :registry_item_name }
       let(:uri)     { 'http://api.github.com/' }
@@ -31,10 +31,10 @@ describe Restify::Global do
       it 'returns relation for stored registry item' do
         Restify::Registry.store(name, uri, **options)
 
-        expect(subject).to be_a Restify::Relation
-        expect(subject.pattern).to eq uri
-        expect(subject.context.uri.to_s).to eq uri
-        expect(subject.context.options).to eq options
+        expect(restify).to be_a Restify::Relation
+        expect(restify.pattern).to eq uri
+        expect(restify.context.uri.to_s).to eq uri
+        expect(restify.context.options).to eq options
       end
     end
   end

data/spec/restify/processors/base_spec.rb

@@ -4,27 +4,26 @@ require 'spec_helper'
 
 describe Restify::Processors::Base do
   let(:context)  { Restify::Context.new('http://test.host/') }
-  let(:response) { double 'response' }
+  let(:response) { instance_double(Restify::Response) }
 
   before do
-    allow(response).to receive(:links).and_return []
-    allow(response).to receive(:follow_location).and_return nil
+    allow(response).to receive_messages(links: [], follow_location: nil)
   end
 
   describe 'class' do
     describe '#accept?' do
-      subject { described_class.accept? response }
+      subject(:accept) { described_class.accept?(response) }
 
       # If no other processor accepts the request, we have an explicit fallback
       # to the base processor.
       it 'does not accept any responses' do
-        expect(subject).to be_falsey
+        expect(accept).to be_falsey
       end
     end
   end
 
   describe '#resource' do
-    subject { described_class.new(context, response).resource }
+    subject(:resource) { described_class.new(context, response).resource }
 
     before { allow(response).to receive(:body).and_return(body) }
 
@@ -37,7 +36,7 @@ describe Restify::Processors::Base do
         end
 
         it { is_expected.to be_a Restify::Resource }
-        it { expect(subject.response).to be response }
+        it { expect(resource.response).to be response }
         it { is_expected.to eq body }
       end
     end