restify 1.15.1 → 2.0.0

data/spec/restify/promise_spec.rb

@@ -7,40 +7,42 @@ describe Restify::Promise do
 
   describe 'factory methods' do
     describe '#fulfilled' do
-      subject { described_class.fulfilled(fulfill_value) }
+      subject(:promise) { described_class.fulfilled(fulfill_value) }
+
       let(:fulfill_value) { 42 }
 
       it 'returns a fulfilled promise' do
-        expect(subject.fulfilled?).to be true
-        expect(subject.rejected?).to be false
+        expect(promise.fulfilled?).to be true
+        expect(promise.rejected?).to be false
       end
 
       it 'wraps the given value' do
-        expect(subject.value!).to eq 42
+        expect(promise.value!).to eq 42
       end
     end
 
     describe '#rejected' do
-      subject { described_class.rejected(rejection_reason) }
+      subject(:promise) { described_class.rejected(rejection_reason) }
+
       let(:rejection_reason) { ArgumentError }
 
       it 'returns a rejected promise' do
-        expect(subject.fulfilled?).to be false
-        expect(subject.rejected?).to be true
+        expect(promise.fulfilled?).to be false
+        expect(promise.rejected?).to be true
       end
 
       it 'bubbles up the caught exception on #value!' do
-        expect { subject.value! }.to raise_error(ArgumentError)
+        expect { promise.value! }.to raise_error(ArgumentError)
       end
 
       it 'swallows the exception on #value' do
-        expect(subject.value).to be nil
+        expect(promise.value).to be_nil
       end
     end
 
     describe '#create' do
       context 'when fulfilling the promise in the writer block' do
-        subject do
+        subject(:promise) do
           described_class.create do |writer|
             # Calculate a value and fulfill the promise with it
             writer.fulfill 42
@@ -48,17 +50,17 @@ describe Restify::Promise do
         end
 
         it 'returns a fulfilled promise' do
-          expect(subject.fulfilled?).to be true
-          expect(subject.rejected?).to be false
+          expect(promise.fulfilled?).to be true
+          expect(promise.rejected?).to be false
         end
 
         it 'wraps the given value' do
-          expect(subject.value!).to eq 42
+          expect(promise.value!).to eq 42
         end
       end
 
       context 'when rejecting the promise in the writer block' do
-        subject do
+        subject(:promise) do
           described_class.create do |writer|
             # Calculate a value and fulfill the promise with it
             writer.reject ArgumentError
@@ -66,21 +68,21 @@ describe Restify::Promise do
         end
 
         it 'returns a rejected promise' do
-          expect(subject.fulfilled?).to be false
-          expect(subject.rejected?).to be true
+          expect(promise.fulfilled?).to be false
+          expect(promise.rejected?).to be true
         end
 
         it 'bubbles up the caught exception on #value!' do
-          expect { subject.value! }.to raise_error(ArgumentError)
+          expect { promise.value! }.to raise_error(ArgumentError)
         end
 
         it 'swallows the exception on #value' do
-          expect(subject.value).to be nil
+          expect(promise.value).to be_nil
         end
       end
 
       context 'when fulfilling the promise asynchronously' do
-        subject do
+        subject(:promise) do
           described_class.create do |writer|
             Thread.new do
               sleep 0.1
@@ -90,20 +92,21 @@ describe Restify::Promise do
         end
 
         it 'returns a pending promise' do
-          expect(subject.fulfilled?).to be false
-          expect(subject.rejected?).to be false
-          expect(subject.pending?).to be true
+          expect(promise.fulfilled?).to be false
+          expect(promise.rejected?).to be false
+          expect(promise.pending?).to be true
         end
 
         it 'waits for the fulfillment value' do
-          expect(subject.value!).to eq 42
+          expect(promise.value!).to eq 42
         end
       end
     end
   end
 
   describe 'result' do
-    subject { described_class.new(*dependencies, &task).value! }
+    subject(:result) { described_class.new(*dependencies, &task).value! }
+
     let(:dependencies) { [] }
     let(:task) { nil }
 
@@ -116,7 +119,7 @@ describe Restify::Promise do
       end
 
       it 'is calculated using the task block' do
-        expect(subject).to eq 42
+        expect(result).to eq 42
       end
     end
 
@@ -125,12 +128,12 @@ describe Restify::Promise do
         [
           Restify::Promise.fulfilled(1),
           Restify::Promise.fulfilled(2),
-          Restify::Promise.fulfilled(3)
+          Restify::Promise.fulfilled(3),
         ]
       end
 
       it 'is an array of the dependencies\' results' do
-        expect(subject).to eq [1, 2, 3]
+        expect(result).to eq [1, 2, 3]
       end
     end
 
@@ -139,12 +142,12 @@ describe Restify::Promise do
         [[
           Restify::Promise.fulfilled(1),
           Restify::Promise.fulfilled(2),
-          Restify::Promise.fulfilled(3)
+          Restify::Promise.fulfilled(3),
         ]]
       end
 
       it 'is an array of the dependencies\' results' do
-        expect(subject).to eq [1, 2, 3]
+        expect(result).to eq [1, 2, 3]
       end
     end
 
