gocardless 1.11.2 → 1.12.0

data/spec/spec_helper.rb

@@ -3,10 +3,10 @@ require 'gocardless'
 
 def stub_get(client, data)
   response = double
-  response.stub(:parsed).and_return(data)
+  allow(response).to receive(:parsed).and_return(data)
 
   token = client.instance_variable_get(:@access_token)
-  token.stub(:get).and_return response
+  allow(token).to receive(:get).and_return response
 end
 
 def unset_ivar(obj, var)
@@ -17,12 +17,12 @@ shared_examples_for "it has a query method for" do |status|
   describe "##{status}?" do
     context "when #{status}" do
       let(:object) { described_class.new(:status => status) }
-      specify { object.send("#{status}?").should be_truthy }
+      specify { expect(object.send("#{status}?")).to be_truthy }
     end
 
     context "when not #{status}" do
       let(:object) { described_class.new }
-      specify { object.send("#{status}?").should be_falsey }
+      specify { expect(object.send("#{status}?")).to be_falsey }
     end
   end
 end

data/spec/subscription_spec.rb

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

data/spec/user_spec.rb

@@ -7,25 +7,25 @@ describe GoCardless::User do
     context "with first and last name" do
       let(:first) { "First" }
       let(:last) { "Last" }
-      specify { user.name.should == "First Last" }
+      specify { expect(user.name).to eq("First Last") }
     end
 
     context "with first name only" do
       let(:first) { "First" }
       let(:last) { nil }
-      specify { user.name.should == "First" }
+      specify { expect(user.name).to eq("First") }
     end
 
     context "with last name only" do
       let(:first) { nil }
       let(:last) { "Last" }
-      specify { user.name.should == "Last" }
+      specify { expect(user.name).to eq("Last") }
     end
 
     context "with no first or last name" do
       let(:first) { nil }
       let(:last) { nil }
-      specify { user.name.should == "" }
+      specify { expect(user.name).to eq("") }
     end
   end
 end

data/spec/utils_spec.rb

@@ -7,33 +7,33 @@ describe GoCardless::Utils do
   describe "string helpers" do
     describe ".camelize" do
       it "converts underscored words to camel case" do
-        GoCardless::Utils.camelize("a_test_string").should == "ATestString"
+        expect(GoCardless::Utils.camelize("a_test_string")).to eq("ATestString")
       end
     end
 
     describe ".underscore" do
       it "converts camel case words to underscored form" do
-        GoCardless::Utils.underscore("ATestString").should == "a_test_string"
+        expect(GoCardless::Utils.underscore("ATestString")).to eq("a_test_string")
       end
     end
 
     describe ".singularize" do
       it "removes trailing 's' characters" do
-        GoCardless::Utils.singularize("desks").should == "desk"
+        expect(GoCardless::Utils.singularize("desks")).to eq("desk")
       end
 
       it "converts 'i' suffix to 'us'" do
-        GoCardless::Utils.singularize("cacti").should == "cactus"
+        expect(GoCardless::Utils.singularize("cacti")).to eq("cactus")
       end
     end
 
     describe '.secure_compare' do
       it 'is true for the same strings' do
-        GoCardless::Utils.secure_compare('hello', 'hello').should be_truthy
+        expect(GoCardless::Utils.secure_compare('hello', 'hello')).to be_truthy
       end
 
       it 'is false for different strings' do
-        GoCardless::Utils.secure_compare('hello', 'banjo').should be_falsey
+        expect(GoCardless::Utils.secure_compare('hello', 'banjo')).to be_falsey
       end
     end
   end
@@ -43,27 +43,27 @@ describe GoCardless::Utils do
       it "converts keys to symbols" do
         hash = {'string' => true, 123 => true, :symbol => true}
         keys = GoCardless::Utils.symbolize_keys(hash).keys
