gocardless 1.11.2 → 1.12.0

data/spec/gocardless_spec.rb

@@ -10,7 +10,7 @@ describe GoCardless do
 
   describe ".account_details=" do
     it "creates a Client instance" do
-      GoCardless::Client.should_receive :new
+      expect(GoCardless::Client).to receive :new
       subject.account_details = @details
     end
 
@@ -21,12 +21,30 @@ describe GoCardless do
     end
   end
 
+  describe ".environment=" do
+    subject(:method) { -> { GoCardless.environment = gc_env } }
+
+    context "with a valid environment" do
+      let(:gc_env) { :production }
+      it { is_expected.to_not raise_error }
+      it 'sets the environment' do
+        method.call
+        expect(GoCardless.environment).to eq(gc_env)
+      end
+    end
+
+    context "with an invalid environment" do
+      let(:gc_env) { :foobar }
+      it { is_expected.to raise_error }
+    end
+  end
+
 
   describe "delegated methods" do
     %w(new_subscription_url new_pre_authorization_url new_bill_url confirm_resource webhook_valid?).each do |name|
       it "#{name} delegates to @client" do
         subject.account_details = @details
-        subject.instance_variable_get(:@client).should_receive(name.to_sym)
+        expect(subject.instance_variable_get(:@client)).to receive(name.to_sym)
         subject.send(name)
       end
 

data/spec/page_spec.rb

@@ -14,12 +14,12 @@ describe GoCardless::Page do
 
     context "when there is next page available" do
       let(:links) {{ "next" => 2, "last" => 2 }}
-      it { should be_truthy }
+      it { is_expected.to be_truthy }
     end
 
     context "when there is no next page" do
       let(:links) {{ "previous" => 1, "first" => 1 }}
-      it { should be_falsey }
+      it { is_expected.to be_falsey }
     end
   end
 
@@ -28,12 +28,12 @@ describe GoCardless::Page do
 
     context "when there is next page available" do
       let(:links) {{ "next" => 2, "last" => 2 }}
-      it { should == 2 }
+      it { is_expected.to eq(2) }
     end
 
     context "when there is no next page" do
       let(:links) {{ "previous" => 1, "first" => 1 }}
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -42,12 +42,12 @@ describe GoCardless::Page do
 
     context "when there is previous page available" do
       let(:links) {{ "previous" => 1, "first" => 1 }}
-      it { should == 1 }
+      it { is_expected.to eq(1) }
     end
 
     context "when there is no previous page" do
       let(:links) {{ "next" => 2, "last" => 2 }}
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -56,12 +56,12 @@ describe GoCardless::Page do
 
     context "when there is first page available" do
       let(:links) {{ "first" => 1, "previous" => 1 }}
-      it { should == 1 }
+      it { is_expected.to eq(1) }
     end
 
     context "when there is no first page" do
       let(:links) {{ "next" => 2, "last" => 2 }}
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -70,12 +70,12 @@ describe GoCardless::Page do
 
     context "when there is last page available" do
       let(:links) {{ "next" => 2, "last" => 2 }}
-      it { should == 2 }
+      it { is_expected.to eq(2) }
     end
 
     context "when there is no last page" do
       let(:links) {{ "previous" => 1, "first" => 1 }}