@@ -152,7 +155,7 @@ describe Restify::Promise do
       let(:dependencies) do
         [
           Restify::Promise.fulfilled(5),
-          Restify::Promise.fulfilled(12)
+          Restify::Promise.fulfilled(12),
         ]
       end
       let(:task) do
@@ -160,7 +163,7 @@ describe Restify::Promise do
       end
 
       it 'can use the dependencies to calculate the value' do
-        expect(subject).to eq 17
+        expect(result).to eq 17
       end
     end
 
@@ -168,25 +171,26 @@ describe Restify::Promise do
     # dependencies is built dynamically.
     context 'with an empty array of dependencies and without task' do
       subject { described_class.new([]).value! }
+
       it { is_expected.to eq [] }
     end
   end
 
   describe '#wait' do
     it 'can time out' do
-      expect { promise.wait(0.1) }.to raise_error ::Timeout::Error
+      expect { promise.wait(0.1) }.to raise_error Timeout::Error
     end
   end
 
   describe '#value' do
     it 'can time out' do
-      expect { promise.value!(0.1) }.to raise_error ::Timeout::Error
+      expect { promise.value(0.1) }.to raise_error Timeout::Error
     end
   end
 
   describe '#value!' do
     it 'can time out' do
-      expect { promise.value!(0.1) }.to raise_error ::Timeout::Error
+      expect { promise.value!(0.1) }.to raise_error Timeout::Error
     end
   end
 end

data/spec/restify/registry_spec.rb

@@ -3,15 +3,13 @@
 require 'spec_helper'
 
 describe Restify::Registry do
-  let(:registry) { described_class.instance }
+  subject(:registry) { described_class.instance }
 
   describe 'class' do
     describe '#instance' do
-      subject { described_class.instance }
-
       it 'returns singleton instance' do
-        expect(subject).to be_a described_class
-        expect(subject).to be described_class.instance
+        expect(registry).to be_a described_class
+        expect(registry).to be described_class.instance
       end
     end
 
@@ -36,14 +34,14 @@ describe Restify::Registry do
   end
 
   describe '#store / #fetch' do
+    subject(:store) { registry.store(name, uri, **opts) }
+
     let(:name) { 'remote' }
     let(:uri)  { 'http://remote/entry/point' }
     let(:opts) { {accept: 'application/vnd.remote+json'} }
 
-    subject { registry.store name, uri, **opts }
-
     it 'stores registry item' do
-      subject
+      store
 
       item = registry.fetch name
 

data/spec/restify/relation_spec.rb

@@ -1,55 +1,234 @@
 # 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(:relation) { described_class.new context, pattern }
-  subject { relation }
+  let(:pattern)  { '/resource/{id}{?q*}' }
 
   describe '#==' do
-    it 'should equal pattern' do
-      expect(subject).to eq pattern
+    it 'equals pattern' do
+      expect(relation).to eq pattern
     end
   end
 
   describe '#expand' do
-    let(:params) { {id: 1337} }
+    subject(:expanded) { relation.expand params }
 
-    subject { relation.expand params }
+    let(:params) { {id: 1337} }
+    let(:cls_to_param) do
+      Class.new do
+        def to_param
+          42
+        end
+      end
+    end
 
     it { is_expected.to be_a Addressable::URI }
 
-    class ParamObject
-      def to_param
-        42
-      end
+    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: ParamObject.new} }
+      let(:params) { {id: cls_to_param.new} }
+
+      it { expect(expanded.to_s).to eq 'http://test.host/resource/42' }
+    end
 
-      it { expect(subject.to_s).to eq 'http://test.host/resource/42' }
+    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(subject.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(subject.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: ParamObject.new} }
+      let(:params) { {id: '5', abc: cls_to_param.new} }
+
+      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
 
-      it { expect(subject.to_s).to eq 'http://test.host/resource/5?abc=42' }
+    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,63 +3,58 @@
 require 'spec_helper'
 
 describe Restify::Resource do
+  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) }
-  subject { resource }
-
-  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
       {
         'users' => 'http://example.org/users',
-        'projects' => 'http://example.org/projects'
+        'projects' => 'http://example.org/projects',
       }
     end
 
     describe '#relation?' do
-      it 'should match 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
+      it 'matches relations' do
+        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 'should return 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
+      it 'returns relation' do
+        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
 
@@ -67,32 +62,32 @@ 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
 
-    context '#follow!' do
+    describe '#follow!' 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
@@ -101,25 +96,25 @@ describe Restify::Resource do
   end
 
   context 'data' do
-    let(:data) { double 'data' }
+    let(:data) { double 'data' } # rubocop:disable RSpec/VerifiedDoubles
 
-    it 'should delegate methods (I)' do
-      expect(data).to receive(:some_method).and_return(42)
+    it 'delegates methods (I)' do
+      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 'should delegate methods (II)' do
-      expect(data).to receive(:[]).with(1).and_return(2)
+    it 'delegates methods (II)' do
+      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 'should return data' do
-        expect(subject.data).to equal data
+      it 'returns data' do
+        expect(resource.data).to equal data
       end
     end
   end