braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/payment_method_spec.rb

@@ -17,28 +17,28 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
         :number => 4111111111111111,
         :expirationMonth => 12,
-        :expirationYear => 2020
+        :expirationYear => 2020,
       )
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
+      expect(found_credit_card).not_to be_nil
     end
 
     it "creates a payment method from an unvalidated credit card nonce" do
@@ -51,29 +51,29 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
         :number => "4111111111111111",
         :expirationMonth => "12",
         :expirationYear => "2020",
-        :options => {:validate => false}
+        :options => {:validate => false},
       )
-      response.code.should == "202"
+      expect(response.code).to eq("202")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
+      expect(found_credit_card).not_to be_nil
     end
 
     it "creates a payment method from a fake apple pay nonce" do
@@ -82,104 +82,142 @@ describe Braintree::PaymentMethod do
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx,
         :customer_id => customer.id,
-        :token => token
+        :token => token,
       )
 
-      result.should be_success
+      expect(result).to be_success
       apple_pay_card = result.payment_method
-      apple_pay_card.should be_a(Braintree::ApplePayCard)
-      apple_pay_card.should_not be_nil
-      apple_pay_card.bin.should_not be_nil
-      apple_pay_card.token.should == token
-      apple_pay_card.card_type.should == Braintree::ApplePayCard::CardType::AmEx
-      apple_pay_card.payment_instrument_name.should == "AmEx 41002"
-      apple_pay_card.source_description.should == "AmEx 41002"
-      apple_pay_card.default.should == true
-      apple_pay_card.image_url.should =~ /apple_pay/
-      apple_pay_card.expiration_month.to_i.should > 0
-      apple_pay_card.expiration_year.to_i.should > 0
-      apple_pay_card.customer_id.should == customer.id
+      expect(apple_pay_card).to be_a(Braintree::ApplePayCard)
+      expect(apple_pay_card).not_to be_nil
+      expect(apple_pay_card.bin).not_to be_nil
+      expect(apple_pay_card.token).to eq(token)
+      expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::AmEx)
+      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
+      expect(apple_pay_card.source_description).to eq("AmEx 41002")
+      expect(apple_pay_card.default).to eq(true)
+      expect(apple_pay_card.image_url).to match(/apple_pay/)
+      expect(apple_pay_card.expiration_month.to_i).to be > 0
+      expect(apple_pay_card.expiration_year.to_i).to be > 0
+      expect(apple_pay_card.customer_id).to eq(customer.id)
+      expect(apple_pay_card.commercial).not_to be_nil
+      expect(apple_pay_card.country_of_issuance).not_to be_nil
+      expect(apple_pay_card.debit).not_to be_nil
+      expect(apple_pay_card.durbin_regulated).not_to be_nil
+      expect(apple_pay_card.healthcare).not_to be_nil
+      expect(apple_pay_card.issuing_bank).not_to be_nil
+      expect(apple_pay_card.payroll).not_to be_nil
+      expect(apple_pay_card.prepaid).not_to be_nil
+      expect(apple_pay_card.product_id).not_to be_nil
     end
 
-    it "creates a payment method from a fake android pay proxy card nonce" do
+    it "creates a payment method from a fake apple pay mpan nonce" do
       customer = Braintree::Customer.create.customer
       token = SecureRandom.hex(16)
       result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+        :payment_method_nonce => Braintree::Test::Nonce::ApplePayMpan,
         :customer_id => customer.id,
-        :token => token
+        :token => token,
       )
 
-      result.should be_success
-      android_pay_card = result.payment_method
-      android_pay_card.should be_a(Braintree::AndroidPayCard)
-      android_pay_card.should_not be_nil
-      android_pay_card.token.should == token
-      android_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.expiration_month.to_i.should > 0
-      android_pay_card.expiration_year.to_i.should > 0
-      android_pay_card.default.should == true
-      android_pay_card.image_url.should =~ /android_pay/
-      android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.source_card_last_4.should == "1111"
-      android_pay_card.google_transaction_id.should == "google_transaction_id"
-      android_pay_card.source_description.should == "Discover 1111"
-      android_pay_card.customer_id.should == customer.id
+      expect(result).to be_success
+      apple_pay_card = result.payment_method
+      expect(apple_pay_card).to be_a(Braintree::ApplePayCard)
+      expect(apple_pay_card).not_to be_nil
+      expect(apple_pay_card.bin).not_to be_nil
+      expect(apple_pay_card.token).to eq(token)
+      expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
+      expect(apple_pay_card.payment_instrument_name).to eq("Visa 8886")
+      expect(apple_pay_card.source_description).to eq("Visa 8886")
+      expect(apple_pay_card.default).to eq(true)
+      expect(apple_pay_card.image_url).to match(/apple_pay/)
+      expect(apple_pay_card.expiration_month.to_i).to be > 0
+      expect(apple_pay_card.expiration_year.to_i).to be > 0
+      expect(apple_pay_card.customer_id).to eq(customer.id)
+      expect(apple_pay_card.commercial).not_to be_nil
+      expect(apple_pay_card.country_of_issuance).not_to be_nil
+      expect(apple_pay_card.debit).not_to be_nil
+      expect(apple_pay_card.durbin_regulated).not_to be_nil
+      expect(apple_pay_card.healthcare).not_to be_nil
+      expect(apple_pay_card.issuing_bank).not_to be_nil
+      expect(apple_pay_card.payroll).not_to be_nil
+      expect(apple_pay_card.prepaid).not_to be_nil
+      expect(apple_pay_card.product_id).not_to be_nil
+      expect(apple_pay_card.merchant_token_identifier).not_to be_nil
+      expect(apple_pay_card.source_card_last4).not_to be_nil
     end
 
-    it "creates a payment method from a android pay network token nonce" do
+    it "creates a payment method from a fake google pay proxy card nonce" do
       customer = Braintree::Customer.create.customer
       token = SecureRandom.hex(16)
       result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayMasterCard,
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
         :customer_id => customer.id,
-        :token => token
+        :token => token,
       )
 
-      result.should be_success
-      android_pay_card = result.payment_method
-      android_pay_card.should be_a(Braintree::AndroidPayCard)
-      android_pay_card.should_not be_nil
-      android_pay_card.token.should == token
-      android_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.expiration_month.to_i.should > 0
-      android_pay_card.expiration_year.to_i.should > 0
-      android_pay_card.default.should == true
-      android_pay_card.image_url.should =~ /android_pay/
-      android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.source_card_last_4.should == "4444"
-      android_pay_card.google_transaction_id.should == "google_transaction_id"
-      android_pay_card.source_description.should == "MasterCard 4444"
-      android_pay_card.customer_id.should == customer.id
+      expect(result).to be_success
+      google_pay_card = result.payment_method
+      expect(google_pay_card).to be_a(Braintree::GooglePayCard)
+      expect(google_pay_card).not_to be_nil
+      expect(google_pay_card.token).to eq(token)
+      expect(google_pay_card.card_type).to eq(Braintree::CreditCard::CardType::Discover)
+      expect(google_pay_card.virtual_card_type).to eq(Braintree::CreditCard::CardType::Discover)
+      expect(google_pay_card.expiration_month.to_i).to be > 0
+      expect(google_pay_card.expiration_year.to_i).to be > 0
+      expect(google_pay_card.default).to eq(true)
+      expect(google_pay_card.image_url).to match(/android_pay/)
+      expect(google_pay_card.is_network_tokenized?).to eq(false)
+      expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::Discover)
+      expect(google_pay_card.source_card_last_4).to eq("1111")
+      expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
+      expect(google_pay_card.source_description).to eq("Discover 1111")
+      expect(google_pay_card.customer_id).to eq(customer.id)
+      expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.country_of_issuance).not_to be_nil
+      expect(google_pay_card.debit).not_to be_nil
+      expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.issuing_bank).not_to be_nil
+      expect(google_pay_card.payroll).not_to be_nil
+      expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.product_id).not_to be_nil
     end
 
-    it "creates a payment method from an amex express checkout card nonce" do
+    it "creates a payment method from a google pay network token nonce" do
       customer = Braintree::Customer.create.customer
       token = SecureRandom.hex(16)
       result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AmexExpressCheckout,
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
         :customer_id => customer.id,
-        :token => token
+        :token => token,
       )
 
