braintree 4.14.0 → 4.16.0

data/lib/braintree/webhook_testing.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class WebhookTesting # :nodoc:
+  class WebhookTesting
     def self.sample_notification(*args)
       Configuration.gateway.webhook_testing.sample_notification(*args)
     end

data/lib/braintree/webhook_testing_gateway.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class WebhookTestingGateway # :nodoc:
+  class WebhookTestingGateway
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
@@ -72,6 +72,8 @@ module Braintree
         _disbursement_exception_sample_xml(id)
       when Braintree::WebhookNotification::Kind::Disbursement
         _disbursement_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::SubscriptionBillingSkipped
+        _subscription_billing_skipped(id)
       when Braintree::WebhookNotification::Kind::SubscriptionChargedSuccessfully
         _subscription_charged_successfully(id)
       when Braintree::WebhookNotification::Kind::SubscriptionChargedUnsuccessfully
@@ -112,6 +114,21 @@ module Braintree
       XML
     end
 
+    def _subscription_billing_skipped(id)
+
+      <<-XML
+        <subscription>
+          <id>#{id}</id>
+          <transactions type="array">
+          </transactions>
+          <add_ons type="array">
+          </add_ons>
+          <discounts type="array">
+          </discounts>
+        </subscription>
+      XML
+    end
+
     def _subscription_charged_successfully(id)
 
       <<-XML

data/lib/braintree/xml/generator.rb

@@ -2,7 +2,7 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml
-    module Generator # :nodoc:
+    module Generator
       XML_TYPE_NAMES = {
         "Fixnum"     => "integer",
         "Bignum"     => "integer",

data/lib/braintree/xml/libxml.rb

@@ -2,7 +2,7 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml
-    module Libxml # :nodoc:
+    module Libxml
       LIB_XML_LIMIT = 30000000
 
       def self.parse(xml_string)

data/lib/braintree/xml/parser.rb

@@ -1,10 +1,10 @@
 # Portions of this code were copied and modified from Ruby on Rails, released
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
-  module Xml # :nodoc:
+  module Xml
     CONTENT_ROOT = "__content__"
 
-    module Parser # :nodoc:
+    module Parser
       XML_PARSING = {
         "datetime" => Proc.new { |time| ::Time.parse(time).utc },
         "integer"  => Proc.new { |integer| integer.to_i },

data/lib/braintree/xml/rexml.rb

@@ -1,8 +1,8 @@
 # Portions of this code were copied and modified from Ruby on Rails, released
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
-  module Xml # :nodoc:
-    module Rexml # :nodoc:
+  module Xml
+    module Rexml
 
       CONTENT_KEY = "__content__".freeze
 

data/lib/braintree/xml.rb

@@ -1,5 +1,5 @@
 module Braintree
-  module Xml # :nodoc:
+  module Xml
     def self.hash_from_xml(xml)
       Parser.hash_from_xml(xml)
     end

data/lib/braintree.rb

@@ -3,7 +3,6 @@ require "bigdecimal"
 require "cgi"
 require "date"
 require "digest/sha1"
-require "enumerator"
 require "forwardable"
 require "logger"
 require "net/http"
@@ -91,6 +90,8 @@ require "braintree/merchant_account/individual_details"
 require "braintree/merchant_account/business_details"
 require "braintree/merchant_account/funding_details"
 require "braintree/merchant_account/address_details"
+require "braintree/meta_checkout_card"
+require "braintree/meta_checkout_token"
 require "braintree/oauth_gateway"
 require "braintree/oauth_credentials"
 require "braintree/payment_instrument_type"
@@ -153,6 +154,8 @@ require "braintree/transaction/installment/adjustment"
 require "braintree/transaction/payment_receipt"
 require "braintree/transaction/payment_receipt/card_present_data.rb"
 require "braintree/transaction/payment_receipt/merchant_address.rb"
+require "braintree/transaction/meta_checkout_card_details"
+require "braintree/transaction/meta_checkout_token_details"
 require "braintree/transaction/paypal_details"
 require "braintree/transaction/paypal_here_details"
 require "braintree/transaction/samsung_pay_card_details"

data/spec/integration/braintree/add_on_spec.rb

@@ -20,15 +20,15 @@ describe Braintree::AddOn do
       add_ons = Braintree::AddOn.all
       add_on = add_ons.select { |add_on| add_on.id == id }.first
 
-      add_on.should_not be_nil
-      add_on.amount.should == BigDecimal(expected[:amount])
-      add_on.created_at.should_not be_nil
-      add_on.description.should == expected[:description]
-      add_on.kind.should == expected[:kind]
-      add_on.name.should == expected[:name]
-      add_on.never_expires.should == expected[:never_expires]
-      add_on.number_of_billing_cycles.should == expected[:number_of_billing_cycles]
-      add_on.updated_at.should_not be_nil
+      expect(add_on).not_to be_nil
+      expect(add_on.amount).to eq(BigDecimal(expected[:amount]))
+      expect(add_on.created_at).not_to be_nil
+      expect(add_on.description).to eq(expected[:description])
+      expect(add_on.kind).to eq(expected[:kind])
+      expect(add_on.name).to eq(expected[:name])
+      expect(add_on.never_expires).to eq(expected[:never_expires])
+      expect(add_on.number_of_billing_cycles).to eq(expected[:number_of_billing_cycles])
+      expect(add_on.updated_at).not_to be_nil
     end
 
     it "raises with a helpful error if public_key and private_key are not set" do

data/spec/integration/braintree/address_spec.rb

@@ -18,21 +18,21 @@ describe Braintree::Address do
         :postal_code => "60622",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.customer_id.should == customer.id
-      result.address.first_name.should == "Ben"
-      result.address.last_name.should == "Moore"
-      result.address.company.should == "Moore Co."
-      result.address.street_address.should == "1811 E Main St"
-      result.address.extended_address.should == "Suite 200"
-      result.address.locality.should == "Chicago"
-      result.address.region.should == "Illinois"
-      result.address.phone_number.should == "5551231234"
-      result.address.postal_code.should == "60622"
-      result.address.country_name.should == "United States of America"
-      result.address.country_code_alpha2.should == "US"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.customer_id).to eq(customer.id)
+      expect(result.address.first_name).to eq("Ben")
+      expect(result.address.last_name).to eq("Moore")
+      expect(result.address.company).to eq("Moore Co.")
+      expect(result.address.street_address).to eq("1811 E Main St")
+      expect(result.address.extended_address).to eq("Suite 200")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.phone_number).to eq("5551231234")
+      expect(result.address.postal_code).to eq("60622")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -43,11 +43,11 @@ describe Braintree::Address do
         :country_code_alpha3 => "ASM",
         :country_code_numeric => "16",
       )
