acfs 1.4.0 → 1.7.0

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(:args) { [params] }
+
     let(:params) { {name: 'James'} }
+    let(:opts) { {} }
     let(:m) { model.new }
-    let(:action) { -> { m.write_attributes(*args) } }
-    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,34 +64,32 @@ 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
 
       context 'with unknown: :raise option' do
-        let(:args) { [params, {unknown: :raise}] }
+        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
-            begin
-              subject.call
-            rescue StandardError
-              true
-            end
-          end.to_not change(m, :attributes)
+            action.call
+          rescue StandardError
+            true
+          end.not_to change(m, :attributes)
         end
       end
     end
@@ -99,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
 
@@ -117,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

data/spec/acfs/resource/initialization_spec.rb

@@ -17,20 +17,19 @@ describe 'Acfs::Resource::Initialization' do
   end
 
   describe '#initialize' do
-    it 'should allow to set attributes with initializer' do
+    it 'allows to set attributes with initializer' do
       m = model.new name: 'John'
       expect(m.name).to eq 'John'
     end
 
-    it 'should raise error when attributes with private setters are given' do
+    it 'raises error when attributes with private setters are given' do
       expect { model.new age: 25 }.to raise_error(NoMethodError)
     end
   end
 
   describe '#persisted?' do
-    subject { model.new.persisted? }
-    it 'should be false' do
-      should be false
+    it 'is false' do
+      expect(model.new.persisted?).to be false
     end
   end
 end

data/spec/acfs/resource/loadable_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Acfs::Resource::Loadable do
   let(:model) { MyUser.find 1 }
+
   before do
     stub_request(:get, 'http://users.example.org/users/1')
       .to_return response id: 1, name: 'Anon', age: 12
@@ -11,11 +12,12 @@ describe Acfs::Resource::Loadable do
 
   describe '#loaded?' do
     context 'before Acfs#run' do
-      it { expect(model).to_not be_loaded }
+      it { expect(model).not_to be_loaded }
     end
 
     context 'afer Acfs#run' do
       before { model && Acfs.run }
+
       it { expect(model).to be_loaded }
     end
   end

data/spec/acfs/resource/locatable_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 
 describe Acfs::Resource::Locatable do
   let(:model) { MyUser }
+
   before do
     stub_request(:get, 'http://users.example.org/users/1')
       .to_return response id: 1, name: 'Anon', age: 12
@@ -12,63 +13,67 @@ describe Acfs::Resource::Locatable do
   end
 
   describe '.url' do
-    it 'should return URL' do
-      expect(model.url).to be == 'http://users.example.org/users'
+    it 'returns URL' do
+      expect(model.url).to eq 'http://users.example.org/users'
     end
 
-    it 'should return URL with id path part if specified' do
-      expect(model.url(5)).to be == 'http://users.example.org/users/5'
+    it 'returns URL with id path part if specified' do
+      expect(model.url(5)).to eq 'http://users.example.org/users/5'
     end
 
     context 'with attribute in path' do
       let(:model) { Profile }
 
-      it 'should replace placeholder' do
+      it 'replaces placeholder' do
         expect(model.url(user_id: 1))
           .to eq 'http://users.example.org/users/1/profile'
       end
 
       context 'without attributes' do
-        it 'should raise an error if attribute is missing' do
+        it 'raises an error if attribute is missing' do
           expect { model.url }.to raise_error ArgumentError
         end
       end
     end
 
     describe 'custom paths' do
+      subject(:location) { Session.location(action: action) }
+
       let(:model) { Session }
-      let(:location) { Session.location action: action }
-      subject { location }
 
       context ':list location' do
         let(:action) { :list }
 
         its(:raw_uri) do
-          should eq 'http://users.example.org/users/:user_id/sessions'
+          is_expected.to eq 'http://users.example.org/users/:user_id/sessions'
         end
       end
 
       context ':create location' do
         let(:action) { :create }
-        its(:raw_uri) { should eq 'http://users.example.org/sessions' }
+
+        its(:raw_uri) { is_expected.to eq 'http://users.example.org/sessions' }
       end
 
       context ':read location' do
         let(:action) { :read }
-        its(:raw_uri) { should eq 'http://users.example.org/sessions/:id' }
+
+        its(:raw_uri) { is_expected.to eq 'http://users.example.org/sessions/:id' }
       end
 
       context ':update location' do
         let(:action) { :update }
+
         its(:raw_uri) do
-          expect { subject }.to raise_error ArgumentError, /update.*disabled/
+          expect { location }.to raise_error ArgumentError, /update.*disabled/
         end
       end
 
       context ':delete location' do
         let(:action) { :delete }
+
         its(:raw_uri) do
-          should eq 'http://users.example.org/users/:user_id/sessions/del/:id'
+          is_expected.to eq 'http://users.example.org/users/:user_id/sessions/del/:id'
         end
       end
     end
@@ -78,20 +83,20 @@ describe Acfs::Resource::Locatable do
     context 'new resource' do
       let(:m) { model.new }
 
-      it 'should return nil' do
+      it 'returns nil' do
         expect(m.url).to be_nil
       end
 
       context 'new resource with id' do
         let(:m) { model.new id: 475 }
 
-        it 'should return resource URL' do
+        it 'returns resource URL' do
           expect(m.url).to eq 'http://users.example.org/users/475'
         end
       end
 
       context 'with attribute in path' do
-        it 'should return nil' do
+        it 'returns nil' do
           expect(m.url).to be_nil
         end
       end
@@ -99,9 +104,10 @@ describe Acfs::Resource::Locatable do
 
     context 'loaded resource' do
       let(:m) { model.find 1 }
+
       before { m && Acfs.run }
 
-      it "should return resource's URL" do
+      it "returns resource's URL" do
         expect(m.url).to eq 'http://users.example.org/users/1'
       end
 
@@ -109,7 +115,7 @@ describe Acfs::Resource::Locatable do
         let(:model) { Profile }
         let(:m) { model.find user_id: 1 }
 
-        it "should return resource's URL" do
+        it "returns resource's URL" do
           expect(m.url).to eq 'http://users.example.org/users/2/profile'
         end
       end