acfs 1.4.0 → 1.7.0

data/spec/acfs/middleware/{msgpack_spec.rb → message_pack_spec.rb}

@@ -16,23 +16,23 @@ describe Acfs::Middleware::MessagePack do
 
   describe 'encode' do
     context 'with not serialized request' do
-      it 'should set Content-Type' do
+      it 'sets Content-Type' do
         expect(request.headers['Content-Type']).to eq 'application/x-msgpack'
       end
 
-      it 'should append Accept header' do
+      it 'appends Accept header' do
         expect(request.headers['Accept']).to eq 'application/x-msgpack;q=1'
       end
 
       context 'with JSON chained' do
         let(:decoder) { Acfs::Middleware::JSON.new super(), q: 0.5 }
 
-        it 'should append to Accept header' do
+        it 'appends to Accept header' do
           expect(request.headers['Accept']).to eq 'application/json;q=0.5,application/x-msgpack;q=1'
         end
       end
 
-      it 'should serialize data to MessagePack' do
+      it 'serializes data to MessagePack' do
         expect(MessagePack.unpack(request.body)).to eq data.map(&:stringify_keys)
       end
     end
@@ -42,7 +42,7 @@ describe Acfs::Middleware::MessagePack do
     let(:headers) { {'Content-Type' => 'application/x-msgpack'} }
     let(:body)    { MessagePack.pack data }
 
-    it 'should decode body data' do
+    it 'decodes body data' do
       request.complete! response
 
       expect(response.data).to be == data.map(&:stringify_keys)
@@ -53,7 +53,7 @@ describe Acfs::Middleware::MessagePack do
     let(:headers) { {'Content-Type' => 'application/text'} }
     let(:body)    { data.to_json }
 
-    it 'should not decode non-MessagePack encoded responses' do
+    it 'does not decode non-MessagePack encoded responses' do
       request.complete! response
 
       expect(response.data).to be_nil

data/spec/acfs/operation_spec.rb

@@ -5,8 +5,9 @@ require 'spec_helper'
 describe ::Acfs::Operation do
   let(:operation) { described_class.new MyUser, :read, params: {id: 0} }
 
-  context '#request' do
+  describe '#request' do
     subject { operation.request }
-    its(:operation) { should eq operation }
+
+    its(:operation) { is_expected.to eq operation }
   end
 end

data/spec/acfs/request/callbacks_spec.rb

@@ -7,42 +7,51 @@ describe Acfs::Request::Callbacks do
   let(:request)  { Acfs::Request.new('fubar') }
 
   describe '#on_complete' do
-    it 'should store a given callback' do
+    it 'stores a given callback' do
       request.on_complete(&callback)
 
       expect(request.callbacks).to have(1).item
-      expect(request.callbacks[0]).to be == callback
+      expect(request.callbacks[0]).to eq callback
     end
 
-    it 'should store multiple callback' do
+    it 'stores multiple callback' do
       request.on_complete {|_res| 'abc' }
       request.on_complete(&callback)
 
       expect(request.callbacks).to have(2).item
-      expect(request.callbacks[0]).to be == callback
+      expect(request.callbacks[0]).to eq callback
     end
   end
 
   describe '#complete!' do
     let(:response) { Acfs::Response.new(request) }
 
-    it 'should trigger registered callbacks with given response' do
+    it 'triggers registered callbacks with given response' do
       expect(callback).to receive(:call).with(response, kind_of(Proc))
 
       request.on_complete(&callback)
       request.complete! response
     end
 
-    it 'should trigger multiple callback in reverted insertion order' do
+    it 'triggers multiple callback in reverted insertion order' do
       check = []
 
-      request.on_complete {|res, nxt| check << 1; nxt.call res }
-      request.on_complete {|res, nxt| check << 2; nxt.call res }
-      request.on_complete {|res, nxt| check << 3; nxt.call res }
+      request.on_complete do |res, nxt|
+        check << 1
+        nxt.call res
+      end
+      request.on_complete do |res, nxt|
+        check << 2
+        nxt.call res
+      end
+      request.on_complete do |res, nxt|
+        check << 3
+        nxt.call res
+      end
 
       request.complete! response
 
-      expect(check).to be == [3, 2, 1]
+      expect(check).to eq [3, 2, 1]
     end
   end
 end

data/spec/acfs/request_spec.rb

@@ -9,18 +9,18 @@ describe Acfs::Request do
   let(:data)    { nil }
   let(:method)  { :get }
   let(:options) { {method: method, headers: headers, params: params, data: data} }
-  let(:request) { Acfs::Request.new(url, options) }
+  let(:request) { Acfs::Request.new(url, **options) }
 
   describe '#url' do
-    it 'should return request URL' do
-      expect(request.url).to be == url
+    it 'returns request URL' do
+      expect(request.url).to eq url
     end
 
     context 'with parameters' do
       let(:params) { {id: 10} }
 
