braintree 4.14.0 → 4.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b00fbf3fe7587ce0788471b730caa3db11f9b574a0077d83e03a9c0aef54e01
-  data.tar.gz: 3dd4395b7ca564f1ac454a290451c9716953b9297ad3b9101d7d6e07f3cc1972
+  metadata.gz: 71fab9e9404ac3f2c30216aca3642baecbd01c942a25c16c70b6748563f32435
+  data.tar.gz: b8900d8aa7aac3716db035478510532bb82edd40ba599626d7cbe770fa939849
 SHA512:
-  metadata.gz: 665d8cef94dfe888f82c1b50c65bad773f5c6b4600937118b37cdc68f92b47150c148d6c0c45130e8e867f7507f13929975f3357ac769c8b9e982f1d7988cab6
-  data.tar.gz: 3555eb3944bf02f23912d17c323250d7112722f09bd825b7e6a5571fa44470d52800a7e92d4d738e6ab8f69c6a2fb98adddf626139b4ec78d39679beea0fee86
+  metadata.gz: 9470b1e652814a7ae2fda1250b2c9f670069f1ef98a601ce2a382a4e3430017eaeaeaf7dabe4bc1b456c755d1b0fb258b06fc0593432d2b35c2ce9fc02671d5a
+  data.tar.gz: e376876f7c6ae2c5a1ce588c847d3494e828b29c4f2aee273d5e2c97348577db364b4bcc48ba0588074d87644a39f771b45c7eb56e7865be1cec730a76e72162

data/lib/braintree/credit_card.rb

@@ -23,6 +23,16 @@ module Braintree
       All = constants.map { |c| const_get(c) }
     end
 
+    module DebitNetwork
+      Accel = "ACCEL"
+      Nyce = "NYCE"
+      Pulse = "PULSE"
+      Star = "STAR"
+      Star_Access = "STAR_ACCESS"
+
+      All = constants.map { |c| const_get(c) }
+    end
+
     module CustomerLocation
       International = "international"
       US = "us"
@@ -160,7 +170,10 @@ module Braintree
     end
 
     # Returns true if the card is associated with Venmo SDK
+    # NEXT_MAJOR_VERSION Remove this method
+    # The old venmo SDK class has been deprecated
     def venmo_sdk?
+      warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
       @venmo_sdk
     end
 

data/lib/braintree/credit_card_gateway.rb

@@ -12,6 +12,10 @@ module Braintree
       if attributes.has_key?(:expiration_date) && (attributes.has_key?(:expiration_month) || attributes.has_key?(:expiration_year))
         raise ArgumentError.new("create with both expiration_month and expiration_year or only expiration_date")
       end
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:venmo_sdk_payment_method_code) || attributes.has_key?(:venmo_sdk_session)
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
+      end
       Util.verify_keys(CreditCardGateway._create_signature, attributes)
       _do_create("/payment_methods", :credit_card => attributes)
     end
@@ -61,6 +65,10 @@ module Braintree
     end
 
     def update(token, attributes)
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:venmo_sdk_payment_method_code) || attributes.has_key?(:venmo_sdk_session)
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
+      end
       Util.verify_keys(CreditCardGateway._update_signature, attributes)
       _do_update(:put, "/payment_methods/credit_card/#{token}", :credit_card => attributes)
     end
@@ -79,21 +87,25 @@ module Braintree
 
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature
+      # NEXT_MAJOR_VERSION Remove venmo_sdk_session
+      # The old venmo SDK class has been deprecated
       options = [
         :fail_on_duplicate_payment_method,
         :make_default,
         :skip_advanced_fraud_checking,
-        :venmo_sdk_session,
+        :venmo_sdk_session, # Deprecated
         :verification_account_type,
         :verification_amount,
         :verification_currency_iso_code,
         :verification_merchant_account_id,
         :verify_card
       ]
+      # NEXT_MAJOR_VERSION Remove venmo_sdk_payment_method_code
+      # The old venmo SDK class has been deprecated
       signature = [
         :billing_address_id, :cardholder_name, :cvv, :expiration_date, :expiration_month,
-        :expiration_year, :number, :token, :venmo_sdk_payment_method_code, :device_data,
-        :payment_method_nonce,
+        :expiration_year, :number, :token, :venmo_sdk_payment_method_code, # Deprecated
+        :device_data, :payment_method_nonce,
         {:external_vault => [:network_transaction_id]},
         {:options => options},
         {:billing_address => billing_address_params}

data/lib/braintree/payment_method_gateway.rb

@@ -9,6 +9,10 @@ module Braintree
     end
 
     def create(attributes)
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:venmo_sdk_payment_method_code) || attributes.has_key?(:venmo_sdk_session)
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
+      end
       Util.verify_keys(PaymentMethodGateway._create_signature, attributes)
       _do_create("/payment_methods", :payment_method => attributes)
     end
