braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/credit_card_spec.rb

@@ -15,17 +15,17 @@ describe Braintree::CreditCard 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)
       credit_card = result.credit_card
-      credit_card.token.should =~ /\A\w{4,}\z/
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      credit_card.expiration_date.should == "05/2009"
-      credit_card.unique_number_identifier.should =~ /\A\w{32}\z/
-      credit_card.venmo_sdk?.should == false
-      credit_card.image_url.should_not be_nil
+      expect(credit_card.token).to match(/\A\w{4,}\z/)
+      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.expiration_date).to eq("05/2009")
+      expect(credit_card.unique_number_identifier).to match(/\A\w{32}\z/)
+      expect(credit_card.venmo_sdk?).to eq(false)
+      expect(credit_card.image_url).not_to be_nil
     end
 
     it "supports creation of cards with security params" do
@@ -35,10 +35,9 @@ describe Braintree::CreditCard do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :device_session_id => "abc123",
-        :fraud_merchant_id => "7"
+        :device_data => "device_data",
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
 
     it "can provide expiration month and year separately" do
@@ -47,13 +46,13 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_month => "05",
-        :expiration_year => "2012"
+        :expiration_year => "2012",
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       credit_card = result.credit_card
-      credit_card.expiration_month.should == "05"
-      credit_card.expiration_year.should == "2012"
-      credit_card.expiration_date.should == "05/2012"
+      expect(credit_card.expiration_month).to eq("05")
+      expect(credit_card.expiration_year).to eq("2012")
+      expect(credit_card.expiration_date).to eq("05/2012")
     end
 
     it "can specify the desired token" do
@@ -64,14 +63,14 @@ describe Braintree::CreditCard do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :token => token
+        :token => token,
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       credit_card = result.credit_card
-      credit_card.token.should == token
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      credit_card.expiration_date.should == "05/2009"
+      expect(credit_card.token).to eq(token)
+      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.expiration_date).to eq("05/2009")
     end
 
     it "accepts billing_address_id" do
@@ -82,12 +81,12 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :billing_address_id => address.id
+        :billing_address_id => address.id,
       ).credit_card
 
-      credit_card.billing_address.id.should == address.id
-      credit_card.billing_address.first_name.should == "Bobby"
-      credit_card.billing_address.last_name.should == "Tables"
+      expect(credit_card.billing_address.id).to eq(address.id)
+      expect(credit_card.billing_address.first_name).to eq("Bobby")
+      expect(credit_card.billing_address.last_name).to eq("Tables")
     end
 
     it "accepts empty options hash" do
@@ -96,9 +95,9 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :options => {}
+        :options => {},
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
 
     it "verifies the credit card if options[verify_card]=true" do
@@ -107,16 +106,16 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :options => {:verify_card => true}
+        :options => {:verify_card => true},
       )
-      result.success?.should == false
-      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.cvv_response_code.should == "I"
-      result.credit_card_verification.avs_error_response_code.should == nil
-      result.credit_card_verification.avs_postal_code_response_code.should == "I"
-      result.credit_card_verification.avs_street_address_response_code.should == "I"
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::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.cvv_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_error_response_code).to eq(nil)
+      expect(result.credit_card_verification.avs_postal_code_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_street_address_response_code).to eq("I")
     end
 
     it "allows passing a specific verification amount" do
@@ -125,20 +124,20 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :options => {:verify_card => true, :verification_amount => "100.00"}
+        :options => {:verify_card => true, :verification_amount => "100.00"},
       )
-      result.success?.should == false
-      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.cvv_response_code.should == "I"
-      result.credit_card_verification.avs_error_response_code.should == nil
-      result.credit_card_verification.avs_postal_code_response_code.should == "I"
-      result.credit_card_verification.avs_street_address_response_code.should == "I"
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::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.cvv_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_error_response_code).to eq(nil)
+      expect(result.credit_card_verification.avs_postal_code_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_street_address_response_code).to eq("I")
     end
 
     it "returns risk data on verification on credit_card create" do
