gocardless 1.11.2 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 417cec8542edd246281e1e82b45294ad06d09a5e
-  data.tar.gz: 2dae626c784514a1b722dbb348bd782e954f7c46
+  metadata.gz: 994ce7a109fb1c42f0f66f94e7fb38cff7ea1197
+  data.tar.gz: 8ac64f43f760b62644faccb532fadc0f86b89413
 SHA512:
-  metadata.gz: d47705fcf702d7fb7ed80a1e847b7953c4b235f6bb78d16961978c97166eaa9c9b1d790dde027e3a2cac7109170e5b2063e1fac1a4588a576aeb143314a68795
-  data.tar.gz: b8c4cc2cc8ad7aebf8586a8f9b901e160116b03039c1c820b5c3bdab1848bddd233e061c07ded755d63f67f5df2ae096dad29169f2c1ad9ffc221ab8932eccf2
+  metadata.gz: 815fb08aef927dbdfc4f285534b4cea78e346949fb0cbee8a5c36ba2cd679f978ebfa5bc652dd5925854feaf17a3d977b7563d9a887cd69904de99c6c25b9c6e
+  data.tar.gz: 47e2766271e9d6df79f1909409c8f128632e4ff1d9476bc81b5bbd3e810eb8a4a14ac360475dd0459c534375151b8a073261ae5a2c40a3727726ae23903ea4f6

data/.travis.yml

@@ -4,11 +4,8 @@ rvm:
   - 2.0.0
   - 1.9.3
   - 1.9.2
-  - 1.8.7
-  - jruby-18mode
   - jruby-19mode
   - rbx-2
-  - ree
 notifications:
   email:
     recipients:

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.12.0 - October 31, 2014
+
+- Update Gem Dependencies
+- Prevent setting bad GoCardless environments
+- Fix timezone-brittle specs
+- Upgrade RSpec & Convert specs to RSpec 3.1.7
+- Handle nil signatures in signature_valid? method
+- Stop testing against Ruby 1.8
+
+
 ## 1.11.2 - October 27, 2014
 
 - Use a constant time string comparison to avoid timing attacks

data/Gemfile

@@ -4,6 +4,7 @@ gemspec
 
 group :development do
   gem "guard", "~> 0.8.8"
+  gem "rspec", "~> 3.1"
   if RUBY_PLATFORM.downcase.include?("darwin")
     gem "guard-rspec", "~> 0.5.4"
     gem "rb-fsevent", "~> 0.9"

data/gocardless.gemspec

@@ -1,13 +1,13 @@
 require File.expand_path('../lib/gocardless/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.add_runtime_dependency 'oauth2', '~> 0.7'
-  gem.add_runtime_dependency 'multi_json', '~> 1.0'
+  gem.add_runtime_dependency 'oauth2', '~> 1.0'
+  gem.add_runtime_dependency 'multi_json', '~> 1.10'
 
   gem.add_development_dependency 'rspec', '~> 2.13'
-  gem.add_development_dependency 'yard', '~> 0.7'
-  gem.add_development_dependency 'activesupport', '~> 3.1'
-  gem.add_development_dependency 'rake', '~> 10.0'
+  gem.add_development_dependency 'yard', '~> 0.8'
+  gem.add_development_dependency 'activesupport', '~> 3.2'
+  gem.add_development_dependency 'rake', '~> 10.3'
 
   gem.authors = ['Harry Marr', 'Tom Blomfield']
   gem.description = %q{A Ruby wrapper for the GoCardless API}

data/lib/gocardless.rb

@@ -12,8 +12,7 @@ module GoCardless
   require 'gocardless/payout'
 
   class << self
-    attr_accessor :environment
-    attr_reader :account_details, :client
+    attr_reader :account_details, :environment, :client
 
     def account_details=(details)
       raise ClientError.new("You must provide a token") unless details[:token]
@@ -21,6 +20,16 @@ module GoCardless
       @client = Client.new(details)
     end
 
+    def environment=(gc_env)
+      valid_environments = GoCardless::Client::BASE_URLS.keys
+      if !gc_env.nil? && !valid_environments.include?(gc_env)
+        raise ClientError.new("The GoCardless environment must be one of " +
+                              valid_environments.join(", "))
+      end
+
+      @environment = gc_env
+    end
+
     %w(new_subscription_url new_pre_authorization_url new_bill_url confirm_resource webhook_valid?).each do |name|
       class_eval <<-EOM
         def #{name}(*args)

data/lib/gocardless/client.rb

@@ -418,6 +418,7 @@ module GoCardless
     def signature_valid?(params)
       params = params.clone
       signature = params.delete(:signature)
+      return false unless signature
       Utils.secure_compare(sign_params(params)[:signature], signature)
     end
 

data/lib/gocardless/version.rb

@@ -1,3 +1,3 @@
 module GoCardless
-  VERSION = '1.11.2'.freeze
+  VERSION = '1.12.0'.freeze
 end

data/spec/bill_spec.rb

@@ -13,28 +13,28 @@ describe GoCardless::Bill do
     bill.source_type = :subscription
     stub_get(client, :id => 123)
     source = bill.source
-    source.should be_a GoCardless::Subscription
-    source.id.should == 123
+    expect(source).to be_a GoCardless::Subscription
+    expect(source.id).to eq(123)
   end
 
   it "source setter works" do
     bill.source = GoCardless::Subscription.new(:id => 123)
-    bill.source_id.should == 123
-    bill.source_type.should.to_s == 'subscription'
+    expect(bill.source_id).to eq(123)
+    expect(bill.source_type.to_s).to eq('subscription')
   end
 
   it "should be able to be retried" do
-    client.should_receive(:api_post).with('/bills/123/retry')
+    expect(client).to receive(:api_post).with('/bills/123/retry')
     bill.retry!
   end
 
   it "should be able to be cancelled" do
-    client.should_receive(:api_put).with('/bills/123/cancel')
+    expect(client).to receive(:api_put).with('/bills/123/cancel')
     bill.cancel!
   end
 
   it "should be able to be refunded" do
-    client.should_receive(:api_post).with('/bills/123/refund')
+    expect(client).to receive(:api_post).with('/bills/123/refund')
     bill.refund!
   end
 

data/spec/client_spec.rb

@@ -10,36 +10,36 @@ describe GoCardless::Client do
   describe ".base_url" do
     it "and_return the correct url for the production environment" do
       GoCardless.environment = :production
-      GoCardless::Client.base_url.should == 'https://gocardless.com'
+      expect(GoCardless::Client.base_url).to eq('https://gocardless.com')
     end
 
     it "and_return the correct url for the sandbox environment" do
       GoCardless.environment = :sandbox
-      GoCardless::Client.base_url.should == 'https://sandbox.gocardless.com'
+      expect(GoCardless::Client.base_url).to eq('https://sandbox.gocardless.com')
     end
 
     it "and_return the correct url when it's set manually" do
       GoCardless::Client.base_url = 'https://abc.gocardless.com'
-      GoCardless::Client.base_url.should == 'https://abc.gocardless.com'
+      expect(GoCardless::Client.base_url).to eq('https://abc.gocardless.com')
     end
   end
 
   describe "#new" do
     it "without an app id should raise an error" do
-      lambda do
+      expect do
         GoCardless::Client.new({:app_secret => @app_secret})
-      end.should raise_exception(GoCardless::ClientError)
+      end.to raise_exception(GoCardless::ClientError)
     end
 
     it "without an app_secret should raise an error" do
-      lambda do
+      expect do
         GoCardless::Client.new({:app_id => @app_id})
-      end.should raise_exception(GoCardless::ClientError)
+      end.to raise_exception(GoCardless::ClientError)
     end
 
     it "does not raise an error if the credentials are provided as environment variables" do
-      ENV.should_receive(:[]).with('GOCARDLESS_APP_ID').and_return(@app_id)
-      ENV.should_receive(:[]).with('GOCARDLESS_APP_SECRET').and_return(@app_secret)
+      expect(ENV).to receive(:[]).with('GOCARDLESS_APP_ID').and_return(@app_id)
+      expect(ENV).to receive(:[]).with('GOCARDLESS_APP_SECRET').and_return(@app_secret)
 
       GoCardless::Client.new
     end
@@ -50,7 +50,7 @@ describe GoCardless::Client do
         :app_secret  => @app_secret,
         :merchant_id => 'xyz'
       })
-      client.send('merchant_id').should == 'xyz'
+      expect(client.send('merchant_id')).to eq('xyz')
     end
   end
 
@@ -60,15 +60,15 @@ describe GoCardless::Client do
 
   describe "#authorize_url" do
     it "fails without a redirect uri" do
-      lambda { @client.authorize_url }.should raise_exception(ArgumentError)
+      expect { @client.authorize_url }.to raise_exception(ArgumentError)
     end
 
     it "generates the authorize url correctly" do
       url = URI.parse(@client.authorize_url(:redirect_uri => @redirect_uri))
       query = CGI.parse(url.query)
-      query['response_type'].first.should == 'code'
-      query['redirect_uri'].first.should == @redirect_uri
-      query['client_id'].first.should == @app_id
+      expect(query['response_type'].first).to eq('code')
+      expect(query['redirect_uri'].first).to eq(@redirect_uri)
+      expect(query['client_id'].first).to eq(@app_id)
     end
 
     it "includes the cancel uri if present" do
@@ -78,14 +78,14 @@ describe GoCardless::Client do
         :cancel_uri   => cancel_uri
       ))
       query = CGI.parse(url.query)
-      query['cancel_uri'].first.should == cancel_uri
+      expect(query['cancel_uri'].first).to eq(cancel_uri)
     end
 
     it "encodes prefilling parameters correctly" do
       params = {:merchant => {:user => {:email => "a@b.com"}}}
       url = @client.authorize_url(params.merge(:redirect_uri => @redirect_uri))
       encoded_key = GoCardless::Utils.percent_encode('merchant[user][email]')
-      URI.parse(url).query.should match /#{encoded_key}=a%40b\.com/
+      expect(URI.parse(url).query).to match /#{encoded_key}=a%40b\.com/
     end
   end
 
@@ -93,9 +93,9 @@ describe GoCardless::Client do
     access_token_url = "#{GoCardless::Client.base_url}/oauth/access_token"
 
     it "fails without a redirect uri" do
-      lambda do
+      expect do
         @client.fetch_access_token('code', {})
-      end.should raise_exception(ArgumentError)
+      end.to raise_exception(ArgumentError)
     end
 
     describe "with valid params" do
@@ -104,12 +104,12 @@ describe GoCardless::Client do
         double(:params => {'scope' => 'manage_merchant:x'}, :token  => 'abc')
       end
 
-      before { oauth_client.auth_code.stub(:get_token).and_return(fake_token) }
+      before { allow(oauth_client.auth_code).to receive(:get_token).and_return(fake_token) }
 
       it "calls correct method with correct args" do
         auth_code = 'fakecode'
 
-        oauth_client.auth_code.should_receive(:get_token).with(
+        expect(oauth_client.auth_code).to receive(:get_token).with(
           auth_code, hash_including(:redirect_uri => @redirect_uri)
         ).and_return(fake_token)
 
@@ -117,15 +117,15 @@ describe GoCardless::Client do
       end
 
       it "sets @access_token" do
-        @client.instance_variable_get(:@access_token).should be_nil
+        expect(@client.instance_variable_get(:@access_token)).to be_nil
         @client.fetch_access_token('code', {:redirect_uri => @redirect_uri})
-        @client.instance_variable_get(:@access_token).should == fake_token
+        expect(@client.instance_variable_get(:@access_token)).to eq(fake_token)
       end
 
       it "sets @merchant_id" do
-        @client.instance_variable_get(:@merchant_id).should be_nil
+        expect(@client.instance_variable_get(:@merchant_id)).to be_nil
         @client.fetch_access_token('code', {:redirect_uri => @redirect_uri})
-        @client.instance_variable_get(:@merchant_id).should == 'x'
+        expect(@client.instance_variable_get(:@merchant_id)).to eq('x')
       end
     end
   end
@@ -137,11 +137,11 @@ describe GoCardless::Client do
       token.params['scope'] = 'a:1 b:2'
       @client.instance_variable_set(:@access_token, token)
 
-      @client.scoped_access_token.should == 'TOKEN123 a:1 b:2'
+      expect(@client.scoped_access_token).to eq('TOKEN123 a:1 b:2')
     end
 
     it "and_return nil when there's no token" do
-      @client.scoped_access_token.should be_nil
+      expect(@client.scoped_access_token).to be_nil
     end
   end
 
@@ -152,31 +152,31 @@ describe GoCardless::Client do
       token.params['scope'] = 'a:1 b:2'
       @client.instance_variable_set(:@access_token, token)
 
-      @client.unscoped_access_token.should == 'TOKEN123'
+      expect(@client.unscoped_access_token).to eq('TOKEN123')
     end
 
     it "and_return nil when there's no token" do
-      @client.unscoped_access_token.should be_nil
+      expect(@client.unscoped_access_token).to be_nil
     end
   end
 
   describe "#access_token" do
-    before { @client.stub(:warn) }
+    before { allow(@client).to receive(:warn) }
     it "serializes access token correctly" do
       oauth_client = @client.instance_variable_get(:@oauth_client)
       token = OAuth2::AccessToken.new(oauth_client, 'TOKEN123')
       token.params['scope'] = 'a:1 b:2'
       @client.instance_variable_set(:@access_token, token)
 
-      @client.access_token.should == 'TOKEN123 a:1 b:2'
+      expect(@client.access_token).to eq('TOKEN123 a:1 b:2')
     end
 
     it "and_return nil when there's no token" do
-      @client.access_token.should be_nil
+      expect(@client.access_token).to be_nil
     end
 
     it "issues a deprecation warning" do
-      @client.should_receive(:warn)
+      expect(@client).to receive(:warn)
       @client.access_token
     end
   end
@@ -188,44 +188,44 @@ describe GoCardless::Client do
       token.params['scope'] = 'a:1 b:2'
       @client.instance_variable_set(:@access_token, token)
 
-      @client.scope.should == 'a:1 b:2'
+      expect(@client.scope).to eq('a:1 b:2')
     end
 
     it "and_return nil when there's no token" do
-      @client.scope.should be_nil
+      expect(@client.scope).to be_nil
     end
   end
 
   describe "#access_token=" do
-    before { @client.stub(:warn) }
+    before { allow(@client).to receive(:warn) }
 
     it "deserializes access token correctly" do
       @client.access_token = 'TOKEN123 a:1 b:2'
       token = @client.instance_variable_get(:@access_token)
-      token.token.should == 'TOKEN123'
-      token.params['scope'].should == 'a:1 b:2'
+      expect(token.token).to eq('TOKEN123')
+      expect(token.params['scope']).to eq('a:1 b:2')
     end
 
     it "pulls out the merchant_id when present" do
       @client.access_token = 'TOKEN123 manage_merchant:xyz'
-      @client.send('merchant_id').should == 'xyz'
+      expect(@client.send('merchant_id')).to eq('xyz')
     end
 
     it "issues a deprecation warning when the scope is present" do
-      @client.should_receive(:warn)
+      expect(@client).to receive(:warn)
       @client.access_token = 'TOKEN123 manage_merchant:xyz'
     end
 
     it "doesn't issue a deprecation warning when the scope is missing" do
-      @client.should_receive(:warn).never
+      expect(@client).to receive(:warn).never
       @client.access_token = 'TOKEN123'
     end
 
     it "ignores 'bearer' if it is present at the start of the string" do
       @client.access_token = 'Bearer TOKEN manage_merchant:123'
       token = @client.instance_variable_get(:@access_token)
-      token.token.should == 'TOKEN'
-      token.params['scope'].should == 'manage_merchant:123'
+      expect(token.token).to eq('TOKEN')
+      expect(token.params['scope']).to eq('manage_merchant:123')
     end
   end
 
@@ -234,10 +234,10 @@ describe GoCardless::Client do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
       r = double
-      r.stub(:parsed)
-      token.should_receive(:get) do |p, o|
+      allow(r).to receive(:parsed)
+      expect(token).to receive(:get) { |p, o|
         expect(p).to satisfy { |v| v =~ %r|/api/v1/test| }
-      end.and_return(r)
+      }.and_return(r)
       @client.api_get('/test')
     end
 
@@ -251,10 +251,10 @@ describe GoCardless::Client do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
       r = double
-      r.stub(:parsed)
-      token.should_receive(:post) do |p,opts|
+      allow(r).to receive(:parsed)
+      expect(token).to receive(:post) { |p,opts|
         expect(opts[:body]).to eq('{"a":1}')
-      end.and_return(r)
+      }.and_return(r)
       @client.api_post('/test', {:a => 1})
     end
 
@@ -268,10 +268,10 @@ describe GoCardless::Client do
       @client.access_token = 'TOKEN123'
       token = @client.instance_variable_get(:@access_token)
       r = double
-      r.stub(:parsed)
-      token.should_receive(:delete) do |p,opts|
+      allow(r).to receive(:parsed)
+      expect(token).to receive(:delete) { |p,opts|
         expect(opts[:body]).to eq('{"a":1}')
-      end.and_return(r)
+      }.and_return(r)
       @client.api_delete('/test', {:a => 1})
     end
 
@@ -285,15 +285,15 @@ describe GoCardless::Client do
       @client.access_token = 'TOKEN'
       @client.merchant_id = '123'
       response = double
-      response.should_receive(:parsed)
+      expect(response).to receive(:parsed)
 
       token = @client.instance_variable_get(:@access_token)
       merchant_url = '/api/v1/merchants/123'
-      token.should_receive(:get) do |p,o|
+      expect(token).to receive(:get) { |p,o|
         expect(p).to eq(merchant_url)
-      end.and_return response
+      }.and_return response
 
-      GoCardless::Merchant.stub(:new_with_client)
+      allow(GoCardless::Merchant).to receive(:new_with_client)
 
       @client.merchant
     end
@@ -302,15 +302,15 @@ describe GoCardless::Client do
       @client.access_token = 'TOKEN'
       @client.merchant_id = '123'
       response = double
-      response.should_receive(:parsed).and_return({:name => 'test', :id => 123})
+      expect(response).to receive(:parsed).and_return({:name => 'test', :id => 123})
 
       token = @client.instance_variable_get(:@access_token)
-      token.should_receive(:get).and_return response
+      expect(token).to receive(:get).and_return response
 
       merchant = @client.merchant
-      merchant.should be_an_instance_of GoCardless::Merchant
-      merchant.id.should == 123
-      merchant.name.should == 'test'
+      expect(merchant).to be_an_instance_of GoCardless::Merchant
+      expect(merchant.id).to eq(123)
+      expect(merchant.name).to eq('test')
     end
   end
 
@@ -321,8 +321,8 @@ describe GoCardless::Client do
         @client.merchant_id = '123'
         stub_get(@client, {:id => 123})
         obj = @client.send(resource, 123)
-        obj.should be_a GoCardless.const_get(GoCardless::Utils.camelize(resource))
-        obj.id.should == 123
+        expect(obj).to be_a GoCardless.const_get(GoCardless::Utils.camelize(resource))
+        expect(obj.id).to eq(123)
       end
     end
   end
@@ -331,7 +331,7 @@ describe GoCardless::Client do
     @client.instance_variable_set(:@app_secret, 'testsecret')
     params = {:test => true}
     sig = '6e4613b729ce15c288f70e72463739feeb05fc0b89b55d248d7f259b5367148b'
-    @client.send(:sign_params, params)[:signature].should == sig
+    expect(@client.send(:sign_params, params)[:signature]).to eq(sig)
   end
 
   describe "#signature_valid?" do
@@ -339,12 +339,17 @@ describe GoCardless::Client do
 
     it "succeeds with a valid signature" do
       params = @client.send(:sign_params, @params)
-      @client.send(:signature_valid?, params).should be_truthy
+      expect(@client.send(:signature_valid?, params)).to be_truthy
     end
 
     it "fails with an invalid signature" do
       params = {:signature => 'invalid'}.merge(@params)
-      @client.send(:signature_valid?, params).should be_falsey
+      expect(@client.send(:signature_valid?, params)).to be_falsey
+    end
+
+    it "fails with a nil signature" do
+      params = {:signature => nil}.merge(@params)
+      expect(@client.send(:signature_valid?, params)).to be_falsey
     end
   end
 
@@ -358,7 +363,7 @@ describe GoCardless::Client do
     end
 
     it "doesn't confirm the resource when the signature is invalid" do
-      @client.should_receive(:request).never
+      expect(@client).to receive(:request).never
       @client.confirm_resource({:signature => 'xxx'}.merge(@params)) rescue nil
     end
 
@@ -370,37 +375,37 @@ 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(double(:parsed => {}))
+      expect(@client).to 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(double(:parsed => {}))
+      allow(@client).to receive(:request).and_return(double(:parsed => {}))
       subscription = GoCardless::Subscription.new_with_client @client
-      GoCardless::Subscription.should_receive(:find_with_client).and_return subscription
+      expect(GoCardless::Subscription).to receive(:find_with_client).and_return subscription
 
       # confirm_resource should use the Subcription class because
       # the :response_type is set to subscription
       resource = @client.confirm_resource(@client.send(:sign_params, @params))
-      resource.should be_a GoCardless::Subscription
+      expect(resource).to be_a GoCardless::Subscription
     end
 
     it "includes valid http basic credentials" do
-      GoCardless::Subscription.stub(:find_with_client)
+      allow(GoCardless::Subscription).to receive(:find_with_client)
       auth = 'Basic YWJjOnh5eg=='
-      @client.should_receive(:request) do |type, path, opts|
-        opts.should include :headers
-        opts[:headers].should include 'Authorization'
-        opts[:headers]['Authorization'].should == auth
-      end.once
+      expect(@client).to receive(:request) { |type, path, opts|
+        expect(opts).to include :headers
+        expect(opts[:headers]).to include 'Authorization'
+        expect(opts[:headers]['Authorization']).to eq(auth)
+      }.once
       @client.confirm_resource(@client.send(:sign_params, @params))
     end
 
     it "works with string params" do
-      @client.stub(:request)
-      GoCardless::Subscription.stub(:find_with_client)
+      allow(@client).to receive(:request)
+      allow(GoCardless::Subscription).to receive(:find_with_client)
       params = Hash[@params.dup.map { |k,v| [k.to_s, v] }]
-      params.keys.each { |p| p.should be_a String }
+      params.keys.each { |p| expect(p).to be_a String }
       # No ArgumentErrors should be raised
       @client.confirm_resource(@client.send(:sign_params, params))
     end
@@ -436,9 +441,9 @@ describe GoCardless::Client do
     end
 
     it "rejects other params not required for the signature" do
-      @client.should_receive(:signature_valid?) do |hash|
+      expect(@client).to receive(:signature_valid?) { |hash|
         !hash.keys.include?(:foo) && !hash.keys.include?('foo')
-      end.and_return(true)
+      }.and_return(true)
 
       params = @client.send(:sign_params, @params).merge('foo' => 'bar')
       @client.response_params_valid?(params)
@@ -446,17 +451,17 @@ describe GoCardless::Client do
 
     it "and_return false when the signature is invalid" do
       params = {:signature => 'xxx'}.merge(@params)
-      @client.response_params_valid?(params).should be_falsey
+      expect(@client.response_params_valid?(params)).to be_falsey
     end
 
     it "and_return true when the signature is valid" do
       params = @client.send(:sign_params, @params)
-      @client.response_params_valid?(params).should be_truthy
+      expect(@client.response_params_valid?(params)).to be_truthy
     end
   end
 
   it "#generate_nonce should generate a random string" do
-    @client.send(:generate_nonce).should_not == @client.send(:generate_nonce)
+    expect(@client.send(:generate_nonce)).not_to eq(@client.send(:generate_nonce))
   end
 
   describe "#new_limit_url" do
@@ -472,7 +477,7 @@ describe GoCardless::Client do
 
     it "should use the correct path" do
       url = @client.send(:new_limit_url, :test_limit, {})
-      URI.parse(url).path.should == '/connect/test_limits/new'
+      expect(URI.parse(url).path).to eq('/connect/test_limits/new')
     end
 
     it "should include the params in the URL query" do
@@ -480,64 +485,64 @@ describe GoCardless::Client do
       url = @client.send(:new_limit_url, :subscription, params)
       url_params = get_params(url)
       params.each do |key, value|
-        url_params["subscription[#{key}]"].should == value
+        expect(url_params["subscription[#{key}]"]).to eq(value)
       end
     end
 
     it "should include the state in the URL query" do
       params = { 'a' => '1', 'b' => '2', :state => "blah" }
       url = @client.send(:new_limit_url, :subscription, params)
-      get_params(url)["state"].should == "blah"
+      expect(get_params(url)["state"]).to eq("blah")
     end
 
     it "should include the redirect_uri in the URL query" do
       params = { 'a' => '1', 'b' => '2', :redirect_uri => "http://www.google.com" }
       url = @client.send(:new_limit_url, :subscription, params)
-      get_params(url)["redirect_uri"].should == "http://www.google.com"
+      expect(get_params(url)["redirect_uri"]).to eq("http://www.google.com")
     end
 
     it "should include the cancel_uri in the URL query" do
       params = { 'a' => '1', 'b' => '2', :cancel_uri => "http://www.google.com" }
       url = @client.send(:new_limit_url, :subscription, params)
-      get_params(url)["cancel_uri"].should == "http://www.google.com"
+      expect(get_params(url)["cancel_uri"]).to eq("http://www.google.com")
     end
 
     it "should add merchant_id to the limit" do
       url = @client.send(:new_limit_url, :subscription, {})
-      get_params(url)['subscription[merchant_id]'].should == @merchant_id
+      expect(get_params(url)['subscription[merchant_id]']).to eq(@merchant_id)
     end
 
     it "should include a valid signature" do
       params = get_params(@client.send(:new_limit_url, :subscription, :x => 1))
-      params.key?('signature').should be_truthy
+      expect(params.key?('signature')).to be_truthy
       sig = params.delete('signature')
-      sig.should == @client.send(:sign_params, params.clone)[:signature]
+      expect(sig).to eq(@client.send(:sign_params, params.clone)[:signature])
     end
 
     it "should include a nonce" do
       params = get_params(@client.send(:new_limit_url, :subscription, :x => 1))
-      params['nonce'].should be_a String
+      expect(params['nonce']).to be_a String
     end
 
     it "should include a client_id" do
       params = get_params(@client.send(:new_limit_url, :subscription, :x => 1))
-      params['client_id'].should == @client.instance_variable_get(:@app_id)
+      expect(params['client_id']).to eq(@client.instance_variable_get(:@app_id))
     end
 
     it "should include a timestamp" do
       # Time.now returning Pacific time
       time = Time.parse('Sat Jan 01 2011 00:00:00 -0800')
-      Time.should_receive(:now).and_return time
+      expect(Time).to receive(:now).and_return time
       params = get_params(@client.send(:new_limit_url, :subscription, :x => 1))
       # Check that timezone is ISO formatted UTC
-      params['timestamp'].should == "2011-01-01T08:00:00Z"
+      expect(params['timestamp']).to eq("2011-01-01T08:00:00Z")
     end
   end
 
   describe "#merchant_id" do
     it "and_return the merchant id when an access token is set" do
       @client.merchant_id = '123'
-      @client.send(:merchant_id).should == '123'
+      expect(@client.send(:merchant_id)).to eq('123')
     end
 
     it "fails if there's no access token" do
@@ -549,26 +554,26 @@ describe GoCardless::Client do
 
   describe "#webhook_valid?" do
     it "and_return false when the webhook signature is invalid" do
-      @client.webhook_valid?({:some => 'stuff', :signature => 'invalid'}).
-        should be_falsey
+      expect(@client.webhook_valid?({:some => 'stuff', :signature => 'invalid'})).
+        to be_falsey
     end
 
     it "and_return true when the webhook signature is valid" do
       valid_signature = '175e814f0f64e5e86d41fb8fe06a857cedda715a96d3dc3d885e6d97dbeb7e49'
-      @client.webhook_valid?({:some => 'stuff', :signature => valid_signature}).
-        should be_truthy
+      expect(@client.webhook_valid?({:some => 'stuff', :signature => valid_signature})).
+        to be_truthy
     end
   end
 
   describe "base_url" do
     it "and_return a custom base URL when one has been set" do
       @client.base_url = 'http://test.com/'
-      @client.base_url.should == 'http://test.com/'
+      expect(@client.base_url).to eq('http://test.com/')
     end
 
     it "and_return the default value when base_url is not set for the instance" do
-      GoCardless::Client.stub(:base_url => 'http://gc.com/')
-      @client.base_url.should == 'http://gc.com/'
+      allow(GoCardless::Client).to receive_messages(:base_url => 'http://gc.com/')
+      expect(@client.base_url).to eq('http://gc.com/')
     end
   end