gocardless 1.9.0 → 1.10.0

data/spec/client_spec.rb

@@ -101,7 +101,7 @@ describe GoCardless::Client do
     describe "with valid params" do
       let(:oauth_client) { @client.instance_variable_get(:@oauth_client) }
       let(:fake_token) do
-        stub(:params => {'scope' => 'manage_merchant:x'}, :token  => 'abc')
+        double(:params => {'scope' => 'manage_merchant:x'}, :token  => 'abc')
       end
 
       before { oauth_client.auth_code.stub(:get_token).and_return(fake_token) }
@@ -182,7 +182,7 @@ describe GoCardless::Client do
     it "uses the correct path prefix" do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
-      r = mock
+      r = double
       r.stub(:parsed)
       token.should_receive(:get).with { |p,o| p =~ %r|/api/v1/test| }.and_return(r)
       @client.api_get('/test')
@@ -197,7 +197,7 @@ describe GoCardless::Client do
     it "encodes data to json" do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
-      r = mock
+      r = double
       r.stub(:parsed)
       token.should_receive(:post).with { |p,opts| opts[:body] == '{"a":1}' }.and_return(r)
       @client.api_post('/test', {:a => 1})
@@ -212,7 +212,7 @@ describe GoCardless::Client do
     it "encodes data to json" do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
-      r = mock
+      r = double
       r.stub(:parsed)
       token.should_receive(:delete).with { |p,opts| opts[:body] == '{"a":1}' }.and_return(r)
       @client.api_delete('/test', {:a => 1})
@@ -227,7 +227,7 @@ describe GoCardless::Client do
     it "looks up the correct merchant" do
       @client.access_token = 'TOKEN'
       @client.merchant_id = '123'
-      response = mock
+      response = double
       response.should_receive(:parsed)
 
       token = @client.instance_variable_get(:@access_token)
@@ -242,7 +242,7 @@ describe GoCardless::Client do
     it "creates a Merchant object" do
       @client.access_token = 'TOKEN'
       @client.merchant_id = '123'
-      response = mock
+      response = double
       response.should_receive(:parsed).and_return({:name => 'test', :id => 123})
 
       token = @client.instance_variable_get(:@access_token)
@@ -255,7 +255,7 @@ describe GoCardless::Client do
     end
   end
 
-  %w{subscription pre_authorization user bill payment}.each do |resource|
+  %w(subscription pre_authorization user bill).each do |resource|
     describe "##{resource}" do
       it "and_return the correct #{GoCardless::Utils.camelize(resource)} object" do
         @client.access_token = 'TOKEN'
@@ -311,12 +311,12 @@ describe GoCardless::Client do
 
     it "confirms the resource when the signature is valid" do
       # Once for confirm, once to fetch result
-      @client.should_receive(:request).twice.and_return(stub(:parsed => {}))
+      @client.should_receive(:request).twice.and_return(double(:parsed => {}))
       @client.confirm_resource(@client.send(:sign_params, @params))
     end
 
     it "and_return the correct object when the signature is valid" do
-      @client.stub(:request).and_return(stub(:parsed => {}))
+      @client.stub(:request).and_return(double(:parsed => {}))
       subscription = GoCardless::Subscription.new_with_client @client
       GoCardless::Subscription.should_receive(:find_with_client).and_return subscription
 
@@ -373,7 +373,7 @@ describe GoCardless::Client do
       params_indifferent_access = HashWithIndifferentAccess.new(params)
       expect do
         @client.response_params_valid? params_indifferent_access
-      end.to_not raise_exception ArgumentError
+      end.to_not raise_exception
     end
 
     it "rejects other params not required for the signature" do