-      with_advanced_fraud_integration_merchant do
+      with_fraud_protection_enterprise_merchant do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(
           :cardholder_name => "Original Holder",
@@ -146,13 +145,57 @@ describe Braintree::CreditCard do
           :cvv => "123",
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2020",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         verification = credit_card.verification
-        verification.risk_data.should respond_to(:id)
-        verification.risk_data.should respond_to(:decision)
-        verification.risk_data.should respond_to(:device_data_captured)
-        verification.risk_data.should respond_to(:fraud_service_provider)
+        expect(verification.risk_data.id).not_to be_nil
+        expect(verification.risk_data.decision).not_to be_nil
+        expect(verification.risk_data.decision_reasons).not_to be_nil
+        expect(verification.risk_data).to respond_to(:device_data_captured)
+        expect(verification.risk_data).to respond_to(:fraud_service_provider)
+        expect(verification.risk_data).to respond_to(:transaction_risk_score)
+      end
+    end
+
+    it "includes risk data when skip_advanced_fraud_checking is false" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!
+        result = Braintree::CreditCard.create(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2020",
+          :options => {
+            :skip_advanced_fraud_checking => false,
+            :verify_card => true,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.credit_card.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!
+        result = Braintree::CreditCard.create(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2020",
+          :options => {
+            :skip_advanced_fraud_checking => true,
+            :verify_card => true,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.credit_card.verification
+        expect(verification.risk_data).to be_nil
       end
     end
 
@@ -172,10 +215,10 @@ describe Braintree::CreditCard do
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2009",
           :cvv => "200",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
-        result.success?.should == false
-        result.credit_card_verification.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::CVV
+        expect(result.success?).to eq(false)
+        expect(result.credit_card_verification.gateway_rejection_reason).to eq(Braintree::CreditCardVerification::GatewayRejectionReason::CVV)
       ensure
         Braintree::Configuration.merchant_id = old_merchant
         Braintree::Configuration.public_key = old_public_key
@@ -189,16 +232,16 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :options => {:verify_card => true, :verification_amount => "1.01"}
+        :options => {:verify_card => true, :verification_amount => "1.01"},
       )
-      result.success?.should == false
-      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.cvv_response_code.should == "I"
-      result.credit_card_verification.avs_error_response_code.should == nil
-      result.credit_card_verification.avs_postal_code_response_code.should == "I"
-      result.credit_card_verification.avs_street_address_response_code.should == "I"
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::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.cvv_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_error_response_code).to eq(nil)
+      expect(result.credit_card_verification.avs_postal_code_response_code).to eq("I")
+      expect(result.credit_card_verification.avs_street_address_response_code).to eq("I")
     end
 
     it "allows user to specify merchant account for verification" do
@@ -210,10 +253,10 @@ describe Braintree::CreditCard do
         :options => {
           :verify_card => true,
           :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
-        }
+        },
       )
-      result.success?.should == false
-      result.credit_card_verification.merchant_account_id.should == SpecHelper::NonDefaultMerchantAccountId
+      expect(result.success?).to eq(false)
+      expect(result.credit_card_verification.merchant_account_id).to eq(SpecHelper::NonDefaultMerchantAccountId)
     end
 
     it "does not verify the card if options[verify_card]=false" do
@@ -222,9 +265,51 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
         :expiration_date => "05/2009",
-        :options => {:verify_card => false}
+        :options => {:verify_card => false},
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
+    end
+
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.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",
+          :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::ThreeDSecureVersionIsRequired)
+      expect(error.message).to eq("ThreeDSecureVersion is required.")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.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},
+      )
+      expect(result.success?).to eq(true)
     end
 
     it "returns 3DS info on cc verification" do
@@ -232,20 +317,20 @@ describe Braintree::CreditCard do
       result = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
-        :options => {:verify_card => true}
+        :options => {:verify_card => true},
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
 
       three_d_secure_info = result.credit_card.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)
+      expect(three_d_secure_info.three_d_secure_authentication_id).to be_a(String)
     end
 
     it "adds credit card with billing address to customer" do
@@ -259,12 +344,12 @@ describe Braintree::CreditCard do
           :locality => "Chicago",
           :region => "Illinois",
           :postal_code => "60622"
-        }
+        },
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       credit_card = result.credit_card
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      credit_card.billing_address.street_address.should == "123 Abc Way"
+      expect(credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::MasterCard[0, 6])
+      expect(credit_card.billing_address.street_address).to eq("123 Abc Way")
     end
 
     it "adds credit card with billing using country_code" do
@@ -278,14 +363,14 @@ describe Braintree::CreditCard do
           :country_code_alpha2 => "US",
           :country_code_alpha3 => "USA",
           :country_code_numeric => "840"
-        }
+        },
       )
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       credit_card = result.credit_card
-      credit_card.billing_address.country_name.should == "United States of America"
-      credit_card.billing_address.country_code_alpha2.should == "US"
-      credit_card.billing_address.country_code_alpha3.should == "USA"
-      credit_card.billing_address.country_code_numeric.should == "840"
+      expect(credit_card.billing_address.country_name).to eq("United States of America")
+      expect(credit_card.billing_address.country_code_alpha2).to eq("US")
+      expect(credit_card.billing_address.country_code_alpha3).to eq("USA")
+      expect(credit_card.billing_address.country_code_numeric).to eq("840")
     end
 
     it "returns an error when given inconsistent country information" do
@@ -297,10 +382,10 @@ describe Braintree::CreditCard do
         :billing_address => {
           :country_name => "Mexico",
           :country_code_alpha2 => "US"
-        }
+        },
       )
-      result.success?.should == false
-      result.errors.for(:credit_card).for(:billing_address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:credit_card).for(:billing_address).on(:base).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error response if unsuccessful" do
@@ -308,10 +393,10 @@ describe Braintree::CreditCard do
       result = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "invalid_date"
+        :expiration_date => "invalid_date",
       )
-      result.success?.should == false
-      result.errors.for(:credit_card).on(:expiration_date)[0].message.should == "Expiration date is invalid."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:credit_card).on(:expiration_date)[0].message).to eq("Expiration date is invalid.")
     end
 
     it "can set the default flag" do
@@ -319,9 +404,9 @@ describe Braintree::CreditCard do
       card1 = 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
+      expect(card1).to be_default
 
       card2 = Braintree::CreditCard.create(
         :customer_id => customer.id,
@@ -329,11 +414,26 @@ describe Braintree::CreditCard do
         :expiration_date => "05/2009",
         :options => {
           :make_default => true
-        }
+        },
       ).credit_card
-      card2.should be_default
+      expect(card2).to be_default
 
-      Braintree::CreditCard.find(card1.token).should_not be_default
+      expect(Braintree::CreditCard.find(card1.token)).not_to be_default
+    end
+
+    it "can set the network transaction identifier when creating a credit card" do
+      customer = Braintree::Customer.create!
+
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+        :external_vault => {
+          :network_transaction_id => "MCC123456789",
+        },
+      )
+
+      expect(result.success?).to eq(true)
     end
 
     context "card type indicators" do