-        keys.length.should == 3
-        keys.should include :string
-        keys.should include :'123'
-        keys.should include :symbol
+        expect(keys.length).to eq(3)
+        expect(keys).to include :string
+        expect(keys).to include :'123'
+        expect(keys).to include :symbol
       end
 
       it "preserves the original hash" do
         hash = {'string' => true}
         GoCardless::Utils.symbolize_keys(hash)
-        hash.keys.should == ['string']
+        expect(hash.keys).to eq(['string'])
       end
 
       it "doesn't overwrite existing symbol keys" do
         hash = {'x' => 1, :x => 2}
-        GoCardless::Utils.symbolize_keys(hash).should == hash
+        expect(GoCardless::Utils.symbolize_keys(hash)).to eq(hash)
       end
 
       it "works with sinatra params' default proc" do
         hash = Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
         hash['x'] = 1
-        GoCardless::Utils.symbolize_keys(hash).should == {:x => 1}
+        expect(GoCardless::Utils.symbolize_keys(hash)).to eq({:x => 1})
       end
     end
 
@@ -71,7 +71,7 @@ describe GoCardless::Utils do
       it "modifies the original hash" do
         hash = {'string' => true}
         GoCardless::Utils.symbolize_keys!(hash)
-        hash.keys.should == [:string]
+        expect(hash.keys).to eq([:string])
       end
     end
   end
@@ -81,37 +81,37 @@ describe GoCardless::Utils do
       subject { GoCardless::Utils.method(:percent_encode) }
 
       it "works with empty strings" do
-        subject[""].should == ""
+        expect(subject[""]).to eq("")
       end
 
       it "doesn't encode lowercase alpha characters" do
-        subject["abcxyz"].should == "abcxyz"
+        expect(subject["abcxyz"]).to eq("abcxyz")
       end
 
       it "doesn't encode uppercase alpha characters" do
-        subject["ABCXYZ"].should == "ABCXYZ"
+        expect(subject["ABCXYZ"]).to eq("ABCXYZ")
       end
 
       it "doesn't encode digits" do
-        subject["1234567890"].should == "1234567890"
+        expect(subject["1234567890"]).to eq("1234567890")
       end
 
       it "doesn't encode unreserved non-alphanumeric characters" do
-        subject["-._~"].should == "-._~"
+        expect(subject["-._~"]).to eq("-._~")
       end
 
       it "encodes non-ascii alpha characters" do
-        subject["å"].should == "%C3%A5"
+        expect(subject["å"]).to eq("%C3%A5")
       end
 
       it "encodes reserved ascii characters" do
-        subject[" !\"\#$%&'()"].should == "%20%21%22%23%24%25%26%27%28%29"
-        subject["*+,/{|}:;"].should == "%2A%2B%2C%2F%7B%7C%7D%3A%3B"
-        subject["<=>?@[\\]^`"].should == "%3C%3D%3E%3F%40%5B%5C%5D%5E%60"
+        expect(subject[" !\"\#$%&'()"]).to eq("%20%21%22%23%24%25%26%27%28%29")
+        expect(subject["*+,/{|}:;"]).to eq("%2A%2B%2C%2F%7B%7C%7D%3A%3B")
+        expect(subject["<=>?@[\\]^`"]).to eq("%3C%3D%3E%3F%40%5B%5C%5D%5E%60")
       end
 
       it "encodes other non-ascii characters" do
-        subject["支払い"].should == "%E6%94%AF%E6%89%95%E3%81%84"
+        expect(subject["支払い"]).to eq("%E6%94%AF%E6%89%95%E3%81%84")
       end
     end
 
@@ -119,66 +119,66 @@ describe GoCardless::Utils do
       subject { GoCardless::Utils.method(:flatten_params) }
 
       it "and_return an empty array when provided with an empty hash" do
-        subject[{}].should == []
+        expect(subject[{}]).to eq([])
       end
 
       it "converts hashes to key-value arrays" do
