acfs 1.3.3 → 1.6.0

data/spec/acfs/resource/persistance_spec.rb

@@ -0,0 +1,322 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Resource::Persistence do
+  let(:model_class) { MyUser }
+  before do
+    @get_stub = stub_request(:get, 'http://users.example.org/users/1').to_return response(id: 1, name: 'Anon', age: 12)
+
+    @patch_stub = stub_request(:put, 'http://users.example.org/users/1')
+                  .with(body: '{"id":1,"name":"Idefix","age":12}')
+                  .to_return response(id: 1, name: 'Idefix', age: 12)
+
+    @post_stub = stub_request(:post, 'http://users.example.org/users')
+                 .with(body: '{"id":null,"name":"Idefix","age":12}')
+                 .to_return response(id: 5, name: 'Idefix', age: 12)
+
+    stub_request(:post, 'http://users.example.org/users')
+      .with(body: '{"id":null,"name":"Anon","age":null}')
+      .to_return response(id: 5, name: 'Anon', age: 12)
+
+    stub_request(:post, 'http://users.example.org/users')
+      .with(body: '{id:null,"name":"Idefix","age":12}')
+      .to_return response(id: 5, name: 'Idefix', age: 12)
+
+    stub_request(:post, 'http://users.example.org/users')
+      .with(body: '{"id":null,"name":null,"age":12}')
+      .to_return response({errors: {name: ['required']}}, {status: 422})
+
+    @del = stub_request(:delete, 'http://users.example.org/users/1')
+           .with(body: '{}')
+           .to_return response({id: 1, name: 'Idefix', age: 12}, {status: 200})
+  end
+
+  context 'new model' do
+    let(:model) { model_class.new }
+
+    it { expect(model).to_not be_persisted }
+    it { expect(model).to be_new }
+
+    describe '#save!' do
+      context 'when modified' do
+        let(:model) { model_class.find 1 }
+        before do
+          model
+          Acfs.run
+          model.name = 'Idefix'
+        end
+
+        it 'should PUT to model URL' do
+          model.save!
+
+          expect(@patch_stub).to have_been_requested
+        end
+      end
+
+      context 'when new' do
+        let(:model) { model_class.new name: 'Idefix', age: 12 }
+
+        it 'should POST to collection URL' do
+          model.save!
+
+          expect(@post_stub).to have_been_requested
+        end
+
+        context 'with unknown attributes' do
+          let!(:req) do
+            stub_request(:post, 'http://users.example.org/users')
+              .with(body: '{"id":null,"name":"Idefix","age":null,"born_at":"Berlin"}')
+              .to_return response(id: 5, name: 'Idefix', age: 12, wuff: 'woa')
+          end
+          let(:model) { model_class.new name: 'Idefix', born_at: 'Berlin' }
+
+          it 'should POST to collection URL' do
+            model.save!
+            expect(req).to have_been_requested
+          end
+
+          it 'should still have unknown attribute' do
+            model.save!
+            expect(model.attributes).to include 'born_at' => 'Berlin'
+          end
+
+          it 'should include server send unknown attribute' do
+            model.save!
+            expect(model.attributes).to include 'wuff' => 'woa'
+          end
+        end
+      end
+    end
+
+    context 'after save' do
+      before { model.save! }
+
+      it { expect(model).to be_persisted }
+      it { expect(model).to_not be_new }
+    end
+  end
+
+  context 'unloaded model' do
+    let!(:model) { model_class.find 1 }
+
+    describe '#update_attributes' do
+      subject { -> { model.update_attributes({name: 'John'}) } }
+      it { expect { subject.call }.to raise_error Acfs::ResourceNotLoaded }
+    end
+
+    describe '#update_attributes!' do
+      subject { -> { model.update_attributes!({name: 'John'}) } }
+      it { expect { subject.call }.to raise_error Acfs::ResourceNotLoaded }
+    end
+  end
+
+  context 'loaded model' do
+    context 'without changes' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run }
+
+      it { expect(model).to be_persisted }
+      it { expect(model).to_not be_new }
+    end
+
+    context 'with changes' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run; model.name = 'dhh' }
+
+      it { expect(model).to be_persisted }
+      it { expect(model).to_not be_new }
+    end
+
+    describe '#delete!' do
+      let(:model) { model_class.find 1 }
+      let(:before_acfs_run) {}
+
+      describe 'normal delete actions' do
+        before { model; Acfs.run }
+
+        it 'should trigger DELETE request' do
+          model.delete!
+          expect(@del).to have_been_requested
+        end
+
+        it 'should be frozen after DELETE' do
+          model.delete!
+          expect(model.__getobj__).to be_frozen
+        end
+      end
+
+      describe 'correct URL generation' do
+        let(:model_class) { PathArguments }
+        let(:model) { model_class.find 1, params: {required_arg: 'some_value'} }
+
+        before :each do
+          resource_url = 'http://users.example.org/some_value/users/1'
+          @my_get_stub = stub_request(:get, resource_url)
+                         .to_return response(id: 1, required_arg: 'some_value')
+          @my_delete_stub = stub_request(:delete, resource_url)
+                            .with(body: '{}')
+                            .to_return response({id: 1, required_arg: 'some_value'}, {status: 200})
+          model
+          Acfs.run
+        end
+
+        it 'should not raise an error on URL generation' do
+          expect do
+            model.delete!
+          end.not_to raise_error
+        end
+
+        it 'should request the delete' do
+          model.delete!
+          expect(@my_delete_stub).to have_been_requested
+        end
+      end
+    end
+
+    describe '#update_atributes!' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run }
+
+      it 'should set attributes' do
+        model.update_attributes({name: 'Idefix'})
+        expect(model.attributes.symbolize_keys).to eq id: 1, name: 'Idefix', age: 12
+      end
+
+      it 'should save resource' do
+        expect(model.__getobj__).to receive(:save)
+        model.update_attributes({name: 'Idefix'})
+      end
+
+      it 'should kwargs to save' do
+        expect(model.__getobj__).to receive(:save).with(bla: 'blub')
+        model.update_attributes({name: 'Idefix'}, bla: 'blub')
+      end
+    end
+
+    describe '#update_atributes' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run }
+
+      it 'should set attributes' do
+        model.update_attributes!({name: 'Idefix'})
+        expect(model.attributes.symbolize_keys).to eq id: 1, name: 'Idefix', age: 12
+      end
+
+      it 'should save resource' do
+        expect(model.__getobj__).to receive(:save!)
+        model.update_attributes!({name: 'Idefix'})
+      end
+
+      it 'should pass second hash to save' do
+        expect(model.__getobj__).to receive(:save!).with(bla: 'blub')
+        model.update_attributes!({name: 'Idefix'}, bla: 'blub')
+      end
+    end
+  end
+
+  describe '.save!' do
+    context 'with invalid data validated on server side' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run }
+
+      before do
+        stub_request(:put, 'http://users.example.org/users/1')
+          .with(body: '{"id":1,"name":"","age":12}')
+          .to_return response({errors: {name: ['required']}}, {status: 422})
+      end
+
+      it 'should set local errors hash' do
+        model.name = ''
+        begin
+          model.save!
+        rescue StandardError
+          nil
+        end
+        expect(model.errors.to_hash).to be == {name: %w[required]}
+      end
+    end
+
+    context 'hash modification on iteration in ActiveModel when errors on field is nil' do
+      let(:model) { model_class.find 1 }
+      before { model; Acfs.run }
+
+      before do
+        stub_request(:put, 'http://users.example.org/users/1')
+          .with(body: '{"id":1,"name":"","age":12}')
+          .to_return response({errors: {name: ['required']}}, {status: 422})
+      end
+    end
+  end
+
+  describe '.create!' do
+    context 'with valid data' do
+      let(:data) { {name: 'Idefix', age: 12} }
+
+      it 'should create new resource' do
+        model = model_class.create! data
+        expect(model.name).to be == 'Idefix'
+        expect(model.age).to be == 12
+      end
+
+      it 'should be persisted' do
+        model = model_class.create! data
+        expect(model).to be_persisted
+      end
+    end
+
+    context 'with invalid data' do
+      let(:data) { {name: nil, age: 12} }
+
+      it 'should raise an error' do
+        expect { model_class.create! data }.to \
+          raise_error(::Acfs::InvalidResource) do |error|
+            expect(error.errors).to be == {'name' => %w[required]}
+          end
+      end
+    end
+  end
+
+  describe '.create' do
+    subject { model_class.create data }
+
+    context 'with valid data' do
+      let(:data) { {name: 'Idefix', age: 12} }
+
+      it 'should create new resource' do
+        expect(subject.name).to be == 'Idefix'
+        expect(subject.age).to be == 12
+      end
+
+      it 'should be persisted' do
+        expect(subject).to be_persisted
+      end
+    end
+
+    context 'with invalid data' do
+      let(:data) { {name: nil, age: 12} }
+
+      it 'should return not persisted resource' do
+        expect(subject).to_not be_persisted
+      end
+
+      it 'should contain error hash' do
+        expect(subject.errors.to_hash).to eq name: %w[required]
+      end
+    end
+
+    context 'with additional data' do
+      let!(:req) do
+        stub_request(:post, 'http://users.example.org/users')
+          .with(body: '{"id":null,"name":"Anon","age":9,"born_at":"today"}')
+          .to_return response(id: 5, name: 'Anon', age: 9)
+      end
+      let(:data) { {age: 9, born_at: 'today'} }
+
+      it 'should store them in attributes' do
+        expect(subject.attributes).to eq 'id' => 5, 'name' => 'Anon',
+                                         'age' => 9, 'born_at' => 'today'
+      end
+    end
+  end
+end