-      result.should be_success
-      amex_express_checkout_card = result.payment_method
-      amex_express_checkout_card.should be_a(Braintree::AmexExpressCheckoutCard)
-      amex_express_checkout_card.should_not be_nil
-
-      amex_express_checkout_card.default.should == true
-      amex_express_checkout_card.card_type.should == "American Express"
-      amex_express_checkout_card.token.should == token
-      amex_express_checkout_card.bin.should =~ /\A\d{6}\z/
-      amex_express_checkout_card.expiration_month.should =~ /\A\d{2}\z/
-      amex_express_checkout_card.expiration_year.should =~ /\A\d{4}\z/
-      amex_express_checkout_card.card_member_number.should =~ /\A\d{4}\z/
-      amex_express_checkout_card.card_member_expiry_date.should =~ /\A\d{2}\/\d{2}\z/
-      amex_express_checkout_card.image_url.should include(".png")
-      amex_express_checkout_card.source_description.should =~ /\AAmEx \d{4}\z/
-      amex_express_checkout_card.customer_id.should == customer.id
+      expect(result).to be_success
+      google_pay_card = result.payment_method
+      expect(google_pay_card).to be_a(Braintree::GooglePayCard)
+      expect(google_pay_card).not_to be_nil
+      expect(google_pay_card.token).to eq(token)
+      expect(google_pay_card.card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+      expect(google_pay_card.virtual_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+      expect(google_pay_card.expiration_month.to_i).to be > 0
+      expect(google_pay_card.expiration_year.to_i).to be > 0
+      expect(google_pay_card.default).to eq(true)
+      expect(google_pay_card.image_url).to match(/android_pay/)
+      expect(google_pay_card.is_network_tokenized?).to eq(true)
+      expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+      expect(google_pay_card.source_card_last_4).to eq("4444")
+      expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
+      expect(google_pay_card.source_description).to eq("MasterCard 4444")
+      expect(google_pay_card.customer_id).to eq(customer.id)
+      expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.country_of_issuance).not_to be_nil
+      expect(google_pay_card.debit).not_to be_nil
+      expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.issuing_bank).not_to be_nil
+      expect(google_pay_card.payroll).not_to be_nil
+      expect(google_pay_card.prepaid).not_to be_nil
+      expect(google_pay_card.product_id).not_to be_nil
     end
 
     it "creates a payment method from venmo account nonce" do
@@ -188,20 +226,20 @@ describe Braintree::PaymentMethod do
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
         :customer_id => customer.id,
-        :token => token
+        :token => token,
       )
 
-      result.should be_success
+      expect(result).to be_success
       venmo_account = result.payment_method
-      venmo_account.should be_a(Braintree::VenmoAccount)
-
-      venmo_account.default.should == true
-      venmo_account.token.should == token
-      venmo_account.username.should == "venmojoe"
-      venmo_account.venmo_user_id.should == "Venmo-Joe-1"
-      venmo_account.image_url.should include(".png")
-      venmo_account.source_description.should == "Venmo Account: venmojoe"
-      venmo_account.customer_id.should == customer.id
+      expect(venmo_account).to be_a(Braintree::VenmoAccount)
+
+      expect(venmo_account.default).to eq(true)
+      expect(venmo_account.token).to eq(token)
+      expect(venmo_account.username).to eq("venmojoe")
+      expect(venmo_account.venmo_user_id).to eq("1234567891234567891")
+      expect(venmo_account.image_url).to include(".png")
+      expect(venmo_account.source_description).to eq("Venmo Account: venmojoe")
+      expect(venmo_account.customer_id).to eq(customer.id)
     end
 
     it "allows passing the make_default option alongside the nonce" do
@@ -210,22 +248,22 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
-        :cvv => "100"
+        :cvv => "100",
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       original_payment_method = result.credit_card
-      original_payment_method.should be_default
+      expect(original_payment_method).to be_default
 
       nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
-        :options => {:make_default => true}
+        :options => {:make_default => true},
       )
 
-      result.should be_success
+      expect(result).to be_success
       new_payment_method = result.payment_method
-      new_payment_method.should be_default
+      expect(new_payment_method).to be_default
     end
 
     it "overrides the token in the nonce" do
@@ -235,17 +273,17 @@ describe Braintree::PaymentMethod do
       second_token = make_token
       nonce = nonce_for_paypal_account(
         :consent_code => "PAYPAL_CONSENT_CODE",
-        :token => first_token
+        :token => first_token,
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
-        :token => second_token
+        :token => second_token,
       )
 
-      result.should be_success
+      expect(result).to be_success
       payment_method = result.payment_method
-      payment_method.token.should ==  second_token
+      expect(payment_method.token).to eq(second_token)
     end
 
     it "respects verify_card and verification_merchant_account_id when included outside of the nonce" do
@@ -254,7 +292,7 @@ describe Braintree::PaymentMethod do
           :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
       customer = Braintree::Customer.create!
       result = Braintree::PaymentMethod.create(
@@ -263,14 +301,14 @@ describe Braintree::PaymentMethod do
         :options => {
           :verify_card => true,
           :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
-        }
+        },
       )
 
-      result.should_not be_success
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      result.credit_card_verification.processor_response_code.should == "2000"
-      result.credit_card_verification.processor_response_text.should == "Do Not Honor"
-      result.credit_card_verification.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+      expect(result).not_to be_success
+      expect(result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+      expect(result.credit_card_verification.processor_response_code).to eq("2000")
+      expect(result.credit_card_verification.processor_response_text).to eq("Do Not Honor")
+      expect(result.credit_card_verification.merchant_account_id).to eq(SpecHelper::NonDefaultMerchantAccountId)
     end
 
     it "respects verification amount when included outside of the nonce" do
@@ -279,7 +317,7 @@ describe Braintree::PaymentMethod do
           :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
       customer = Braintree::Customer.create!
       result = Braintree::PaymentMethod.create(
@@ -288,14 +326,58 @@ describe Braintree::PaymentMethod do
         :options => {
           :verify_card => true,
           :verification_amount => "100.00"
-        }
+        },
+      )
+
+      expect(result).not_to be_success
+      expect(result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+      expect(result.credit_card_verification.processor_response_code).to eq("2000")
+      expect(result.credit_card_verification.processor_response_text).to eq("Do Not Honor")
+      expect(result.credit_card_verification.amount).to eq(BigDecimal("100.00"))
+    end
+
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => "05",
+          :cavv => "some_cavv",
+          :xid => "some_xid",
+          :three_d_secure_version => "xx",
+          :authentication_response => "Y",
+          :directory_response => "Y",
+          :cavv_algorithm => "2",
+          :ds_transaction_id => "some_ds_transaction_id",
+        },
+        :options => {:verify_card => true},
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+      expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => "05",
+          :cavv => "some_cavv",
+          :xid => "some_xid",
+          :three_d_secure_version => "1.0.2",
+          :authentication_response => "Y",
+          :directory_response => "Y",
+          :cavv_algorithm => "2",
+          :ds_transaction_id => "some_ds_transaction_id",
+        },
+        :options => {:verify_card => true},
       )
 
-      result.should_not be_success
-      result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      result.credit_card_verification.processor_response_code.should == "2000"
-      result.credit_card_verification.processor_response_text.should == "Do Not Honor"
-      result.credit_card_verification.amount.should == BigDecimal("100.00")
+      expect(result).to be_success
     end
 
     it "returns 3DS info on cc verification" do
@@ -305,18 +387,17 @@ describe Braintree::PaymentMethod do
         :options => {:verify_card => true},
         :customer_id => customer.id,
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       three_d_secure_info = result.payment_method.verification.three_d_secure_info
-      three_d_secure_info.enrolled.should == "Y"
-      three_d_secure_info.should be_liability_shifted
-      three_d_secure_info.should be_liability_shift_possible
-      three_d_secure_info.status.should == "authenticate_successful"
-      three_d_secure_info.cavv.should == "cavv_value"
-      three_d_secure_info.xid.should == "xid_value"
-      three_d_secure_info.eci_flag.should == "05"
-      three_d_secure_info.three_d_secure_version.should == "1.0.2"
-      three_d_secure_info.ds_transaction_id.should == nil
+      expect(three_d_secure_info.status).to eq("authenticate_successful")
+      expect(three_d_secure_info).to be_liability_shifted
+      expect(three_d_secure_info).to be_liability_shift_possible
+      expect(three_d_secure_info.enrolled).to be_a(String)
+      expect(three_d_secure_info.cavv).to be_a(String)
+      expect(three_d_secure_info.xid).to be_a(String)
+      expect(three_d_secure_info.eci_flag).to be_a(String)
+      expect(three_d_secure_info.three_d_secure_version).to be_a(String)
     end
 
     it "respects fail_on_duplicate_payment_method when included outside of the nonce" do