-      it { should be_nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -86,7 +86,7 @@ describe GoCardless::Page do
     end
 
     it "properly initialises the resources" do
-      page.map(&:id).should == ['a', 'b']
+      expect(page.map(&:id)).to eq(['a', 'b'])
     end
   end
 end

data/spec/paginator_spec.rb

@@ -19,7 +19,7 @@ describe GoCardless::Paginator do
   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,
+  before { allow(client).to receive(:api_request).and_return(response_p1, response_p2,
                                                 response_p1, response_p2) }
 
   let(:paginator) { described_class.new(client, resource_class, path, query) }
@@ -28,17 +28,17 @@ describe GoCardless::Paginator do
   describe "#per_page" do
     context "given no arguments" do
       subject { paginator.per_page }
-      it { should == per_page }
+      it { is_expected.to eq(per_page) }
     end
 
     context "given an argument" do
       it "is chainable" do
-        paginator.per_page(60).should == paginator
+        expect(paginator.per_page(60)).to eq(paginator)
       end
     end
 
     it "resets pagination metadata" do
-      paginator.should_receive(:load_page).exactly(2).times
+      expect(paginator).to receive(:load_page).exactly(2).times
       paginator.count  # reset metadata, check that we have to reload it
       paginator.per_page(50)
       paginator.count
@@ -47,7 +47,7 @@ describe GoCardless::Paginator do
 
   describe "#load_page" do
     it "asks the client for the correct path" do
-      client.should_receive(:api_request).
+      expect(client).to receive(:api_request).
              with(:get, '/test', anything).
              and_return(response_p1)
       paginator.page(page_number)
@@ -55,9 +55,9 @@ describe GoCardless::Paginator do
 
     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)
+      expect(client).to receive(:api_request) { |_, _, opts|
+        expect(opts[:params]).to include pagination_params
+      }.and_return(response_p1)
       paginator.page(page_number)
     end
   end
@@ -89,19 +89,19 @@ describe GoCardless::Paginator do
     context "when metadata is loaded" do
       before { paginator.page(1) }
 
-      it { should == 15 }
+      it { is_expected.to eq(15) }
 
       it "doesn't reload metadata" do
-        paginator.should_not_receive(:load_page)
+        expect(paginator).not_to receive(:load_page)
         paginator.count
       end
     end
 
     context "when metadata is not loaded" do
-      it { should == 15 }
+      it { is_expected.to eq(15) }
 
       it "loads metadata" do
-        paginator.should_receive(:load_page)
+        expect(paginator).to receive(:load_page)
         paginator.count
       end
     end
@@ -113,19 +113,19 @@ describe GoCardless::Paginator do
     context "when metadata is loaded" do
       before { paginator.page(1) }
 
-      it { should == 2 }
+      it { is_expected.to eq(2) }
 
       it "doesn't reload metadata" do
-        paginator.should_not_receive(:load_page)
+        expect(paginator).not_to receive(:load_page)
         paginator.page_count
       end
     end
 
     context "when metadata is not loaded" do
-      it { should == 2 }
+      it { is_expected.to eq(2) }
 
       it "loads metadata" do
-        paginator.should_receive(:load_page)
+        expect(paginator).to receive(:load_page)
         paginator.page_count
       end
     end

data/spec/pre_authorization_spec.rb

@@ -9,7 +9,7 @@ describe GoCardless::PreAuthorization do
   let(:preauth) { GoCardless::PreAuthorization.new(:id => '009988') }
 
   it "should be cancellable" do
-    client.should_receive(:api_put).with('/pre_authorizations/009988/cancel')
+    expect(client).to receive(:api_put).with('/pre_authorizations/009988/cancel')
     preauth.cancel!
   end
 

data/spec/resource_spec.rb

@@ -7,7 +7,7 @@ describe GoCardless::Resource do
     end
     props = {:id => 1, :name => 'test', :uri => 'http://test'}
     resource = test_resource.new(props)
-    props.each { |k,v| resource.send(k).should == v }
+    props.each { |k,v| expect(resource.send(k)).to eq(v) }
   end
 
   describe "#date_writer" do
@@ -16,16 +16,16 @@ describe GoCardless::Resource do
     end
 
     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= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :created_at= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :modified_at= }
     end
 
     it "date writers work properly" do
       time = '2011-12-12T12:00:00Z'
       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
+      expect(date_time).to be_instance_of DateTime
+      expect(date_time.strftime('%Y-%m-%dT%H:%M:%SZ')).to eq(time)
     end
   end
 
@@ -35,17 +35,17 @@ describe GoCardless::Resource do
     end
 
     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 }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :created_at= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :created_at }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :modified_at= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :modified_at }
     end
 
     it "date readers work properly" do
       resource = test_resource.new
       date = DateTime.now
       resource.instance_variable_set(:@created_at, date)