@@ -343,10 +443,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+        expect(credit_card.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
       end
 
       it "sets the healthcare field if the card is healthcare" do
@@ -355,11 +455,11 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Healthcare,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.healthcare.should == Braintree::CreditCard::Healthcare::Yes
-        credit_card.product_id.should == "J3"
+        expect(credit_card.healthcare).to eq(Braintree::CreditCard::Healthcare::Yes)
+        expect(credit_card.product_id).to eq("J3")
       end
 
       it "sets the durbin regulated field if the card is durbin regulated" do
@@ -368,10 +468,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::DurbinRegulated,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
+        expect(credit_card.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Yes)
       end
 
       it "sets the country of issuance field" do
@@ -380,10 +480,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::CountryOfIssuance,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.country_of_issuance.should == Braintree::Test::CreditCardDefaults::CountryOfIssuance
+        expect(credit_card.country_of_issuance).to eq(Braintree::Test::CreditCardDefaults::CountryOfIssuance)
       end
 
       it "sets the issuing bank field" do
@@ -392,10 +492,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::IssuingBank,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.issuing_bank.should == Braintree::Test::CreditCardDefaults::IssuingBank
+        expect(credit_card.issuing_bank).to eq(Braintree::Test::CreditCardDefaults::IssuingBank)
       end
 
       it "sets the payroll field if the card is payroll" do
@@ -404,11 +504,11 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Payroll,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.payroll.should == Braintree::CreditCard::Payroll::Yes
-        credit_card.product_id.should == "MSA"
+        expect(credit_card.payroll).to eq(Braintree::CreditCard::Payroll::Yes)
+        expect(credit_card.product_id).to eq("MSA")
       end
 
       it "sets the debit field if the card is debit" do
@@ -417,10 +517,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Debit,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.debit.should == Braintree::CreditCard::Debit::Yes
+        expect(credit_card.debit).to eq(Braintree::CreditCard::Debit::Yes)
       end
 
       it "sets the commercial field if the card is commercial" do
@@ -429,10 +529,10 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Commercial,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.commercial.should == Braintree::CreditCard::Commercial::Yes
+        expect(credit_card.commercial).to eq(Braintree::CreditCard::Commercial::Yes)
       end
 
       it "sets negative card type identifiers" do
@@ -441,16 +541,16 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::No,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.prepaid.should == Braintree::CreditCard::Prepaid::No
-        credit_card.commercial.should == Braintree::CreditCard::Prepaid::No
-        credit_card.payroll.should == Braintree::CreditCard::Prepaid::No
-        credit_card.debit.should == Braintree::CreditCard::Prepaid::No
-        credit_card.durbin_regulated.should == Braintree::CreditCard::Prepaid::No
-        credit_card.healthcare.should == Braintree::CreditCard::Prepaid::No
-        credit_card.product_id.should == "MSB"
+        expect(credit_card.prepaid).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.commercial).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.payroll).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.debit).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.durbin_regulated).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.healthcare).to eq(Braintree::CreditCard::Prepaid::No)
+        expect(credit_card.product_id).to eq("MSB")
       end
 
       it "doesn't set the card type identifiers for an un-identified card" do
@@ -459,81 +559,21 @@ describe Braintree::CreditCard do
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Unknown,
           :expiration_date => "05/2014",
-          :options => {:verify_card => true}
+          :options => {:verify_card => true},
         )
         credit_card = result.credit_card
-        credit_card.prepaid.should == Braintree::CreditCard::Prepaid::Unknown
-        credit_card.commercial.should == Braintree::CreditCard::Prepaid::Unknown
-        credit_card.payroll.should == Braintree::CreditCard::Prepaid::Unknown
-        credit_card.debit.should == Braintree::CreditCard::Prepaid::Unknown
-        credit_card.durbin_regulated.should == Braintree::CreditCard::Prepaid::Unknown
-        credit_card.healthcare.should == Braintree::CreditCard::Prepaid::Unknown
+        expect(credit_card.prepaid).to eq(Braintree::CreditCard::Prepaid::Unknown)
+        expect(credit_card.commercial).to eq(Braintree::CreditCard::Prepaid::Unknown)
+        expect(credit_card.payroll).to eq(Braintree::CreditCard::Prepaid::Unknown)
+        expect(credit_card.debit).to eq(Braintree::CreditCard::Prepaid::Unknown)
+        expect(credit_card.durbin_regulated).to eq(Braintree::CreditCard::Prepaid::Unknown)
+        expect(credit_card.healthcare).to eq(Braintree::CreditCard::Prepaid::Unknown)
         credit_card.country_of_issuance == Braintree::CreditCard::CountryOfIssuance::Unknown
         credit_card.issuing_bank == Braintree::CreditCard::IssuingBank::Unknown
         credit_card.product_id == Braintree::CreditCard::ProductId::Unknown
       end
     end
 