@@ -324,26 +405,53 @@ describe Braintree::PaymentMethod do
       result = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
-      result.should be_success
+      expect(result).to be_success
 
       nonce = nonce_for_new_payment_method(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2012"
-        }
+        },
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
         :options => {
           :fail_on_duplicate_payment_method => true
-        }
+        },
+      )
+
+      expect(result).not_to be_success
+      expect(result.errors.first.code).to eq("81724")
+    end
+
+    it "respects fail_on_duplicate_payment_method_for_customer when included outside of the nonce" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => 4111111111111111,
+        :expiration_date => "05/2012",
+      )
+      expect(result).to be_success
+
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => 4111111111111111,
+          :expiration_date => "05/2012"
+        },
+      )
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :fail_on_duplicate_payment_method_for_customer => true
+        },
       )
 
-      result.should_not be_success
-      result.errors.first.code.should == "81724"
+      expect(result).not_to be_success
+      expect(result.errors.first.code).to eq("81763")
     end
 
     it "allows passing the billing address outside of the nonce" do
@@ -356,33 +464,36 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
         :number => "4111111111111111",
         :expirationMonth => "12",
         :expirationYear => "2020",
-        :options => {:validate => false}
+        :options => {:validate => false},
       )
-      response.code.should == "202"
+      expect(response.code).to eq("202")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
         :billing_address => {
-          :street_address => "123 Abc Way"
-        }
+          :street_address => "123 Abc Way",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
+        },
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
-      found_credit_card.billing_address.street_address.should == "123 Abc Way"
+      expect(found_credit_card).not_to be_nil
+      expect(found_credit_card.billing_address.street_address).to eq("123 Abc Way")
+      expect(found_credit_card.billing_address.international_phone[:country_code]).to eq("1")
+      expect(found_credit_card.billing_address.international_phone[:national_number]).to eq("3121234567")
     end
 
     it "allows passing a billing address id outside of the nonce" do
@@ -395,16 +506,16 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
         :number => "4111111111111111",
         :expirationMonth => "12",
         :expirationYear => "2020",
-        :options => {:validate => false}
+        :options => {:validate => false},
       )
-      response.code.should == "202"
+      expect(response.code).to eq("202")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
 
@@ -412,17 +523,17 @@ describe Braintree::PaymentMethod do
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
-        :billing_address_id => address.id
+        :billing_address_id => address.id,
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
-      found_credit_card.billing_address.first_name.should == "Bobby"
-      found_credit_card.billing_address.last_name.should == "Tables"
+      expect(found_credit_card).not_to be_nil
+      expect(found_credit_card.billing_address.first_name).to eq("Bobby")
+      expect(found_credit_card.billing_address.last_name).to eq("Tables")
     end
 
     it "overrides the billing address in the nonce" do
@@ -435,7 +546,7 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
@@ -445,9 +556,9 @@ describe Braintree::PaymentMethod do
         :options => {:validate => false},
         :billing_address => {
           :street_address => "456 Xyz Way"
-        }
+        },
       )
-      response.code.should == "202"
+      expect(response.code).to eq("202")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       result = Braintree::PaymentMethod.create(
@@ -455,16 +566,16 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :billing_address => {
           :street_address => "123 Abc Way"
-        }
+        },
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
-      found_credit_card.billing_address.street_address.should == "123 Abc Way"
+      expect(found_credit_card).not_to be_nil
+      expect(found_credit_card.billing_address.street_address).to eq("123 Abc Way")
     end
 
     it "does not override the billing address for a vaulted credit card" do
@@ -477,7 +588,7 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
@@ -486,9 +597,9 @@ describe Braintree::PaymentMethod do
         :expirationYear => 2020,
         :billing_address => {
           :street_address => "456 Xyz Way"
-        }
+        },
       )
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       result = Braintree::PaymentMethod.create(
@@ -496,16 +607,68 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :billing_address => {
           :street_address => "123 Abc Way"
-        }
+        },
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
-      found_credit_card.billing_address.street_address.should == "456 Xyz Way"
+      expect(found_credit_card).not_to be_nil
+      expect(found_credit_card.billing_address.street_address).to eq("456 Xyz Way")
+    end
+
+    it "includes risk data when skip_advanced_fraud_checking is false" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!
+
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+        )
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => false,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.payment_method.verification
+        expect(verification.risk_data).not_to be_nil
+      end
+    end
+
+    it "does not include risk data when skip_advanced_fraud_checking is true" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!
+
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+        )
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => true,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.payment_method.verification
+        expect(verification.risk_data).to be_nil
+      end
     end
 
     context "account_type" do
@@ -515,7 +678,7 @@ describe Braintree::PaymentMethod do
             :number => Braintree::Test::CreditCardNumbers::Hiper,
             :expiration_month => "11",
             :expiration_year => "2099",
-          }
+          },
         )
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
@@ -523,13 +686,13 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
-          }
+          },
         )
 
-        result.should be_success
-        result.payment_method.verification.credit_card[:account_type].should == "debit"
+        expect(result).to be_success
+        expect(result.payment_method.verification.credit_card[:account_type]).to eq("debit")
       end
 
       it "verifies card with account_type credit" do
@@ -538,7 +701,7 @@ describe Braintree::PaymentMethod do
             :number => Braintree::Test::CreditCardNumbers::Hiper,
             :expiration_month => "11",
             :expiration_year => "2099",
-          }
+          },
         )
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
@@ -548,11 +711,11 @@ describe Braintree::PaymentMethod do
             :verify_card => true,
             :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
             :verification_account_type => "credit",
-          }
+          },
         )
 
-        result.should be_success
-        result.payment_method.verification.credit_card[:account_type].should == "credit"
+        expect(result).to be_success
+        expect(result.payment_method.verification.credit_card[:account_type]).to eq("credit")
       end
 
       it "errors with invalid account_type" do
@@ -561,7 +724,7 @@ describe Braintree::PaymentMethod do
             :number => Braintree::Test::CreditCardNumbers::Hiper,
             :expiration_month => "11",
             :expiration_year => "2099",
-          }
+          },
         )
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
@@ -571,11 +734,11 @@ describe Braintree::PaymentMethod do
             :verify_card => true,
             :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
             :verification_account_type => "ach",
-          }
+          },
         )
 
-        result.should_not be_success
-        result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code.should == Braintree::ErrorCodes::CreditCard::VerificationAccountTypeIsInvalid
+        expect(result).not_to be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq(Braintree::ErrorCodes::CreditCard::VerificationAccountTypeIsInvalid)
       end
 
       it "errors when account_type not supported by merchant" do
@@ -584,7 +747,7 @@ describe Braintree::PaymentMethod do
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_month => "11",
             :expiration_year => "2099",
-          }
+          },
         )
         customer = Braintree::Customer.create!
         result = Braintree::PaymentMethod.create(
@@ -593,11 +756,11 @@ describe Braintree::PaymentMethod do
           :options => {
             :verify_card => true,
             :verification_account_type => "credit",
-          }
+          },
         )
 
-        result.should_not be_success
-        result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code.should == Braintree::ErrorCodes::CreditCard::VerificationAccountTypeNotSupported
+        expect(result).not_to be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_account_type)[0].code).to eq(Braintree::ErrorCodes::CreditCard::VerificationAccountTypeNotSupported)
       end
 
       it "updates the credit card with account_type credit" do
@@ -607,7 +770,7 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :cardholder_name => "New Holder",
@@ -620,8 +783,8 @@ describe Braintree::PaymentMethod do
             :verification_account_type => "credit",
           },
         )
-        update_result.success?.should == true
-        update_result.payment_method.verification.credit_card[:account_type].should == "credit"
+        expect(update_result.success?).to eq(true)
+        expect(update_result.payment_method.verification.credit_card[:account_type]).to eq("credit")
       end
 
       it "updates the credit card with account_type debit" do
@@ -631,7 +794,7 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :cardholder_name => "New Holder",
@@ -640,12 +803,12 @@ describe Braintree::PaymentMethod do
           :expiration_date => "06/2013",
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
           },
         )
-        update_result.success?.should == true
-        update_result.payment_method.verification.credit_card[:account_type].should == "debit"
+        expect(update_result.success?).to eq(true)
+        expect(update_result.payment_method.verification.credit_card[:account_type]).to eq("debit")
       end
     end
 
@@ -655,16 +818,16 @@ describe Braintree::PaymentMethod do
         customer = Braintree::Customer.create.customer
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.image_url.should_not be_nil
+        expect(result).to be_success
+        expect(result.payment_method).to be_a(Braintree::PayPalAccount)
+        expect(result.payment_method.image_url).not_to be_nil
         token = result.payment_method.token
 
         found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
