restify 1.15.2 → 2.0.1

data/spec/restify/relation_spec.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'active_support'
 
 describe Restify::Relation do
   subject(:relation) { described_class.new context, pattern }
 
   let(:context)  { Restify::Context.new('http://test.host/') }
-  let(:pattern)  { '/resource/{id}' }
+  let(:pattern)  { '/resource/{id}{?q*}' }
 
   describe '#==' do
     it 'equals pattern' do
-      expect(subject).to eq pattern
+      expect(relation).to eq pattern
     end
   end
 
   describe '#expand' do
-    subject(:expaned) { relation.expand params }
+    subject(:expanded) { relation.expand params }
 
     let(:params) { {id: 1337} }
     let(:cls_to_param) do
@@ -28,29 +29,206 @@ describe Restify::Relation do
 
     it { is_expected.to be_a Addressable::URI }
 
+    context 'with nil' do
+      let(:params) { {id: nil} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/' }
+    end
+
+    context 'with false' do
+      let(:params) { {id: false} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/' }
+    end
+
+    context 'with true' do
+      let(:params) { {id: true} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/true' }
+    end
+
     context 'with #to_param object' do
       let(:params) { {id: cls_to_param.new} }
 
-      it { expect(expaned.to_s).to eq 'http://test.host/resource/42' }
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/42' }
+    end
+
+    context 'with array parameter' do
+      let(:params) { {id: [1, 2]} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/1,2' }
     end
 
     context 'with unknown additional query parameter' do
       let(:pattern) { '/resource{?a,b}' }
       let(:params) { {a: 1, b: 2, c: 3} }
 
-      it { expect(expaned.to_s).to eq 'http://test.host/resource?a=1&b=2&c=3' }
+      it { expect(expanded.to_s).to eq 'http://test.host/resource?a=1&b=2&c=3' }
     end
 
     context 'with additional parameters' do
       let(:params) { {id: '5', abc: 'cde'} }
 
-      it { expect(expaned.to_s).to eq 'http://test.host/resource/5?abc=cde' }
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=cde' }
+    end
+
+    context 'with additional nil parameters' do
+      let(:params) { {id: '5', abc: nil} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc' }
+    end
+
+    context 'with additional false parameters' do
+      let(:params) { {id: '5', abc: false} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=false' }
+    end
+
+    context 'with additional true parameters' do
+      let(:params) { {id: '5', abc: true} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=true' }
     end
 
     context 'with additional #to_param parameter' do
       let(:params) { {id: '5', abc: cls_to_param.new} }
 
-      it { expect(expaned.to_s).to eq 'http://test.host/resource/5?abc=42' }
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=42' }
+    end
+
+    context 'with additional array parameter' do
+      let(:params) { {id: 5, abc: [1, 2]} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=1&abc=2' }
     end
+
+    context 'with additional array parameter with objects' do
+      let(:params) { {id: 5, abc: [1, 2, cls_to_param.new]} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/5?abc=1&abc=2&abc=42' }
+    end
+
+    context 'with additional nested array parameter' do
+      let(:params) { {id: 5, abc: [1, 2, [1]]} }
+
+      it { expect { expanded }.to raise_exception TypeError, /Can't convert Array into String./ }
+    end
+
+    context 'with additional hash parameter' do
+      let(:params) { {id: 5, abc: {a: 1, b: 2}} }
+
+      it { expect { expanded }.to raise_exception TypeError, /Can't convert Hash into String./ }
+    end
+  end
+
+  shared_examples 'non-data-request' do |method|
+    it "issues a #{method.upcase} request" do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/'
+        expect(opts).to be_nil
+      end
+      relation.send(method)
+    end
+
+    it 'accepts params as keyword argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to be_nil
+      end
+      relation.send(method, params: {id: 1})
+    end
+
+    it 'accepts params as positional argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to be_nil
+      end
+      relation.send(method, {id: 1})
+    end
+
+    it 'merges keyword params into positional params' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1?a=2&b=3'
+        expect(opts).to be_nil
+      end
+      relation.send(method, {id: 1, q: {a: 1, c: 1}}, params: {q: {a: 2, b: 3}})
+    end
+  end
+
+  describe '#get' do
+    include_examples 'non-data-request', :get
+  end
+
+  describe '#head' do
+    include_examples 'non-data-request', :head
+  end
+
+  describe '#delete' do
+    include_examples 'non-data-request', :delete
+  end
+
+  shared_examples 'data-request' do |method|
+    let(:data) { Object.new }
+
+    it "issues a #{method.upcase} request" do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/'
+        expect(opts).to eq({data: nil})
+      end
+      relation.send(method)
+    end
+
+    it 'accepts params as keyword argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to eq({data: nil})
+      end
+      relation.send(method, params: {id: 1})
+    end
+
+    it 'accepts data as keyword argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to eq({data:})
+      end
+      relation.send(method, data:, params: {id: 1})
+    end
+
+    it 'accepts data as position argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to eq({data:})
+      end
+      relation.send(method, data, params: {id: 1})
+    end
+
+    it 'prefers data from keyword argument' do
+      expect(context).to receive(:request) do |meth, uri, opts|
+        expect(meth).to eq method
+        expect(uri.to_s).to eq 'http://test.host/resource/1'
+        expect(opts).to eq({data:})
+      end
+      relation.send(method, 'DATA', data:, params: {id: 1})
+    end
+  end
+
+  describe '#post' do
+    include_examples 'data-request', :post
+  end
+
+  describe '#put' do
+    include_examples 'data-request', :put
+  end
+
+  describe '#patch' do
+    include_examples 'data-request', :patch
   end
 end

data/spec/restify/resource_spec.rb

@@ -3,18 +3,12 @@
 require 'spec_helper'
 
 describe Restify::Resource do
-  subject { resource }
+  subject(:resource) { described_class.new(context, response:, data:, relations:) }
 
   let(:data)      { {} }
   let(:relations) { {} }
-  let(:context)   { double 'context' }
-  let(:response)  { double 'response' }
-  let(:resource)  { described_class.new(context, response: response, data: data, relations: relations) }
-
-  before do
-    allow(context).to receive(:relation?).and_return(false)
-    allow(context).to receive(:relation).and_raise(KeyError)
-  end
+  let(:context)   { instance_double(Restify::Context) }
+  let(:response)  { instance_double(Restify::Response) }
 
   context 'relations' do
     let(:relations) do
@@ -26,41 +20,41 @@ describe Restify::Resource do
 
     describe '#relation?' do
       it 'matches relations' do
-        expect(subject.relation?(:users)).to eq true
-        expect(subject.relation?('users')).to eq true
-        expect(subject.relation?(:projects)).to eq true
-        expect(subject.relation?('projects')).to eq true
-        expect(subject.relation?('fuu')).to eq false
-
-        expect(subject).to have_relation :users
-        expect(subject).to have_relation :projects
-
-        expect(subject.rel?(:users)).to eq true
-        expect(subject.rel?('users')).to eq true
-        expect(subject.rel?(:projects)).to eq true
-        expect(subject.rel?('projects')).to eq true
-        expect(subject.rel?('fuu')).to eq false
-
-        expect(subject).to have_rel :users
-        expect(subject).to have_rel :projects
+        expect(resource.relation?(:users)).to be true
+        expect(resource.relation?('users')).to be true
+        expect(resource.relation?(:projects)).to be true
+        expect(resource.relation?('projects')).to be true
+        expect(resource.relation?('fuu')).to be false
+
+        expect(resource).to have_relation :users
+        expect(resource).to have_relation :projects
+
+        expect(resource.rel?(:users)).to be true
+        expect(resource.rel?('users')).to be true
+        expect(resource.rel?(:projects)).to be true
+        expect(resource.rel?('projects')).to be true
+        expect(resource.rel?('fuu')).to be false
+
+        expect(resource).to have_rel :users
+        expect(resource).to have_rel :projects
       end
     end
 
     describe '#relation' do
       it 'returns relation' do
-        expect(subject.rel(:users)).to be_a Restify::Relation
-
-        expect(subject.rel(:users)).to eq 'http://example.org/users'
-        expect(subject.rel('users')).to eq 'http://example.org/users'
-        expect(subject.rel(:projects)).to eq 'http://example.org/projects'
-        expect(subject.rel('projects')).to eq 'http://example.org/projects'
-        expect { subject.rel(:fuu) }.to raise_error KeyError
-
-        expect(subject.relation(:users)).to eq 'http://example.org/users'
-        expect(subject.relation('users')).to eq 'http://example.org/users'
-        expect(subject.relation(:projects)).to eq 'http://example.org/projects'
-        expect(subject.relation('projects')).to eq 'http://example.org/projects'
-        expect { subject.relation(:fuu) }.to raise_error KeyError
+        expect(resource.rel(:users)).to be_a Restify::Relation
+
+        expect(resource.rel(:users)).to eq 'http://example.org/users'
+        expect(resource.rel('users')).to eq 'http://example.org/users'
+        expect(resource.rel(:projects)).to eq 'http://example.org/projects'
+        expect(resource.rel('projects')).to eq 'http://example.org/projects'
+        expect { resource.rel(:fuu) }.to raise_error KeyError
+
+        expect(resource.relation(:users)).to eq 'http://example.org/users'
+        expect(resource.relation('users')).to eq 'http://example.org/users'
+        expect(resource.relation(:projects)).to eq 'http://example.org/projects'
+        expect(resource.relation('projects')).to eq 'http://example.org/projects'
+        expect { resource.relation(:fuu) }.to raise_error KeyError
       end
     end
 
@@ -68,15 +62,15 @@ describe Restify::Resource do
       let(:relations) { {_restify_follow: 'http://localhost/10'} }
 
       it 'returns follow relation' do
-        expect(subject.follow).to be_a Restify::Relation
-        expect(subject.follow).to eq 'http://localhost/10'
+        expect(resource.follow).to be_a Restify::Relation
+        expect(resource.follow).to eq 'http://localhost/10'
       end
 
       context 'when nil' do
         let(:relations) { {} }
 
         it 'returns nil' do
-          expect(subject.follow).to be nil
+          expect(resource.follow).to be_nil
         end
       end
     end
@@ -85,15 +79,15 @@ describe Restify::Resource do
       let(:relations) { {_restify_follow: 'http://localhost/10'} }
 
       it 'returns follow relation' do
-        expect(subject.follow!).to be_a Restify::Relation
-        expect(subject.follow!).to eq 'http://localhost/10'
+        expect(resource.follow!).to be_a Restify::Relation
+        expect(resource.follow!).to eq 'http://localhost/10'
       end
 
       context 'when nil' do
         let(:relations) { {} }
 
         it 'raise runtime error' do
-          expect { subject.follow! }.to raise_error RuntimeError do |err|
+          expect { resource.follow! }.to raise_error RuntimeError do |err|
             expect(err.message).to eq 'Nothing to follow'
           end
         end
@@ -102,25 +96,25 @@ describe Restify::Resource do
   end
 
   context 'data' do
-    let(:data) { double 'data' }
+    let(:data) { double 'data' } # rubocop:disable RSpec/VerifiedDoubles
 
     it 'delegates methods (I)' do
-      expect(data).to receive(:some_method).and_return(42)
+      allow(data).to receive(:some_method).and_return(42)
 
-      expect(subject).to respond_to :some_method
-      expect(subject.some_method).to eq 42
+      expect(resource).to respond_to :some_method
+      expect(resource.some_method).to eq 42
     end
 
     it 'delegates methods (II)' do
-      expect(data).to receive(:[]).with(1).and_return(2)
+      allow(data).to receive(:[]).with(1).and_return(2)
 
-      expect(subject).to respond_to :[]
-      expect(subject[1]).to eq 2
+      expect(resource).to respond_to :[]
+      expect(resource[1]).to eq 2
     end
 
     describe '#data' do
       it 'returns data' do
-        expect(subject.data).to equal data
+        expect(resource.data).to equal data
       end
     end
   end

data/spec/restify/timeout_spec.rb

@@ -16,7 +16,7 @@ describe Restify::Timeout do
       it 'calls given block' do
         expect { timer.timeout! }.not_to raise_error
         sleep timer.send(:wait_interval)
-        expect { timer.timeout! }.to raise_error ::Restify::Timeout::Error
+        expect { timer.timeout! }.to raise_error Restify::Timeout::Error
       end
     end
   end
@@ -25,13 +25,13 @@ describe Restify::Timeout do
     it 'calls block on IVar timeout' do
       expect do
         timer.wait_on!(Concurrent::IVar.new)
-      end.to raise_error ::Restify::Timeout::Error
+      end.to raise_error Restify::Timeout::Error
     end
 
     it 'calls block on Promise timeout' do
       expect do
         timer.wait_on!(Restify::Promise.new)
-      end.to raise_error ::Restify::Timeout::Error
+      end.to raise_error Restify::Timeout::Error
     end
 
     it 'does nothing on successful IVar' do

data/spec/restify_spec.rb

@@ -132,21 +132,21 @@ describe Restify do
           # Because we forgot to send a "name" the server complains
           # with an error code that will lead to a raised error.
 
-          expect(e.status).to eq :unprocessable_entity
+          expect(e.status).to eq :unprocessable_content
           expect(e.code).to eq 422
           expect(e.errors).to eq 'name' => ["can't be blank"]
         end
 
         # Let's try again.
-        created_user = users_relation.post(name: 'John Smith').value!
+        created_user = users_relation.post({name: 'John Smith'}).value!
 
         # The server returns a 201 Created response with the created
         # resource.
         expect(created_user.response.status).to eq :created
         expect(created_user.response.code).to eq 201
 
-        expect(created_user).to have_key :name
-        expect(created_user.name).to eq 'John Smith'
+        expect(created_user).to have_key 'name'
+        expect(created_user['name']).to eq 'John Smith'
 
         # Let's follow the "Location" header.
         followed_resource = created_user.follow.get.value!
@@ -154,8 +154,8 @@ describe Restify do
         expect(followed_resource.response.status).to eq :ok
         expect(followed_resource.response.code).to eq 200
 
-        expect(followed_resource).to have_key :name
-        expect(followed_resource.name).to eq 'John Smith'
+        expect(followed_resource).to have_key 'name'
+        expect(followed_resource['name']).to eq 'John Smith'
 
         # Now we will fetch a list of all users.
         users = users_relation.get.value!
@@ -168,80 +168,19 @@ describe Restify do
 
         # We have all our attributes and relations here as defined in the
         # responses from the server.
-        expect(user).to have_key :name
-        expect(user[:name]).to eq 'John Smith'
+        expect(user).to have_key 'name'
+        expect(user['name']).to eq 'John Smith'
         expect(user).to have_relation :self
         expect(user).to have_relation :blurb
 
         # Let's get the blurb.
         blurb = user.rel(:blurb).get.value!
 
-        expect(blurb).to have_key :title
-        expect(blurb).to have_key :image
+        expect(blurb).to have_key 'title'
+        expect(blurb).to have_key 'image'
 
-        expect(blurb[:title]).to eq 'Prof. Dr. John Smith'
-        expect(blurb[:image]).to eq 'http://example.org/avatar.png'
-      end
-    end
-
-    context 'within EM-synchrony' do
-      it 'consumes the API' do
-        skip 'Seems to be impossible to detect EM scheduled fibers from within'
-
-        EM.synchrony do
-          root = Restify.new('http://localhost:9292/base').get.value!
-
-          users_relation = root.rel(:users)
-
-          expect(users_relation).to be_a Restify::Relation
-
-          create_user_promise = users_relation.post
-          expect(create_user_promise).to be_a Restify::Promise
-
-          expect { create_user_promise.value! }.to \
-            raise_error(Restify::ClientError) do |e|
-            expect(e.status).to eq :unprocessable_entity
-            expect(e.code).to eq 422
-            expect(e.errors).to eq 'name' => ["can't be blank"]
-          end
-
-          created_user = users_relation.post(name: 'John Smith').value!
-
-          expect(created_user.response.status).to eq :created
-          expect(created_user.response.code).to eq 201
-
-          expect(created_user).to have_key :name
-          expect(created_user.name).to eq 'John Smith'
-
-          followed_resource = created_user.follow.get.value!
-
-          expect(followed_resource.response.status).to eq :ok
-          expect(followed_resource.response.code).to eq 200
-
-          expect(followed_resource).to have_key :name
-          expect(followed_resource.name).to eq 'John Smith'
-
-          users = users_relation.get.value!
-
-          expect(users).to have(2).items
-
-          user = users.first
-
-          expect(user).to have_key :name
-          expect(user[:name]).to eq 'John Smith'
-          expect(user).to have_relation :self
-          expect(user).to have_relation :blurb
-
-          blurb = user.rel(:blurb).get.value!
-
-          expect(blurb).to have_key :title
-          expect(blurb).to have_key :image
-
-          expect(blurb[:title]).to eq 'Prof. Dr. John Smith'
-          expect(blurb[:image]).to eq 'http://example.org/avatar.png'
-
-          EventMachine.stop
-        end
+        expect(blurb['title']).to eq 'Prof. Dr. John Smith'
+        expect(blurb['image']).to eq 'http://example.org/avatar.png'
       end
     end
   end

data/spec/spec_helper.rb

@@ -4,25 +4,21 @@ require 'rspec'
 require 'rspec/collection_matchers'
 
 require 'simplecov'
+require 'simplecov-cobertura'
+
 SimpleCov.start do
   add_filter 'spec'
 end
 
-if ENV['CI']
-  require 'codecov'
-  SimpleCov.formatter = SimpleCov::Formatter::Codecov
-end
+SimpleCov.formatters = [
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::CoberturaFormatter,
+]
 
 require 'restify'
 
 if ENV['ADAPTER']
   case ENV['ADAPTER'].to_s.downcase
-    when 'em'
-      require 'restify/adapter/em'
-      Restify.adapter = Restify::Adapter::EM.new
-    when 'em-pooled'
-      require 'restify/adapter/pooled_em'
-      Restify.adapter = Restify::Adapter::PooledEM.new
     when 'typhoeus'
       require 'restify/adapter/typhoeus'
       Restify.adapter = Restify::Adapter::Typhoeus.new
@@ -34,27 +30,28 @@ if ENV['ADAPTER']
   end
 end
 
+require_relative 'support/opentelemetry'
 require_relative 'support/stub_server'
 
 RSpec.configure do |config|
   config.order = 'random'
 
   config.before(:suite) do
-    ::Restify::Timeout.default_timeout = 1.0
+    Restify::Timeout.default_timeout = 1.0
   end
 
   config.before do |example|
     next unless (adapter = example.metadata[:adapter])
-    next if Restify.adapter.is_a?(adapter)
+    next if Restify.adapter.class.ancestors.map(&:to_s).include?(adapter)
 
     skip 'Spec not enabled for current adapter'
   end
 
   config.before do
-    Ethon.logger = ::Logging.logger[Ethon] if defined?(Ethon)
+    Ethon.logger = Logging.logger[Ethon] if defined?(Ethon)
 
-    ::Logging.logger.root.level = :debug
-    ::Logging.logger.root.add_appenders ::Logging.appenders.stdout
+    Logging.logger.root.level = :debug
+    Logging.logger.root.add_appenders Logging.appenders.stdout
   end
 
   config.warnings = true

data/spec/support/opentelemetry.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/sdk'
+require 'opentelemetry/instrumentation/ethon'
+
+OTLE_EXPORTER = OpenTelemetry::SDK::Trace::Export::InMemorySpanExporter.new
+span_processor = OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(OTLE_EXPORTER)
+
+OpenTelemetry::SDK.configure do |c|
+  c.error_handler = ->(exception:, message:) { raise(exception || message) }
+  c.logger = Logger.new($stderr, level: ENV.fetch('OTEL_LOG_LEVEL', 'fatal').to_sym)
+  c.add_span_processor span_processor
+
+  c.use 'OpenTelemetry::Instrumentation::Ethon'
+end
+
+RSpec.configure do |config|
+  config.around do |example|
+    OTLE_EXPORTER.reset
+
+    original_propagation = OpenTelemetry.propagation
+    propagator = OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator
+    OpenTelemetry.propagation = propagator
+
+    example.run
+  ensure
+    OpenTelemetry.propagation = original_propagation
+  end
+end

data/spec/support/stub_server.rb

@@ -18,6 +18,10 @@ module Stub
   # If no stub is found a special HTTP 599 error code will be returned.
   class Handler
     def call(env)
+      if env['REQUEST_URI'] == '/echo'
+        return [200, {'content-type': 'application/json'}, [env.to_json]]
+      end
+
       signature = WebMock::RequestSignature.new(
         env['REQUEST_METHOD'].downcase,
         "http://stubserver#{env['REQUEST_URI']}",