data/spec/page_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+require 'gocardless/page'
+
+describe GoCardless::Page do
+  #let(:resource_class) { Class.new(GoCardless::Resource) { } }
+  let(:resource_class) { GoCardless::Resource }
+  let(:links) {{ "next" => 2, "last" => 2 }}
+  let(:data) {[ { :id => 'a' }, { :id => 'b' } ]}
+
+  let(:page) { GoCardless::Page.new(resource_class, data, links) }
+
+  describe "#has_next?" do
+    subject { page.has_next? }
+
+    context "when there is next page available" do
+      let(:links) {{ "next" => 2, "last" => 2 }}
+      it { should be_true }
+    end
+
+    context "when there is no next page" do
+      let(:links) {{ "previous" => 1, "first" => 1 }}
+      it { should be_false }
+    end
+  end
+
+  describe "#next_page" do
+    subject { page.next_page }
+
+    context "when there is next page available" do
+      let(:links) {{ "next" => 2, "last" => 2 }}
+      it { should == 2 }
+    end
+
+    context "when there is no next page" do
+      let(:links) {{ "previous" => 1, "first" => 1 }}
+      it { should be_nil }
+    end
+  end
+
+  describe "#previous_page" do
+    subject { page.previous_page }
+
+    context "when there is previous page available" do
+      let(:links) {{ "previous" => 1, "first" => 1 }}
+      it { should == 1 }
+    end
+
+    context "when there is no previous page" do
+      let(:links) {{ "next" => 2, "last" => 2 }}
+      it { should be_nil }
+    end
+  end
+
+  describe "#first_page" do
+    subject { page.first_page }
+
+    context "when there is first page available" do
+      let(:links) {{ "first" => 1, "previous" => 1 }}
+      it { should == 1 }
+    end
+
+    context "when there is no first page" do
+      let(:links) {{ "next" => 2, "last" => 2 }}
+      it { should be_nil }
+    end
+  end
+
+  describe "#last_page" do
+    subject { page.last_page }
+
+    context "when there is last page available" do
+      let(:links) {{ "next" => 2, "last" => 2 }}
+      it { should == 2 }
+    end
+
+    context "when there is no last page" do
+      let(:links) {{ "previous" => 1, "first" => 1 }}
+      it { should be_nil }
+    end
+  end
+
+  describe "#each" do
+    it "yields resource instances for each data item" do
+      resources = [a_kind_of(resource_class), a_kind_of(resource_class)]
+      expect { |b| page.each(&b) }.to yield_successive_args(*resources)
+    end
+
+    it "properly initialises the resources" do
+      page.map(&:id).should == ['a', 'b']
+    end
+  end
+end
+