-        subject['a' => 'b'].should == [['a', 'b']]
+        expect(subject['a' => 'b']).to eq([['a', 'b']])
       end
 
       it "works with integer keys and values" do
-        subject[123 => 456].should == [['123', '456']]
+        expect(subject[123 => 456]).to eq([['123', '456']])
       end
 
       it "converts DateTime objects to ISO8601-fomatted strings" do
         date = '2001-02-03T12:23:45Z'
-        subject[:date => Time.parse(date)][0][1].should == date
+        expect(subject[:date => Time.parse(date)][0][1]).to eq(date)
       end
 
       it "works with symbol keys and values" do
-        subject[:a => :b].should == [['a', 'b']]
+        expect(subject[:a => :b]).to eq([['a', 'b']])
       end
 
       it "uses empty-bracket syntax for arrays" do
-        subject['a' => ['b']].should == [['a[]', 'b']]
+        expect(subject['a' => ['b']]).to eq([['a[]', 'b']])
       end
 
       it "excludes values with empty arrays" do
-        subject['a' => []].should == []
+        expect(subject['a' => []]).to eq([])
       end
 
       it "includes all array values separately" do
         result = subject['a' => ['b', 'c']]
-        result.should include ['a[]', 'b']
-        result.should include ['a[]', 'c']
-        result.length.should == 2
+        expect(result).to include ['a[]', 'b']
+        expect(result).to include ['a[]', 'c']
+        expect(result.length).to eq(2)
       end
 
       it "flattens nested arrays" do
-        subject['a' => [['b']]].should == [['a[][]', 'b']]
+        expect(subject['a' => [['b']]]).to eq([['a[][]', 'b']])
       end
 
       it "uses the bracket-syntax for hashes" do
-        subject['a' => {'b' => 'c'}].should == [['a[b]', 'c']]
+        expect(subject['a' => {'b' => 'c'}]).to eq([['a[b]', 'c']])
       end
 
       it "includes all hash k/v pairs separately" do
         result = subject['a' => {'b' => 'c', 'd' => 'e'}]
-        result.should include ['a[b]', 'c']
-        result.should include ['a[d]', 'e']
-        result.length.should == 2
+        expect(result).to include ['a[b]', 'c']
+        expect(result).to include ['a[d]', 'e']
+        expect(result.length).to eq(2)
       end
 
       it "flattens nested hashes" do
-        subject['a' => {'b' => {'c' => 'd'}}].should == [['a[b][c]', 'd']]
+        expect(subject['a' => {'b' => {'c' => 'd'}}]).to eq([['a[b][c]', 'd']])
       end
 
       it "works with arrays inside hashes" do
-        subject['a' => {'b' => ['c']}].should == [['a[b][]', 'c']]
+        expect(subject['a' => {'b' => ['c']}]).to eq([['a[b][]', 'c']])
       end
 
       it "works with hashes inside arrays" do
-        subject['a' => [{'b' => 'c'}]].should == [['a[][b]', 'c']]
+        expect(subject['a' => [{'b' => 'c'}]]).to eq([['a[][b]', 'c']])
       end
     end
 
@@ -186,19 +186,19 @@ describe GoCardless::Utils do
       subject { GoCardless::Utils.method(:normalize_params) }
 
       it "percent encodes keys and values" do
-        subject['!' => '+'].split('=').should == ['%21', '%2B']
+        expect(subject['!' => '+'].split('=')).to eq(['%21', '%2B'])
       end
 
       it "joins items by '=' signs" do
-        subject['a' => 'b'].should == 'a=b'
+        expect(subject['a' => 'b']).to eq('a=b')
       end
 
       it "joins pairs by '&' signs" do
-        subject['a' => 'b', 'c' => 'd'].should == 'a=b&c=d'
+        expect(subject['a' => 'b', 'c' => 'd']).to eq('a=b&c=d')
       end
 
       it "sorts pairs by name then value" do