-    context "venmo_sdk" do
-      describe "venmo_sdk_payment_method_code" do
-        it "can pass a venmo sdk payment method code" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-          result.credit_card.bin.should == "400934"
-          result.credit_card.last_4.should == "1881"
-        end
-
-        it "success? returns false when given an invalid venmo sdk payment method code" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode
-          )
-
-          result.success?.should == false
-          result.message.should == "Invalid VenmoSDK payment method code"
-          result.errors.first.code.should == "91727"
-        end
-      end
-
-      describe "venmo_sdk_session" do
-        it "venmo_sdk? returns true when given a valid session" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009",
-            :cvv => "100",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-            }
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-        end
-
-        it "venmo_sdk? returns false when given an invalid session" do
-          customer = Braintree::Customer.create!
-          result = Braintree::CreditCard.create(
-            :customer_id => customer.id,
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "05/2009",
-            :cvv => "100",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
-            }
-          )
-          result.success?.should == true
-          result.credit_card.venmo_sdk?.should == false
-        end
-      end
-    end
-
     context "client API" do
       it "adds credit card to an existing customer using a payment method nonce" do
         nonce = nonce_for_new_payment_method(
@@ -542,19 +582,19 @@ describe Braintree::CreditCard do
             :expiration_month => "11",
             :expiration_year => "2099",
           },
-          :share => true
+          :share => true,
         )
         customer = Braintree::Customer.create!
         result = Braintree::CreditCard.create(
           :customer_id => customer.id,
-          :payment_method_nonce => nonce
+          :payment_method_nonce => nonce,
         )
 
-        result.success?.should == true
+        expect(result.success?).to eq(true)
         credit_card = result.credit_card
-        credit_card.bin.should == "411111"
-        credit_card.last_4.should == "1111"
-        credit_card.expiration_date.should == "11/2099"
+        expect(credit_card.bin).to eq("411111")
+        expect(credit_card.last_4).to eq("1111")
+        expect(credit_card.expiration_date).to eq("11/2099")
       end
     end
 
@@ -566,9 +606,9 @@ describe Braintree::CreditCard do
           :number => Braintree::Test::CreditCardNumbers::Elo,
           :expiration_date => "10/2020",
         )
-        result.success?.should == true
+        expect(result.success?).to eq(true)
         credit_card = result.credit_card
-        credit_card.card_type.should == Braintree::CreditCard::CardType::Elo
+        expect(credit_card.card_type).to eq(Braintree::CreditCard::CardType::Elo)
       end
     end
 
@@ -582,9 +622,9 @@ describe Braintree::CreditCard do
           :expiration_year => "2099",
           :options => {
             :verify_card => true,
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
             :verification_account_type => "debit",
-          }
+          },
         )
 
         expect(result).to be_success
@@ -601,14 +641,13 @@ describe Braintree::CreditCard do
             :verify_card => true,
             :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
             :verification_account_type => "credit",
-          }
+          },
         )
 
         expect(result).to be_success
       end
 
       it "errors with invalid account_type" do
-        customer = Braintree::Customer.create!
         result = Braintree::CreditCard.create(
           :number => Braintree::Test::CreditCardNumbers::Hiper,
           :expiration_month => "11",
@@ -617,7 +656,7 @@ describe Braintree::CreditCard do
             :verify_card => true,
             :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
             :verification_account_type => "ach",
-          }
+          },
         )
 
         expect(result).to_not be_success
@@ -625,7 +664,6 @@ describe Braintree::CreditCard do
       end
 
       it "errors when account_type not supported by merchant" do
-        customer = Braintree::Customer.create!
         result = Braintree::CreditCard.create(
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_month => "11",
@@ -633,7 +671,7 @@ describe Braintree::CreditCard do
           :options => {
             :verify_card => true,
             :verification_account_type => "credit",
-          }
+          },
         )
 
         expect(result).to_not be_success