+        expect(found_paypal_account).not_to be_nil
       end
 
       it "creates a limited use payment method from a paypal account nonce for a paypal intent==order payment" do
@@ -697,15 +860,15 @@ describe Braintree::PaymentMethod do
           },
         )
 
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.image_url.should_not be_nil
-        result.payment_method.payer_id.should_not be_nil
+        expect(result).to be_success
+        expect(result.payment_method).to be_a(Braintree::PayPalAccount)
+        expect(result.payment_method.image_url).not_to be_nil
+        expect(result.payment_method.payer_id).not_to be_nil
         token = result.payment_method.token
 
         found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
-        found_paypal_account.payer_id.should_not be_nil
+        expect(found_paypal_account).not_to be_nil
+        expect(found_paypal_account.payer_id).not_to be_nil
       end
 
       it "creates a billing agreement payment method from a refresh token" do
@@ -715,34 +878,16 @@ describe Braintree::PaymentMethod do
           :paypal_refresh_token => "some_future_payment_token",
         )
 
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.billing_agreement_id.should eq("B_FAKE_ID")
-        result.payment_method.payer_id.should_not be_nil
-        token = result.payment_method.token
-
-        found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
-        found_paypal_account.billing_agreement_id.should eq("B_FAKE_ID")
-        found_paypal_account.payer_id.should_not be_nil
-      end
-
-      it "creates a billing agreement payment method from a refresh token without upgrading" do
-        customer = Braintree::Customer.create.customer
-        result = Braintree::PaymentMethod.create(
-          :customer_id => customer.id,
-          :paypal_refresh_token => "some_future_payment_token",
-          :paypal_vault_without_upgrade => true,
-        )
-
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.billing_agreement_id.should be_nil
+        expect(result).to be_success
+        expect(result.payment_method).to be_a(Braintree::PayPalAccount)
+        expect(result.payment_method.billing_agreement_id).to eq("B_FAKE_ID")
+        expect(result.payment_method.payer_id).not_to be_nil
         token = result.payment_method.token
 
         found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
-        found_paypal_account.billing_agreement_id.should be_nil
+        expect(found_paypal_account).not_to be_nil
+        expect(found_paypal_account.billing_agreement_id).to eq("B_FAKE_ID")
+        expect(found_paypal_account.payer_id).not_to be_nil
       end
 
       it "does not create a payment method from an unvalidated onetime paypal account nonce" do
@@ -750,11 +895,11 @@ describe Braintree::PaymentMethod do
         nonce = nonce_for_paypal_account(:access_token => "PAYPAL_ACCESS_TOKEN")
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
-        result.should_not be_success
-        result.errors.first.code.should == "82902"
+        expect(result).not_to be_success
+        expect(result.errors.first.code).to eq("82902")
       end
 
       it "ignores passed billing address params" do
@@ -765,16 +910,16 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :billing_address => {
             :street_address => "123 Abc Way"
-          }
+          },
         )
 
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.image_url.should_not be_nil
+        expect(result).to be_success
+        expect(result.payment_method).to be_a(Braintree::PayPalAccount)
+        expect(result.payment_method.image_url).not_to be_nil
         token = result.payment_method.token
 
         found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
+        expect(found_paypal_account).not_to be_nil
       end
 
       it "ignores passed billing address id" do
@@ -783,16 +928,16 @@ describe Braintree::PaymentMethod do
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
           :customer_id => customer.id,
-          :billing_address_id => "address_id"
+          :billing_address_id => "address_id",
         )
 
-        result.should be_success
-        result.payment_method.should be_a(Braintree::PayPalAccount)
-        result.payment_method.image_url.should_not be_nil
+        expect(result).to be_success
+        expect(result.payment_method).to be_a(Braintree::PayPalAccount)
+        expect(result.payment_method.image_url).not_to be_nil
         token = result.payment_method.token
 
         found_paypal_account = Braintree::PayPalAccount.find(token)
-        found_paypal_account.should_not be_nil
+        expect(found_paypal_account).not_to be_nil
       end
 
       it "returns appropriate validation errors" do
@@ -800,13 +945,13 @@ describe Braintree::PaymentMethod do
         nonce = nonce_for_paypal_account(:token => "PAYPAL_TOKEN")
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
-        result.should_not be_success
+        expect(result).not_to be_success
         errors = result.errors.map(&:code)
-        errors.should include("82901")
-        errors.should include("82902")
+        expect(errors).to include("82901")
+        expect(errors).to include("82902")
       end
 
       it "doesn't return an error if credit card options are present for a paypal nonce" do
@@ -814,7 +959,7 @@ describe Braintree::PaymentMethod do
         original_token = random_payment_method_token
         nonce = nonce_for_paypal_account(
           :consent_code => "consent-code",
-          :token => original_token
+          :token => original_token,
         )
 
         result = Braintree::PaymentMethod.create(
@@ -824,10 +969,10 @@ describe Braintree::PaymentMethod do
             :verify_card => true,
             :fail_on_duplicate_payment_method => true,
             :verification_merchant_account_id => "not_a_real_merchant_account_id"
-          }
+          },
         )
 
-        result.should be_success
+        expect(result).to be_success
       end
     end
 
@@ -838,14 +983,107 @@ describe Braintree::PaymentMethod do
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable,
           :customer_id => customer.id,
-          :token => token
+          :token => token,
         )
 
-        result.should be_success
+        expect(result).to be_success
         payment_method = result.payment_method
-        payment_method.should_not be_nil
-        payment_method.token.should == token
-        payment_method.should be_a Braintree::UnknownPaymentMethod
+        expect(payment_method).not_to be_nil
+        expect(payment_method.token).to eq(token)
+        expect(payment_method).to be_a Braintree::UnknownPaymentMethod
+      end
+    end
+
+    context "verification_currency_iso_code" do
+      it "validates verification_currency_iso_code against currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "USD"
+          },
+        )
+
+        expect(result).to be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+      end
+
+      it "validates verification_currency_iso_code against currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "USD"
+          },
+        )
+
+        expect(result).to be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+        result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+      end
+
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "GBP"
+          },
+        )
+        expect(result).not_to be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount)
+      end
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "GBP"
+          },
+        )
+
+        expect(result).not_to be_success
+        expect(result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount)
       end
     end
   end
@@ -861,27 +1099,27 @@ describe Braintree::PaymentMethod do
         config,
         :authorization_fingerprint => authorization_fingerprint,
         :shared_customer_identifier => "fake_identifier",
-        :shared_customer_identifier_type => "testing"
+        :shared_customer_identifier_type => "testing",
       )
 
       response = http.create_credit_card(
         :number => 4111111111111111,
         :expirationMonth => 12,
-        :expirationYear => 2020
+        :expirationYear => 2020,
       )