-      result.success?.should == true
-      result.address.country_name.should == "American Samoa"
-      result.address.country_code_alpha2.should == "AS"
-      result.address.country_code_alpha3.should == "ASM"
-      result.address.country_code_numeric.should == "016"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("American Samoa")
+      expect(result.address.country_code_alpha2).to eq("AS")
+      expect(result.address.country_code_alpha3).to eq("ASM")
+      expect(result.address.country_code_numeric).to eq("016")
     end
 
     it "accepts utf-8 country names" do
@@ -56,8 +56,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_name => "Åland",
       )
-      result.success?.should == true
-      result.address.country_name.should == "Åland"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Åland")
     end
 
     it "returns an error response given inconsistent country codes" do
@@ -67,8 +67,8 @@ describe Braintree::Address do
         :country_code_alpha2 => "AS",
         :country_code_alpha3 => "USA",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:base).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error response given an invalid country_code_alpha2" do
@@ -77,8 +77,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_alpha2 => "zz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_alpha3" do
@@ -87,8 +87,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_alpha3 => "zzz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_numeric" do
@@ -97,8 +97,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_numeric => "zz",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns an error response if invalid" do
@@ -107,8 +107,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_name => "United States of Invalid",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
 
     it "allows -, _, A-Z, a-z, and 0-9 in customer_id without raising an ArgumentError" do
@@ -137,14 +137,14 @@ describe Braintree::Address do
         :postal_code => "60623",
         :country_name => "United States of America",
       )