-      it 'should return URL without query' do
-        expect(request.url).to be == url.to_s
+      it 'returns URL without query' do
+        expect(request.url).to eq url.to_s
       end
     end
   end
@@ -28,8 +28,8 @@ describe Acfs::Request do
   describe '#headers' do
     let(:headers) { {'Accept' => 'application/json'} }
 
-    it 'should return request headers' do
-      expect(request.headers).to be == headers
+    it 'returns request headers' do
+      expect(request.headers).to eq headers
     end
   end
 
@@ -37,43 +37,39 @@ describe Acfs::Request do
     context 'when nil given' do
       let(:method) { nil }
 
-      it 'should default to :get' do
-        expect(request.method).to be == :get
+      it 'defaults to :get' do
+        expect(request.method).to eq :get
       end
     end
 
-    it 'should return request method' do
-      expect(request.method).to be == method
+    it 'returns request method' do
+      expect(request.method).to eq method
     end
   end
 
   describe '#params' do
     let(:params) { {id: 10} }
 
-    it 'should return request headers' do
-      expect(request.params).to be == params
+    it 'returns request headers' do
+      expect(request.params).to eq params
     end
   end
 
   describe '#data' do
     let(:data) { {id: 10, name: 'Anon'} }
 
-    it 'should return request data' do
-      expect(request.data).to be == data
+    it 'returns request data' do
+      expect(request.data).to eq data
     end
-  end
 
-  describe '#data' do
     context 'with data' do
-      let(:data) { {id: 10, name: 'Anon'} }
-
       it { expect(request).to be_data }
     end
 
     context 'without data' do
       let(:data) { nil }
 
-      it { expect(request).to_not be_data }
+      it { expect(request).not_to be_data }
     end
   end
 end

data/spec/acfs/resource/attributes/boolean_spec.rb

@@ -3,56 +3,56 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::Boolean do
-  subject { Acfs::Resource::Attributes::Boolean.new }
+  subject(:type) { Acfs::Resource::Attributes::Boolean.new }
 
   describe '#cast' do
     it 'casts nil' do
-      expect(subject.cast(nil)).to eq nil
+      expect(type.cast(nil)).to eq nil
     end
 
     it 'casts empty string to false' do
-      expect(subject.cast('')).to eq nil
+      expect(type.cast('')).to eq nil
     end
 
     it 'casts blank string to false' do
-      expect(subject.cast("  \t")).to eq nil
+      expect(type.cast("  \t")).to eq nil
     end
 
     it 'preserves boolean values' do
-      expect(subject.cast(false)).to eq false
-      expect(subject.cast(true)).to eq true
+      expect(type.cast(false)).to eq false
+      expect(type.cast(true)).to eq true
     end
 
     it 'casts falsy values to false' do
-      expect(subject.cast(false)).to eq false
-      expect(subject.cast(0)).to eq false
-      expect(subject.cast('0')).to eq false
-      expect(subject.cast('no')).to eq false
-      expect(subject.cast('NO')).to eq false
-      expect(subject.cast('off')).to eq false
-      expect(subject.cast('OFF')).to eq false
-      expect(subject.cast('false')).to eq false
-      expect(subject.cast('FALSE')).to eq false
-      expect(subject.cast('f')).to eq false
-      expect(subject.cast('F')).to eq false
+      expect(type.cast(false)).to eq false
+      expect(type.cast(0)).to eq false
+      expect(type.cast('0')).to eq false
+      expect(type.cast('no')).to eq false
+      expect(type.cast('NO')).to eq false
+      expect(type.cast('off')).to eq false
+      expect(type.cast('OFF')).to eq false
+      expect(type.cast('false')).to eq false
+      expect(type.cast('FALSE')).to eq false
+      expect(type.cast('f')).to eq false
+      expect(type.cast('F')).to eq false
     end
 
     it 'casts any other value to true' do
-      expect(subject.cast(true)).to eq true
-      expect(subject.cast(1)).to eq true
-      expect(subject.cast('1')).to eq true
-      expect(subject.cast('yes')).to eq true
-      expect(subject.cast('YES')).to eq true
-      expect(subject.cast('on')).to eq true
-      expect(subject.cast('ON')).to eq true
-      expect(subject.cast('true')).to eq true
-      expect(subject.cast('TRUE')).to eq true
-      expect(subject.cast('t')).to eq true
-      expect(subject.cast('T')).to eq true
-
-      expect(subject.cast(2)).to eq true
-      expect(subject.cast('wrong')).to eq true
-      expect(subject.cast('random')).to eq true
+      expect(type.cast(true)).to eq true
+      expect(type.cast(1)).to eq true
+      expect(type.cast('1')).to eq true
+      expect(type.cast('yes')).to eq true
+      expect(type.cast('YES')).to eq true
+      expect(type.cast('on')).to eq true
+      expect(type.cast('ON')).to eq true
+      expect(type.cast('true')).to eq true
+      expect(type.cast('TRUE')).to eq true
+      expect(type.cast('t')).to eq true
+      expect(type.cast('T')).to eq true
+
+      expect(type.cast(2)).to eq true
+      expect(type.cast('wrong')).to eq true
+      expect(type.cast('random')).to eq true
     end
   end
 end