-      response.code.should == "201"
+      expect(response.code).to eq("201")
 
       nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
       payment_method = Braintree::PaymentMethod.create!(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
-      payment_method.should be_a(Braintree::CreditCard)
+      expect(payment_method).to be_a(Braintree::CreditCard)
       token = payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
+      expect(found_credit_card).not_to be_nil
     end
   end
 
@@ -892,15 +1130,15 @@ describe Braintree::PaymentMethod do
         result = Braintree::CreditCard.create(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
-        result.success?.should == true
+        expect(result.success?).to eq(true)
 
         credit_card = Braintree::PaymentMethod.find(result.credit_card.token)
-        credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-        credit_card.token.should == result.credit_card.token
-        credit_card.expiration_date.should == "05/2012"
+        expect(credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+        expect(credit_card.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+        expect(credit_card.token).to eq(result.credit_card.token)
+        expect(credit_card.expiration_date).to eq("05/2012")
       end
 
       it "returns associated subscriptions with the credit card" do
@@ -908,20 +1146,20 @@ describe Braintree::PaymentMethod do
         credit_card = Braintree::CreditCard.create(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         ).credit_card
 
         subscription = Braintree::Subscription.create(
           :payment_method_token => credit_card.token,
           :plan_id => "integration_trialless_plan",
-          :price => "1.00"
+          :price => "1.00",
         ).subscription
 
         found_card = Braintree::PaymentMethod.find(credit_card.token)
-        found_card.subscriptions.first.id.should == subscription.id
-        found_card.subscriptions.first.plan_id.should == "integration_trialless_plan"
-        found_card.subscriptions.first.payment_method_token.should == credit_card.token
-        found_card.subscriptions.first.price.should == BigDecimal("1.00")
+        expect(found_card.subscriptions.first.id).to eq(subscription.id)
+        expect(found_card.subscriptions.first.plan_id).to eq("integration_trialless_plan")
+        expect(found_card.subscriptions.first.payment_method_token).to eq(credit_card.token)
+        expect(found_card.subscriptions.first.price).to eq(BigDecimal("1.00"))
       end
     end
 
@@ -931,19 +1169,19 @@ describe Braintree::PaymentMethod do
         payment_method_token = make_token
         nonce = nonce_for_paypal_account(
           :consent_code => "consent-code",
-          :token => payment_method_token
+          :token => payment_method_token,
         )
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
-        result.should be_success
+        expect(result).to be_success
 
         paypal_account = Braintree::PaymentMethod.find(payment_method_token)
-        paypal_account.should be_a(Braintree::PayPalAccount)
-        paypal_account.token.should == payment_method_token
-        paypal_account.email.should == "jane.doe@example.com"
-        paypal_account.customer_id.should == customer.id
+        expect(paypal_account).to be_a(Braintree::PayPalAccount)
+        expect(paypal_account.token).to eq(payment_method_token)
+        expect(paypal_account.email).to eq("jane.doe@example.com")
+        expect(paypal_account.customer_id).to eq(customer.id)
       end
     end
 
@@ -954,21 +1192,46 @@ describe Braintree::PaymentMethod do
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx,
           :customer_id => customer.id,
-          :token => payment_method_token
+          :token => payment_method_token,
+        )
+        expect(result).to be_success
+
+        apple_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        expect(apple_pay_card).to be_a(Braintree::ApplePayCard)
+        expect(apple_pay_card).not_to be_nil
+        expect(apple_pay_card.token).to eq(payment_method_token)
+        expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::AmEx)
+        expect(apple_pay_card.default).to eq(true)
+        expect(apple_pay_card.image_url).to match(/apple_pay/)
+        expect(apple_pay_card.expiration_month.to_i).to be > 0
+        expect(apple_pay_card.expiration_year.to_i).to be > 0
+        expect(apple_pay_card.source_description).to eq("AmEx 41002")
+        expect(apple_pay_card.customer_id).to eq(customer.id)
+      end
+
+      it "finds the payment method with the given mpan token" do
+        customer = Braintree::Customer.create!
+        payment_method_token = make_token
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayMpan,
+          :customer_id => customer.id,
+          :token => payment_method_token,
         )
-        result.should be_success
+        expect(result).to be_success
 
         apple_pay_card = Braintree::PaymentMethod.find(payment_method_token)
-        apple_pay_card.should be_a(Braintree::ApplePayCard)
-        apple_pay_card.should_not be_nil
-        apple_pay_card.token.should == payment_method_token
-        apple_pay_card.card_type.should == Braintree::ApplePayCard::CardType::AmEx
-        apple_pay_card.default.should == true
-        apple_pay_card.image_url.should =~ /apple_pay/
-        apple_pay_card.expiration_month.to_i.should > 0
-        apple_pay_card.expiration_year.to_i.should > 0
-        apple_pay_card.source_description.should == "AmEx 41002"
-        apple_pay_card.customer_id.should == customer.id
+        expect(apple_pay_card).to be_a(Braintree::ApplePayCard)
+        expect(apple_pay_card).not_to be_nil
+        expect(apple_pay_card.token).to eq(payment_method_token)
+        expect(apple_pay_card.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
+        expect(apple_pay_card.default).to eq(true)
+        expect(apple_pay_card.image_url).to match(/apple_pay/)
+        expect(apple_pay_card.expiration_month.to_i).to be > 0
+        expect(apple_pay_card.expiration_year.to_i).to be > 0
+        expect(apple_pay_card.source_description).to eq("Visa 8886")
+        expect(apple_pay_card.customer_id).to eq(customer.id)
+        apple_pay_card.merchant_token_identifier == "DNITHE302308980427388297"
+        apple_pay_card.source_card_last4 == "2006"
       end
     end
 
@@ -979,76 +1242,78 @@ describe Braintree::PaymentMethod do
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => Braintree::Test::Nonce::VenmoAccount,
           :customer_id => customer.id,
-          :token => payment_method_token
+          :token => payment_method_token,
         )
-        result.should be_success
+        expect(result).to be_success
 
         venmo_account = Braintree::PaymentMethod.find(payment_method_token)
-        venmo_account.should be_a(Braintree::VenmoAccount)
-        venmo_account.should_not be_nil
-        venmo_account.token.should == payment_method_token
-        venmo_account.default.should == true
-        venmo_account.image_url.should =~ /venmo/
-        venmo_account.username.should == 'venmojoe'
-        venmo_account.venmo_user_id.should == 'Venmo-Joe-1'
-        venmo_account.source_description.should == "Venmo Account: venmojoe"
-        venmo_account.customer_id.should == customer.id
+        expect(venmo_account).to be_a(Braintree::VenmoAccount)
+        expect(venmo_account).not_to be_nil
+        expect(venmo_account.token).to eq(payment_method_token)
+        expect(venmo_account.default).to eq(true)
+        expect(venmo_account.image_url).to match(/venmo/)
+        expect(venmo_account.username).to eq("venmojoe")
+        expect(venmo_account.venmo_user_id).to eq("1234567891234567891")
+        expect(venmo_account.source_description).to eq("Venmo Account: venmojoe")
+        expect(venmo_account.customer_id).to eq(customer.id)
       end
     end
 
-    context "android pay cards" do
+    context "google pay cards" do
       it "finds the proxy card payment method with the given token" do
         customer = Braintree::Customer.create!
         payment_method_token = make_token
         result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
           :customer_id => customer.id,
-          :token => payment_method_token
-        )
-        result.should be_success
-
-        android_pay_card = Braintree::PaymentMethod.find(payment_method_token)
-        android_pay_card.should be_a(Braintree::AndroidPayCard)
-        android_pay_card.should_not be_nil
-        android_pay_card.token.should == payment_method_token
-        android_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.expiration_month.to_i.should > 0
-        android_pay_card.expiration_year.to_i.should > 0
-        android_pay_card.default.should == true
-        android_pay_card.image_url.should =~ /android_pay/
-        android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.source_card_last_4.should == "1111"
-        android_pay_card.google_transaction_id.should == "google_transaction_id"
-        android_pay_card.source_description.should == "Discover 1111"
-        android_pay_card.customer_id.should == customer.id
+          :token => payment_method_token,
+        )
+        expect(result).to be_success
+
+        google_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        expect(google_pay_card).to be_a(Braintree::GooglePayCard)
+        expect(google_pay_card).not_to be_nil
+        expect(google_pay_card.token).to eq(payment_method_token)
+        expect(google_pay_card.card_type).to eq(Braintree::CreditCard::CardType::Discover)
+        expect(google_pay_card.virtual_card_type).to eq(Braintree::CreditCard::CardType::Discover)
+        expect(google_pay_card.expiration_month.to_i).to be > 0
+        expect(google_pay_card.expiration_year.to_i).to be > 0
+        expect(google_pay_card.default).to eq(true)
+        expect(google_pay_card.image_url).to match(/android_pay/)
+        expect(google_pay_card.is_network_tokenized?).to eq(false)
+        expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::Discover)
+        expect(google_pay_card.source_card_last_4).to eq("1111")
+        expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
+        expect(google_pay_card.source_description).to eq("Discover 1111")
+        expect(google_pay_card.customer_id).to eq(customer.id)
       end
 
       it "finds the network token payment method with the given token" do
         customer = Braintree::Customer.create!
         payment_method_token = make_token
         result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayMasterCard,
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
           :customer_id => customer.id,