@@ -649,12 +687,12 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :cardholder_name => "Adam Davis",
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
+        :expiration_date => "05/2009",
       )
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      credit_card.cardholder_name.should == "Adam Davis"
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      credit_card.expiration_date.should == "05/2009"
+      expect(credit_card.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(credit_card.cardholder_name).to eq("Adam Davis")
+      expect(credit_card.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(credit_card.expiration_date).to eq("05/2009")
     end
 
     it "raises a ValidationsFailed if unsuccessful" do
@@ -663,32 +701,34 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "invalid_date"
+          :expiration_date => "invalid_date",
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end
 
+  # NEXT_MAJOR_VERSION remove this test
+  # CreditCard.credit has been deprecated in favor of Transaction.credit
   describe "self.credit" do
     it "creates a credit transaction using the payment method token, returning a result object" do
       customer = Braintree::Customer.create!(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::CreditCard.credit(
         customer.credit_cards[0].token,
-        :amount => "100.00"
+        :amount => "100.00",
       )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "credit"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("credit")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(result.transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(result.transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -698,108 +738,19 @@ describe Braintree::CreditCard do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction = Braintree::CreditCard.credit!(
         customer.credit_cards[0].token,
-        :amount => "100.00"
-      )
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "credit"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "self.create_from_transparent_redirect" do
-    it "returns a successful result if successful" do
-      result = Braintree::Customer.create
-      result.success?.should == true
-      customer = result.customer
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      credit_card = result.credit_card
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      credit_card.cardholder_name.should == "Card Holder"
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      credit_card.expiration_month.should == "05"
-      credit_card.expiration_year.should == "2012"
-      credit_card.expiration_date.should == "05/2012"
-      credit_card.customer_id.should == customer.id
-    end
-
-    it "create card as default" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
+        :amount => "100.00",
       )
-      card1 = customer.credit_cards[0]
-
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012",
-          :options => {:make_default => true}
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      card2 = result.credit_card
-
-      Braintree::CreditCard.find(card1.token).should_not be_default
-      card2.should be_default
-    end
-
-    it "returns xml with nested errors if validation errors" do
-      customer = Braintree::Customer.create.customer
-      params =  {
-        :credit_card => {
-          :cardholder_name => "Card Holder",
-          :number => "eleventy",
-          :expiration_date => "y2k"
-        }
-      }
-      tr_data_params = {
-        :credit_card => {
-          :customer_id => customer.id
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.create_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.create_credit_card_url)
-      result = Braintree::CreditCard.create_from_transparent_redirect(query_string_response)
-      result.success?.should == false
-      result.params[:customer_id] == customer.id
-      result.params[:credit_card]["cardholder_name"] == customer.id
-      result.params[:credit_card]["number"] == "eleventy"
-      result.params[:credit_card]["exipiration_date"] == "y2k"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("credit")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
@@ -811,21 +762,124 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :cvv => "123",
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
       update_result = Braintree::CreditCard.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.credit_card.should == credit_card
+      expect(update_result.success?).to eq(true)
+      expect(update_result.credit_card).to eq(credit_card)
       updated_credit_card = update_result.credit_card
-      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"
-      updated_credit_card.cardholder_name.should == "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")
+      expect(updated_credit_card.cardholder_name).to eq("New Holder")
+    end
+
+    it "validates presence of three_d_secure_version in 3ds pass thru params" 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",
+      )
+      result = Braintree::CreditCard.update(credit_card.token,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => "05",
+          :cavv => "some_cavv",
+          :xid => "some_xid",
+          :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::ThreeDSecureVersionIsRequired)
+      expect(error.message).to eq("ThreeDSecureVersion is required.")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" 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",
+      )
+      result = Braintree::CreditCard.update(credit_card.token,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => "05",
+          :cavv => "some_cavv",
+          :three_d_secure_version=> "2.1.0",
+          :xid => "some_xid",
+          :authentication_response => "Y",
+          :directory_response => "Y",
+          :cavv_algorithm => "2",
+          :ds_transaction_id => "some_ds_transaction_id",
+        },
+        :options => {:verify_card => true},
+      )
+
+      expect(result.success?).to eq(true)
+    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!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2020",
+        )
+        updated_result = Braintree::CreditCard.update(credit_card.token,
+          :expiration_date => "05/2021",
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => false,
+          },
+        )
+
+        expect(updated_result).to be_success
+        verification = updated_result.credit_card.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!(
+          :cardholder_name => "Original Holder",
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2020",
+        )
+        updated_result = Braintree::CreditCard.update(credit_card.token,
+          :expiration_date => "05/2021",
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => true,
+          },
+        )
+
+        expect(updated_result).to be_success
+        verification = updated_result.credit_card.verification
+        expect(verification.risk_data).to be_nil
+      end
     end
 
     context "billing address" do
@@ -837,18 +891,18 @@ describe Braintree::CreditCard do
           :expiration_date => "05/2012",
           :billing_address => {
             :street_address => "123 Nigeria Ave"
-          }
+          },
         )
         update_result = Braintree::CreditCard.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.credit_card
-        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
@@ -859,19 +913,19 @@ describe Braintree::CreditCard do
           :expiration_date => "05/2012",
           :billing_address => {
             :street_address => "123 Nigeria Ave"
-          }
+          },
         )
         update_result = Braintree::CreditCard.update(credit_card.token,
           :billing_address => {
             :region => "IL",
             :options => {:update_existing => true}
-          }
+          },
         )
-        update_result.success?.should == true
+        expect(update_result.success?).to eq(true)
         updated_credit_card = update_result.credit_card
-        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.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
@@ -882,7 +936,7 @@ describe Braintree::CreditCard do
           :expiration_date => "05/2012",
           :billing_address => {
             :street_address => "123 Nigeria Ave"
-          }
+          },
         )
         update_result = Braintree::CreditCard.update(credit_card.token,
           :billing_address => {
@@ -891,14 +945,14 @@ describe Braintree::CreditCard 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.credit_card
-        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
 
@@ -907,18 +961,18 @@ describe Braintree::CreditCard 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::CreditCard.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.credit_card.should == credit_card
-      update_result.credit_card.expiration_month.should == "07"
-      update_result.credit_card.expiration_year.should == "2011"
-      update_result.credit_card.expiration_date.should == "07/2011"
+      expect(update_result.success?).to eq(true)
+      expect(update_result.credit_card).to eq(credit_card)
+      expect(update_result.credit_card.expiration_month).to eq("07")
+      expect(update_result.credit_card.expiration_year).to eq("2011")
+      expect(update_result.credit_card.expiration_date).to eq("07/2011")
     end
 
     it "verifies the update if options[verify_card]=true" do
@@ -928,18 +982,18 @@ describe Braintree::CreditCard do
         :customer_id => customer.id,
         :cvv => "123",
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
       update_result = Braintree::CreditCard.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::CreditCardVerification::Status::ProcessorDeclined)
+      expect(update_result.credit_card_verification.gateway_rejection_reason).to be_nil
     end
 
     it "can update the billing address" do
@@ -960,7 +1014,7 @@ describe Braintree::CreditCard do
           :region => "Old State",
           :postal_code => "12345",
           :country_name => "Canada"
-        }
+        },
       )
       result = Braintree::CreditCard.update(credit_card.token,
         :options => {:verify_card => false},
@@ -974,19 +1028,19 @@ describe Braintree::CreditCard 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.credit_card.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
@@ -995,15 +1049,15 @@ describe Braintree::CreditCard 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::CreditCard.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
@@ -1011,21 +1065,21 @@ describe Braintree::CreditCard 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::CreditCard.update(card2.token, :options => {:make_default => true})
 
-      Braintree::CreditCard.find(card1.token).should_not be_default
-      Braintree::CreditCard.find(card2.token).should be_default
+      expect(Braintree::CreditCard.find(card1.token)).not_to be_default
+      expect(Braintree::CreditCard.find(card2.token)).to be_default
     end
 
     context "verification_account_type" do
@@ -1059,7 +1113,7 @@ describe Braintree::CreditCard do
           :options => {
             :verify_card => true,
             :verification_account_type => "debit",
-            :verification_merchant_account_id => SpecHelper::HiperBRLMerchantAccountId,
+            :verification_merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
           },
         )
         expect(update_result).to be_success