data/spec/acfs/resource/query_methods_spec.rb

@@ -0,0 +1,548 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Acfs::Resource::QueryMethods do
+  let(:model) { MyUser }
+
+  describe '.find' do
+    context 'with single id' do
+      context 'with successful response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users/1')
+            .to_return response id: 1, name: 'Anon', age: 12, born_at: 'Berlin'
+          stub_request(:get, 'http://users.example.org/users/2')
+            .to_return response id: 2, type: 'Customer',
+                                name: 'Clare Customer', age: 24
+        end
+
+        let(:action) { ->(cb = nil) { model.find(1, &cb) } }
+        it_behaves_like 'a query method with multi-callback support'
+
+        it 'should load a single remote resource' do
+          user = action.call
+          Acfs.run
+
+          expect(user.attributes).to eq id: 1, name: 'Anon',
+                                        age: 12, born_at: 'Berlin'
+        end
+
+        context 'with resource type inheritance' do
+          let!(:user) { MyUser.find 2 }
+          subject { user }
+          before { Acfs.run }
+
+          it 'should respect resource type inheritance' do
+            expect(subject).to be_a Customer
+          end
+
+          it 'should implement ActiveModel class interface' do
+            expect(subject.class).to be_a ActiveModel::Naming
+            expect(subject.class).to be_a ActiveModel::Translation
+          end
+        end
+      end
+
+      context 'with 404 response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users/1')
+            .to_return response({error: 'not found'}, {status: 404})
+        end
+
+        it 'should raise a NotFound error' do
+          @user = model.find 1
+
+          expect { Acfs.run }.to raise_error(Acfs::ResourceNotFound)
+
+          expect(@user).to_not be_loaded
+        end
+      end
+
+      context 'with 500 response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users/1')
+            .to_return response(nil, status: 500)
+        end
+
+        it 'should raise a response error' do
+          @user = model.find 1
+
+          expect { Acfs.run }.to raise_error(Acfs::ErroneousResponse)
+
+          expect(@user).to_not be_loaded
+        end
+      end
+    end
+
+    context 'with multiple ids' do
+      before do
+        stub_request(:get, 'http://users.example.org/users/1')
+          .to_return response id: 1, name: 'Anon', age: 12
+        stub_request(:get, 'http://users.example.org/users/2')
+          .to_return response id: 2, name: 'Johnny', age: 42
+        stub_request(:get, 'http://users.example.org/users/3')
+          .to_return response id: 3, type: 'Customer', name: 'Anon', age: 12
+        stub_request(:get, 'http://users.example.org/users/4')
+          .to_return response id: 4, name: 'Johnny', age: 42
+      end
+
+      context 'with successful response' do
+        it 'should load a multiple remote resources' do
+          users = model.find([1, 2])
+          Acfs.run
+
+          expect(users.size).to be == 2
+          expect(users[0].attributes).to eq id: 1, name: 'Anon', age: 12
+          expect(users[1].attributes).to eq id: 2, name: 'Johnny', age: 42
+        end
+
+        it 'should invoke callback after all models are loaded' do
+          block = proc {}
+          expect(block).to receive(:call) do |users|
+            expect(users).to equal @users
+            expect(users.size).to be == 2
+            expect(users).to be_loaded
+          end
+
+          @users = model.find([1, 2], &block)
+          Acfs.run
+        end
+
+        it 'should invoke multiple callback after all models are loaded' do
+          proc1 = proc {}
+          proc2 = proc {}
+          expect(proc1).to receive(:call) do |users|
+            expect(users).to equal @users
+            expect(users.size).to be == 2
+            expect(users).to be_loaded
+          end
+          expect(proc2).to receive(:call) do |users|
+            expect(users).to equal @users
+            expect(users.size).to be == 2
+            expect(users).to be_loaded
+          end
+
+          @users = model.find([1, 2], &proc1)
+          Acfs.add_callback(@users, &proc2)
+          Acfs.run
+        end
+
+        it 'should respect resource type inheritance' do
+          customers = MyUser.find [3, 4]
+          Acfs.run
+
+          expect(customers[0]).to be_a Customer
+          expect(customers[1]).to be_a MyUser
+        end
+      end
+
+      context 'with one 404 response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users/1')
+            .to_return response({error: 'not found'}, {status: 404})
+        end
+
+        it 'should raise resource not found error' do
+          model.find [1, 2]
+
+          expect { Acfs.run }.to raise_error(Acfs::ResourceNotFound)
+        end
+      end
+    end
+  end
+
+  describe '.all' do
+    let(:computer) { Computer }
+    let(:pc) { PC }
+    let(:mac) { Mac }
+    before do
+      stub_request(:get, 'http://computers.example.org/computers')
+        .to_return response [
+          {id: 1, type: 'PC'},
+          {id: 2, type: 'Computer'},
+          {id: 3, type: 'Mac'}
+        ]
+    end
+
+    it 'should invoke multiple callback after all models are loaded' do
+      proc1 = proc {}
+      proc2 = proc {}
+      expect(proc1).to receive(:call) do |computers|
+        expect(computers).to equal @computers
+        expect(computers.size).to be == 3
+        expect(computers).to be_loaded
+      end
+      expect(proc2).to receive(:call) do |computers|
+        expect(computers).to equal @computers
+        expect(computers.size).to be == 3
+        expect(computers).to be_loaded
+      end
+
+      @computers = computer.all(&proc1)
+      Acfs.add_callback(@computers, &proc2)
+      Acfs.run
+    end
+
+    context 'with resource type inheritance' do
+      it 'should create appropriate subclass resources' do
+        @computers = Computer.all
+
+        expect(@computers).to_not be_loaded
+
+        Acfs.run
+
+        expect(@computers).to be_loaded
+        expect(@computers).to have(3).items
+        expect(@computers[0]).to be_a PC
+        expect(@computers[1]).to be_a Computer
+        expect(@computers[2]).to be_a Mac
+      end
+
+      context 'with invalid type set' do
+        shared_examples 'with invalid type' do
+          it 'should raise error if type is no subclass' do
+            Computer.all
+            expect { Acfs.run }.to raise_error(Acfs::ResourceTypeError)
+          end
+        end
+
+        context 'with another resource as type instead' do
+          before do
+            stub_request(:get, 'http://computers.example.org/computers')
+              .to_return response [
+                {id: 1, type: 'MyUser'},
+                {id: 2, type: 'Computer'},
+                {id: 3, type: 'Mac'}
+              ]
+          end
+          it_behaves_like 'with invalid type'
+        end
+
+        context 'with a random string as type instead' do
+          before do
+            stub_request(:get, 'http://computers.example.org/computers')
+              .to_return response [
+                {id: 1, type: 'PC'},
+                {id: 2, type: 'noValidType'},
+                {id: 3, type: 'Mac'}
+              ]
+          end
+          it_behaves_like 'with invalid type'
+        end
+
+        context 'with a non-string as type instead' do
+          before do
+            stub_request(:get, 'http://computers.example.org/computers')
+              .to_return response [
+                {id: 1, type: 'PC'},
+                {id: 2, type: 'Computer'},
+                {id: 3, type: 42}
+              ]
+          end
+          it_behaves_like 'with invalid type'
+        end
+      end
+    end
+  end
+
+  shared_examples 'find_by' do
+    context 'standard resource' do
+      let(:model) { MyUser }
+      let!(:user) { model.send described_method, age: 24 }
+      subject { Acfs.run && user }
+
+      context 'return value' do
+        subject { user }
+
+        it { should be_a MyUser }
+        it { should_not be_loaded }
+      end
+
+      context 'with params' do
+        let!(:request) do
+          stub_request(:get, 'http://users.example.org/users?age=24')
+            .to_return response([{id: 1, name: 'Mike', age: 24}])
+        end
+
+        it 'should include params in URI to index action' do
+          subject
+          expect(request).to have_been_requested
+        end
+      end
+
+      context 'with non-empty response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users?age=24')
+            .to_return response [
+              {id: 1, name: 'Mike', age: 24},
+              {id: 4, type: 'Maria', age: 24},
+              {id: 7, type: 'James', age: 24}
+            ]
+        end
+
+        it 'should invoke callback after model is loaded' do
+          block = proc {}
+
+          expect(block).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a MyUser
+            expect(user).to be_loaded
+          end
+
+          @user = model.send described_method, age: 24, &block
+          Acfs.run
+        end
+
+        it 'should invoke multiple callbacks after model is loaded' do
+          proc1 = proc {}
+          proc2 = proc {}
+
+          expect(proc1).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a MyUser
+            expect(user).to be_loaded
+          end
+
+          expect(proc2).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a MyUser
+            expect(user).to be_loaded
+          end
+
+          @user = model.send described_method, age: 24, &proc1
+          Acfs.add_callback @user, &proc2
+          Acfs.run
+        end
+
+        it 'should load a single MyUser object' do
+          expect(subject).to be_a MyUser
+        end
+      end
+    end
+
+    context 'singleton resource' do
+      let(:model) { Single }
+
+      it '.find_by should not be defined' do
+        expect { model.find_by }.to raise_error ::Acfs::UnsupportedOperation
+      end
+    end
+  end
+
+  describe '.find_by' do
+    let(:described_method) { :find_by }
+    it_behaves_like 'find_by'
+
+    context 'standard resource' do
+      let(:model) { MyUser }
+      let!(:user) { model.send described_method, age: 24 }
+      subject { Acfs.run && user }
+
+      context 'with empty response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users?age=24')
+            .to_return response []
+        end
+
+        it { should be_nil }
+
+        it 'should invoke callback after model is loaded' do
+          block = proc {}
+
+          expect(block).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a NilClass
+          end
+
+          @user = model.find_by age: 24, &block
+          Acfs.run
+        end
+
+        it 'should invoke multiple callbacks after model is loaded' do
+          proc1 = proc {}
+          proc2 = proc {}
+
+          expect(proc1).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a NilClass
+          end
+          expect(proc2).to receive(:call) do |user|
+            expect(user).to eql @user.__getobj__
+            expect(user).to be_a NilClass
+          end
+
+          @user = model.find_by age: 24, &proc1
+          Acfs.add_callback @user, &proc2
+          Acfs.run
+        end
+      end
+    end
+  end
+
+  describe '.find_by!' do
+    let(:described_method) { :find_by! }
+    it_behaves_like 'find_by'
+
+    context 'standard resource' do
+      let(:model) { MyUser }
+      let!(:user) { model.send described_method, age: 24 }
+      subject { Acfs.run && user }
+
+      context 'with empty response' do
+        before do
+          stub_request(:get, 'http://users.example.org/users?age=24')
+            .to_return response []
+        end
+
+        it 'should raise an ResourceNotFound error' do
+          model.find_by! age: 24
+          expect { Acfs.run }.to raise_error Acfs::ResourceNotFound
+        end
+
+        it 'should not invoke callback after model could not be loaded' do
+          block = proc {}
+
+          expect(block).not_to receive(:call)
+
+          model.find_by! age: 24, &block
+          expect { Acfs.run }.to raise_error Acfs::ResourceNotFound
+        end
+      end
+    end
+
+    describe '#each_page' do
+      context 'without parameters' do
+        before do
+          stub_request(:get, 'http://users.example.org/users')
+            .to_return response([{id: 1, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=2>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=2')
+            .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=3>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=3')
+            .to_return response([{id: 3, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=4>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=4')
+            .to_return response([{id: 4, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => ''
+              })
+        end
+
+        it 'should iterate all pages' do
+          index = 0
+          model.each_page do |page|
+            expect(page).to be_a Acfs::Collection
+
+            index += 1
+            expect(page.first.id).to eq index
+          end
+          Acfs.run
+
+          expect(index).to eq 4
+        end
+      end
+
+      context 'with parameters' do
+        before do
+          stub_request(:get, 'http://users.example.org/users?param=bla')
+            .to_return response([{id: 1, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?where=fuu&page=2>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?where=fuu&page=2')
+            .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=3>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=3')
+            .to_return response([{id: 3, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=4>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=4')
+            .to_return response([{id: 4, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => ''
+              })
+        end
+
+        it 'should call first page with params and follow relations' do
+          index = 0
+          model.each_page(param: 'bla') do |page|
+            expect(page).to be_a Acfs::Collection
+
+            index += 1
+            expect(page.first.id).to eq index
+          end
+          Acfs.run
+
+          expect(index).to eq 4
+        end
+      end
+    end
+
+    describe '#each_item' do
+      context 'without parameters' do
+        before do
+          stub_request(:get, 'http://users.example.org/users')
+            .to_return response([{id: 1, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=2>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=2')
+            .to_return response([{id: 2, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=3>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=3')
+            .to_return response([{id: 3, name: 'Anno', age: 1604, born_at: 'Santa Maria'}, {id: 4, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => '<http://users.example.org/users?page=4>; rel="next"'
+              })
+          stub_request(:get, 'http://users.example.org/users?page=4')
+            .to_return response([{id: 5, name: 'Anno', age: 1604, born_at: 'Santa Maria'}],
+              headers: {
+                'X-Total-Pages' => '4',
+                'Link' => ''
+              })
+        end
+
+        it 'should iterate all pages' do
+          indices = []
+          model.each_item do |item|
+            expect(item).to be_a MyUser
+            indices << item.id
+          end
+          Acfs.run
+
+          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
+  end
+end