-      resource.created_at.should == date
+      expect(resource.created_at).to eq(date)
     end
   end
 
@@ -56,10 +56,10 @@ describe GoCardless::Resource do
 
     it "instantiates the correct object" do
       mock_client = double
-      mock_client.should_receive(:api_get).and_return({:id => 123})
+      expect(mock_client).to receive(:api_get).and_return({:id => 123})
       resource = test_resource.find_with_client(mock_client, 123)
-      resource.should be_a test_resource
-      resource.id.should == 123
+      expect(resource).to be_a test_resource
+      expect(resource.id).to eq(123)
     end
   end
 
@@ -69,8 +69,8 @@ describe GoCardless::Resource do
     end
 
     it "calls find with the default client" do
-      GoCardless.stub(:client => double)
-      test_resource.should_receive(:find_with_client).with(GoCardless.client, 1)
+      allow(GoCardless).to receive_messages(:client => double)
+      expect(test_resource).to receive(:find_with_client).with(GoCardless.client, 1)
       test_resource.find(1)
       unset_ivar GoCardless, :client
     end
@@ -86,16 +86,16 @@ describe GoCardless::Resource do
     end
 
     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= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant_id= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user_id= }
     end
 
     it "direct assignment methods work properly" do
       resource = test_resource.new
       resource.user = GoCardless::User.new(:id => 123)
-      resource.instance_variable_get(:@user_id).should == 123
+      expect(resource.instance_variable_get(:@user_id)).to eq(123)
     end
 
     it "requires args to end with _id" do
@@ -124,10 +124,10 @@ describe GoCardless::Resource do
     end
 
     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 }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant_id }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user_id }
     end
 
     it "lookup methods work properly" do
@@ -137,8 +137,8 @@ describe GoCardless::Resource do
       @client.merchant_id = '123'
       stub_get(@client, {:id => 123})
       user = resource.user
-      user.should be_a GoCardless::User
-      user.id.should == 123
+      expect(user).to be_a GoCardless::User
+      expect(user.id).to eq(123)
     end
 
     it "requires args to end with _id" do
@@ -158,20 +158,20 @@ describe GoCardless::Resource do
     end
 
     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= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant_id }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user_id }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :merchant_id= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user= }
+      specify { expect(test_resource.instance_methods.map(&:to_sym)).to include :user_id= }
     end
   end
 
   it "#persisted? works" do
-    GoCardless::Resource.new.persisted?.should be_falsey
-    GoCardless::Resource.new(:id => 1).persisted?.should be_truthy
+    expect(GoCardless::Resource.new.persisted?).to be_falsey
+    expect(GoCardless::Resource.new(:id => 1).persisted?).to be_truthy
   end
 
   describe "#save" do
@@ -193,28 +193,28 @@ describe GoCardless::Resource do
         client = double
         data = {:x => 1, :y => 2}
         resource = @test_resource.new_with_client(client, data)
-        client.should_receive(:api_post).with(anything, data)
+        expect(client).to receive(:api_post).with(anything, data)
         resource.save
       end
 
       it "sends the correct path" do
         client = double
         resource = @test_resource.new_with_client(client)
-        client.should_receive(:api_post).with('/test', anything)
+        expect(client).to receive(:api_post).with('/test', anything)
         resource.save
       end
 
       it "POSTs when not persisted" do
         client = double
         resource = @test_resource.new_with_client(client)
-        client.should_receive(:api_post)
+        expect(client).to receive(:api_post)
         resource.save
       end
 
       it "PUTs when already persisted" do
         client = double
         resource = @test_resource.new_with_client(client, :id => 1)
-        client.should_receive(:api_put)
+        expect(client).to receive(:api_put)
         resource.save
       end
     end
@@ -263,7 +263,7 @@ describe GoCardless::Resource do
 
     attrs = {:id => 1, :uri => 'http:', :x => 'y'}
     resource = test_resource.new_with_client(double, attrs)