@@ -60,6 +64,10 @@ module Braintree
     end
 
     def update(token, attributes)
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:venmo_sdk_payment_method_code) || attributes.has_key?(:venmo_sdk_session)
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
+      end
       Util.verify_keys(PaymentMethodGateway._update_signature, attributes)
       _do_update(:put, "/payment_methods/any/#{token}", :payment_method => attributes)
     end
@@ -149,11 +157,13 @@ module Braintree
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature
       paypal_options_shipping_signature = AddressGateway._shared_signature
+      # NEXT_MAJOR_VERSION Remove venmo_sdk_session
+      # The old venmo SDK class has been deprecated
       options = [
         :make_default,
         :skip_advanced_fraud_checking,
         :us_bank_account_verification_method,
-        :venmo_sdk_session,
+        :venmo_sdk_session, # Deprecated
         :verification_account_type,
         :verification_amount,
         :verification_currency_iso_code,
@@ -168,10 +178,12 @@ module Braintree
           {:shipping => paypal_options_shipping_signature}
         ],
       ]
+      # NEXT_MAJOR_VERSION Remove venmo_sdk_payment_method_code
+      # The old venmo SDK class has been deprecated
       signature = [
         :billing_address_id, :cardholder_name, :cvv, :expiration_date, :expiration_month,
-        :expiration_year, :number, :token, :venmo_sdk_payment_method_code, :device_data,
-        :payment_method_nonce,
+        :expiration_year, :number, :token, :venmo_sdk_payment_method_code, # Deprecated
+        :device_data, :payment_method_nonce,
         {:options => options},
         {:billing_address => billing_address_params}
       ]

data/lib/braintree/test/nonce.rb

@@ -53,6 +53,7 @@ module Braintree
       TransactableCountryOfIssuanceUSA = "fake-valid-country-of-issuance-usa-nonce"
       TransactableCountryOfIssuanceCAD = "fake-valid-country-of-issuance-cad-nonce"
       TransactableIssuingBankNetworkOnly = "fake-valid-issuing-bank-network-only-nonce"
+      TransactablePinlessDebitVisa = "fake-pinless-debit-visa-nonce"
       ProcessorDeclinedVisa = "fake-processor-declined-visa-nonce"
       ProcessorDeclinedMasterCard = "fake-processor-declined-mastercard-nonce"
       ProcessorDeclinedAmEx = "fake-processor-declined-amex-nonce"

data/lib/braintree/test/venmo_sdk.rb

@@ -1,3 +1,5 @@
+# NEXT_MAJOR_VERSION Remove this class
+# The old venmo SDK class has been deprecated
 module Braintree
   module Test
     module VenmoSDK

data/lib/braintree/transaction/credit_card_details.rb

@@ -64,7 +64,10 @@ module Braintree
         "#{bin}******#{last_4}"
       end
 
+      # NEXT_MAJOR_VERSION Remove this method
+      # The old venmo SDK class has been deprecated
       def venmo_sdk?
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
         @venmo_sdk
       end
 

data/lib/braintree/transaction/local_payment_details.rb

@@ -8,6 +8,8 @@ module Braintree
       attr_reader :debug_id
       attr_reader :description
       attr_reader :funding_source
+      attr_reader :implicitly_vaulted_payment_method_global_id
+      attr_reader :implicitly_vaulted_payment_method_token
       attr_reader :payer_id
       attr_reader :payment_id
       attr_reader :refund_from_transaction_fee_amount

data/lib/braintree/transaction.rb

@@ -91,8 +91,9 @@ module Braintree
       end
     end
 
-    attr_reader :acquirer_reference_number
     attr_reader :ach_return_code
+    attr_reader :ach_return_responses
+    attr_reader :acquirer_reference_number
     attr_reader :add_ons
     attr_reader :additional_processor_response          # The raw response from the processor.
     attr_reader :amount
@@ -111,6 +112,7 @@ module Braintree
     attr_reader :custom_fields
     attr_reader :customer_details
     attr_reader :cvv_response_code
+    attr_reader :debit_network
     attr_reader :descriptor
     attr_reader :disbursement_details
     attr_reader :discount_amount
@@ -150,8 +152,8 @@ module Braintree
     attr_reader :purchase_order_number
     attr_reader :recurring
     attr_reader :refund_ids
-    attr_reader :refunded_transaction_id
     attr_reader :refunded_installments
+    attr_reader :refunded_transaction_id
     attr_reader :retried
     attr_reader :retried_transaction_id                 # the primary/parent transaction id of any retried transaction
     attr_reader :retrieval_reference_number