-          :token => payment_method_token
-        )
-        result.should be_success
-
-        android_pay_card = Braintree::PaymentMethod.find(payment_method_token)
-        android_pay_card.should be_a(Braintree::AndroidPayCard)
-        android_pay_card.should_not be_nil
-        android_pay_card.token.should == payment_method_token
-        android_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.expiration_month.to_i.should > 0
-        android_pay_card.expiration_year.to_i.should > 0
-        android_pay_card.default.should == true
-        android_pay_card.image_url.should =~ /android_pay/
-        android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.source_card_last_4.should == "4444"
-        android_pay_card.google_transaction_id.should == "google_transaction_id"
-        android_pay_card.source_description.should == "MasterCard 4444"
-        android_pay_card.customer_id.should == customer.id
+          :token => payment_method_token,
+        )
+        expect(result).to be_success
+
+        google_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        expect(google_pay_card).to be_a(Braintree::GooglePayCard)
+        expect(google_pay_card).not_to be_nil
+        expect(google_pay_card.token).to eq(payment_method_token)
+        expect(google_pay_card.card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+        expect(google_pay_card.virtual_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+        expect(google_pay_card.expiration_month.to_i).to be > 0
+        expect(google_pay_card.expiration_year.to_i).to be > 0
+        expect(google_pay_card.default).to eq(true)
+        expect(google_pay_card.image_url).to match(/android_pay/)
+        expect(google_pay_card.is_network_tokenized?).to eq(true)
+        expect(google_pay_card.source_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
+        expect(google_pay_card.source_card_last_4).to eq("4444")
+        expect(google_pay_card.google_transaction_id).to eq("google_transaction_id")
+        expect(google_pay_card.source_description).to eq("MasterCard 4444")
+        expect(google_pay_card.customer_id).to eq(customer.id)
       end
     end
 
@@ -1059,16 +1324,16 @@ describe Braintree::PaymentMethod do
         result = Braintree::PaymentMethod.create(
           :payment_method_nonce => Braintree::Test::Nonce::AbstractTransactable,
           :customer_id => customer.id,
-          :token => payment_method_token
+          :token => payment_method_token,
         )
-        result.should be_success
+        expect(result).to be_success
 
         payment_method = Braintree::PaymentMethod.find(payment_method_token)
-        payment_method.should_not be_nil
-        payment_method.token.should == payment_method_token
-        payment_method.image_url.should_not be_nil
-        payment_method.should be_a Braintree::UnknownPaymentMethod
-        payment_method.customer_id.should == customer.id
+        expect(payment_method).not_to be_nil
+        expect(payment_method.token).to eq(payment_method_token)
+        expect(payment_method.image_url).not_to be_nil
+        expect(payment_method).to be_a Braintree::UnknownPaymentMethod
+        expect(payment_method.customer_id).to eq(customer.id)
       end
     end
 
@@ -1080,21 +1345,21 @@ describe Braintree::PaymentMethod do
   end
 
   describe "self.delete" do
-    it "deletes an android pay card" do
+    it "deletes an google pay card" do
       customer = Braintree::Customer.create!
 
       create_result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
-        :customer_id => customer.id
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
+        :customer_id => customer.id,
       )
 
       token = create_result.payment_method.token
 
-      android_card = Braintree::PaymentMethod.find(token)
-      android_card.should be_a(Braintree::AndroidPayCard)
+      google_card = Braintree::PaymentMethod.find(token)
+      expect(google_card).to be_a(Braintree::GooglePayCard)
 
       delete_result = Braintree::PaymentMethod.delete(token)
-      delete_result.success?.should == true
+      expect(delete_result.success?).to eq(true)
 
       expect do
         Braintree::PaymentMethod.find(token)
@@ -1106,15 +1371,15 @@ describe Braintree::PaymentMethod do
 
       create_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       token = create_result.payment_method.token
 
       apple_pay_card = Braintree::PaymentMethod.find(token)
-      apple_pay_card.should be_a(Braintree::ApplePayCard)
+      expect(apple_pay_card).to be_a(Braintree::ApplePayCard)
 
       delete_result = Braintree::PaymentMethod.delete(token)
-      delete_result.success?.should == true
+      expect(delete_result.success?).to eq(true)
 
       expect do
         Braintree::PaymentMethod.find(token)
@@ -1127,18 +1392,18 @@ describe Braintree::PaymentMethod do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "PAYPAL_CONSENT_CODE",
-        :token => paypal_account_token
+        :token => paypal_account_token,
       )
       Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       paypal_account = Braintree::PaymentMethod.find(paypal_account_token)
-      paypal_account.should be_a(Braintree::PayPalAccount)
+      expect(paypal_account).to be_a(Braintree::PayPalAccount)
 
       result = Braintree::PaymentMethod.delete(paypal_account_token, {:revoke_all_grants => false})
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       expect do
         Braintree::PaymentMethod.find(paypal_account_token)
@@ -1160,11 +1425,11 @@ describe Braintree::PaymentMethod do
 
       Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       result = Braintree::PaymentMethod.delete(token)
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       expect do
         Braintree::PaymentMethod.find(token)
@@ -1173,7 +1438,6 @@ describe Braintree::PaymentMethod do
 
     it "raises a NotFoundError exception if payment method cannot be found" do
       token = make_token
-      customer = Braintree::Customer.create!
 
       expect do
         Braintree::PaymentMethod.delete(token)
@@ -1183,6 +1447,71 @@ describe Braintree::PaymentMethod do
 
   describe "self.update" do
     context "credit cards" do
+      it "throws validation error when passing invalid  pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "xx",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_transaction_id",
+          },
+          :options => {:verify_card => true},
+        )
+        expect(update_result).to_not be_success
+        error = update_result.errors.for(:verification).first
+        expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+        expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+      end
+
+      it "updates the credit card with three_d_secure pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => "02",
+            :cavv => "some_cavv",
+            :xid => "some_xid",
+            :three_d_secure_version => "1.0.2",
+            :authentication_response => "Y",
+            :directory_response => "Y",
+            :cavv_algorithm => "2",
+            :ds_transaction_id => "some_ds_transaction_id",
+          },
+          :options => {:verify_card => true},
+        )
+        expect(update_result.success?).to eq(true)
+        expect(update_result.payment_method).to eq(credit_card)
+        updated_credit_card = update_result.payment_method
+        expect(updated_credit_card.cardholder_name).to eq("New Holder")
+        expect(updated_credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+        expect(updated_credit_card.last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+        expect(updated_credit_card.expiration_date).to eq("06/2013")
+      end
+
       it "updates the credit card" do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(
@@ -1190,23 +1519,159 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :cardholder_name => "New Holder",
           :cvv => "456",
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "06/2013"
+          :expiration_date => "06/2013",
         )
-        update_result.success?.should == true
-        update_result.payment_method.should == credit_card
+        expect(update_result.success?).to eq(true)
+        expect(update_result.payment_method).to eq(credit_card)
         updated_credit_card = update_result.payment_method
-        updated_credit_card.cardholder_name.should == "New Holder"
-        updated_credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-        updated_credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-        updated_credit_card.expiration_date.should == "06/2013"
+        expect(updated_credit_card.cardholder_name).to eq("New Holder")
+        expect(updated_credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+        expect(updated_credit_card.last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+        expect(updated_credit_card.expiration_date).to eq("06/2013")
+      end
+
+      it "includes risk data when skip_advanced_fraud_checking is false" do
+        with_fraud_protection_enterprise_merchant do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(
+            credit_card.token,
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :skip_advanced_fraud_checking => false
+            },
+          )
+
+          expect(update_result).to be_success
+          verification = update_result.payment_method.verification
+          expect(verification.risk_data).not_to be_nil
+        end
       end
 
+      it "does not include risk data when skip_advanced_fraud_checking is true" do
+        with_fraud_protection_enterprise_merchant do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(
+            credit_card.token,
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :skip_advanced_fraud_checking => true
+            },
+          )
+
+          expect(update_result).to be_success
+          verification = update_result.payment_method.verification
+          expect(verification.risk_data).to be_nil
+        end
+      end
+
+      context "verification_currency_iso_code" do
+        it "validates verification_currency_iso_code and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "USD"},
+                                                         )
+          expect(update_result.success?).to eq(true)
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+        end
+
+        it "validates verification_currency_iso_code against the given verification_merchant_account_id and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "USD"},
+                                                         )
+          expect(update_result.success?).to eq(true)
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+          update_result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "GBP"},
+                                                         )
+          expect(update_result).to_not be_success
+          expect(update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount)
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code of the given verification merchant account id" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "GBP"},
+                                                         )
+          expect(update_result).to_not be_success
+          expect(update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount)
+        end
+      end
+
+
       context "billing address" do
         it "creates a new billing address by default" do
           customer = Braintree::Customer.create!
@@ -1216,18 +1681,18 @@ describe Braintree::PaymentMethod do
             :expiration_date => "05/2012",
             :billing_address => {
               :street_address => "123 Nigeria Ave"
-            }
+            },
           )
           update_result = Braintree::PaymentMethod.update(credit_card.token,
             :billing_address => {
               :region => "IL"
-            }
+            },
           )
-          update_result.success?.should == true
+          expect(update_result.success?).to eq(true)
           updated_credit_card = update_result.payment_method