data/spec/paginator_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'gocardless/paginator'
+
+describe GoCardless::Paginator do
+  let(:resource_class) { GoCardless::Resource }
+  let(:path) { '/test' }
+  let(:query) { { :status => 'active' } }
+  let(:per_page) { 10 }
+  let(:page_number) { 1 }
+
+  let(:headers_p1) {{
+    'X-Pagination' => '{"records":15,"pages":2,"links":{"next":2,"last":2}}'
+  }}
+  let(:response_p1) { double(:headers => headers_p1, :parsed => [{:id => 'a'}]) }
+
+  let(:headers_p2) {{
+    'X-Pagination' => '{"records":15,"pages":2,"links":{"previous":1,"first":1}}'
+  }}
+  let(:response_p2) { double(:headers => headers_p2, :parsed => [{:id => 'b'}]) }
+
+  let(:client) { double('client') }
+  before { client.stub(:api_request).and_return(response_p1, response_p2,
+                                                response_p1, response_p2) }
+
+  let(:paginator) { described_class.new(client, resource_class, path, query) }
+  before { paginator.per_page(per_page) }
+
+  describe "#per_page" do
+    context "given no arguments" do
+      subject { paginator.per_page }
+      it { should == per_page }
+    end
+
+    context "given an argument" do
+      it "is chainable" do
+        paginator.per_page(60).should == paginator
+      end
+    end
+
+    it "resets pagination metadata" do
+      paginator.should_receive(:load_page).exactly(2).times
+      paginator.count  # reset metadata, check that we have to reload it
+      paginator.per_page(50)
+      paginator.count
+    end
+  end
+
+  describe "#load_page" do
+    it "asks the client for the correct path" do
+      client.should_receive(:api_request).
+             with(:get, '/test', anything).
+             and_return(response_p1)
+      paginator.page(page_number)
+    end
+
+    it "passes the correct pagination parameters through" do
+      pagination_params = { :page => page_number, :per_page => per_page }
+      client.should_receive(:api_request) do |_, _, opts|
+        opts[:params].should include pagination_params
+      end.and_return(response_p1)
+      paginator.page(page_number)
+    end
+  end
+
+  describe "#each" do
+    it "yields every item from each page" do
+      resources = [a_kind_of(resource_class), a_kind_of(resource_class)]
+      expect { |b| paginator.each(&b) }.to yield_successive_args(*resources)
+    end
+  end
+
+  describe "#each_page" do
+    let(:pages) { [a_kind_of(GoCardless::Page), a_kind_of(GoCardless::Page)] }
+
+    it "yields each page until there are none left" do
+      expect { |b| paginator.each_page(&b) }.to yield_successive_args(*pages)
+    end
+
+    it "can be iterated over multiple times" do
+      2.times do
+        expect { |b| paginator.each_page(&b) }.to yield_successive_args(*pages)
+      end
+    end
+  end
+
+  describe "#count" do
+    subject { paginator.count }
+
+    context "when metadata is loaded" do
+      before { paginator.page(1) }
+
+      it { should == 15 }
+
+      it "doesn't reload metadata" do
+        paginator.should_not_receive(:load_page)
+        paginator.count
+      end
+    end
+
+    context "when metadata is not loaded" do
+      it { should == 15 }
+
+      it "loads metadata" do
+        paginator.should_receive(:load_page)
+        paginator.count
+      end
+    end
+  end
+
+  describe "#page_count" do
+    subject { paginator.page_count }
+
+    context "when metadata is loaded" do
+      before { paginator.page(1) }
+
+      it { should == 2 }
+
+      it "doesn't reload metadata" do
+        paginator.should_not_receive(:load_page)
+        paginator.page_count
+      end
+    end
+
+    context "when metadata is not loaded" do
+      it { should == 2 }
+
+      it "loads metadata" do
+        paginator.should_receive(:load_page)
+        paginator.page_count
+      end
+    end
+  end
+end
+

data/spec/pre_authorization_spec.rb

@@ -1,57 +1,20 @@
 require 'spec_helper'
 
 describe GoCardless::PreAuthorization do
-  before :each do
-    @app_id = 'abc'
-    @app_secret = 'xyz'
-    GoCardless.account_details = {:app_id => @app_id, :app_secret => @app_secret,
-                                  :token  => 'xxx', :merchant_id => '1'}
-    @client = GoCardless.client
+  before do
+    GoCardless.account_details = {:app_id => 'abc', :app_secret => 'xyz',
+                                  :token  => 'xxx', :merchant_id => '123'}
   end
+  let(:client) { GoCardless.client }
+  let(:preauth) { GoCardless::PreAuthorization.new(:id => '009988') }
 
   it "should be cancellable" do
-    s = GoCardless::PreAuthorization.new_with_client(@client, :id => '009988')
-    @client.should_receive(:api_put).with('/pre_authorizations/009988/cancel')
-    s.cancel!
+    client.should_receive(:api_put).with('/pre_authorizations/009988/cancel')
+    preauth.cancel!
   end
 
-  describe "inactive query method" do
-    it "and_return true when the subscription status is inactive" do
-      GoCardless::PreAuthorization.new(:status => 'inactive').inactive?.should be_true
-    end
-
-    it "and_return false otherwise" do
-      GoCardless::PreAuthorization.new.inactive?.should be_false
-    end
-  end
-
-  describe "active query method" do
-    it "and_return true when the subscription status is active" do
-      GoCardless::PreAuthorization.new(:status => 'active').active?.should be_true
-    end
-
-    it "and_return false otherwise" do
-      GoCardless::PreAuthorization.new.active?.should be_false
-    end
-  end
-
-  describe "cancelled query method" do
-    it "and_return true when the subscription status is cancelled" do
-      GoCardless::PreAuthorization.new(:status => 'cancelled').cancelled?.should be_true
-    end
-
-    it "and_return false otherwise" do
-      GoCardless::PreAuthorization.new.cancelled?.should be_false
-    end
-  end
-
-  describe "expired query method" do
-    it "and_return true when the subscription status is expired" do
-      GoCardless::PreAuthorization.new(:status => 'expired').expired?.should be_true
-    end
-
-    it "and_return false otherwise" do
-      GoCardless::PreAuthorization.new.expired?.should be_false
-    end
-  end
+  it_behaves_like "it has a query method for", "inactive"
+  it_behaves_like "it has a query method for", "active"
+  it_behaves_like "it has a query method for", "cancelled"
+  it_behaves_like "it has a query method for", "expired"
 end

data/spec/resource_spec.rb

@@ -11,23 +11,18 @@ describe GoCardless::Resource do
   end
 
   describe "#date_writer" do
-    it "creates date writers properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        date_writer :created_at, :modified_at
-      end
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { date_writer :created_at, :modified_at }
+    end
 
-      test_resource.instance_methods.map(&:to_s).should include 'created_at='
-      test_resource.instance_methods.map(&:to_s).should include 'modified_at='
+    describe "creates date writers" do
+      specify { test_resource.instance_methods.map(&:to_sym).should include :created_at= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :modified_at= }
     end
 
     it "date writers work properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        date_writer :created_at
-      end
-
-      resource = test_resource.new
       time = '2011-12-12T12:00:00Z'
-      resource.created_at = time
+      resource = test_resource.new(:created_at => time)
       date_time = resource.instance_variable_get(:@created_at)
       date_time.should be_instance_of DateTime
       date_time.strftime('%Y-%m-%dT%H:%M:%SZ').should == time
@@ -35,22 +30,18 @@ describe GoCardless::Resource do
   end
 
   describe "#date_accessor" do
-    it "creates date readers and writers properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        date_accessor :created_at, :modified_at
-      end
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { date_accessor :created_at, :modified_at }
+    end
 
-      test_resource.instance_methods.map(&:to_s).should include 'created_at='
-      test_resource.instance_methods.map(&:to_s).should include 'created_at'
-      test_resource.instance_methods.map(&:to_s).should include 'modified_at='
-      test_resource.instance_methods.map(&:to_s).should include 'modified_at'
+    describe "creates date readers and writers" do
+      specify { test_resource.instance_methods.map(&:to_sym).should include :created_at= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :created_at }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :modified_at= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :modified_at }
     end
 
     it "date readers work properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        date_accessor :created_at
-      end
-
       resource = test_resource.new
       date = DateTime.now
       resource.instance_variable_set(:@created_at, date)
@@ -59,11 +50,12 @@ describe GoCardless::Resource do
   end
 
   describe ".find_with_client" do
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { self.endpoint = '/test/:id' }
+    end
+
     it "instantiates the correct object" do
-      test_resource = Class.new(GoCardless::Resource) do
-        self.endpoint = '/test/:id'
-      end
-      mock_client = mock
+      mock_client = double
       mock_client.should_receive(:api_get).and_return({:id => 123})
       resource = test_resource.find_with_client(mock_client, 123)
       resource.should be_a test_resource
@@ -72,41 +64,35 @@ describe GoCardless::Resource do
   end
 
   describe ".find" do
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { self.endpoint = '/test/:id' }
+    end
+
     it "calls find with the default client" do
-      test_resource = Class.new(GoCardless::Resource) do
-        self.endpoint = '/test/:id'
-      end
-      GoCardless.stub(:client => mock)
+      GoCardless.stub(:client => double)
       test_resource.should_receive(:find_with_client).with(GoCardless.client, 1)
       test_resource.find(1)
       unset_ivar GoCardless, :client
     end
 
     it "raises a helpful error when there is no default client" do
-      test_resource = Class.new(GoCardless::Resource) do
-        self.endpoint = '/test/:id'
-      end
       expect { test_resource.find(1) }.to raise_error
     end
   end
 
   describe "#reference_writer" do
-    it "creates reference writers properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        reference_writer :merchant_id, :user_id
-      end
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { reference_writer :merchant_id, :user_id }
+    end
 
