acfs 1.6.0 → 1.7.0

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

data/spec/acfs/resource/attributes_spec.rb

@@ -9,12 +9,12 @@ describe Acfs::Resource::Attributes do
   describe '#initialize' do
     before { model.attribute :name, :string, default: 'John' }
 
-    it 'should have attribute list' do
+    it 'has attribute list' do
       expect(model.new.attributes).to include(:name)
     end
 
-    it 'should set default attributes' do
-      expect(model.new.name).to be == 'John'
+    it 'sets default attributes' do
+      expect(model.new.name).to eq 'John'
     end
 
     context 'with dynamic default value' do
@@ -23,8 +23,8 @@ describe Acfs::Resource::Attributes do
         model.attribute :mail, :string, default: -> { "#{name}@srv.tld" }
       end
 
-      it 'should set dynamic default attributes' do
-        expect(model.new.mail).to be == 'John@srv.tld'
+      it 'sets dynamic default attributes' do
+        expect(model.new.mail).to eq 'John@srv.tld'
       end
     end
   end
@@ -35,12 +35,14 @@ describe Acfs::Resource::Attributes do
       model.attribute :age, :integer, default: 25
     end
 
-    it 'should return hash of all attributes' do
+    it 'returns hash of all attributes' do
       expect(model.new.attributes).to eq(name: 'John', age: 25)
     end
   end
 
   describe '#write_attributes' do
+    subject(:action) { -> { m.write_attributes(params, **opts) } }
+
     before do
       model.attribute :name, :string, default: 'John'
       model.attribute :age, :integer, default: 25
@@ -48,14 +50,13 @@ describe Acfs::Resource::Attributes do
         write_attribute :name, "The Great #{name}"
       end
     end
+
     let(:params) { {name: 'James'} }
     let(:opts) { {} }
     let(:m) { model.new }
-    let(:action) { -> { m.write_attributes(params, **opts) } }
-    subject { action }
 
-    it 'should update attributes' do
-      should change(m, :attributes)
+    it 'updates attributes' do
+      expect(action).to change(m, :attributes)
         .from(name: 'The Great John', age: 25)
         .to(name: 'The Great James', age: 25)
     end
@@ -63,17 +64,17 @@ describe Acfs::Resource::Attributes do
     context 'without non-hash params' do
       let(:params) { 'James' }
 
-      it { should_not change(m, :attributes) }
-      its(:call) { should eq false }
+      it { expect(action).not_to change(m, :attributes) }
+      it { expect(action.call).to eq false }
     end
 
     context 'with unknown attributes' do
       let(:params) { {name: 'James', born_at: 'today'} }
 
-      it { should_not raise_error }
+      it { expect(action).not_to raise_error }
 
-      it 'should update known attributes and store unknown' do
-        should change(m, :attributes)
+      it 'updates known attributes and store unknown' do
+        expect(action).to change(m, :attributes)
           .from(name: 'The Great John', age: 25)
           .to(name: 'The Great James', age: 25, born_at: 'today')
       end
@@ -81,14 +82,14 @@ describe Acfs::Resource::Attributes do
       context 'with unknown: :raise option' do
         let(:opts) { {unknown: :raise} }
 
-        it { should raise_error(ArgumentError, /unknown attribute/i) }
+        it { expect(action).to raise_error(ArgumentError, /unknown attribute/i) }
 
         it do
           expect do
-            subject.call
+            action.call
           rescue StandardError
             true
-          end.to_not change(m, :attributes)
+          end.not_to change(m, :attributes)
         end
       end
     end
@@ -97,15 +98,15 @@ describe Acfs::Resource::Attributes do
   describe '#_getter_' do
     before { model.attribute :name, :string, default: 'John' }
 
-    it 'should return value' do
+    it 'returns value' do
       mo = model.new
       mo.name = 'Paul'
 
-      expect(mo.name).to be == 'Paul'
+      expect(mo.name).to eq 'Paul'
     end
 
-    it 'should return default value' do
-      expect(model.new.name).to be == 'John'
+    it 'returns default value' do
+      expect(model.new.name).to eq 'John'
     end
   end
 
@@ -115,49 +116,49 @@ describe Acfs::Resource::Attributes do
       model.attribute :age, :integer, default: '25'
     end
 
-    it 'should set value' do
+    it 'sets value' do
       o = model.new
       o.name = 'Paul'
 
-      expect(o.name).to be == 'Paul'
+      expect(o.name).to eq 'Paul'
     end
 
-    it 'should update attributes hash' do
+    it 'updates attributes hash' do
       o = model.new
       o.name = 'Johannes'
 
-      expect(o.attributes['name']).to be == 'Johannes'
+      expect(o.attributes['name']).to eq 'Johannes'
     end
 
-    it 'should cast values' do
+    it 'casts values' do
       o = model.new
       o.age = '28'
 
-      expect(o.age).to be == 28
+      expect(o.age).to eq 28
     end
   end
 
   describe 'class' do
     describe '#attributes' do
-      it 'should add an attribute to model attribute list' do
+      it 'adds an attribute to model attribute list' do
         model.send :attribute, :name, :string
 
         expect(model.attributes.symbolize_keys).to eq name: nil
       end
 
-      it 'should accept a default value' do
+      it 'accepts a default value' do
         model.send :attribute, :name, :string, default: 'John'
 
         expect(model.attributes.symbolize_keys).to eq name: 'John'
       end
 
-      it 'should accept a symbolic type' do
+      it 'accepts a symbolic type' do
         model.send :attribute, :age, :integer, default: '12'
 
         expect(model.attributes.symbolize_keys).to eq age: 12
       end
 
-      it 'should accept a class type' do
+      it 'accepts a class type' do
         model.send :attribute, :age, Acfs::Resource::Attributes::Integer,
           default: '12'
 

data/spec/acfs/resource/dirty_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Acfs::Resource::Dirty do
   let(:model) { MyUser.new }
+
   before do
     stub_request(:get, 'http://users.example.org/users/1')
       .to_return response id: 1, name: 'Anon', age: 12
@@ -23,21 +24,23 @@ describe Acfs::Resource::Dirty do
 
       context 'and saving' do
         before { user.save }
-        it { expect(user).to_not be_changed }
+
+        it { expect(user).not_to be_changed }
       end
     end
 
     context 'after model load' do
       let(:user) { MyUser.find 1 }
+
       before { user && Acfs.run }
 
-      it { expect(user).to_not be_changed }
+      it { expect(user).not_to be_changed }
     end
 
     context 'after model new without attrs' do
       let(:user) { MyUser.new }
 
-      it { expect(user).to_not be_changed }
+      it { expect(user).not_to be_changed }
     end
 
     context 'after model new with attrs' do