restify 1.15.1 → 2.0.0

data/spec/restify/features/request_headers_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Restify do
   let!(:request_stub) do
-    stub_request(:get, "http://stubserver/base").to_return do
+    stub_request(:get, 'http://stubserver/base').to_return do
       <<~HTTP
         HTTP/1.1 200 OK
         Content-Type: application/json
@@ -20,15 +20,14 @@ 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!
 
       expect(request_stub).to have_been_requested.twice
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.once
     end
   end
@@ -37,7 +36,7 @@ describe Restify do
     let(:context) do
       Restify.new(
         'http://localhost:9292/base',
-        headers: {'Accept' => 'application/msgpack, application/json'}
+        headers: {'Accept' => 'application/msgpack, application/json'},
       )
     end
 
@@ -47,39 +46,37 @@ describe Restify do
       root.rel(:self).get.value!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.twice
     end
 
     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!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/xml'})
+        request_stub.with(headers: {'Accept' => 'application/xml'}),
       ).to have_been_requested.once
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.once
     end
 
     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!
 
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json'}),
       ).to have_been_requested.twice
       expect(
-        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json', 'X-Custom' => 'foobar'})
+        request_stub.with(headers: {'Accept' => 'application/msgpack, application/json', 'X-Custom' => 'foobar'}),
       ).to have_been_requested.once
     end
   end

data/spec/restify/features/response_errors_spec.rb

@@ -3,9 +3,9 @@
 require 'spec_helper'
 
 describe Restify do
-  let!(:request_stub) 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/global_spec.rb

@@ -7,34 +7,34 @@ describe Restify::Global do
 
   describe '#new' do
     context 'with string URI' do
+      subject(:restify) { global.new(uri, **options) }
+
       let(:uri)     { 'http://api.github.com/' }
       let(:options) { {accept: 'application.vnd.github.v3+json'} }
 
-      subject { global.new uri, **options }
-
       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
-      let(:name)  { :registry_item_name }
+      subject(:restify) { global.new(uri, **options) }
+
+      let(:name) { :registry_item_name }
       let(:uri)     { 'http://api.github.com/' }
       let(:options) { {accept: 'application.vnd.github.v3+json'} }
       let(:context) { Restify::Context.new uri, **options }
 
-      subject { global.new(name, **options) }
-
       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/link_spec.rb

@@ -5,27 +5,27 @@ require 'spec_helper'
 describe Restify::Link do
   describe 'class' do
     describe '#parse' do
-      it 'should parse link with quotes' do
+      it 'parses link with quotes' do
         links = described_class
-                .parse('<http://example.org/search{?query}>; rel="search"')
+          .parse('<http://example.org/search{?query}>; rel="search"')
 
         expect(links).to have(1).item
         expect(links[0].uri).to eq 'http://example.org/search{?query}'
         expect(links[0].metadata).to eq 'rel' => 'search'
       end
 
-      it 'should parse link without quotes' do
+      it 'parses link without quotes' do
         links = described_class
-                .parse('<http://example.org/search{?query}>; rel=search')
+          .parse('<http://example.org/search{?query}>; rel=search')
 
         expect(links).to have(1).item
         expect(links[0].uri).to eq 'http://example.org/search{?query}'
         expect(links[0].metadata).to eq 'rel' => 'search'
       end
 
-      it 'should parse multiple links' do
+      it 'parses multiple links' do
         links = described_class
-                .parse('<p://h.tld/p>; rel=abc, <p://h.tld/b>; a=b; c="d"')
+          .parse('<p://h.tld/p>; rel=abc, <p://h.tld/b>; a=b; c="d"')
 
         expect(links).to have(2).item
         expect(links[0].uri).to eq 'p://h.tld/p'
@@ -34,19 +34,19 @@ describe Restify::Link do
         expect(links[1].metadata).to eq 'a' => 'b', 'c' => 'd'
       end
 
-      it 'should parse link w/o meta' do
+      it 'parses link w/o meta' do
         links = described_class.parse('<p://h.tld/b>')
 
         expect(links[0].uri).to eq 'p://h.tld/b'
       end
 
-      it 'should parse on invalid URI' do
+      it 'parses on invalid URI' do
         links = described_class.parse('<hp://:&*^/fwbhg3>')
 
         expect(links[0].uri).to eq 'hp://:&*^/fwbhg3'
       end
 
-      it 'should error on invalid header' do
+      it 'errors on invalid header' do
         expect { described_class.parse('</>; rel="s", abc-invalid') }
           .to raise_error ArgumentError, /Invalid token at \d+:/i
       end

data/spec/restify/processors/base_spec.rb

@@ -4,27 +4,27 @@ 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) }
 
     describe 'parsing' do
@@ -36,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

data/spec/restify/processors/json_spec.rb

@@ -4,31 +4,31 @@ require 'spec_helper'
 
 describe Restify::Processors::Json 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 JSON mime type (I)' do
-        expect(response).to receive(:content_type).and_return('application/json')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/json')
+        expect(accept).to be_truthy
       end
 
       it 'accepts JSON mime type (II)' do
-        expect(response).to receive(:content_type).and_return('application/json; abc')
-        expect(subject).to be_truthy
+        allow(response).to receive(:content_type).and_return('application/json; 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
@@ -40,7 +40,7 @@ describe Restify::Processors::Json 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 'json' => 'value' }
       end
 
@@ -52,12 +52,12 @@ describe Restify::Processors::Json do
         end
 
         it do
-          is_expected.to eq \
+          expect(resource).to eq \
             'json' => '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
@@ -67,7 +67,7 @@ describe Restify::Processors::Json do
           JSON
         end
 
-        it { expect(subject.relation(:self)).to eq '/self' }
+        it { expect(resource.relation(:self)).to eq '/self' }
       end
 
       context 'single array' do
@@ -78,7 +78,7 @@ describe Restify::Processors::Json 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 [1, 2, nil, 'STR'] }
       end
 
@@ -101,11 +101,11 @@ describe Restify::Processors::Json do
         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
@@ -119,14 +119,14 @@ describe Restify::Processors::Json 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 '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
 
@@ -138,49 +138,9 @@ describe Restify::Processors::Json 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 'BLUB' }
       end
-
-      context 'with indifferent access' do
-        let(:body) do
-          <<-JSON
-            {"name": "John", "age": 24}
-          JSON
-        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
-          <<-JSON
-            {"name": "John", "age": 24}
-          JSON
-        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/processors/msgpack_spec.rb

@@ -4,94 +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}'
+            'search_url' => 'https://google.com{?q}',
           )
         end
 
         it do
-          is_expected.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(
-            'url' => '/self'
+          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}] }
@@ -99,87 +99,51 @@ describe Restify::Processors::Msgpack do
 
       context 'array with resources' do
         let(:body) do
-          ::MessagePack.dump([
-                               {'name' => 'John', 'self_url' => '/users/john'},
-                               {'name' => 'Jane', 'self_url' => '/users/jane'}
-                             ])
+          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'}
+            '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