-      test_resource.instance_methods.map(&:to_s).should include 'merchant='
-      test_resource.instance_methods.map(&:to_s).should include 'merchant_id='
-      test_resource.instance_methods.map(&:to_s).should include 'user='
-      test_resource.instance_methods.map(&:to_s).should include 'user_id='
+    describe "creates reference writers" do
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant_id= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user_id= }
     end
 
     it "direct assignment methods work properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        reference_writer :user_id
-      end
-
       resource = test_resource.new
       resource.user = GoCardless::User.new(:id => 123)
       resource.instance_variable_get(:@user_id).should == 123
@@ -121,12 +107,7 @@ describe GoCardless::Resource do
     end
 
     it "fails with the wrong object type" do
-      test_resource = Class.new(GoCardless::Resource) do
-        reference_writer :user_id
-      end
-      expect do
-        test_resource.new.user = 'asdf'
-      end.to raise_exception ArgumentError
+      expect { test_resource.new.user = 'asdf' }.to raise_exception ArgumentError
     end
   end
 
@@ -138,22 +119,18 @@ describe GoCardless::Resource do
       @redirect_uri = 'http://test.com/cb'
     end
 
-    it "creates reference writers properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        reference_reader :merchant_id, :user_id
-      end
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) { reference_reader :merchant_id, :user_id }
+    end
 
-      test_resource.instance_methods.map(&:to_s).should include 'merchant'
-      test_resource.instance_methods.map(&:to_s).should include 'merchant_id'
-      test_resource.instance_methods.map(&:to_s).should include 'user'
-      test_resource.instance_methods.map(&:to_s).should include 'user_id'
+    describe "creates reference readers" do
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant_id }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user_id }
     end
 
     it "lookup methods work properly" do
-      test_resource = Class.new(GoCardless::Resource) do
-        reference_reader :user_id
-      end
-
       resource = test_resource.new_with_client(@client)
       resource.instance_variable_set(:@user_id, 123)
       @client.access_token = 'TOKEN'
@@ -174,19 +151,21 @@ describe GoCardless::Resource do
   end
 
   describe "#reference_accessor" do
-    it "creates reference readers and writers" do
-      test_resource = Class.new(GoCardless::Resource) do
+    let(:test_resource) do
+      Class.new(GoCardless::Resource) do
         reference_accessor :merchant_id, :user_id
       end
+    end
 
-      test_resource.instance_methods.map(&:to_s).should include 'merchant'
-      test_resource.instance_methods.map(&:to_s).should include 'merchant_id'
-      test_resource.instance_methods.map(&:to_s).should include 'user'
-      test_resource.instance_methods.map(&:to_s).should include 'user_id'
-      test_resource.instance_methods.map(&:to_s).should include 'merchant='
-      test_resource.instance_methods.map(&:to_s).should include 'merchant_id='
-      test_resource.instance_methods.map(&:to_s).should include 'user='
-      test_resource.instance_methods.map(&:to_s).should include 'user_id='
+    describe "creates reference readers and writers" do
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant_id }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user_id }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :merchant_id= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user= }
+      specify { test_resource.instance_methods.map(&:to_sym).should include :user_id= }
     end
   end
 
@@ -211,7 +190,7 @@ describe GoCardless::Resource do
       end
 
       it "sends the correct data parameters" do
-        client = mock
+        client = double
         data = {:x => 1, :y => 2}
         resource = @test_resource.new_with_client(client, data)
         client.should_receive(:api_post).with(anything, data)
@@ -219,21 +198,21 @@ describe GoCardless::Resource do
       end
 
       it "sends the correct path" do
-        client = mock
+        client = double
         resource = @test_resource.new_with_client(client)
         client.should_receive(:api_post).with('/test', anything)
         resource.save
       end
 
       it "POSTs when not persisted" do
-        client = mock
+        client = double
         resource = @test_resource.new_with_client(client)
         client.should_receive(:api_post)
         resource.save
       end
 
       it "PUTs when already persisted" do
-        client = mock
+        client = double
         resource = @test_resource.new_with_client(client, :id => 1)
         client.should_receive(:api_put)
         resource.save
