braintree 4.23.0 → 4.34.0

data/spec/integration/braintree/transaction_spec.rb

@@ -267,6 +267,71 @@ describe Braintree::Transaction do
         expect(result.transaction.credit_card_details.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
         expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
       end
+
+      it "sets the prepaid_reloadable field if the card is prepaid reloadable" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::PrepaidReloadable,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the business field if the card is business" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Business,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.business).to eq(Braintree::CreditCard::Business::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the consumer field if the card is consumer" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Consumer,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.consumer).to eq(Braintree::CreditCard::Consumer::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the corporate field if the card is corporate" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Corporate,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.corporate).to eq(Braintree::CreditCard::Corporate::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
+
+      it "sets the purchase field if the card is purchase" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Purchase,
+            :expiration_date => "05/2009"
+          },
+        )
+        expect(result.transaction.credit_card_details.purchase).to eq(Braintree::CreditCard::Purchase::Yes)
+        expect(result.transaction.payment_instrument_type).to eq(Braintree::PaymentInstrumentType::CreditCard)
+      end
     end
 
     describe "sca_exemption" do
@@ -1151,27 +1216,32 @@ describe Braintree::Transaction do
           :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
           :logger => Logger.new("/dev/null"),
         )
-        result = gateway.merchant.create(
-          :email => "name@email.com",
-          :country_code_alpha3 => "GBR",
-          :payment_methods => ["credit_card", "paypal"],
+
+        code = Braintree::OAuthTestHelper.create_grant(gateway, {
+          :merchant_public_id => "partner_merchant_id",
+          :scope => "read_write"
+        })
+
+        result = gateway.oauth.create_token_from_code(
+          :code => code,
+          :scope => "read_write",
         )
 
-        gateway = Braintree::Gateway.new(
+        merchant_gateway = Braintree::Gateway.new(
           :access_token => result.credentials.access_token,
           :logger => Logger.new("/dev/null"),
         )
 
-        result = gateway.transaction.create(
+        transaction_result = merchant_gateway.transaction.create(
           :type => "sale",
-          :amount => "4000.00",
+          :amount => "5001.00",
           :credit_card => {
             :number => Braintree::Test::CreditCardNumbers::Visa,
             :expiration_date => "05/2020"
           },
         )
-        expect(result.success?).to eq(false)
-        expect(result.transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::ApplicationIncomplete)
+        expect(transaction_result.success?).to eq(false)
+        expect(transaction_result.transaction.gateway_rejection_reason).to eq(Braintree::Transaction::GatewayRejectionReason::ApplicationIncomplete)
       end
 
       it "exposes the avs gateway rejection reason" do
@@ -1974,108 +2044,6 @@ describe Braintree::Transaction do
       end
     end
 
-    context "service fees" do
-      it "allows specifying service fees" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(true)
-        expect(result.transaction.service_fee_amount).to eq(BigDecimal("1.00"))
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::ServiceFeeAmountNotAllowedOnMasterMerchantAccount
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if no service fee is present on a sub merchant account transaction" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::SubMerchantAccountRequiresServiceFeeAmount
-        expect(result.errors.for(:transaction).on(:merchant_account_id)[0].code).to eq(expected_error_code)
-      end
-
-      it "raises an error if service fee amount is negative" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "-1.00",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountCannotBeNegative)
-      end
-
-      it "raises an error if service fee amount is invalid" do
-        result = Braintree::Transaction.create(
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :service_fee_amount => "invalid amount",
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:service_fee_amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::ServiceFeeAmountFormatIsInvalid)
-      end
-    end
-
-    context "escrow" do
-      it "allows specifying transactions to be held for escrow" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "10.00",
-          :options => {:hold_in_escrow => true},
-        )
-
-        expect(result.success?).to eq(true)
-        expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-      end
-
-      it "raises an error if transaction merchant account is a master" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :service_fee_amount => "1.00",
-          :options => {:hold_in_escrow => true},
-        )
-        expect(result.success?).to eq(false)
-        expected_error_code = Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
-        expect(result.errors.for(:transaction).on(:base)[0].code).to eq(expected_error_code)
-      end
-    end
-
     context "client API" do
       it "can create a transaction with a shared card nonce" do
         nonce = nonce_for_new_payment_method(
@@ -2170,9 +2138,12 @@ describe Braintree::Transaction do
         meta_checkout_card_details = result.transaction.meta_checkout_card_details
         meta_checkout_card_details.should_not be_nil
         meta_checkout_card_details.bin.should == "401288"
+        meta_checkout_card_details.business.should == "Unknown"
         meta_checkout_card_details.card_type.should == Braintree::CreditCard::CardType::Visa
         meta_checkout_card_details.cardholder_name.should == "Meta Checkout Card Cardholder"
+        meta_checkout_card_details.consumer.should == "Unknown"
         meta_checkout_card_details.container_id.should == "container123"
+        meta_checkout_card_details.corporate.should == "Unknown"
         meta_checkout_card_details.customer_location.should == "US"
         next_year = Date.today().next_year().year.to_s
         meta_checkout_card_details.expiration_date.should == "12/".concat(next_year)
@@ -2183,6 +2154,8 @@ describe Braintree::Transaction do
         meta_checkout_card_details.last_4.should == "1881"
         meta_checkout_card_details.masked_number.should == "401288******1881"
         meta_checkout_card_details.prepaid.should == "No"
+        meta_checkout_card_details.prepaid_reloadable.should == "Unknown"
+        meta_checkout_card_details.purchase.should == "Unknown"
       end
 
       it "can create a transaction with a fake meta checkout token nonce" do
@@ -2198,9 +2171,12 @@ describe Braintree::Transaction do
 
         meta_checkout_token_details.should_not be_nil
         meta_checkout_token_details.bin.should == "401288"
+        meta_checkout_token_details.business.should == "Unknown"
         meta_checkout_token_details.card_type.should == Braintree::CreditCard::CardType::Visa
         meta_checkout_token_details.cardholder_name.should == "Meta Checkout Token Cardholder"
+        meta_checkout_token_details.consumer.should == "Unknown"
         meta_checkout_token_details.container_id.should == "container123"
+        meta_checkout_token_details.corporate.should == "Unknown"
         meta_checkout_token_details.cryptogram.should == "AlhlvxmN2ZKuAAESNFZ4GoABFA=="
         meta_checkout_token_details.customer_location.should == "US"
         meta_checkout_token_details.ecommerce_indicator.should == "07"
@@ -2213,6 +2189,8 @@ describe Braintree::Transaction do
         meta_checkout_token_details.last_4.should == "1881"
         meta_checkout_token_details.masked_number.should == "401288******1881"
         meta_checkout_token_details.prepaid.should == "No"
+        meta_checkout_token_details.prepaid_reloadable.should == "Unknown"
+        meta_checkout_token_details.purchase.should == "Unknown"
       end
 
       it "can create a transaction with a fake apple pay nonce" do
@@ -2241,6 +2219,37 @@ describe Braintree::Transaction do
         expect(apple_pay_details.commercial).not_to be_nil
         expect(apple_pay_details.payroll).not_to be_nil
         expect(apple_pay_details.product_id).not_to be_nil
+        expect(apple_pay_details.is_device_token).to eq(true)
+      end
+
+      it "can create a transaction with a fake apple pay mpan nonce" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::ApplePayMpan,
+        )
+        expect(result.success?).to eq(true)
+        expect(result.transaction).not_to be_nil
+        apple_pay_details = result.transaction.apple_pay_details
+        expect(apple_pay_details).not_to be_nil
+        expect(apple_pay_details.bin).not_to be_nil
+        expect(apple_pay_details.card_type).to eq(Braintree::ApplePayCard::CardType::Visa)
+        expect(apple_pay_details.payment_instrument_name).to eq("Visa 2006")
+        expect(apple_pay_details.source_description).to eq("Visa 2006")
+        expect(apple_pay_details.expiration_month.to_i).to be > 0
+        expect(apple_pay_details.expiration_year.to_i).to be > 0
+        expect(apple_pay_details.cardholder_name).not_to be_nil
+        expect(apple_pay_details.image_url).not_to be_nil
+        expect(apple_pay_details.token).to be_nil
+        expect(apple_pay_details.prepaid).not_to be_nil
+        expect(apple_pay_details.healthcare).not_to be_nil
+        expect(apple_pay_details.debit).not_to be_nil
+        expect(apple_pay_details.durbin_regulated).not_to be_nil
+        expect(apple_pay_details.commercial).not_to be_nil
+        expect(apple_pay_details.payroll).not_to be_nil
+        expect(apple_pay_details.product_id).not_to be_nil
+        expect(apple_pay_details.merchant_token_identifier).not_to be_nil
+        expect(apple_pay_details.is_device_token).to eq(false)
       end
 
       it "can create a vaulted transaction with a fake apple pay nonce" do