-    resource.to_hash.should == attrs
+    expect(resource.to_hash).to eq(attrs)
   end
 
   it "#to_json converts to the correct JSON format" do
@@ -281,15 +281,15 @@ describe GoCardless::Resource do
     })
 
     result = MultiJson.decode(bill.to_json)
-    result['amount'].should == bill.amount
-    result['when'].should == time_str
-    result['person_id'].should == 15
+    expect(result['amount']).to eq(bill.amount)
+    expect(result['when']).to eq(time_str)
+    expect(result['person_id']).to eq(15)
   end
 
   describe "resource permissions" do
     it "are not given by default" do
-      GoCardless::Resource.creatable?.should be_falsey
-      GoCardless::Resource.updatable?.should be_falsey
+      expect(GoCardless::Resource.creatable?).to be_falsey
+      expect(GoCardless::Resource.updatable?).to be_falsey
     end
 
     it "are present when specified" do
@@ -301,14 +301,14 @@ describe GoCardless::Resource do
         updatable
       end
 
-      CreatableResource.creatable?.should be_truthy
-      CreatableResource.updatable?.should be_falsey
+      expect(CreatableResource.creatable?).to be_truthy
+      expect(CreatableResource.updatable?).to be_falsey
 
-      UpdatableResource.creatable?.should be_falsey
-      UpdatableResource.updatable?.should be_truthy
+      expect(UpdatableResource.creatable?).to be_falsey
+      expect(UpdatableResource.updatable?).to be_truthy
 
-      GoCardless::Resource.creatable?.should be_falsey
-      GoCardless::Resource.updatable?.should be_falsey
+      expect(GoCardless::Resource.creatable?).to be_falsey
+      expect(GoCardless::Resource.updatable?).to be_falsey
     end
   end
 
@@ -324,31 +324,31 @@ describe GoCardless::Resource do
 
     it "are defined on instances" do
       r = test_resource.new(@attrs)
-      r.should respond_to :bills
+      expect(r).to respond_to :bills
     end
 
     it "aren't defined for other instances of the class" do
       test_resource.new(@attrs)
       resource = test_resource.new
-      resource.should_not respond_to :bills
+      expect(resource).not_to respond_to :bills
     end
 
     it "use the correct resource" do
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to receive(:new).
                             with(anything, GoCardless::Bill, anything, anything)
       r = test_resource.new_with_client(double, @attrs)
       r.bills
     end
 
     it "use the correct uri path" do
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to 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
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to receive(:new).
                             with(anything, anything, '/bills/', anything)
       uris = {'bills' => 'https://test.com/api/v123/bills/'}
       r = test_resource.new_with_client(double, 'sub_resource_uris' => uris)
@@ -357,7 +357,7 @@ describe GoCardless::Resource do
 
     it "use the correct query string params" do
       query = { 'merchant_id' => '1' }
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to receive(:new).
                             with(anything, anything, anything, query)
       r = test_resource.new_with_client(double, @attrs)
       r.bills
@@ -365,7 +365,7 @@ describe GoCardless::Resource do
 
     it "adds provided params to existing query string params" do
       params = { 'merchant_id' => '1', :amount => '10.00' }
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to receive(:new).
                             with(anything, anything, anything, params)
       r = test_resource.new_with_client(double, @attrs)
       r.bills(:amount => '10.00')
@@ -373,7 +373,7 @@ describe GoCardless::Resource do
 
     it "adds provided params when there are no existing query string params" do
       params = { :source_id => 'xxx' }
-      GoCardless::Paginator.should_receive(:new).
+      expect(GoCardless::Paginator).to receive(:new).
                             with(anything, anything, anything, params)
       r = test_resource.new_with_client(double, {
         'sub_resource_uris' => {
@@ -385,7 +385,7 @@ describe GoCardless::Resource do
 
     it "return instances of the correct resource class" do
       r = test_resource.new_with_client(double, @attrs)
-      r.bills.should be_a GoCardless::Paginator
+      expect(r.bills).to be_a GoCardless::Paginator
     end
   end
 end