@@ -159,9 +161,9 @@ module Braintree
     attr_reader :risk_data
     attr_reader :samsung_pay_card_details
     attr_reader :sca_exemption_requested
-    attr_reader :service_fee_amount
     attr_reader :sepa_direct_debit_account_details
     attr_reader :sepa_direct_debit_return_code
+    attr_reader :service_fee_amount
     attr_reader :settlement_batch_id
     attr_reader :shipping_amount
     attr_reader :shipping_details
@@ -179,7 +181,6 @@ module Braintree
     attr_reader :venmo_account_details
     attr_reader :visa_checkout_card_details
     attr_reader :voice_referral_number
-    attr_reader :ach_return_responses
 
     def self.adjust_authorization(*args)
       Configuration.gateway.transaction.adjust_authorization(*args)

data/lib/braintree/transaction_gateway.rb

@@ -9,6 +9,14 @@ module Braintree
     end
 
     def create(attributes)
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:venmo_sdk_payment_method_code) || attributes.has_key?(:venmo_sdk_session)
+        warn "[DEPRECATED] The Venmo SDK integration is Unsupported. Please update your integration to use Pay with Venmo instead."
+      end
+      # NEXT_MAJOR_VERSION remove this check
+      if attributes.has_key?(:three_d_secure_token)
+        warn "[DEPRECATED] Passing :three_d_secure_token to create is deprecated. Please use :three_d_secure_authentication_id"
+      end
       Util.verify_keys(TransactionGateway._create_signature, attributes)
       _do_create "/transactions", :transaction => attributes
     end
@@ -183,6 +191,10 @@ module Braintree
       [:amount, :channel, {:options => [:submit_for_settlement]}]
     end
 
+
+    # NEXT_MAJOR_VERSION Remove venmo_sdk_payment_method_code, venmo_sdk_session, and three_d_secure_token
+    # The old venmo SDK class has been deprecated
+    # three_d_secure_token has been deprecated in favor of three_d_secure_authentication_id
     def self._create_signature # :nodoc:
       [
         :amount, :billing_address_id, :channel, :customer_id, :device_data, :discount_amount,
@@ -190,8 +202,8 @@ module Braintree
         :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
         :shared_customer_id, :shared_payment_method_nonce, :shared_payment_method_token,
         :shared_shipping_address_id, :shipping_address_id, :shipping_amount,
-        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,
-        :three_d_secure_token, :transaction_source, :type, :venmo_sdk_payment_method_code,
+        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,:three_d_secure_token, #Deprecated
+        :transaction_source, :type, :venmo_sdk_payment_method_code, # Deprecated
         :sca_exemption, :currency_iso_code, :exchange_rate_quote_id,
         {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
         {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
@@ -222,7 +234,7 @@ module Braintree
           :submit_for_settlement,
           :add_billing_address_to_payment_method,
           :store_shipping_address_in_vault,
-          :venmo_sdk_session,
+          :venmo_sdk_session, # Deprecated
           :payee_id,
           :payee_email,
           :skip_advanced_fraud_checking,

data/lib/braintree/transaction_search.rb

@@ -54,15 +54,16 @@ module Braintree
       CreditCard::CustomerLocation::International,
       CreditCard::CustomerLocation::US
     ]
+    multiple_value_field :debit_network, :allows => CreditCard::DebitNetwork::All
     multiple_value_field :ids
-    multiple_value_field :payment_instrument_type
-    multiple_value_field :user
     multiple_value_field :merchant_account_id
-    multiple_value_field :status, :allows => Transaction::Status::All
+    multiple_value_field :payment_instrument_type
+    multiple_value_field :reason_code
     multiple_value_field :source
-    multiple_value_field :type, :allows => Transaction::Type::All
+    multiple_value_field :status, :allows => Transaction::Status::All
     multiple_value_field :store_ids
-    multiple_value_field :reason_code
+    multiple_value_field :type, :allows => Transaction::Type::All
+    multiple_value_field :user
 
     key_value_fields :refund
 

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 4
-    Minor = 14
+    Minor = 15
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/lib/braintree/webhook_notification.rb

@@ -45,6 +45,7 @@ module Braintree
 
       RecipientUpdatedGrantedPaymentMethod = "recipient_updated_granted_payment_method"
 
+      SubscriptionBillingSkipped = "subscription_billing_skipped"
       SubscriptionCanceled = "subscription_canceled"
       SubscriptionChargedSuccessfully = "subscription_charged_successfully"
       SubscriptionChargedUnsuccessfully = "subscription_charged_unsuccessfully"

data/lib/braintree/webhook_testing_gateway.rb

@@ -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/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)