@@ -1074,19 +1128,19 @@ describe Braintree::CreditCard do
         :cardholder_name => "Original Holder",
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
       updated_credit_card = Braintree::CreditCard.update!(credit_card.token,
         :cardholder_name => "New Holder",
         :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
+        :expiration_date => "06/2013",
       )
-      updated_credit_card.token.should == credit_card.token
-      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"
-      updated_credit_card.cardholder_name.should == "New Holder"
-      updated_credit_card.updated_at.between?(Time.now - 60, Time.now).should == true
+      expect(updated_credit_card.token).to eq(credit_card.token)
+      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")
+      expect(updated_credit_card.cardholder_name).to eq("New Holder")
+      expect(updated_credit_card.updated_at.between?(Time.now - 60, Time.now)).to eq(true)
     end
 
     it "raises a ValidationsFailed if invalid" do
@@ -1095,156 +1149,30 @@ describe Braintree::CreditCard do
         :cardholder_name => "Original Holder",
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
+        :expiration_date => "05/2012",
       )
       expect do
         Braintree::CreditCard.update!(credit_card.token,
           :cardholder_name => "New Holder",
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "invalid/date"
+          :expiration_date => "invalid/date",
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
   end
 
-  describe "self.update_from_transparent_redirect" do
-    it "updates the credit card" do
-      old_token = "token_#{rand(10**10)}"
-      new_token = "token_#{rand(10**10)}"
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012",
-          :token => old_token
-        }
-      )
-      credit_card = customer.credit_cards[0]
-      params = {
-        :credit_card => {
-          :cardholder_name => "New Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "05/2014"
-        }
-      }
-      tr_data_params = {
-        :payment_method_token => old_token,
-        :credit_card => {
-          :token => new_token
-        }
-      }
-      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.update_credit_card_url)
-      result = Braintree::CreditCard.update_from_transparent_redirect(query_string_response)
-      result.success?.should == true
-      credit_card = result.credit_card
-      credit_card.cardholder_name.should == "New Cardholder Name"
-      credit_card.masked_number.should == "555555******4444"
-      credit_card.expiration_date.should == "05/2014"
-      credit_card.token.should == new_token
-    end
-
-    it "updates the default credit card" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :cardholder_name => "Old Cardholder Name",
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2012"
-        }
-      )
-      card1 = customer.credit_cards[0]
-
-      card2 = Braintree::CreditCard.create(
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
-      ).credit_card
-
-      card1.should be_default
-      card2.should_not be_default
-
-      params = {
-        :credit_card => {
-          :options => {:make_default => true}
-        }
-      }
-      tr_data_params = {
-        :payment_method_token => card2.token
-      }
-      tr_data = Braintree::TransparentRedirect.update_credit_card_data({:redirect_url => "http://example.com"}.merge(tr_data_params))
-      query_string_response = SpecHelper.simulate_form_post_for_tr(tr_data, params, Braintree::CreditCard.update_credit_card_url)
-      result = Braintree::CreditCard.update_from_transparent_redirect(query_string_response)
-
-      Braintree::CreditCard.find(card1.token).should_not be_default
-      Braintree::CreditCard.find(card2.token).should be_default
-    end
-  end
-
-  describe "credit" do
-    it "creates a credit transaction using the customer, returning a result object" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      result = customer.credit_cards[0].credit(
-        :amount => "100.00"
-      )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "credit"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "credit!" do
-    it "returns the created credit tranaction if valid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      transaction = customer.credit_cards[0].credit!(:amount => "100.00")
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "credit"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-
-    it "raises a ValidationsFailed if invalid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      expect do
-        customer.credit_cards[0].credit!(:amount => "invalid")
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.delete" do
     it "deletes the credit card" do
       customer = Braintree::Customer.create.customer
       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 = result.credit_card
-      Braintree::CreditCard.delete(credit_card.token).should == true
+      expect(Braintree::CreditCard.delete(credit_card.token)).to eq(true)
       expect do
         Braintree::CreditCard.find(credit_card.token)
       end.to raise_error(Braintree::NotFoundError)
@@ -1259,18 +1187,18 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "01/2015"
+          :expiration_date => "01/#{Time.now.year - 3}",
         )
       end
 
       collection = Braintree::CreditCard.expired
-      collection.maximum_size.should > 100
+      expect(collection.maximum_size).to be > 100
 
       credit_card_ids = collection.map do |c|
-        c.expired?.should == true
+        expect(c.expired?).to eq(true)
         c.token
       end.uniq.compact
