acfs 1.3.2 → 1.3.3

data/spec/acfs/resource/persistance_spec.rb

@@ -1,316 +0,0 @@
-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).with({})
-        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
-
-    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!).with({})
-        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 = ''
-        model.save! rescue nil
-        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

@@ -1,541 +0,0 @@
-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