@@ -2333,7 +2342,8 @@ describe Braintree::Transaction do
         expect(google_pay_details.virtual_card_type).to eq(Braintree::CreditCard::CardType::MasterCard)
         expect(google_pay_details.last_4).to eq("4444")
         expect(google_pay_details.virtual_card_last_4).to eq("4444")
-        expect(google_pay_details.source_description).to eq("MasterCard 4444")
+        expect(google_pay_details.source_card_last_4).to eq("0005")
+        expect(google_pay_details.source_description).to eq("MasterCard 0005")
         expect(google_pay_details.expiration_month.to_i).to be > 0
         expect(google_pay_details.expiration_year.to_i).to be > 0
         expect(google_pay_details.google_transaction_id).to eq("google_transaction_id")
@@ -2990,30 +3000,6 @@ describe Braintree::Transaction do
         expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:three_d_secure_version)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureThreeDSecureVersionIsInvalid)
       end
 
-      it "returns an error for transaction when the three_d_secure_pass_thru authentication_response is invalid" do
-        result = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper:: AdyenMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "12/12",
-          },
-          :three_d_secure_pass_thru => {
-            :eci_flag => "05",
-            :cavv => "some_cavv",
-            :xid => "some_xid",
-            :three_d_secure_version => "1.0.2",
-            :authentication_response => "asdf",
-            :directory_response => "Y",
-            :cavv_algorithm => "2",
-            :ds_transaction_id => "some_ds_id",
-          },
-        )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:authentication_response)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureAuthenticationResponseIsInvalid)
-      end
-
       it "returns an error for transaction when the three_d_secure_pass_thru directory_response is invalid" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -3058,8 +3044,9 @@ describe Braintree::Transaction do
             :ds_transaction_id => "some_ds_id",
           },
         )
