acfs 0.45.0 → 0.50.0

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

@@ -1,55 +1,49 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::DateTime do
-  let(:model) { Class.new Acfs::Resource }
-  let(:params) { {} }
-  subject { Acfs::Resource::Attributes::DateTime.new params }
+  let(:type) { Acfs::Resource::Attributes::DateTime.new }
 
-  describe 'cast' do
-    it 'should return same object, if obj is already of DateTime class' do
-      date_time = DateTime.now
-      retval = subject.cast(date_time)
-      expect(retval).to be == date_time
+  describe '#cast' do
+    subject { -> { type.cast value } }
+
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
     end
 
-    it 'should return parsed object, if obj is of Time class' do
-      time = Time.now
-      retval = subject.cast(time)
-      expect(retval).to be == DateTime.iso8601(time.iso8601)
+    context 'with empty string' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq nil }
     end
 
-    it 'should return parsed object, if obj is of Date class' do
-      date = Date.today
-      retval = subject.cast(date)
-      expect(retval).to be == DateTime.iso8601(date.iso8601)
+    context 'with blank string' do
+      let(:value) { "  \t" }
+      it { expect(subject.call).to eq nil }
     end
 
-    it 'should return parsed object, if obj is of String class in ISO-8601 format' do
-      date_time_string = DateTime.now.iso8601
-      retval = subject.cast(date_time_string)
-      expect(retval).to be == DateTime.iso8601(date_time_string)
+    context 'with DateTime' do
+      let(:value) { DateTime.now }
+      it { expect(subject.call).to eq value }
     end
 
-    it 'should raise an error if obj is of String class not in valid ISO-8601 format' do
-      malformed_string = 'qwe123'
-      expect do
-        subject.cast(malformed_string)
-      end.to raise_error ArgumentError
+    context 'with Time' do
+      let(:value) { Time.now }
+      it { expect(subject.call).to eq value.to_datetime }
     end
 
-    it 'should raise an error if obj is of wrong class (Fixnum)' do
-      fixnum = 12
-      expect do
-        subject.cast(fixnum)
-      end.to raise_error TypeError
+    context 'with Date' do
+      let(:value) { Date.today }
+      it { expect(subject.call).to eq value.to_datetime }
     end
 
-    context 'with allow_nil option' do
-      let(:params) { {allow_nil: true} }
+    context 'with ISO8601' do
+      let(:value) { DateTime.now.iso8601 }
+      it { expect(subject.call.iso8601).to eq value }
+    end
 
-      it 'should accept empty string as nil' do
-        expect(subject.cast('')).to eq nil
-      end
+    context 'with invalid string' do
+      let(:value) { 'qwe123' }
+      it { is_expected.to raise_error ArgumentError }
     end
   end
 end

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

@@ -1,50 +1,75 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::Dict do
-  let(:model) { Class.new(Acfs::Resource) }
-  subject { Acfs::Resource::Attributes::Dict.new }
+  let(:type) { Acfs::Resource::Attributes::Dict.new }
 
-  describe '.cast' do
-    context 'with hash' do
-      let(:sample) { {3 => true, 'asfd' => 4} }
+  describe '#cast' do
+    subject { -> { type.cast value } }
 
-      it 'should return unmodified hash' do
-        expect(subject.cast(sample)).to be sample
-      end
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
+    end
+
+    context 'with blank string (I)' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq Hash.new }
+    end
+
+    context 'with blank string (II)' do
+      let(:value) { "  \t" }
+      it { expect(subject.call).to eq Hash.new }
+    end
+
+    context 'with hash' do
+      let(:value) { {3 => true, abc: 4} }
+      it { expect(subject.call).to eq value }
     end
 
-    context 'with not hashable object' do
-      let(:sample) { Object.new }
+    context 'with non hashable object' do
+      let(:value) { Object.new }
+      it { is_expected.to raise_error TypeError }
+    end
 
-      it 'should raise a TypeError' do
-        expect do
-          subject.cast(sample)
-        end.to raise_error TypeError
+    context 'with hashable object (I)' do
+      let(:value) do
+        Class.new do
+          def to_hash
+            {id: object_id}
+          end
+        end.new
       end
+
+      it { expect(subject.call).to eq id: value.object_id }
     end
 