data/spec/acfs/resource/attributes/date_time_spec.rb

@@ -6,45 +6,53 @@ describe Acfs::Resource::Attributes::DateTime do
   let(:type) { Acfs::Resource::Attributes::DateTime.new }
 
   describe '#cast' do
-    subject { -> { type.cast value } }
+    subject(:cast) { -> { type.cast value } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with empty string' do
       let(:value) { '' }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with blank string' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with DateTime' do
       let(:value) { DateTime.now }
-      it { expect(subject.call).to eq value }
+
+      it { expect(cast.call).to eq value }
     end
 
     context 'with Time' do
       let(:value) { Time.now }
-      it { expect(subject.call).to eq value.to_datetime }
+
+      it { expect(cast.call).to eq value.to_datetime }
     end
 
     context 'with Date' do
       let(:value) { Date.today }
-      it { expect(subject.call).to eq value.to_datetime }
+
+      it { expect(cast.call).to eq value.to_datetime }
     end
 
     context 'with ISO8601' do
       let(:value) { DateTime.now.iso8601 }
-      it { expect(subject.call.iso8601).to eq value }
+
+      it { expect(cast.call.iso8601).to eq value }
     end
 
     context 'with invalid string' do
       let(:value) { 'qwe123' }
+
       it { is_expected.to raise_error ArgumentError }
     end
   end

data/spec/acfs/resource/attributes/dict_spec.rb

@@ -6,30 +6,35 @@ describe Acfs::Resource::Attributes::Dict do
   let(:type) { Acfs::Resource::Attributes::Dict.new }
 
   describe '#cast' do
-    subject { -> { type.cast value } }
+    subject(:cast) { -> { type.cast value } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with blank string (I)' do
       let(:value) { '' }
-      it { expect(subject.call).to eq({}) }
+
+      it { expect(cast.call).to eq({}) }
     end
 
     context 'with blank string (II)' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq({}) }
+
+      it { expect(cast.call).to eq({}) }
     end
 
     context 'with hash' do
       let(:value) { {3 => true, abc: 4} }
-      it { expect(subject.call).to eq value }
+
+      it { expect(cast.call).to eq value }
     end
 
     context 'with non hashable object' do
       let(:value) { Object.new }
+
       it { is_expected.to raise_error TypeError }
     end
 
@@ -42,7 +47,7 @@ describe Acfs::Resource::Attributes::Dict do
         end.new
       end
 
-      it { expect(subject.call).to eq id: value.object_id }
+      it { expect(cast.call).to eq id: value.object_id }
     end
 
     context 'with hashable object (II)' do
@@ -54,7 +59,7 @@ describe Acfs::Resource::Attributes::Dict do
         end.new
       end
 
-      it { expect(subject.call).to eq id: value.object_id }
+      it { expect(cast.call).to eq id: value.object_id }
     end
 
     context 'with serializable object' do
@@ -66,12 +71,13 @@ describe Acfs::Resource::Attributes::Dict do
         end.new
       end
 
-      it { expect(subject.call).to eq id: value.object_id }
+      it { expect(cast.call).to eq id: value.object_id }
     end
 
     context 'with hash subclass object' do
       let(:value) { HashWithIndifferentAccess.new test: :foo }
-      it { expect(subject.call).to be value }
+
+      it { expect(cast.call).to be value }
     end
   end
 end

data/spec/acfs/resource/attributes/float_spec.rb

@@ -6,55 +6,65 @@ describe Acfs::Resource::Attributes::Float do
   let(:type) { Acfs::Resource::Attributes::Float.new }
 
   describe '#cast' do
-    subject { -> { type.cast value } }
+    subject(:cast) { -> { type.cast value } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with blank string (I)' do
       let(:value) { '' }
-      it { expect(subject.call).to eq 0.0 }
+
+      it { expect(cast.call).to eq 0.0 }
     end
 
     context 'with blank string (II)' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq 0.0 }
+
+      it { expect(cast.call).to eq 0.0 }
     end
 
     context 'with float' do
       let(:value) { 1.7 }
-      it { expect(subject.call).to eq 1.7 }
+
+      it { expect(cast.call).to eq 1.7 }
     end
 
     context 'with Infinity' do
       let(:value) { 'Infinity' }
-      it { expect(subject.call).to eq ::Float::INFINITY }
+
+      it { expect(cast.call).to eq ::Float::INFINITY }
     end
 
     context 'with -Infinity' do
       let(:value) { '-Infinity' }
-      it { expect(subject.call).to eq -::Float::INFINITY }
+
+      it { expect(cast.call).to eq(-::Float::INFINITY) }
     end
 
     context 'with NaN' do
       let(:value) { 'NaN' }
-      it { expect(subject.call).to be_nan }
+
+      it { expect(cast.call).to be_nan }
     end
 
     context 'with fixnum' do
       let(:value) { 1 }
-      it { expect(subject.call).to eq 1.0 }
+
+      it { expect(cast.call).to eq 1.0 }
     end
 
     context 'with valid string' do
       let(:value) { '1.7' }
-      it { expect(subject.call).to eq 1.7 }
+
+      it { expect(cast.call).to eq 1.7 }
     end
 
     context 'with invalid string (I)' do
       let(:value) { '1.7a' }
+
       it { is_expected.to raise_error ArgumentError }
     end
   end

data/spec/acfs/resource/attributes/integer_spec.rb

@@ -6,30 +6,35 @@ describe Acfs::Resource::Attributes::Integer do
   let(:type) { Acfs::Resource::Attributes::Integer.new }
 
   describe '#cast' do
-    subject { -> { type.cast value } }
+    subject(:cast) { -> { type.cast value } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with empty string' do
       let(:value) { '' }
-      it { expect(subject.call).to eq 0 }
+
+      it { expect(cast.call).to eq 0 }
     end
 
     context 'with blank string' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq 0 }
+
+      it { expect(cast.call).to eq 0 }
     end
 
     context 'with string' do
       let(:value) { '123' }
-      it { expect(subject.call).to eq 123 }
+
+      it { expect(cast.call).to eq 123 }
     end
 
     context 'with invalid string' do
       let(:value) { '123a' }
+
       it { is_expected.to raise_error ArgumentError }
     end
   end

data/spec/acfs/resource/attributes/list_spec.rb

@@ -6,26 +6,30 @@ describe Acfs::Resource::Attributes::List do
   let(:type) { Acfs::Resource::Attributes::List.new }
 
   describe '#cast' do
-    subject { -> { type.cast value } }
+    subject(:cast) { -> { type.cast value } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with blank string (I)' do
       let(:value) { '' }
-      it { expect(subject.call).to eq [] }
+
+      it { expect(cast.call).to eq [] }
     end
 
     context 'with blank string (II)' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq [] }
+
+      it { expect(cast.call).to eq [] }
     end
 
     context 'with array' do
       let(:value) { %w[abc cde efg] }
-      it { expect(subject.call).to eq value }
+
+      it { expect(cast.call).to eq value }
     end
 
     context 'with convertable object (I)' do
@@ -37,7 +41,7 @@ describe Acfs::Resource::Attributes::List do
         end.new
       end
 
-      it { expect(subject.call).to eq [1, 2, 3] }
+      it { expect(cast.call).to eq [1, 2, 3] }
     end
 
     context 'with convertable object (II)' do
@@ -49,12 +53,13 @@ describe Acfs::Resource::Attributes::List do
         end.new
       end
 
-      it { expect(subject.call).to eq [1, 2, 3] }
+      it { expect(cast.call).to eq [1, 2, 3] }
     end
 
     context 'with non castable object' do
       let(:value) { Object.new }
-      it { expect(subject.call).to eq [value] }
+
+      it { expect(cast.call).to eq [value] }
     end
   end
 end

data/spec/acfs/resource/attributes/uuid_spec.rb

@@ -6,36 +6,42 @@ describe Acfs::Resource::Attributes::UUID do
   let(:type) { Acfs::Resource::Attributes::UUID.new }
 
   describe '#cast' do
-    subject { -> { type.cast(value) } }
+    subject(:cast) { -> { type.cast(value) } }
 
     context 'with nil' do
       let(:value) { nil }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with empty string' do
       let(:value) { '' }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with blank string' do
       let(:value) { "  \t" }
-      it { expect(subject.call).to eq nil }
+
+      it { expect(cast.call).to eq nil }
     end
 
     context 'with string UUID' do
       let(:value) { '450b7a40-94ad-11e3-baa8-0800200c9a66' }
-      it { expect(subject.call).to be_a String }
-      it { expect(subject.call).to eq value }
+
+      it { expect(cast.call).to be_a String }
+      it { expect(cast.call).to eq value }
     end
 
     context 'with invalid string' do
       let(:value) { 'invalid string' }
+
       it { is_expected.to raise_error TypeError, /invalid UUID/i }
     end
 
     context 'with invalid UUID' do
       let(:value) { 'xxxxxxxx-yyyy-11e3-baa8-0800200c9a66' }
+
       it { is_expected.to raise_error TypeError, /invalid UUID/i }
     end
   end