-          updated_credit_card.billing_address.region.should == "IL"
-          updated_credit_card.billing_address.street_address.should == nil
-          updated_credit_card.billing_address.id.should_not == credit_card.billing_address.id
+          expect(updated_credit_card.billing_address.region).to eq("IL")
+          expect(updated_credit_card.billing_address.street_address).to eq(nil)
+          expect(updated_credit_card.billing_address.id).not_to eq(credit_card.billing_address.id)
         end
 
         it "updates the billing address if option is specified" do
@@ -1238,19 +1703,22 @@ describe Braintree::PaymentMethod do
             :expiration_date => "05/2012",
             :billing_address => {
               :street_address => "123 Nigeria Ave"
-            }
+            },
           )
           update_result = Braintree::PaymentMethod.update(credit_card.token,
             :billing_address => {
+              :international_phone => {:country_code => "1", :national_number => "3121234567"},
               :region => "IL",
               :options => {:update_existing => true}
-            }
+            },
           )
-          update_result.success?.should == true
+          expect(update_result.success?).to eq(true)
           updated_credit_card = update_result.payment_method
-          updated_credit_card.billing_address.region.should == "IL"
-          updated_credit_card.billing_address.street_address.should == "123 Nigeria Ave"
-          updated_credit_card.billing_address.id.should == credit_card.billing_address.id
+          expect(updated_credit_card.billing_address.international_phone[:country_code]).to eq("1")
+          expect(updated_credit_card.billing_address.international_phone[:national_number]).to eq("3121234567")
+          expect(updated_credit_card.billing_address.region).to eq("IL")
+          expect(updated_credit_card.billing_address.street_address).to eq("123 Nigeria Ave")
+          expect(updated_credit_card.billing_address.id).to eq(credit_card.billing_address.id)
         end
 
         it "updates the country via codes" do
@@ -1261,7 +1729,7 @@ describe Braintree::PaymentMethod do
             :expiration_date => "05/2012",
             :billing_address => {
               :street_address => "123 Nigeria Ave"
-            }
+            },
           )
           update_result = Braintree::PaymentMethod.update(credit_card.token,
             :billing_address => {
@@ -1270,14 +1738,14 @@ describe Braintree::PaymentMethod do
               :country_code_alpha3 => "ASM",
               :country_code_numeric => "016",
               :options => {:update_existing => true}
-            }
+            },
           )
-          update_result.success?.should == true
+          expect(update_result.success?).to eq(true)
           updated_credit_card = update_result.payment_method
-          updated_credit_card.billing_address.country_name.should == "American Samoa"
-          updated_credit_card.billing_address.country_code_alpha2.should == "AS"
-          updated_credit_card.billing_address.country_code_alpha3.should == "ASM"
-          updated_credit_card.billing_address.country_code_numeric.should == "016"
+          expect(updated_credit_card.billing_address.country_name).to eq("American Samoa")
+          expect(updated_credit_card.billing_address.country_code_alpha2).to eq("AS")
+          expect(updated_credit_card.billing_address.country_code_alpha3).to eq("ASM")
+          expect(updated_credit_card.billing_address.country_code_numeric).to eq("016")
         end
       end
 
@@ -1286,18 +1754,18 @@ describe Braintree::PaymentMethod do
         credit_card = Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
           :expiration_month => "07",
-          :expiration_year => "2011"
+          :expiration_year => "2011",
         )
-        update_result.success?.should == true
-        update_result.payment_method.should == credit_card
-        update_result.payment_method.expiration_month.should == "07"
-        update_result.payment_method.expiration_year.should == "2011"
-        update_result.payment_method.expiration_date.should == "07/2011"
+        expect(update_result.success?).to eq(true)
+        expect(update_result.payment_method).to eq(credit_card)
+        expect(update_result.payment_method.expiration_month).to eq("07")
+        expect(update_result.payment_method.expiration_year).to eq("2011")
+        expect(update_result.payment_method.expiration_date).to eq("07/2011")
       end
 
       it "verifies the update if options[verify_card]=true" do
@@ -1307,18 +1775,18 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :cardholder_name => "New Holder",
           :cvv => "456",
           :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::MasterCard,
           :expiration_date => "06/2013",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
-        update_result.success?.should == false
-        update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-        update_result.credit_card_verification.gateway_rejection_reason.should be_nil
+        expect(update_result.success?).to eq(false)
+        expect(update_result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+        expect(update_result.credit_card_verification.gateway_rejection_reason).to be_nil
       end
 
       it "accepts a custom verification amount" do
@@ -1328,16 +1796,16 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2020"
+          :expiration_date => "05/2020",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :payment_method_nonce => Braintree::Test::Nonce::ProcessorDeclinedMasterCard,
-          :options => {:verify_card => true, :verification_amount => "2.34"}
+          :options => {:verify_card => true, :verification_amount => "2.34"},
         )
-        update_result.success?.should == false
-        update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-        update_result.credit_card_verification.gateway_rejection_reason.should be_nil
-        update_result.credit_card_verification.amount.should == BigDecimal("2.34")
+        expect(update_result.success?).to eq(false)
+        expect(update_result.credit_card_verification.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
+        expect(update_result.credit_card_verification.gateway_rejection_reason).to be_nil
+        expect(update_result.credit_card_verification.amount).to eq(BigDecimal("2.34"))
       end
 
       it "can update the billing address" do
@@ -1358,7 +1826,7 @@ describe Braintree::PaymentMethod do
             :region => "Old State",
             :postal_code => "12345",
             :country_name => "Canada"
-          }
+          },
         )
         result = Braintree::PaymentMethod.update(credit_card.token,
           :options => {:verify_card => false},
@@ -1372,19 +1840,19 @@ describe Braintree::PaymentMethod do
             :region => "New State",
             :postal_code => "56789",
             :country_name => "United States of America"
-          }
+          },
         )
-        result.success?.should == true
+        expect(result.success?).to eq(true)
         address = result.payment_method.billing_address
-        address.first_name.should == "New First Name"
-        address.last_name.should == "New Last Name"
-        address.company.should == "New Company"
-        address.street_address.should == "123 New St"
-        address.extended_address.should == "Apt New"
-        address.locality.should == "New City"
-        address.region.should == "New State"
-        address.postal_code.should == "56789"
-        address.country_name.should == "United States of America"
+        expect(address.first_name).to eq("New First Name")
+        expect(address.last_name).to eq("New Last Name")
+        expect(address.company).to eq("New Company")
+        expect(address.street_address).to eq("123 New St")
+        expect(address.extended_address).to eq("Apt New")
+        expect(address.locality).to eq("New City")
+        expect(address.region).to eq("New State")
+        expect(address.postal_code).to eq("56789")
+        expect(address.country_name).to eq("United States of America")
       end
 
       it "returns an error response if invalid" do
@@ -1393,15 +1861,15 @@ describe Braintree::PaymentMethod do
           :cardholder_name => "Original Holder",
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
+          :expiration_date => "05/2012",
         )
         update_result = Braintree::PaymentMethod.update(credit_card.token,
           :cardholder_name => "New Holder",
           :number => "invalid",
-          :expiration_date => "05/2014"
+          :expiration_date => "05/2014",
         )
-        update_result.success?.should == false
-        update_result.errors.for(:credit_card).on(:number)[0].message.should == "Credit card number must be 12-19 digits."
+        expect(update_result.success?).to eq(false)
+        expect(update_result.errors.for(:credit_card).on(:number)[0].message).to eq("Credit card number must be 12-19 digits.")
       end
 
       it "can update the default" do
@@ -1409,37 +1877,21 @@ describe Braintree::PaymentMethod do
         card1 = Braintree::CreditCard.create(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
+          :expiration_date => "05/2009",
         ).credit_card
         card2 = Braintree::CreditCard.create(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
+          :expiration_date => "05/2009",
         ).credit_card
 
-        card1.should be_default
-        card2.should_not be_default
+        expect(card1).to be_default
+        expect(card2).not_to be_default
 
         Braintree::PaymentMethod.update(card2.token, :options => {:make_default => true})
 
-        Braintree::CreditCard.find(card1.token).should_not be_default
-        Braintree::CreditCard.find(card2.token).should be_default
-      end
-    end
-
-    context "coinbase accounts" do
-      it "cannot create a payment method token with Coinbase" do
-        customer = Braintree::Customer.create!
-
-        nonce = Braintree::Test::Nonce::Coinbase
-        result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => nonce,
-          :customer_id => customer.id
-        )
-
-        result.should_not be_success
-
-        result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
+        expect(Braintree::CreditCard.find(card1.token)).not_to be_default
+        expect(Braintree::CreditCard.find(card2.token)).to be_default
       end
     end
 