-    context 'with hashable object' do
-      let(:sample) do
-        o = Object.new
-        class << o
+    context 'with hashable object (II)' do
+      let(:value) do
+        Class.new do
           def to_h
-            {3 => 4, 'test' => true}
+            {id: object_id}
           end
-        end
-        o
+        end.new
       end
 
-      it 'should cast object to hash' do
-        expect(subject.cast(sample)).to eq 3 => 4, 'test' => true
-      end
+      it { expect(subject.call).to eq id: value.object_id }
     end
 
-    context 'with hash subclass' do
-      let(:sample) { HashWithIndifferentAccess.new :test => :foo, 34 => 12 }
-
-      it 'should return obj unmodified' do
-        expect(subject.cast(sample)).to be sample
+    context 'with serializable object' do
+      let(:value) do
+        Class.new do
+          def serializable_hash
+            {id: object_id}
+          end
+        end.new
       end
+
+      it { expect(subject.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 }
     end
   end
 end

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

@@ -1,20 +1,59 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::Float do
-  let(:model) { Class.new Acfs::Resource }
-  subject { described_class.new }
+  let(:type) { Acfs::Resource::Attributes::Float.new }
 
-  describe 'cast' do
-    it 'should return same object, if obj is already of float class' do
-      expect(subject.cast(1.3)).to be == 1.3
+  describe '#cast' do
+    subject { -> { type.cast value } }
+
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
+    end
+
+    context 'with blank string (I)' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq 0.0 }
+    end
+
+    context 'with blank string (II)' do
+      let(:value) { "  \t" }
+      it { expect(subject.call).to eq 0.0 }
+    end
+
+    context 'with float' do
+      let(:value) { 1.7 }
+      it { expect(subject.call).to eq 1.7 }
+    end
+
+    context 'with Infinity' do
+      let(:value) { 'Infinity' }
+      it { expect(subject.call).to eq ::Float::INFINITY }
+    end
+
+    context 'with -Infinity' do
+      let(:value) { '-Infinity' }
+      it { expect(subject.call).to eq -::Float::INFINITY }
+    end
+
+    context 'with NaN' do
+      let(:value) { 'NaN' }
+      it { expect(subject.call).to be_nan }
+    end
+
+    context 'with fixnum' do
+      let(:value) { 1 }
+      it { expect(subject.call).to eq 1.0 }
     end
 
-    it 'should return parsed object, if obj is of Fixnum class' do
-      expect(subject.cast(7)).to be == 7.0
+    context 'with valid string' do
+      let(:value) { '1.7' }
+      it { expect(subject.call).to eq 1.7 }
     end
 
-    it 'should return parsed object, if obj is of String class containing a float' do
-      expect(subject.cast('1.7')).to be == 1.7
+    context 'with invalid string (I)' do
+      let(:value) { '1.7a' }
+      it { is_expected.to raise_error ArgumentError }
     end
   end
 end

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

@@ -1,19 +1,34 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::Integer do
-  subject { Acfs::Resource::Attributes::Integer.new }
+  let(:type) { Acfs::Resource::Attributes::Integer.new }
 
-  describe 'cast' do
-    it 'should cast integer strings' do
-      expect(subject.cast('123')).to eq 123
+  describe '#cast' do
+    subject { -> { type.cast value } }
+
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
+    end
+
+    context 'with empty string' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq 0 }
+    end
+
+    context 'with blank string' do
+      let(:value) { "  \t" }
+      it { expect(subject.call).to eq 0 }
     end
 
-    it 'should cast empty string (backward compatibility)' do
-      expect(subject.cast('')).to eq 0
+    context 'with string' do
+      let(:value) { '123' }
+      it { expect(subject.call).to eq 123 }
     end
 
-    it 'should not cast invalid integers' do
-      expect { subject.cast 'abc' }.to raise_error TypeError
+    context 'with invalid string' do
+      let(:value) { '123a' }
+      it { is_expected.to raise_error ArgumentError }
     end
   end
 end

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

@@ -1,34 +1,58 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::List do
-  let(:model) { Class.new Acfs::Resource }
-  subject { described_class.new }
+  let(:type) { Acfs::Resource::Attributes::List.new }
 