-      address.customer_id.should == customer.id
-      address.street_address.should == "1812 E Main St"
-      address.extended_address.should == "Suite 201"
-      address.locality.should == "Bartlett"
-      address.region.should == "IL"
-      address.phone_number.should == "5551231234"
-      address.postal_code.should == "60623"
-      address.country_name.should == "United States of America"
+      expect(address.customer_id).to eq(customer.id)
+      expect(address.street_address).to eq("1812 E Main St")
+      expect(address.extended_address).to eq("Suite 201")
+      expect(address.locality).to eq("Bartlett")
+      expect(address.region).to eq("IL")
+      expect(address.phone_number).to eq("5551231234")
+      expect(address.postal_code).to eq("60623")
+      expect(address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed if invalid" do
@@ -162,7 +162,7 @@ describe Braintree::Address do
     it "deletes the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer.id, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer.id, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -171,7 +171,7 @@ describe Braintree::Address do
     it "deletes the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -182,13 +182,13 @@ describe Braintree::Address do
     it "finds the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer, address.id).should == address
+      expect(Braintree::Address.find(customer, address.id)).to eq(address)
     end
 
     it "finds the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer.id, address.id).should == address
+      expect(Braintree::Address.find(customer.id, address.id)).to eq(address)
     end
 
     it "raises a NotFoundError if it cannot be found because of customer id" do
@@ -242,16 +242,16 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.street_address.should == "123 E New St"
-      result.address.extended_address.should == "New Suite 3"
-      result.address.locality.should == "Chicago"
-      result.address.region.should == "Illinois"
-      result.address.postal_code.should == "60621"
-      result.address.country_name.should == "United States of America"
-      result.address.country_code_alpha2.should == "US"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.street_address).to eq("123 E New St")
+      expect(result.address.extended_address).to eq("New Suite 3")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.postal_code).to eq("60621")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -266,11 +266,11 @@ describe Braintree::Address do
         :country_name => "Azerbaijan",
       )
 
-      result.success?.should == true
-      result.address.country_name.should == "Azerbaijan"
-      result.address.country_code_alpha2.should == "AZ"
-      result.address.country_code_alpha3.should == "AZE"
-      result.address.country_code_numeric.should == "031"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Azerbaijan")
+      expect(result.address.country_code_alpha2).to eq("AZ")
+      expect(result.address.country_code_alpha3).to eq("AZE")
+      expect(result.address.country_code_numeric).to eq("031")
     end
 
     it "returns an error response if invalid" do
@@ -285,8 +285,8 @@ describe Braintree::Address do
         :street_address => "123 E New St",
         :country_name => "United States of Invalid",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
   end
 
@@ -320,13 +320,13 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      updated_address.should == address
-      updated_address.street_address.should == "123 E New St"
-      updated_address.extended_address.should == "New Suite 3"
-      updated_address.locality.should == "Chicago"
-      updated_address.region.should == "Illinois"
-      updated_address.postal_code.should == "60621"
-      updated_address.country_name.should == "United States of America"
+      expect(updated_address).to eq(address)
+      expect(updated_address.street_address).to eq("123 E New St")
+      expect(updated_address.extended_address).to eq("New Suite 3")
+      expect(updated_address.locality).to eq("Chicago")
+      expect(updated_address.region).to eq("Illinois")
+      expect(updated_address.postal_code).to eq("60621")
+      expect(updated_address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed invalid" do
@@ -352,7 +352,7 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
       result = Braintree::Address.delete(customer.id, address.id)
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)

data/spec/integration/braintree/advanced_search_spec.rb

@@ -29,8 +29,8 @@ describe Braintree::AdvancedSearch do
         search.id.is "subscription1_#{id}"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "is_not" do
@@ -54,8 +54,8 @@ describe Braintree::AdvancedSearch do
         search.price.is "11"
       end
 
-      collection.should_not include(subscription1)
-      collection.should include(subscription2)
+      expect(collection).not_to include(subscription1)
+      expect(collection).to include(subscription2)
     end
 
     it "starts_with" do
@@ -76,8 +76,8 @@ describe Braintree::AdvancedSearch do
         search.id.starts_with "subscription1_"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "ends_with" do
@@ -98,8 +98,8 @@ describe Braintree::AdvancedSearch do
         search.id.ends_with "1_#{id}"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
 
     it "contains" do