+
         expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).for(:three_d_secure_pass_thru).on(:cavv_algorithm)[0].code).to eq(Braintree::ErrorCodes::Transaction::ThreeDSecureCavvAlgorithmIsInvalid)
+        expect(result.errors.for(:transaction).for(:credit_card).on(:cvv)[0].code).to eq(Braintree::ErrorCodes::CreditCard::CvvIsRequired)
       end
     end
 
@@ -3419,13 +3406,13 @@ describe Braintree::Transaction do
           config = Braintree::Configuration.instantiate
           config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
           result = Braintree::Transaction.refund(transaction.id, :amount => "2046.00")
-          expect(result.success?).to eq(false)
+          expect(result.success?).to eq(true)
           expect(result.transaction.id).to match(/^\w{6,}$/)
           expect(result.transaction.type).to eq("credit")
-          expect(result.transaction.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
-          expect(result.transaction.processor_response_code).to eq("2046")
-          expect(result.transaction.processor_response_text).to eq("Declined")
-          expect(result.transaction.processor_response_type).to eq(Braintree::ProcessorResponseTypes::SoftDeclined)
+          expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
+          expect(result.transaction.processor_response_code).to eq("1005")
+          expect(result.transaction.processor_response_text).to eq("Auth Declined but Settlement Captured")
+          expect(result.transaction.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
           expect(result.transaction.additional_processor_response).to eq("2046 : Declined")
         end
 
@@ -3439,15 +3426,15 @@ describe Braintree::Transaction do
           )
           config = Braintree::Configuration.instantiate
           config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
-          result = Braintree::Transaction.refund(transaction.id, :amount => "2009.00")
+          result = Braintree::Transaction.refund(transaction.id, :amount => "2004.00")
           expect(result.success?).to eq(false)
           expect(result.transaction.id).to match(/^\w{6,}$/)
           expect(result.transaction.type).to eq("credit")
           expect(result.transaction.status).to eq(Braintree::Transaction::Status::ProcessorDeclined)
-          expect(result.transaction.processor_response_code).to eq("2009")
-          expect(result.transaction.processor_response_text).to eq("No Such Issuer")
+          expect(result.transaction.processor_response_code).to eq("2004")
+          expect(result.transaction.processor_response_text).to eq("Expired Card")
           expect(result.transaction.processor_response_type).to eq(Braintree::ProcessorResponseTypes::HardDeclined)
-          expect(result.transaction.additional_processor_response).to eq("2009 : No Such Issuer")
+          expect(result.transaction.additional_processor_response).to eq("2004 : Expired Card")
         end
       end
 
@@ -5321,6 +5308,61 @@ describe Braintree::Transaction do
       expect(transaction.shipping_details.international_phone[:national_number]).to eq("3121234567")
     end
 
+    it "accepts processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "5411",
+      )
+
+      expect(result.success?).to eq(true)
+    end
+
+    it "returns validation error for a too long processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "54111",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
+    it "returns validation error for an alphanumeric processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "541A",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
+    it "returns validation error for a too short processing_merchant_category_code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2028"
+        },
+        :processing_merchant_category_code => "541",
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:transaction).on(:processing_merchant_category_code)[0].code).to eq(Braintree::ErrorCodes::Transaction::ProcessingMerchantCategoryCodeIsInvalid)
+    end
+
     it "allows merchant account to be specified" do
       result = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -5724,7 +5766,6 @@ describe Braintree::Transaction do
       end
     end
 