-  describe '.cast' do
-    context 'with array' do
-      let(:sample) { %w(abc cde efg) }
+  describe '#cast' do
+    subject { -> { type.cast value } }
 
-      it 'should return unmodified array' do
-        expect(subject.cast(sample)).to be == %w(abc cde efg)
-      end
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
     end
 
-    context 'with not listable object' do
-      let(:sample) { Object.new }
+    context 'with blank string (I)' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq Array.new }
+    end
 
-      it 'should raise a TypeError' do
-        expect do
-          subject.cast(sample)
-        end.to raise_error TypeError
-      end
+    context 'with blank string (II)' do
+      let(:value) { "  \t" }
+      it { expect(subject.call).to eq Array.new }
     end
 
-    context 'with listable object' do
-      let(:sample) { 5..10 }
+    context 'with array' do
+      let(:value) { %w(abc cde efg) }
+      it { expect(subject.call).to eq value }
+    end
 
-      it 'should cast object to array' do
-        expect(subject.cast(sample)).to be == [5, 6, 7, 8, 9, 10]
+    context 'with convertable object (I)' do
+      let(:value) do
+        Class.new do
+          def to_ary
+            [1, 2, 3]
+          end
+        end.new
       end
+
+      it { expect(subject.call).to eq [1, 2, 3] }
+    end
+
+    context 'with convertable object (II)' do
+      let(:value) do
+        Class.new do
+          def to_a
+            [1, 2, 3]
+          end
+        end.new
+      end
+
+      it { expect(subject.call).to eq [1, 2, 3] }
+    end
+
+    context 'with non castable object' do
+      let(:value) { Object.new }
+      it { expect(subject.call).to eq [value] }
     end
   end
 end

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

@@ -1,63 +1,40 @@
 require 'spec_helper'
 
 describe Acfs::Resource::Attributes::UUID do
-  let(:model) { Class.new Acfs::Resource }
-  let(:params) { {} }
-  let(:instance) { described_class.new params }
-  subject { instance }
-
-  describe '#cast_type' do
-    let(:param) { '450b7a40-94ad-11e3-baa8-0800200c9a66' }
-    let(:action) { instance.cast param }
-    subject { action }
-
-    context 'with String as param' do
-      context 'with valid UUID' do
-        let(:param) { '450b7a40-94ad-11e3-baa8-0800200c9a66' }
-        it { should be_a String }
-        it { should eq param }
-      end
-
-      context 'with invalid UUID' do
-        subject { -> { action } }
-
-        context 'with random non-empty string' do
-          let(:param) { 'invalid string' }
-          it { should raise_error ArgumentError }
-        end
-
-        context 'with UUID string containing invalid characters' do
-          let(:param) { 'xxxxxxxx-yyyy-11e3-baa8-0800200c9a66' }
-          it { should raise_error ArgumentError }
-        end
-
-        context 'with empty string' do
-          let(:param) { '' }
-
-          context 'with allow_nil option' do
-            let(:params) { {allow_nil: true} }
-            subject { action }
-            it { should eq nil }
-          end
-
-          context 'without allow_nil option' do
-            let(:params) { {allow_nil: false} }
-            it { should raise_error ArgumentError }
-          end
-        end
-      end
+  let(:type) { Acfs::Resource::Attributes::UUID.new }
+
+  describe '#cast' do
+    subject { -> { type.cast(value) } }
+
+    context 'with nil' do
+      let(:value) { nil }
+      it { expect(subject.call).to eq nil }
     end
 