@@ -1449,21 +1901,21 @@ describe Braintree::PaymentMethod do
         original_token = random_payment_method_token
         nonce = nonce_for_paypal_account(
           :consent_code => "consent-code",
-          :token => original_token
+          :token => original_token,
         )
         original_result = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
         updated_token = make_token
-        updated_result = Braintree::PaymentMethod.update(
+        Braintree::PaymentMethod.update(
           original_token,
-          :token => updated_token
+          :token => updated_token,
         )
 
         updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
-        updated_paypal_account.email.should == original_result.payment_method.email
+        expect(updated_paypal_account.email).to eq(original_result.payment_method.email)
 
         expect do
           Braintree::PayPalAccount.find(original_token)
@@ -1476,23 +1928,23 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009",
-          :options => {:make_default => true}
+          :options => {:make_default => true},
         )
-        result.should be_success
+        expect(result).to be_success
 
         nonce = nonce_for_paypal_account(:consent_code => "consent-code")
         original_token = Braintree::PaymentMethod.create(
           :payment_method_nonce => nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         ).payment_method.token
 
-        updated_result = Braintree::PaymentMethod.update(
+        Braintree::PaymentMethod.update(
           original_token,
-          :options => {:make_default => true}
+          :options => {:make_default => true},
         )
 
         updated_paypal_account = Braintree::PayPalAccount.find(original_token)
-        updated_paypal_account.should be_default
+        expect(updated_paypal_account).to be_default
       end
 
       it "returns an error if a token for account is used to attempt an update" do
@@ -1502,29 +1954,29 @@ describe Braintree::PaymentMethod do
 
         first_nonce = nonce_for_paypal_account(
           :consent_code => "consent-code",
-          :token => first_token
+          :token => first_token,
         )
-        first_result = Braintree::PaymentMethod.create(
+        Braintree::PaymentMethod.create(
           :payment_method_nonce => first_nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
         second_nonce = nonce_for_paypal_account(
           :consent_code => "consent-code",
-          :token => second_token
+          :token => second_token,
         )
-        second_result = Braintree::PaymentMethod.create(
+        Braintree::PaymentMethod.create(
           :payment_method_nonce => second_nonce,
-          :customer_id => customer.id
+          :customer_id => customer.id,
         )
 
         updated_result = Braintree::PaymentMethod.update(
           first_token,
-          :token => second_token
+          :token => second_token,
         )
 
-        updated_result.should_not be_success
-        updated_result.errors.first.code.should == "92906"
+        expect(updated_result).not_to be_success
+        expect(updated_result.errors.first.code).to eq("92906")
       end
     end
   end
@@ -1537,19 +1989,19 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :cvv => "123",
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
       payment_method = Braintree::PaymentMethod.update!(credit_card.token,
         :cardholder_name => "New Holder",
         :cvv => "456",
         :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
+        :expiration_date => "06/2013",
       )
-      payment_method.should == credit_card
-      payment_method.cardholder_name.should == "New Holder"
-      payment_method.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      payment_method.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-      payment_method.expiration_date.should == "06/2013"
+      expect(payment_method).to eq(credit_card)
+      expect(payment_method.cardholder_name).to eq("New Holder")
+      expect(payment_method.bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(payment_method.last_4).to eq(Braintree::Test::CreditCardNumbers::MasterCard[-4..-1])
+      expect(payment_method.expiration_date).to eq("06/2013")
     end
   end
 
@@ -1560,7 +2012,7 @@ describe Braintree::PaymentMethod do
         :public_key => "oauth_app_partner_user_public_key",
         :private_key => "oauth_app_partner_user_private_key",
         :environment => Braintree::Configuration.environment,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
       customer = @partner_merchant_gateway.customer.create(
         :first_name => "Joe",
@@ -1569,19 +2021,19 @@ describe Braintree::PaymentMethod do
         :email => "joe@example.com",
         :phone => "312.555.1234",
         :fax => "614.555.5678",
-        :website => "www.example.com"
+        :website => "www.example.com",
       ).customer
       @credit_card = @partner_merchant_gateway.credit_card.create(
         :customer_id => customer.id,
         :cardholder_name => "Adam Davis",
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
+        :expiration_date => "05/2009",
       ).credit_card
 
       @oauth_gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
       access_token = Braintree::OAuthTestHelper.create_token(@oauth_gateway, {
         :merchant_public_id => "integration_merchant_id",
@@ -1590,31 +2042,31 @@ describe Braintree::PaymentMethod do
 
       @granting_gateway = Braintree::Gateway.new(
         :access_token => access_token,
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
     end
 
     describe "self.grant" do
       it "returns an error result when the grant doesn't succeed" do
         grant_result = @granting_gateway.payment_method.grant("payment_method_from_grant", true)
-        grant_result.should_not be_success
+        expect(grant_result).not_to be_success
       end
 
       it "returns a nonce that is transactable by a partner merchant exactly once" do
         grant_result = @granting_gateway.payment_method.grant(@credit_card.token, :allow_vaulting => false)
-        grant_result.should be_success
+        expect(grant_result).to be_success
 
         result = Braintree::Transaction.sale(
           :payment_method_nonce => grant_result.payment_method_nonce.nonce,
-          :amount => Braintree::Test::TransactionAmounts::Authorize
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
         )
-        result.should be_success
+        expect(result).to be_success
 
         result2 = Braintree::Transaction.sale(
           :payment_method_nonce => grant_result.payment_method_nonce.nonce,
-          :amount => Braintree::Test::TransactionAmounts::Authorize
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
         )
-        result2.should_not be_success
+        expect(result2).not_to be_success
       end
 
       it "returns a nonce that is not vaultable" do
@@ -1624,9 +2076,9 @@ describe Braintree::PaymentMethod do
 
         result = Braintree::PaymentMethod.create(
           :customer_id => customer_result.customer.id,
-          :payment_method_nonce => grant_result.payment_method_nonce.nonce
+          :payment_method_nonce => grant_result.payment_method_nonce.nonce,
         )
-        result.should_not be_success
+        expect(result).not_to be_success
       end
 
       it "returns a nonce that is vaultable" do
@@ -1636,21 +2088,21 @@ describe Braintree::PaymentMethod do
 
         result = Braintree::PaymentMethod.create(
           :customer_id => customer_result.customer.id,
-          :payment_method_nonce => grant_result.payment_method_nonce.nonce
+          :payment_method_nonce => grant_result.payment_method_nonce.nonce,
         )
-        result.should be_success
+        expect(result).to be_success
       end
 
       it "raises an error if the token isn't found" do
         expect do
           @granting_gateway.payment_method.grant("not_a_real_token", false)
-        end.to raise_error
+        end.to raise_error(Braintree::NotFoundError)
       end
 
       it "returns a valid nonce with no options set" do
         expect do
           grant_result = @granting_gateway.payment_method.grant(@credit_card.token)
-          grant_result.should be_success
+          expect(grant_result).to be_success
         end
       end
     end
@@ -1659,35 +2111,35 @@ describe Braintree::PaymentMethod do
       it "raises an error if the token isn't found" do
         expect do
           @granting_gateway.payment_method.revoke("not_a_real_token")
-        end.to raise_error
+        end.to raise_error(Braintree::NotFoundError)
       end
 
       it "renders a granted nonce useless" do
         grant_result = @granting_gateway.payment_method.grant(@credit_card.token)
         revoke_result = @granting_gateway.payment_method.revoke(@credit_card.token)
-        revoke_result.should be_success
+        expect(revoke_result).to be_success
 
         customer_result = Braintree::Customer.create()
 
         result = Braintree::PaymentMethod.create(
           :customer_id => customer_result.customer.id,
-          :payment_method_nonce => grant_result.payment_method_nonce.nonce
+          :payment_method_nonce => grant_result.payment_method_nonce.nonce,
         )
-        result.should_not be_success
+        expect(result).not_to be_success
       end
 
       it "renders a granted nonce obtained uisng options hash, useless" do
         grant_result = @granting_gateway.payment_method.grant(@credit_card.token, :allow_vaulting => true)
         revoke_result = @granting_gateway.payment_method.revoke(@credit_card.token)
-        revoke_result.should be_success
+        expect(revoke_result).to be_success
 
         customer_result = Braintree::Customer.create()
 
         result = Braintree::PaymentMethod.create(
           :customer_id => customer_result.customer.id,
-          :payment_method_nonce => grant_result.payment_method_nonce.nonce
+          :payment_method_nonce => grant_result.payment_method_nonce.nonce,
         )
-        result.should_not be_success
+        expect(result).not_to be_success
       end
     end
   end