-
     context "3rd party Card on File Network Token" do
       it "Works with all params" do
         params = {
@@ -5765,6 +5806,32 @@ describe Braintree::Transaction do
         expect(result.success?).to eq(false)
         expect(result.errors.for(:transaction).for(:credit_card).map { |e| e.code }.sort).to eq [Braintree::ErrorCodes::CreditCard::NetworkTokenizationAttributeCryptogramIsRequired]
       end
+
+      it "Works with missing cryptogram and specified previous_network_transaction_id" do
+        params = {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+            :network_tokenization_attributes => {
+              :ecommerce_indicator => "05",
+              :token_requestor_id => "45310020105"
+            },
+          },
+          :external_vault => {
+            :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
+            :previous_network_transaction_id => "123456789012345"
+          },
+          :transaction_source => "recurring"
+        }
+        result = Braintree::Transaction.sale(params)
+        expect(result.success?).to eq true
+        expect(result.transaction.status).to eq Braintree::Transaction::Status::Authorized
+        expect(result.transaction.processed_with_network_token?).to eq true
+
+        network_token_details = result.transaction.network_token_details
+        expect(network_token_details.is_network_tokenized?).to eq true
+      end
     end
 
     xit "Amex Pay with Points" do
@@ -5914,7 +5981,8 @@ describe Braintree::Transaction do
     end
 
     context "Pinless debit transaction" do