-    context 'with non-String as param' do
-      subject { -> { action } }
+    context 'with empty string' do
+      let(:value) { '' }
+      it { expect(subject.call).to eq nil }
+    end
+
+    context 'with blank string' do
+      let(:value) { "  \t" }
+      it { expect(subject.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 }
+    end
+
+    context 'with invalid string' do
+      let(:value) { 'invalid string' }
+      it { is_expected.to raise_error TypeError, /invalid UUID/i }
+    end
 
-      invalid_params = {fixnum: 1, float: 3.2, symbol: :invalid, boolean: true}
-      invalid_params.each do |type, incorrect_param|
-        context "with #{type} as param" do
-          let(:param) { incorrect_param }
-          it { should raise_error ArgumentError }
-        end
-      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
 end

data/spec/acfs/resource/attributes_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 describe Acfs::Resource::Attributes do
   let(:model) { Class.new Acfs::Resource }
+  let(:submodel) { Class.new model }
 
   describe '#initialize' do
     before { model.attribute :name, :string, default: 'John' }
@@ -137,7 +138,7 @@ describe Acfs::Resource::Attributes do
   end
 
   describe 'class' do
-    describe '#attribute' do
+    describe '#attributes' do
       it 'should add an attribute to model attribute list' do
         model.send :attribute, :name, :string
 
@@ -150,42 +151,27 @@ describe Acfs::Resource::Attributes do
         expect(model.attributes.symbolize_keys).to eq name: 'John'
       end
 
-      it 'should accept an symbolic type' do
+      it 'should accept a symbolic type' do
         model.send :attribute, :age, :integer, default: '12'
 
         expect(model.attributes.symbolize_keys).to eq age: 12
       end
 
-      it 'should accept an class type' do
+      it 'should accept a class type' do
         model.send :attribute, :age, Acfs::Resource::Attributes::Integer,
           default: '12'
 
         expect(model.attributes.symbolize_keys).to eq age: 12
       end
 
-      context 'allow nil option' do
-        it 'should allow nil as value' do
-          model.send :attribute, :updated_at, :date_time,
-            default: DateTime.new, allow_nil: true
-
-          resource = model.new
-          expect(resource.updated_at).to eq DateTime.new
-
-          resource.updated_at = ''
-          expect(resource.updated_at).to eq nil
+      context 'on inherited resources' do
+        before do
+          model.attribute :age, :integer, default: 5
+          submodel.attribute :born_at, :date_time
         end
-      end
-
-      context 'allow blank option' do
-        it 'should allow blank as value' do
-          model.send :attribute, :updated_at, :date_time,
-            default: DateTime.new, allow_blank: true
-
-          resource = model.new
-          expect(resource.updated_at).to eq DateTime.new
 
-          resource.updated_at = ''
-          expect(resource.updated_at).to eq nil
+        it 'includes superclass attributes' do
+          expect(submodel.attributes.keys).to match_array %w(age born_at)
         end
       end
     end

data/spec/acfs/resource/query_methods_spec.rb

@@ -519,14 +519,21 @@ describe Acfs::Resource::QueryMethods do
         end
 
         it 'should iterate all pages' do
-          indecies = []
+          indices = []
           model.each_item do |item|
             expect(item).to be_a MyUser
-            indecies << item.id
+            indices << item.id
           end
           Acfs.run
 
-          expect(indecies).to eq [1, 2, 3, 4, 5]
+          expect(indices).to eq [1, 2, 3, 4, 5]
+        end
+
+        it 'should pass the collection to the provided block' do
+          model.each_item do |_item, collection|
+            expect(collection).to be_a Acfs::Collection
+          end
+          Acfs.run
         end
       end
     end

data/spec/acfs/response/formats_spec.rb

@@ -12,7 +12,7 @@ describe Acfs::Response::Formats do
     let(:headers)   { {} }
 
     it "should fallback on 'text/plain'" do
-      expect(response.content_type).to be == Mime::TEXT
+      expect(response.content_type).to be == Mime[:text]
     end
   end
 
@@ -21,7 +21,7 @@ describe Acfs::Response::Formats do
 
     describe '#content_type' do
       it 'should return Mime::JSON' do
-        expect(response.content_type).to be == Mime::JSON
+        expect(response.content_type).to be == Mime[:json]
       end
     end
 
@@ -36,7 +36,7 @@ describe Acfs::Response::Formats do
 
       describe '#content_type' do
         it 'should return Mime::JSON' do
-          expect(response.content_type).to be == Mime::JSON
+          expect(response.content_type).to be == Mime[:json]
         end
       end
 

data/spec/spec_helper.rb

@@ -9,7 +9,7 @@ if ENV['CI'] || (defined?(:RUBY_ENGINE) && RUBY_ENGINE != 'rbx')
 end
 
 require 'bundler'
-Bundler.require
+Bundler.require(:default, :test)
 
 require 'acfs'
 require 'webmock/rspec'