@@ -283,7 +262,7 @@ describe GoCardless::Resource do
     end
 
     attrs = {:id => 1, :uri => 'http:', :x => 'y'}
-    resource = test_resource.new_with_client(mock, attrs)
+    resource = test_resource.new_with_client(double, attrs)
     resource.to_hash.should == attrs
   end
 
@@ -334,9 +313,8 @@ describe GoCardless::Resource do
   end
 
   describe "sub_resource_uri methods" do
+    let(:test_resource) { Class.new(GoCardless::Resource) }
     before :each do
-      @test_resource = Class.new(GoCardless::Resource) do
-      end
       @attrs = {
         'sub_resource_uris' => {
           'bills' => 'https://test.com/api/bills/?merchant_id=1'
@@ -345,51 +323,52 @@ describe GoCardless::Resource do
     end
 
     it "are defined on instances" do
-      r = @test_resource.new(@attrs)
+      r = test_resource.new(@attrs)
       r.should respond_to :bills
     end
 
     it "aren't defined for other instances of the class" do
-      @test_resource.new(@attrs)
-      resource = @test_resource.new
+      test_resource.new(@attrs)
+      resource = test_resource.new
       resource.should_not respond_to :bills
     end
 
     it "use the correct uri path" do
-      client = mock()
-      client.should_receive(:api_get).with('/api/bills/', anything).and_return([])
-      r = @test_resource.new_with_client(client, @attrs)
+      GoCardless::Paginator.should_receive(:new).
+                            with(anything, anything, '/api/bills/', anything)
+      r = test_resource.new_with_client(double, @attrs)
       r.bills
     end
 
     it "strips the api prefix from the path" do
-      client = mock()
-      client.should_receive(:api_get).with('/bills/', anything).and_return([])
+      GoCardless::Paginator.should_receive(:new).
+                            with(anything, anything, '/bills/', anything)
       uris = {'bills' => 'https://test.com/api/v123/bills/'}
-      r = @test_resource.new_with_client(client, 'sub_resource_uris' => uris)
+      r = test_resource.new_with_client(double, 'sub_resource_uris' => uris)
       r.bills
     end
 
     it "use the correct query string params" do
-      client = mock()
-      client.should_receive(:api_get).with(anything, 'merchant_id' => '1').and_return([])
-      r = @test_resource.new_with_client(client, @attrs)
+      query = { 'merchant_id' => '1' }
+      GoCardless::Paginator.should_receive(:new).
+                            with(anything, anything, anything, query)
+      r = test_resource.new_with_client(double, @attrs)
       r.bills
     end
 
     it "adds provided params to existing query string params" do
-      client = mock()
       params = { 'merchant_id' => '1', :amount => '10.00' }
-      client.should_receive(:api_get).with(anything, params).and_return([])
-      r = @test_resource.new_with_client(client, @attrs)
+      GoCardless::Paginator.should_receive(:new).
+                            with(anything, anything, anything, params)
+      r = test_resource.new_with_client(double, @attrs)
       r.bills(:amount => '10.00')
     end
 
     it "adds provided params when there are no existing query string params" do
-      client = mock()
       params = { :source_id => 'xxx' }
-      client.should_receive(:api_get).with(anything, params).and_return([])
-      r = @test_resource.new_with_client(client, {
+      GoCardless::Paginator.should_receive(:new).
+                            with(anything, anything, anything, params)
+      r = test_resource.new_with_client(double, {
         'sub_resource_uris' => {
           'bills' => 'https://test.com/merchants/1/bills'
         }
@@ -398,11 +377,8 @@ describe GoCardless::Resource do
     end
 
     it "return instances of the correct resource class" do
-      client = stub(:api_get => [{:id => 1}])
-      r = @test_resource.new_with_client(client, @attrs)
-      ret = r.bills
-      ret.should be_a Array
-      ret.first.should be_a GoCardless::Bill
+      r = test_resource.new_with_client(double, @attrs)
+      r.bills.should be_a GoCardless::Paginator
     end
   end
 end