-      credit_card_ids.size.should == collection.maximum_size
+      expect(credit_card_ids.size).to eq(collection.maximum_size)
     end
   end
 
@@ -1278,9 +1206,9 @@ describe Braintree::CreditCard do
     it "finds payment methods expiring between the given dates" do
       next_year = Time.now.year + 1
       collection = Braintree::CreditCard.expiring_between(Time.mktime(next_year, 1), Time.mktime(next_year, 12))
-      collection.maximum_size.should > 0
-      collection.all? { |pm| pm.expired?.should == false }
-      collection.all? { |pm| pm.expiration_year.should == next_year.to_s }
+      expect(collection.maximum_size).to be > 0
+      collection.all? { |pm| expect(pm.expired?).to eq(false) }
+      collection.all? { |pm| expect(pm.expiration_year).to eq(next_year.to_s) }
     end
 
     it "can iterate over all items" do
@@ -1290,15 +1218,15 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.create!(
           :customer_id => customer.id,
           :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "01/2010"
+          :expiration_date => "01/2010",
         )
       end
 
       collection = Braintree::CreditCard.expiring_between(Time.mktime(2010, 1, 1), Time.mktime(2010,3, 1))
-      collection.maximum_size.should > 100
+      expect(collection.maximum_size).to be > 100
 
-      credit_card_ids = collection.map {|c| c.token }.uniq.compact
-      credit_card_ids.size.should == collection.maximum_size
+      credit_card_ids = collection.map { |c| c.token }.uniq.compact
+      expect(credit_card_ids.size).to eq(collection.maximum_size)
     end
   end
 
@@ -1308,14 +1236,14 @@ describe Braintree::CreditCard 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::CreditCard.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
@@ -1323,20 +1251,20 @@ describe Braintree::CreditCard 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::CreditCard.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
 
     it "raises a NotFoundError exception if payment method cannot be found" do
@@ -1373,12 +1301,12 @@ describe Braintree::CreditCard do
           :expiration_month => "11",
           :expiration_year => "2099",
         },
-        :client_token_options => {:customer_id => customer.id}
+        :client_token_options => {:customer_id => customer.id},
       )
 
       credit_card = Braintree::CreditCard.from_nonce(nonce)
       customer = Braintree::Customer.find(customer.id)
-      credit_card.should == customer.credit_cards.first
+      expect(credit_card).to eq(customer.credit_cards.first)
     end
 
     it "does not find a payment method for an unlocked nonce that points to a shared credit card" do
@@ -1387,7 +1315,7 @@ describe Braintree::CreditCard do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
       expect do
         Braintree::CreditCard.from_nonce(nonce)
@@ -1402,7 +1330,7 @@ describe Braintree::CreditCard do
           :expiration_month => "11",
           :expiration_year => "2099",
         },
-        :client_token_options => {:customer_id => customer.id}
+        :client_token_options => {:customer_id => customer.id},
       )
 
       Braintree::CreditCard.from_nonce(nonce)
@@ -1412,24 +1340,26 @@ describe Braintree::CreditCard do
     end
   end
 
+  # NEXT_MAJOR_VERSION remove these tests
+  # CreditCard.sale has been deprecated in favor of Transaction.sale
   describe "self.sale" do
     it "creates a sale transaction using the credit card, returning a result object" do
       customer = Braintree::Customer.create!(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::CreditCard.sale(customer.credit_cards[0].token, :amount => "100.00")
 
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(result.transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(result.transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
 
     it "allows passing a cvv in addition to the token" do
@@ -1437,303 +1367,74 @@ describe Braintree::CreditCard do
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       result = Braintree::CreditCard.sale(customer.credit_cards[0].token,
         :amount => "100.00",
         :credit_card => {
           :cvv => "301"
-        }
+        },
       )
 
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.cvv_response_code.should == "S"
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(result.transaction.cvv_response_code).to eq("S")
     end
   end
 
+  # NEXT_MAJOR_VERSION remove this test
+  # CreditCard.sale has been deprecated in favor of Transaction.sale
   describe "self.sale!" do
     it "creates a sale transaction using the credit card, returning the transaction" do
       customer = Braintree::Customer.create!(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::Visa,
           :expiration_date => "05/2010"
-        }
+        },
       )
       transaction = Braintree::CreditCard.sale!(customer.credit_cards[0].token, :amount => "100.00")
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.credit_card_details.token).to eq(customer.credit_cards[0].token)
+      expect(transaction.credit_card_details.bin).to eq(Braintree::Test::CreditCardNumbers::Visa[0, 6])
+      expect(transaction.credit_card_details.last_4).to eq(Braintree::Test::CreditCardNumbers::Visa[-4..-1])
+      expect(transaction.credit_card_details.expiration_date).to eq("05/2010")
     end
   end
 
-  describe "sale" do
-    it "creates a sale transaction using the credit card, returning a result object" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      result = customer.credit_cards[0].sale(
-        :amount => "100.00"
-      )
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      result.transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      result.transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      result.transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-  end
-
-  describe "sale!" do
-    it "returns the created sale tranaction if valid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      transaction = customer.credit_cards[0].sale!(:amount => "100.00")
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.credit_card_details.token.should == customer.credit_cards[0].token
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
-      transaction.credit_card_details.expiration_date.should == "05/2010"
-    end
-
-    it "raises a ValidationsFailed if invalid" do
-      customer = Braintree::Customer.create!(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2010"
-        }
-      )
-      expect do
-        customer.credit_cards[0].sale!(:amount => "invalid")
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  describe "update" do
-    it "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 = credit_card.update(
-        :cardholder_name => "New Holder",
-        :cvv => "456",
-        :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
-      )
-      update_result.success?.should == true
-      update_result.credit_card.should == credit_card
-      updated_credit_card = update_result.credit_card
-      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"
-      updated_credit_card.cardholder_name.should == "New Holder"
-    end
-
-    it "verifies the update if options[verify_card]=true" 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 = credit_card.update(
-        :cardholder_name => "New Holder",
-        :cvv => "456",
-        :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::MasterCard,
-        :expiration_date => "06/2013",
-        :options => {:verify_card => true}
-      )
-      update_result.success?.should == false
-      update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-    end
-
-    it "fails on create if credit_card[options][fail_on_duplicate_payment_method]=true and there is a duplicated payment method" do
-      customer = Braintree::Customer.create!
-      Braintree::CreditCard.create(
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2015"
-      )
-
-      result = Braintree::CreditCard.create(
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2015",
-        :options => {:fail_on_duplicate_payment_method => true}
-      )
-
-      result.success?.should == false
-      result.errors.for(:credit_card).on(:number)[0].message.should == "Duplicate card exists in the vault."
-    end
-
-    it "allows user to specify merchant account for verification" 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 = credit_card.update(
-        :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
-        :expiration_date => "05/2009",
-        :options => {
-          :verify_card => true,
-          :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId
-        }
-      )
-      update_result.success?.should == false
-      update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
-      update_result.credit_card_verification.processor_response_code.should == "2000"
-      update_result.credit_card_verification.processor_response_text.should == "Do Not Honor"
-      update_result.credit_card_verification.cvv_response_code.should == "I"
-      update_result.credit_card_verification.avs_error_response_code.should == nil
-      update_result.credit_card_verification.avs_postal_code_response_code.should == "I"
-      update_result.credit_card_verification.avs_street_address_response_code.should == "I"
-    end
-
-    it "can update the billing address" do
+  describe "nonce" do
+    it "returns the credit card nonce" 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",
-        :billing_address => {
-          :first_name => "Old First Name",
-          :last_name => "Old Last Name",
-          :company => "Old Company",
-          :street_address => "123 Old St",
-          :extended_address => "Apt Old",
-          :locality => "Old City",
-          :region => "Old State",
-          :postal_code => "12345",
-          :country_name => "Canada"
-        }
-      )
-      result = credit_card.update(
-        :options => {:verify_card => false},
-        :billing_address => {
-          :first_name => "New First Name",
-          :last_name => "New Last Name",
-          :company => "New Company",
-          :street_address => "123 New St",
-          :extended_address => "Apt New",
-          :locality => "New City",
-          :region => "New State",
-          :postal_code => "56789",
-          :country_name => "United States of America"
-        }
       )
-      result.success?.should == true
-      address = result.credit_card.billing_address
-      address.should == credit_card.billing_address # making sure credit card instance was updated
-      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"
-    end
 
-    it "returns an error response if invalid" do
-      customer = Braintree::Customer.create!
-      credit_card = Braintree::CreditCard.create!(
-        :cardholder_name => "Original Holder",
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-      update_result = credit_card.update(
-        :cardholder_name => "New Holder",
-        :number => "invalid",
-        :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(credit_card.nonce).not_to be_nil
     end
   end
 
-  describe "update!" do
-    it "updates the credit card and returns true if valid" do
-      customer = Braintree::Customer.create!
-      credit_card = Braintree::CreditCard.create!(
-        :cardholder_name => "Original Holder",
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-      credit_card.update!(
-        :cardholder_name => "New Holder",
-        :number => Braintree::Test::CreditCardNumbers::MasterCard,
-        :expiration_date => "06/2013"
-      ).should == credit_card
-      credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
-      credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
-      credit_card.expiration_date.should == "06/2013"
-      credit_card.cardholder_name.should == "New Holder"
-      credit_card.updated_at.between?(Time.now - 60, Time.now).should == true
-    end
-
-    it "raises a ValidationsFailed if invalid" do
-      customer = Braintree::Customer.create!
-      credit_card = Braintree::CreditCard.create!(
-        :cardholder_name => "Original Holder",
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-      expect do
-        credit_card.update!(
-          :cardholder_name => "New Holder",
-          :number => Braintree::Test::CreditCardNumbers::MasterCard,
-          :expiration_date => "invalid/date"
-        )
-      end.to raise_error(Braintree::ValidationsFailed)
+  describe "card on file network tokenization" do
+    it "should find a network tokenized credit card" do
+      credit_card = Braintree::CreditCard.find("network_tokenized_credit_card")
+      expect(credit_card.is_network_tokenized?).to eq(true)
     end
-  end
 
-  describe "nonce" do
-    it "returns the credit card nonce" do
+    it "should find a non-network tokenized credit card" do
       customer = Braintree::Customer.create!
-      credit_card = Braintree::CreditCard.create!(
-        :cardholder_name => "Original Holder",
+      credit_card = Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-
-      credit_card.nonce.should_not be_nil
+        :expiration_date => "05/2009",
+      ).credit_card
+      credit_card_vaulted = Braintree::CreditCard.find(credit_card.token)
+      expect(credit_card_vaulted.is_network_tokenized?).to eq(false)
     end
   end
 end