braintree 4.34.0 → 4.36.0

data/spec/integration/braintree/transaction_idempotency_spec.rb

@@ -0,0 +1,320 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction, "idempotency" do
+  describe "sale" do
+    it "returns original transaction on duplicate request with same api_request_key" do
+      api_request_key = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params)
+      expect(result1).to be_success
+      transaction1 = result1.transaction
+      expect(transaction1.id).not_to be_nil
+
+      result2 = Braintree::Transaction.sale(transaction_params)
+      expect(result2).to be_success
+      transaction2 = result2.transaction
+
+      expect(transaction1.status).to eq(transaction2.status)
+      expect(transaction1.id).to eq(transaction2.id)
+    end
+
+    it "fails when different request used with same key" do
+      api_request_key = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params1 = {
+        :amount => "100.00",
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+
+      transaction_params2 = {
+        :amount => "200.00",
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+
+      expect(result2).not_to be_success
+      expect(result2.errors).not_to be_nil
+      errors = result2.errors.for(:transaction)
+      expect(errors.size).to be > 0
+      expect(errors.first.code).to eq(Braintree::ErrorCodes::Transaction::ApiRequestKeyCanBeReusedOnlyWithTheSameRequest)
+    end
+
+    it "same sales with different api_request_keys create different transactions" do
+      api_request_key1 = "idempotency-key-#{rand(1000000)}"
+
+      transaction_params1 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key1,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+      transaction1 = result1.transaction
+      expect(transaction1.id).not_to be_nil
+
+      api_request_key2 = "idempotency-key-different-#{rand(1000000)}"
+      transaction_params2 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key2,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+      expect(result2).to be_success
+      transaction2 = result2.transaction
+
+      expect(transaction1.id).not_to eq(transaction2.id)
+    end
+
+    it "fails when api_request_key is too big" do
+      transaction_params1 = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => "x" * 255,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result1 = Braintree::Transaction.sale(transaction_params1)
+      expect(result1).to be_success
+
+      transaction_params2 = {
+        :amount => "200.00",
+        :api_request_key => "x" * 256,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      result2 = Braintree::Transaction.sale(transaction_params2)
+
+      expect(result2).not_to be_success
+      expect(result2.errors).not_to be_nil
+      errors = result2.errors.for(:transaction)
+      expect(errors.size).to be > 0
+      expect(errors.first.code).to eq(Braintree::ErrorCodes::Transaction::ApiRequestKeyTooLong)
+    end
+  end
+
+  describe "credit" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "credit-idempotency-key-#{rand(1000000)}"
+
+      transaction_params = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :api_request_key => api_request_key,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      credit_result1 = Braintree::Transaction.credit(transaction_params)
+      expect(credit_result1).to be_success
+      credit_transaction1 = credit_result1.transaction
+      expect(credit_transaction1.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(credit_transaction1.id).not_to be_nil
+
+      credit_result2 = Braintree::Transaction.credit(transaction_params)
+      expect(credit_result2).to be_success
+      credit_transaction2 = credit_result2.transaction
+
+      expect(credit_transaction1.id).to eq(credit_transaction2.id)
+      expect(credit_transaction1.type).to eq(credit_transaction2.type)
+    end
+  end
+
+  describe "submit_for_partial_settlement" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "partial-settlement-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      partial_amount = "50.00"
+      partial_settlement_options = {
+        :api_request_key => api_request_key
+      }
+
+      partial_settlement_result1 = Braintree::Transaction.submit_for_partial_settlement(
+        transaction_id,
+        partial_amount,
+        partial_settlement_options,
+      )
+      expect(partial_settlement_result1).to be_success
+      partial_settlement_transaction1 = partial_settlement_result1.transaction
+      expect(partial_settlement_transaction1.amount).to eq(BigDecimal(partial_amount))
+      expect(partial_settlement_transaction1.id).not_to be_nil
+
+      partial_settlement_result2 = Braintree::Transaction.submit_for_partial_settlement(
+        transaction_id,
+        partial_amount,
+        partial_settlement_options,
+      )
+      expect(partial_settlement_result2).to be_success
+      partial_settlement_transaction2 = partial_settlement_result2.transaction
+
+      expect(partial_settlement_transaction1.id).to eq(partial_settlement_transaction2.id)
+      expect(partial_settlement_transaction1.amount).to eq(partial_settlement_transaction2.amount)
+    end
+  end
+
+  describe "submit_for_settlement" do
+    it "returns original on duplicate request with same api_request_key" do
+      api_request_key = "settlement-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+      original_amount = sale_result.transaction.amount
+
+      settlement_options = {
+        :api_request_key => api_request_key
+      }
+
+      settlement_result1 = Braintree::Transaction.submit_for_settlement(
+        transaction_id,
+        nil,
+        settlement_options,
+      )
+      expect(settlement_result1).to be_success
+      settlement_transaction1 = settlement_result1.transaction
+      expect(settlement_transaction1.amount).to eq(original_amount)
+      expect(settlement_transaction1.id).not_to be_nil
+
+      settlement_result2 = Braintree::Transaction.submit_for_settlement(
+        transaction_id,
+        nil,
+        settlement_options,
+      )
+      expect(settlement_result2).to be_success
+      settlement_transaction2 = settlement_result2.transaction
+
+      expect(settlement_transaction1.id).to eq(settlement_transaction2.id)
+      expect(settlement_transaction1.amount).to eq(settlement_transaction2.amount)
+    end
+  end
+
+  describe "void" do
+    it "returns original void on duplicate request with same api_request_key" do
+      api_request_key = "void-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      void_options = {
+        :api_request_key => api_request_key
+      }
+
+      void_result1 = Braintree::Transaction.void(transaction_id, void_options)
+      expect(void_result1).to be_success
+      voided_transaction1 = void_result1.transaction
+      expect(voided_transaction1.status).to eq(Braintree::Transaction::Status::Voided)
+
+      void_result2 = Braintree::Transaction.void(transaction_id, void_options)
+      expect(void_result2).to be_success
+      voided_transaction2 = void_result2.transaction
+
+      expect(voided_transaction1.id).to eq(voided_transaction2.id)
+      expect(voided_transaction1.status).to eq(voided_transaction2.status)
+      expect(voided_transaction2.status).to eq(Braintree::Transaction::Status::Voided)
+    end
+  end
+
+  describe "refund" do
+    it "returns original refund on duplicate request with same api_request_key" do
+      api_request_key = "refund-idempotency-key-#{rand(1000000)}"
+
+      sale_request = {
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_date => "05/2035"
+        },
+        :options => {
+          :submit_for_settlement => true
+        }
+      }
+
+      sale_result = Braintree::Transaction.sale(sale_request)
+      expect(sale_result).to be_success
+      transaction_id = sale_result.transaction.id
+
+      settled_result = Braintree::TestTransaction.settle(transaction_id)
+      expect(settled_result.transaction.status).to eq(Braintree::Transaction::Status::Settled)
+
+      refund_options = {
+        :api_request_key => api_request_key
+      }
+
+      refund_result1 = Braintree::Transaction.refund(transaction_id, refund_options)
+      expect(refund_result1).to be_success
+      refund_transaction1 = refund_result1.transaction
+      expect(refund_transaction1.type).to eq(Braintree::Transaction::Type::Credit)
+      expect(refund_transaction1.id).not_to be_nil
+
+      refund_result2 = Braintree::Transaction.refund(transaction_id, refund_options)
+      expect(refund_result2).to be_success
+      refund_transaction2 = refund_result2.transaction
+
+      expect(refund_transaction1.id).to eq(refund_transaction2.id)
+      expect(refund_transaction1.type).to eq(refund_transaction2.type)
+    end
+  end
+end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -69,6 +69,7 @@ describe Braintree::Transaction, "search" do
       credit_card = Braintree::CreditCard.find(token)
 
       search_criteria = {
+        :acquirer_reference_number => transaction.acquirer_reference_number,
         :billing_company => "Braintree",
         :billing_country_name => "United States of America",
         :billing_extended_address => "Suite 123",
@@ -207,9 +208,9 @@ describe Braintree::Transaction, "search" do
       end
       item = collection.find { |t| t.id == transaction_id }
       expect(item.ach_return_code).to eq("RJCT")
-      expect(item.ach_reject_reason).to eq("Bank accounts located outside of the U.S. are not supported.")
+      expect(item.ach_reject_reason).to eq("Bank accounts located outside of the U.S. are not supported")
       expect(item.ach_return_responses.first[:reason_code]).to eq("RJCT")
-      expect(item.ach_return_responses.first[:reject_reason]).to eq("Bank accounts located outside of the U.S. are not supported.")
+      expect(item.ach_return_responses.first[:reject_reason]).to eq("Bank accounts located outside of the U.S. are not supported")
     end
 
     it "searches on reason_codes" do

data/spec/integration/braintree/transaction_spec.rb

@@ -812,6 +812,22 @@ describe Braintree::Transaction do
         expect(result.transaction.foreign_retailer).to be_nil
       end
 
+      it "returns true for partial_authorization if the processor_response_code is 1004" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::PartiallyAuthorized,
+          :accept_partial_authorization => true,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2029"
+          },
+        )
+
+        expect(result.success?).to eq(true)
+        expect(result.transaction.processor_response_code).to eq("1004")
+        expect(result.transaction.partially_authorized).to eq(true)
+      end
+
       it "returns nil when foreign_retailer param is nil" do
         result = Braintree::Transaction.create(
           :type => "sale",
@@ -5308,6 +5324,64 @@ describe Braintree::Transaction do
       expect(transaction.shipping_details.international_phone[:national_number]).to eq("3121234567")
     end
 
+    it "accepts customer international_phone" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1", :national_number => "3121234567"},
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      transaction = result.transaction
+      expect(transaction.customer_details.first_name).to eq("Dan")
+      expect(transaction.customer_details.last_name).to eq("Smith")
+      expect(transaction.customer_details.international_phone[:country_code]).to eq("1")
+      expect(transaction.customer_details.international_phone[:national_number]).to eq("3121234567")
+    end
+
+    it "returns validation error for an invalid international_phone country code" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1111", :national_number => "3121234567"},
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include(Braintree::ErrorCodes::Customer::InternationalPhoneCountryCodeIsInvalid)
+    end
+
+    it "returns validation error for an invalid international_phone national number" do
+      result = Braintree::Transaction.sale(
+        :amount => "100.00",
+        :credit_card => {
+          :number => "5105105105105100",
+          :expiration_date => "05/2011",
+        },
+        :customer => {
+          :first_name => "Dan",
+          :last_name => "Smith",
+          :international_phone => {:country_code => "1", :national_number => "31212345611111"},
+        },
+      )
+
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include(Braintree::ErrorCodes::Customer::InternationalPhoneNationalNumberIsInvalid)
+    end
+
     it "accepts processing_merchant_category_code" do
       result = Braintree::Transaction.sale(
         :amount => "100.00",
@@ -7885,4 +7959,21 @@ describe Braintree::Transaction do
       expect(transaction.upcoming_retry_date).to eq(tomorrow.to_s)
     end
   end
+
+  context "Surcharge Amount" do
+    it "accepts surcharge_amount field" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => "10.00",
+        :surcharge_amount => "1.00",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2029"
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.surcharge_amount).to eq(BigDecimal("1.00"))
+    end
+  end
 end

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -143,6 +143,25 @@ describe Braintree::Transaction do
             expect(transaction.us_bank_account_details.ach_mandate.accepted_at).to be_a Time
           end
 
+          it "returns ach_type and requested_ach_type on transaction create" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_nonce => non_plaid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+                :us_bank_account => {
+                  :ach_type => "same_day",
+                },
+              },
+            )
+            expect(result.success?).to eq(true)
+            # if the test is ran before 2pm - it returns 'same_day', otherwise 'standard'
+            expect(result.transaction.ach_type).to eq("same_day").or eq("standard")
+            expect(result.transaction.requested_ach_type).to eq("same_day")
+          end
+
           it "sale fails for invalid nonce" do
             result = Braintree::Transaction.create(
               :type => "sale",
@@ -192,4 +211,27 @@ describe Braintree::Transaction do
       end
     end
   end
+
+  describe "self.find" do
+    it "returns ach_type and requested_ach_type for same_day ach with same_day requested" do
+      transaction = Braintree::Transaction.find("sameday_ach_sameday_requested")
+
+      expect(transaction.ach_type).to eq("same_day")
+      expect(transaction.requested_ach_type).to eq("same_day")
+    end
+
+    it "returns ach_type and requested_ach_type for standard ach with same_day requested" do
+      transaction = Braintree::Transaction.find("standard_ach_sameday_requested")
+
+      expect(transaction.ach_type).to eq("standard")
+      expect(transaction.requested_ach_type).to eq("same_day")
+    end
+
+    it "returns ach_type and requested_ach_type for standard ach with standard requested" do
+      transaction = Braintree::Transaction.find("standard_ach_standard_requested")
+
+      expect(transaction.ach_type).to eq("standard")
+      expect(transaction.requested_ach_type).to eq("standard")
+    end
+  end
 end

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -1,110 +1,14 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
+# DEPRECATED: Visa Checkout is no longer supported for creating new transactions.
+# Search functionality is retained for historical transactions only.
 describe Braintree::VisaCheckoutCard do
-  it "can create from payment method nonce" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::PaymentMethod.create(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-    )
-    expect(result).to be_success
-
-    visa_checkout_card = result.payment_method
-    expect(visa_checkout_card).to be_a(Braintree::VisaCheckoutCard)
-    expect(visa_checkout_card.call_id).to eq("abc123")
-    expect(visa_checkout_card.billing_address).not_to be_nil
-    expect(visa_checkout_card.bin).not_to be_nil
-    expect(visa_checkout_card.card_type).not_to be_nil
-    expect(visa_checkout_card.cardholder_name).not_to be_nil
-    expect(visa_checkout_card.commercial).not_to be_nil
-    expect(visa_checkout_card.country_of_issuance).not_to be_nil
-    expect(visa_checkout_card.created_at).not_to be_nil
-    expect(visa_checkout_card.customer_id).not_to be_nil
-    expect(visa_checkout_card.customer_location).not_to be_nil
-    expect(visa_checkout_card.debit).not_to be_nil
-    expect(visa_checkout_card.default?).not_to be_nil
-    expect(visa_checkout_card.durbin_regulated).not_to be_nil
-    expect(visa_checkout_card.expiration_date).not_to be_nil
-    expect(visa_checkout_card.expiration_month).not_to be_nil
-    expect(visa_checkout_card.expiration_year).not_to be_nil
-    expect(visa_checkout_card.expired?).not_to be_nil
-    expect(visa_checkout_card.healthcare).not_to be_nil
-    expect(visa_checkout_card.image_url).not_to be_nil
-    expect(visa_checkout_card.issuing_bank).not_to be_nil
-    expect(visa_checkout_card.last_4).not_to be_nil
-    expect(visa_checkout_card.payroll).not_to be_nil
-    expect(visa_checkout_card.prepaid).not_to be_nil
-    expect(visa_checkout_card.product_id).not_to be_nil
-    expect(visa_checkout_card.subscriptions).not_to be_nil
-    expect(visa_checkout_card.token).not_to be_nil
-    expect(visa_checkout_card.unique_number_identifier).not_to be_nil
-    expect(visa_checkout_card.updated_at).not_to be_nil
-
-    customer = Braintree::Customer.find(customer.id)
-    expect(customer.visa_checkout_cards.size).to eq(1)
-    expect(customer.visa_checkout_cards.first).to eq(visa_checkout_card)
-  end
-
-  it "can create with verification" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::PaymentMethod.create(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-      :options => {:verify_card => true},
-    )
-    expect(result).to be_success
-    expect(result.payment_method.verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
-  end
-
-  it "can search for transactions" do
-    transaction_create_result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :amount => "47.00",
-    )
-    expect(transaction_create_result).to be_success
-    transaction_id = transaction_create_result.transaction.id
-
+  it "can search by payment instrument type" do
     search_results = Braintree::Transaction.search do |search|
-      search.id.is transaction_id
       search.payment_instrument_type.is Braintree::PaymentInstrumentType::VisaCheckoutCard
     end
-    expect(search_results.first.id).to eq(transaction_id)
-  end
-
-  it "can create transaction from nonce and vault" do
-    customer = Braintree::Customer.create!
-
-    result = Braintree::Transaction.sale(
-      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
-      :customer_id => customer.id,
-      :amount => "47.00",
-      :options => {:store_in_vault => true},
-    )
-    expect(result).to be_success
 
-    visa_checkout_card_details = result.transaction.visa_checkout_card_details
-    expect(visa_checkout_card_details.call_id).to eq("abc123")
-    expect(visa_checkout_card_details.bin).not_to be_nil
-    expect(visa_checkout_card_details.card_type).not_to be_nil
-    expect(visa_checkout_card_details.cardholder_name).not_to be_nil
-    expect(visa_checkout_card_details.commercial).not_to be_nil
-    expect(visa_checkout_card_details.country_of_issuance).not_to be_nil
-    expect(visa_checkout_card_details.customer_location).not_to be_nil
-    expect(visa_checkout_card_details.debit).not_to be_nil
-    expect(visa_checkout_card_details.durbin_regulated).not_to be_nil
-    expect(visa_checkout_card_details.expiration_date).not_to be_nil
-    expect(visa_checkout_card_details.expiration_month).not_to be_nil
-    expect(visa_checkout_card_details.expiration_year).not_to be_nil
-    expect(visa_checkout_card_details.healthcare).not_to be_nil
-    expect(visa_checkout_card_details.image_url).not_to be_nil
-    expect(visa_checkout_card_details.issuing_bank).not_to be_nil
-    expect(visa_checkout_card_details.last_4).not_to be_nil
-    expect(visa_checkout_card_details.payroll).not_to be_nil
-    expect(visa_checkout_card_details.prepaid).not_to be_nil
-    expect(visa_checkout_card_details.product_id).not_to be_nil
-    expect(visa_checkout_card_details.token).not_to be_nil
+    expect(search_results).not_to be_nil
   end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   require "bundler/setup"
+
   require "rspec"
   require "rspec/retry"
   require "pry"
@@ -42,6 +43,7 @@ unless defined?(SPEC_HELPER_LOADED)
     HiperBRLMerchantAccountId = "hiper_brl"
     NonDefaultMerchantAccountId = "sandbox_credit_card_non_default"
     PinlessDebitMerchantAccountId = "pinless_debit"
+    SuspendedAccount = "suspended_account"
     ThreeDSecureMerchantAccountId = "three_d_secure_merchant_account"
     UsBankMerchantAccountId = "us_bank_merchant_account"
 

data/spec/unit/braintree/credit_card_verification_spec.rb

@@ -19,7 +19,7 @@ describe Braintree::CreditCardVerification do
         :network_response_code => "05",
         :network_response_text => "Do not Honor",
       )
-      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
+      expect(verification.inspect).to eq(%(#<Braintree::CreditCardVerification amount: "12.45", ani_first_name_response_code: "I", ani_last_name_response_code: "I", apple_pay: nil, avs_error_response_code: "I", avs_postal_code_response_code: "I", avs_street_address_response_code: "I", billing: nil, created_at: nil, credit_card: nil, currency_iso_code: "USD", cvv_response_code: "I", gateway_rejection_reason: nil, id: nil, merchant_account_id: "some_id", network_response_code: "05", network_response_text: "Do not Honor", processor_response_code: "2000", processor_response_text: "Do Not Honor", status: "verified">))
     end
 
     it "has a status" do