restify 1.15.2 → 2.0.0

data/spec/restify/processors/msgpack_spec.rb

@@ -4,95 +4,94 @@ require 'spec_helper'
 
 describe Restify::Processors::Msgpack 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) }
 
       it 'accepts msgpack mime type (I)' do
-        expect(response).to receive(:content_type).and_return('application/msgpack')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/msgpack')
+        expect(accept).to be_truthy
       end
 
       it 'accepts msgpack mime type (II)' do
-        expect(response).to receive(:content_type).and_return('application/msgpack; abc')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/msgpack; abc')
+        expect(accept).to be_truthy
       end
 
       it 'accepts x-msgpack mime type (I)' do
-        expect(response).to receive(:content_type).and_return('application/x-msgpack')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/x-msgpack')
+        expect(accept).to be_truthy
       end
 
       it 'accepts x-msgpack mime type (II)' do
-        expect(response).to receive(:content_type).and_return('application/x-msgpack; abc')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/x-msgpack; abc')
+        expect(accept).to be_truthy
       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) }
 
     describe 'parsing' do
       context 'single object' do
         let(:body) do
-          ::MessagePack.dump('msg' => 'value')
+          MessagePack.dump('msg' => 'value')
         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 'msg' => 'value' }
       end
 
       context 'object with relation fields' do
         let(:body) do
-          ::MessagePack.dump(
+          MessagePack.dump(
             'msg' => 'value',
             'search_url' => 'https://google.com{?q}',
           )
         end
 
         it do
-          expect(subject).to eq \
+          expect(resource).to eq \
             'msg' => 'value', 'search_url' => 'https://google.com{?q}'
         end
 
         it { is_expected.to have_relation :search }
-        it { expect(subject.relation(:search)).to eq 'https://google.com{?q}' }
+        it { expect(resource.relation(:search)).to eq 'https://google.com{?q}' }
       end
 
       context 'object with implicit self relation' do
         let(:body) do
-          ::MessagePack.dump(
+          MessagePack.dump(
             'url' => '/self',
           )
         end
 
-        it { expect(subject.relation(:self)).to eq '/self' }
+        it { expect(resource.relation(:self)).to eq '/self' }
       end
 
       context 'single array' do
         let(:body) do
-          ::MessagePack.dump([1, 2, nil, 'STR'])
+          MessagePack.dump([1, 2, nil, 'STR'])
         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 [1, 2, nil, 'STR'] }
       end
 
       context 'array with objects' do
         let(:body) do
-          ::MessagePack.dump([{'a' => 0}, {'b' => 1}])
+          MessagePack.dump([{'a' => 0}, {'b' => 1}])
         end
 
         it { is_expected.to eq [{'a' => 0}, {'b' => 1}] }
@@ -100,87 +99,51 @@ describe Restify::Processors::Msgpack do
 
       context 'array with resources' do
         let(:body) do
-          ::MessagePack.dump([
+          MessagePack.dump([
             {'name' => 'John', 'self_url' => '/users/john'},
             {'name' => 'Jane', 'self_url' => '/users/jane'},
           ])
         end
 
         it 'parses objects as resources' do
-          expect(subject).to all(be_a(Restify::Resource))
+          expect(resource).to all(be_a(Restify::Resource))
         end
 
         it 'parses relations of resources' do
-          expect(subject.map {|r| r.relation :self }).to eq \
+          expect(resource.map {|r| r.relation :self }).to eq \
             ['/users/john', '/users/jane']
         end
       end
 
       context 'nested objects' do
         let(:body) do
-          ::MessagePack.dump(
+          MessagePack.dump(
             'john' => {'name' => 'John'},
             'jane' => {'name' => 'Jane'},
           )
         end
 
         it { is_expected.to be_a Restify::Resource }
-        it { expect(subject.response).to be response }
+        it { expect(resource.response).to be response }
 
         it 'parses objects as resources' do
-          expect(subject['john']).to be_a Restify::Resource
-          expect(subject['jane']).to be_a Restify::Resource
+          expect(resource['john']).to be_a Restify::Resource
+          expect(resource['jane']).to be_a Restify::Resource
 
-          expect(subject['john']['name']).to eq 'John'
-          expect(subject['jane']['name']).to eq 'Jane'
+          expect(resource['john']['name']).to eq 'John'
+          expect(resource['jane']['name']).to eq 'Jane'
         end
       end
 
       context 'single value' do
         let(:body) do
-          ::MessagePack.dump('BLUB')
+          MessagePack.dump('BLUB')
         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 'BLUB' }
       end
-
-      context 'with indifferent access' do
-        let(:body) do
-          ::MessagePack.dump('name' => 'John', 'age' => 24)
-        end
-
-        it '#key?' do
-          expect(subject).to have_key 'name'
-          expect(subject).to have_key 'age'
-
-          expect(subject).to have_key :name
-          expect(subject).to have_key :age
-        end
-
-        it '#[]' do
-          expect(subject['name']).to eq 'John'
-          expect(subject['age']).to eq 24
-
-          expect(subject[:name]).to eq 'John'
-          expect(subject[:age]).to eq 24
-        end
-      end
-
-      context 'with method getter access' do
-        let(:body) do
-          ::MessagePack.dump('name' => 'John', 'age' => 24)
-        end
-
-        it '#<method getter>' do
-          expect(subject).to respond_to :name
-          expect(subject).to respond_to :age
-
-          expect(subject.name).to eq 'John'
-          expect(subject.age).to eq 24
-        end
-      end
     end
   end
 end

data/spec/restify/promise_spec.rb

@@ -7,42 +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
@@ -50,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
@@ -68,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
@@ -92,20 +92,20 @@ 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 }
@@ -119,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
 
@@ -133,7 +133,7 @@ describe Restify::Promise do
       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
 
@@ -147,7 +147,7 @@ describe Restify::Promise do
       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
 
@@ -163,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
 
@@ -178,19 +178,19 @@ describe Restify::Promise do
 
   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 { registry.store name, uri, **opts }
+    subject(:store) { registry.store(name, uri, **opts) }
 
     let(:name) { 'remote' }
     let(:uri)  { 'http://remote/entry/point' }
     let(:opts) { {accept: 'application/vnd.remote+json'} }
 
     it 'stores registry item' do
-      subject
+      store
 
       item = registry.fetch name
 

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