-      it "succesfully submits for settlement" do
+      xit "succesfully submits for settlement" do
+        # Flaky test
         result = Braintree::Transaction.sale(
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :merchant_account_id => SpecHelper::PinlessDebitMerchantAccountId,
@@ -6093,24 +6161,6 @@ describe Braintree::Transaction do
       expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement)
     end
 
-    context "service fees" do
-      it "returns an error result if amount submitted for settlement is less than service fee amount" do
-        transaction = Braintree::Transaction.create(
-          :type => "sale",
-          :amount => Braintree::Test::TransactionAmounts::Authorize,
-          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::Visa,
-            :expiration_date => "06/2009"
-          },
-          :service_fee_amount => "1.00",
-        ).transaction
-        result = Braintree::Transaction.submit_for_settlement(transaction.id, "0.01")
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:transaction).on(:amount)[0].code).to eq(Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount)
-      end
-    end
-
     it "succeeds when industry data is provided" do
       transaction = Braintree::Transaction.create(
         :type => "sale",
@@ -6674,101 +6724,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.release_from_escrow" do
-    it "returns the transaction if successful" do
-      original_transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.release_from_escrow(original_transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "returns an error result if escrow_status is not HeldForEscrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotReleaseFromEscrow)
-    end
-  end
-
-  describe "self.release_from_escrow!" do
-    it "returns the transaction when successful" do
-      original_transaction = create_escrowed_transcation
-
-      transaction = Braintree::Transaction.release_from_escrow!(original_transaction.id)
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-    end
-
-    it "raises an error when transaction is not successful" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-        :service_fee_amount => "1.00",
-      )
-
-      expect(transaction.escrow_status).to be_nil
-
-      expect do
-        Braintree::Transaction.release_from_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
-  describe "self.cancel_release" do
-    it "returns the transaction if successful" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "returns an error result if escrow_status is not ReleasePending" do
-      transaction = create_escrowed_transcation
-
-      result = Braintree::Transaction.cancel_release(transaction.id)
-
-      expect(result.success?).to be(false)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotCancelRelease)
-    end
-  end
-
-  describe "self.cancel_release!" do
-    it "returns the transaction when release is cancelled" do
-      transaction = create_escrowed_transcation
-      result = Braintree::Transaction.release_from_escrow(transaction.id)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::ReleasePending)
-
-      transaction = Braintree::Transaction.cancel_release!(transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::Held)
-    end
-
-    it "raises an error when release cannot be cancelled" do
-      transaction = create_escrowed_transcation
-
-      expect {
-        transaction = Braintree::Transaction.cancel_release!(transaction.id)
-      }.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.credit" do
     it "returns a successful result with type=credit if successful" do
       result = Braintree::Transaction.credit(
@@ -6922,6 +6877,34 @@ describe Braintree::Transaction do
       expect(transaction.acquirer_reference_number).to eq("123456789 091019")
     end
 
+    it "finds a transaction and returns a payment_account_reference if the transaction has one" do
+      transaction = Braintree::Transaction.find("aft_txn")
+
+      expect(transaction.credit_card_details).not_to be_nil
+      expect(transaction.credit_card_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in apple_pay_details if the transaction has one" do
+      transaction = Braintree::Transaction.find("apple_pay_transaction")
+
+      expect(transaction.apple_pay_details).not_to be_nil
+      expect(transaction.apple_pay_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in google_pay_details if the transaction has one" do
+      transaction = Braintree::Transaction.find("android_pay_card_transaction")
+
+      expect(transaction.google_pay_details).not_to be_nil
+      expect(transaction.google_pay_details).to respond_to(:payment_account_reference)
+    end
+
+    it "finds a transaction and returns a payment_account_reference in google_pay_details for network token if the transaction has one" do
+      transaction = Braintree::Transaction.find("android_pay_network_token_transaction")
+
+      expect(transaction.google_pay_details).not_to be_nil
+      expect(transaction.google_pay_details).to respond_to(:payment_account_reference)
+    end
+
     context "disbursement_details" do
       it "includes disbursement_details on found transactions" do
         found_transaction = Braintree::Transaction.find("deposittransaction")
@@ -7054,76 +7037,6 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.hold_in_escrow" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      result = Braintree::Transaction.hold_in_escrow(result.transaction.id)
-
-      expect(result.success?).to be(true)
-      expect(result.transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "returns an error result if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      result = Braintree::Transaction.hold_in_escrow(transaction.id)
-      expect(result.errors.for(:transaction).on(:base)[0].code).to eq(Braintree::ErrorCodes::Transaction::CannotHoldInEscrow)
-    end
-  end
-
-  describe "self.hold_in_escrow!" do
-    it "returns the transaction if successful" do
-      result = Braintree::Transaction.create(
-        :type => "sale",
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "12/12",
-        },
-        :service_fee_amount => "10.00",
-      )
-
-      expect(result.transaction.escrow_status).to be_nil
-      transaction = Braintree::Transaction.hold_in_escrow!(result.transaction.id)
-
-      expect(transaction.escrow_status).to eq(Braintree::Transaction::EscrowStatus::HoldPending)
-    end
-
-    it "raises an error if the transaction cannot be held in escrow" do
-      transaction = Braintree::Transaction.sale!(
-        :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_date => "05/2009"
-        },
-      )
-
-      expect do
-        Braintree::Transaction.hold_in_escrow!(transaction.id)
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
-
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(
@@ -7139,6 +7052,18 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::Voided)
     end
 
+    it "returns a successful result if contact details passed in" do
+      result = Braintree::Transaction.sale(
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :amount => "10",
+        :options => {
+          :paypal => {}
+        },
+      )
+      expect(result.success?).to eq(true)
+      expect(result.transaction.paypal_details.recipient_email).to eq("test@paypal.com")
+    end
+
     it "returns an error result if unsuccessful" do
       transaction = Braintree::Transaction.sale(
         :amount => Braintree::Test::TransactionAmounts::Decline,
@@ -7321,24 +7246,6 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
-  def create_escrowed_transcation
-    transaction = Braintree::Transaction.sale!(
-      :amount => Braintree::Test::TransactionAmounts::Authorize,
-      :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
-      :credit_card => {
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2009"
-      },
-      :service_fee_amount => "1.00",
-      :options => {:hold_in_escrow => true},
-    )
-
-    config = Braintree::Configuration.instantiate
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/settle")
-    config.http.put("#{config.base_merchant_path}/transactions/#{transaction.id}/escrow")
-    Braintree::Transaction.find(transaction.id)
-  end
-
   context "paypal" do
     it "can create a transaction for a paypal account" do
       result = Braintree::Transaction.sale(
@@ -7868,7 +7775,7 @@ describe Braintree::Transaction do
 
         expect(adjustment_transaction.success?).to eq(false)
         expect(adjustment_transaction.transaction.amount).to eq(BigDecimal("75.50"))
-        expect(adjustment_transaction.errors.for(:authorization_adjustment).on(:amount).first.code).to eq(Braintree::ErrorCodes::Transaction::AdjustmentAmountMustBeGreaterThanZero)
+        expect(adjustment_transaction.errors.for(:transaction).on(:amount).first.code).to eq(Braintree::ErrorCodes::Transaction::AmountMustBeGreaterThanZero)
       end
 
       it "returns failure response, when adjusted amount submitted same as authorized amount" do
@@ -7969,4 +7876,13 @@ describe Braintree::Transaction do
       expect(result.transaction.status).to eq(Braintree::Transaction::Status::SubmittedForSettlement)
     end
   end
+
+  describe "upcoming_retry_date" do
+    it "returns the upcoming retry date for ACH transactions" do
+      transaction = Braintree::Transaction.find("first_attempted_ach_transaction")
+
+      tomorrow = Date.today + 1
+      expect(transaction.upcoming_retry_date).to eq(tomorrow.to_s)
+    end
+  end
 end