@@ -120,8 +120,8 @@ describe Braintree::AdvancedSearch do
         search.id.contains "scription1_"
       end
 
-      collection.should include(subscription1)
-      collection.should_not include(subscription2)
+      expect(collection).to include(subscription1)
+      expect(collection).not_to include(subscription2)
     end
   end
 
@@ -147,8 +147,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "12"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       it "returns only matching results" do
@@ -171,8 +171,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "13"
         end
 
-        collection.should include(subscription1)
-        collection.should_not include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).not_to include(subscription2)
       end
 
       it "returns only matching results given an argument list" do
@@ -195,8 +195,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "14"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       describe "is" do
@@ -220,8 +220,8 @@ describe Braintree::AdvancedSearch do
             search.price.is "15"
           end
 
-          collection.should include(subscription1)
-          collection.should_not include(subscription2)
+          expect(collection).to include(subscription1)
+          expect(collection).not_to include(subscription2)
         end
       end
 
@@ -245,8 +245,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "16"
         end
 
-        collection.should include(subscription1)
-        collection.should include(subscription2)
+        expect(collection).to include(subscription1)
+        expect(collection).to include(subscription2)
       end
 
       it "returns expired subscriptions" do
@@ -254,8 +254,8 @@ describe Braintree::AdvancedSearch do
           search.status.in [Braintree::Subscription::Status::Expired]
         end
 
-        collection.maximum_size.should > 0
-        collection.all? { |subscription| subscription.status.should == Braintree::Subscription::Status::Expired }
+        expect(collection.maximum_size).to be > 0
+        collection.all? { |subscription| expect(subscription.status).to eq(Braintree::Subscription::Status::Expired) }
       end
     end
   end
@@ -287,7 +287,7 @@ describe Braintree::AdvancedSearch do
           search.price.is "17"
         end
 
-        collection.maximum_size.should > 0
+        expect(collection.maximum_size).to be > 0
         collection.all? { |subscription| plan_ids.include?(subscription.plan_id) }
       end
     end
@@ -298,7 +298,7 @@ describe Braintree::AdvancedSearch do
           search.plan_id.is "not_a_real_plan_id"
         end
 
-        collection.maximum_size.should == 0
+        expect(collection.maximum_size).to eq(0)
       end
     end
 
@@ -321,8 +321,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "18"
         end
 
-        collection.should include(trialless_subscription)
-        collection.should_not include(trial_subscription)
+        expect(collection).to include(trialless_subscription)
+        expect(collection).not_to include(trial_subscription)
       end
     end
 
@@ -345,8 +345,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "19"
         end
 
-        collection.should_not include(trialless_subscription)
-        collection.should include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
       end
     end
 
@@ -369,8 +369,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "20"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
 
@@ -393,8 +393,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "21"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
 
@@ -417,8 +417,8 @@ describe Braintree::AdvancedSearch do
           search.price.is "22"
         end
 
-        collection.should include(trial_subscription)
-        collection.should_not include(trialless_subscription)
+        expect(collection).to include(trial_subscription)
+        expect(collection).not_to include(trialless_subscription)
       end
     end
   end
@@ -441,8 +441,8 @@ describe Braintree::AdvancedSearch do
         search.price.is "5.00"
       end
 
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_501)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_501)
     end
 
     it "<=" do
@@ -468,9 +468,9 @@ describe Braintree::AdvancedSearch do
         search.price <= "5.00"
       end
 
-      collection.should include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_501)
+      expect(collection).to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_501)
     end
 
     it ">=" do
@@ -496,9 +496,9 @@ describe Braintree::AdvancedSearch do
         search.price >= "1000.00"
       end
 
-      collection.should_not include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should include(subscription_501)
+      expect(collection).not_to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).to include(subscription_501)
     end
 
     it "between" do
@@ -524,9 +524,9 @@ describe Braintree::AdvancedSearch do
         search.price.between "4.99", "5.01"
       end
 
-      collection.should include(subscription_499)
-      collection.should include(subscription_500)
-      collection.should_not include(subscription_502)
+      expect(collection).to include(subscription_499)
+      expect(collection).to include(subscription_500)
+      expect(collection).not_to include(subscription_502)
     end
   end
 end