-        subject['a0' => 'b', 'a' => 'c'].should == 'a=c&a0=b'
+        expect(subject['a0' => 'b', 'a' => 'c']).to eq('a=c&a0=b')
       end
     end
 
@@ -207,7 +207,7 @@ describe GoCardless::Utils do
         key = 'testsecret'
         params = {:test => true}
         sig = '6e4613b729ce15c288f70e72463739feeb05fc0b89b55d248d7f259b5367148b'
-        GoCardless::Utils.sign_params(params, key).should == sig
+        expect(GoCardless::Utils.sign_params(params, key)).to eq(sig)
       end
     end
   end
@@ -215,40 +215,44 @@ describe GoCardless::Utils do
   describe "date and time helpers" do
     describe ".iso_format_time" do
       it "should work with a Time object" do
-        d = GoCardless::Utils.iso_format_time(Time.parse("1st January 2012"))
-        d.should == "2012-01-01T00:00:00Z"
+        t = "1st January 2012 00:00 UTC"
+        d = GoCardless::Utils.iso_format_time(Time.parse(t))
+        expect(d).to eq("2012-01-01T00:00:00Z")
       end
 
       it "should work with a DateTime object" do
         d = GoCardless::Utils.iso_format_time(DateTime.parse("1st January 2012"))
-        d.should == "2012-01-01T00:00:00Z"
+        expect(d).to eq("2012-01-01T00:00:00Z")
       end
 
       it "should work with a Date object" do
         d = GoCardless::Utils.iso_format_time(Date.parse("1st January 2012"))
-        d.should == "2012-01-01T00:00:00Z"
+        expect(d).to eq("2012-01-01T00:00:00Z")
       end
 
       it "should leave a string untouched" do
         date = "1st January 2012"
-        GoCardless::Utils.iso_format_time(date).should == date
+        expect(GoCardless::Utils.iso_format_time(date)).to eq(date)
       end
     end
 
     describe ".stringify_times" do
       it "stringifies time objects" do
-        d = GoCardless::Utils.stringify_times(Time.parse("1st Jan 2012"))
-        d.should == "2012-01-01T00:00:00Z"
+        t = "1st January 2012 00:00 UTC"
+        d = GoCardless::Utils.iso_format_time(Time.parse(t))
+        expect(d).to eq("2012-01-01T00:00:00Z")
       end
 
       it "stringifies time values in hashes" do
-        d = GoCardless::Utils.stringify_times(:t => Time.parse("1st Jan 2012"))
-        d.should == { :t => "2012-01-01T00:00:00Z" }
+        t = "1st Jan 2012 00:00 UTC"
+        d = GoCardless::Utils.stringify_times(:t => Time.parse(t))
+        expect(d).to eq({ :t => "2012-01-01T00:00:00Z" })
       end
 
       it "stringifies time values in arrays" do
-        d = GoCardless::Utils.stringify_times([Time.parse("1st Jan 2012")])
-        d.should == ["2012-01-01T00:00:00Z"]
+        t = "1st Jan 2012 00:00 UTC"
+        d = GoCardless::Utils.stringify_times([Time.parse(t)])
+        expect(d).to eq(["2012-01-01T00:00:00Z"])
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gocardless
 version: !ruby/object:Gem::Version
-  version: 1.11.2
+  version: 1.12.0
 platform: ruby
 authors:
 - Harry Marr
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-27 00:00:00.000000000 Z
+date: 2014-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oauth2
@@ -17,28 +17,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -59,42 +59,42 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '0.7'
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '10.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '10.3'
 description: A Ruby wrapper for the GoCardless API
 email:
 - developers@gocardless.com
@@ -157,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for the GoCardless API
@@ -173,3 +173,4 @@ test_files:
 - spec/subscription_spec.rb
 - spec/user_spec.rb
 - spec/utils_spec.rb
+has_rdoc: