braintree 4.27.0 → 4.28.0

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -67,6 +67,28 @@ describe Braintree::CreditCardVerification, "search" do
       expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
     end
 
+    it "creates a new verification for Visa ANI when account information inquiry is passed" do
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "05/2032",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :account_information_inquiry => "send_data",
+        }
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      expect(result).to be_success
+      expect(result.credit_card_verification.status).to eq(Braintree::CreditCardVerification::Status::Verified)
+      expect(result.credit_card_verification.processor_response_code).to eq("1000")
+      expect(result.credit_card_verification.processor_response_text).to eq("Approved")
+      expect(result.credit_card_verification.ani_first_name_response_code).to eq("I")
+      expect(result.credit_card_verification.ani_last_name_response_code).to eq("I")
+      expect(result.credit_card_verification.processor_response_type).to eq(Braintree::ProcessorResponseTypes::Approved)
+    end
+
     it "creates a new verification from external vault param" do
       verification_params = {
         :credit_card => {
@@ -346,6 +368,102 @@ describe Braintree::CreditCardVerification, "search" do
         found_verification = Braintree::CreditCardVerification.find(verification_id)
         expect(found_verification.credit_card[:prepaid_reloadable]).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
       end
+
+      it "returns business on a business card" do
+        cardholder_name = "Tom #{rand(1_000_000)} Smith"
+
+        Braintree::Customer.create(
+          :credit_card => {
+          :cardholder_name => cardholder_name,
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Business,
+          :cvv => "200",
+          :options => {
+            :verify_card => true
+        }
+        })
+
+        search_results = Braintree::CreditCardVerification.search do |search|
+          search.credit_card_cardholder_name.is cardholder_name
+        end
+
+        verification_id = search_results.first.id
+
+        found_verification = Braintree::CreditCardVerification.find(verification_id)
+        expect(found_verification.credit_card[:business]).to eq(Braintree::CreditCard::Business::Yes)
+      end
+
+      it "returns consumer on a consumer card" do
+        cardholder_name = "Tom #{rand(1_000_000)} Smith"
+
+        Braintree::Customer.create(
+          :credit_card => {
+          :cardholder_name => cardholder_name,
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Consumer,
+          :cvv => "200",
+          :options => {
+            :verify_card => true
+        }
+        })
+
+        search_results = Braintree::CreditCardVerification.search do |search|
+          search.credit_card_cardholder_name.is cardholder_name
+        end
+
+        verification_id = search_results.first.id
+
+        found_verification = Braintree::CreditCardVerification.find(verification_id)
+        expect(found_verification.credit_card[:consumer]).to eq(Braintree::CreditCard::Consumer::Yes)
+      end
+
+      it "returns corporate on a corporate card" do
+        cardholder_name = "Tom #{rand(1_000_000)} Smith"
+
+        Braintree::Customer.create(
+          :credit_card => {
+          :cardholder_name => cardholder_name,
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Corporate,
+          :cvv => "200",
+          :options => {
+            :verify_card => true
+        }
+        })
+
+        search_results = Braintree::CreditCardVerification.search do |search|
+          search.credit_card_cardholder_name.is cardholder_name
+        end
+
+        verification_id = search_results.first.id
+
+        found_verification = Braintree::CreditCardVerification.find(verification_id)
+        expect(found_verification.credit_card[:corporate]).to eq(Braintree::CreditCard::Corporate::Yes)
+      end
+
+      it "returns purchase on a purchase card" do
+        cardholder_name = "Tom #{rand(1_000_000)} Smith"
+
+        Braintree::Customer.create(
+          :credit_card => {
+          :cardholder_name => cardholder_name,
+          :expiration_date => "05/2012",
+          :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Purchase,
+          :cvv => "200",
+          :options => {
+            :verify_card => true
+        }
+        })
+
+        search_results = Braintree::CreditCardVerification.search do |search|
+          search.credit_card_cardholder_name.is cardholder_name
+        end
+
+        verification_id = search_results.first.id
+
+        found_verification = Braintree::CreditCardVerification.find(verification_id)
+        expect(found_verification.credit_card[:purchase]).to eq(Braintree::CreditCard::Purchase::Yes)
+      end
     end
   end
 

data/spec/integration/braintree/customer_session_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::CustomerSessionGateway do
-  let(:gateway) do
+  let(:pwpp_gateway) do
     Braintree::Gateway.new(
       :environment => :development,
       :merchant_id => "pwpp_multi_account_merchant",
@@ -13,37 +13,43 @@ describe Braintree::CustomerSessionGateway do
 
   describe "create" do
     it "can create customer session without email and phone" do
-      input = Braintree::CreateCustomerSessionInput.new(merchant_account_id: "usd_pwpp_multi_account_merchant_account")
-      result = gateway.customer_session.create_customer_session(input)
+      input = Braintree::CreateCustomerSessionInput.new(
+        merchant_account_id: "usd_pwpp_multi_account_merchant_account",
+      )
+      result = pwpp_gateway.customer_session.create_customer_session(input)
       expect(result.success?).to eq(true)
       expect(result.session_id).not_to be_nil
     end
 
-    it "can can create customer session with merchant provided session id" do
+    it "can create customer session with merchant provided session id" do
       merchant_session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
       input = Braintree::CreateCustomerSessionInput.new(
         session_id: merchant_session_id,
       )
-      result = gateway.customer_session.create_customer_session(input)
+      result = pwpp_gateway.customer_session.create_customer_session(input)
       expect(result.success?).to eq(true)
       expect(result.session_id).to eq(merchant_session_id)
     end
 
     it "can create customer session with API-derived session id" do
-      input = Braintree::CreateCustomerSessionInput.new({})
-      result = gateway.customer_session.create_customer_session(input)
+      result = build_customer_session(nil)
+      expect(result.session_id).not_to be_nil
+    end
+
+    it "can create customer session with purchase units" do
+      input = Braintree::CreateCustomerSessionInput.new(
+        purchase_units: build_purchase_units,
+      )
+      result = pwpp_gateway.customer_session.create_customer_session(input)
       expect(result.success?).to eq(true)
       expect(result.session_id).not_to be_nil
     end
 
     it "cannot create duplicate customer session" do
       existing_session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
-      input = Braintree::CreateCustomerSessionInput.new(
-        session_id: existing_session_id,
-      )
-      result = gateway.customer_session.create_customer_session(input)
+      result = build_customer_session(existing_session_id)
       expect(result.success?).to eq(false)
-      expect(result.errors.first.message).to include("Session IDs must be unique per merchant.")
+      expect(result.errors.first.message).to include("Session IDs must be unique per merchant")
     end
   end
 
@@ -53,33 +59,29 @@ describe Braintree::CustomerSessionGateway do
       create_input = Braintree::CreateCustomerSessionInput.new(
         merchant_account_id: "usd_pwpp_multi_account_merchant_account",
         session_id: session_id,
+        purchase_units: build_purchase_units,
       )
+      pwpp_gateway.customer_session.create_customer_session(create_input)
 
-      gateway.customer_session.create_customer_session(create_input)
-
-      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
-
+      customer = build_customer_session_input
       update_input = Braintree::UpdateCustomerSessionInput.new(
         session_id: session_id,
         customer: customer,
       )
-
-      result = gateway.customer_session.update_customer_session(update_input)
+      result = pwpp_gateway.customer_session.update_customer_session(update_input)
 
       expect(result.success?).to eq(true)
       expect(result.session_id).to eq(session_id)
-
     end
 
     it "cannot update a non-existent customer session" do
       session_id = "11EF-34BC-2702904B-9026-C3ECF4BAC765"
-      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
+      customer = build_customer_session_input
       update_input = Braintree::UpdateCustomerSessionInput.new(
         session_id: session_id,
         customer: customer,
       )
-
-      result = gateway.customer_session.update_customer_session(update_input)
+      result = pwpp_gateway.customer_session.update_customer_session(update_input)
 
       expect(result.success?).to eq(false)
       expect(result.errors.first.message).to include("does not exist")
@@ -88,56 +90,64 @@ describe Braintree::CustomerSessionGateway do
 
   describe "customer recommendations" do
     it "can get customer recommendations" do
-      customer = build_customer_session_input("PR5_test@example.com", "4085005005")
-      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+      customer = build_customer_session_input
       customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
-        session_id: "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC",
-        recommendations: recommendations,
+        session_id: "94f0b2db-5323-4d86-add3-paypal000000",
         customer: customer,
+        purchase_units: build_purchase_units,
+        domain: "domain.com",
       )
-      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      result = pwpp_gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
 
       expect(result.success?).to eq(true)
       payload = result.customer_recommendations
       expect(payload.is_in_paypal_network).to eq(true)
-      payment_options = payload.recommendations.payment_options
-      expect(payment_options[0].payment_option).to eq(Braintree::RecommendedPaymentOption::PAYPAL)
-      expect(payment_options[0].recommended_priority).to equal(1)
+
+      recommendation = payload.recommendations.payment_recommendations[0]
+      expect(recommendation.payment_option).to eq(Braintree::RecommendedPaymentOption::PAYPAL)
+      expect(recommendation.recommended_priority).to eq(1)
     end
 
-    it "cannot get customer recommendations for non-existent session" do
-      customer = build_customer_session_input("PR9_test@example.com", "4085005009")
-      recommendations = [Braintree::Recommendations::PAYMENT_RECOMMENDATIONS]
+    it "raises an error when not authorized" do
+      customer = build_customer_session_input
       customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
-        session_id: "11EF-34BC-2702904B-9026-C3ECF4BAC765",
-        recommendations: recommendations,
+        session_id: "6B29FC40-CA47-1067-B31D-00DD010662DA",
         customer: customer,
+        purchase_units: build_purchase_units,
+        domain: "domain.com",
+        merchant_account_id: "gbp_pwpp_multi_account_merchant_account",
       )
-      result = gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
 
-      expect(result.success?).to eq(false)
-      expect(result.errors.first.message).to include("does not exist")
+      expect {
+        pwpp_gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+      }.to raise_error(Braintree::AuthorizationError)
     end
   end
 
   private
 
   def build_customer_session(session_id = nil)
-    customer = build_customer_session_input("PR1_test@example.com", "4085005002")
+    customer = build_customer_session_input
+    input_attributes = {customer: customer}
+    input_attributes[:session_id] = session_id if session_id
 
-    input = session_id ? CreateCustomerSessionInput.new(customer: customer, session_id: session_id) : CreateCustomerSessionInput.new(customer => customer)
-    @gateway.customer_session.create_customer_session(input)
+    input = Braintree::CreateCustomerSessionInput.new(input_attributes)
+    pwpp_gateway.customer_session.create_customer_session(input)
   end
 
-  def build_customer_session_input(email, phone_number)
+  def build_customer_session_input
     {
-      email: email,
-      device_fingerprint_id: "test",
-      phone: {country_phone_code: "1", phone_number: phone_number},
-      paypal_app_installed: true,
-      venmo_app_installed: true,
-      user_agent: "Mozilla"
+      hashed_email: "48ddb93f0b30c475423fe177832912c5bcdce3cc72872f8051627967ef278e08",
+      hashed_phone_number: "a2df2987b2a3384210d3aa1c9fb8b627ebdae1f5a9097766c19ca30ec4360176",
+      device_fingerprint_id: "00DD010662DE",
+      user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/x.x.x.x Safari/537.36",
     }
   end
 
-end
+  def build_purchase_units
+    amount = {currency_code: "USD", value: "10.00"}
+    purchase_unit = {amount: amount}
+    [purchase_unit]
+  end
+end

data/spec/integration/braintree/customer_spec.rb

@@ -991,7 +991,10 @@ describe Braintree::Customer do
       expect(found_customer.apple_pay_cards).not_to be_nil
       apple_pay_card = found_customer.apple_pay_cards.first
       expect(apple_pay_card).to be_a Braintree::ApplePayCard
+      expect(apple_pay_card.business).not_to be_nil
       expect(apple_pay_card.commercial).not_to be_nil
+      expect(apple_pay_card.consumer).not_to be_nil
+      expect(apple_pay_card.corporate).not_to be_nil
       expect(apple_pay_card.country_of_issuance).not_to be_nil
       expect(apple_pay_card.debit).not_to be_nil
       expect(apple_pay_card.durbin_regulated).not_to be_nil
@@ -1003,6 +1006,7 @@ describe Braintree::Customer do
       expect(apple_pay_card.prepaid).not_to be_nil
       expect(apple_pay_card.prepaid_reloadable).not_to be_nil
       expect(apple_pay_card.product_id).not_to be_nil
+      expect(apple_pay_card.purchase).not_to be_nil
       expect(apple_pay_card.token).not_to be_nil
     end
 
@@ -1017,7 +1021,10 @@ describe Braintree::Customer do
       expect(found_customer.payment_methods.size).to eq(1)
       google_pay_card = found_customer.google_pay_cards.first
       expect(google_pay_card).to be_a Braintree::GooglePayCard
+      expect(google_pay_card.business).not_to be_nil
       expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.consumer).not_to be_nil
+      expect(google_pay_card.corporate).not_to be_nil
       expect(google_pay_card.country_of_issuance).not_to be_nil
       expect(google_pay_card.debit).not_to be_nil
       expect(google_pay_card.durbin_regulated).not_to be_nil
@@ -1029,6 +1036,7 @@ describe Braintree::Customer do
       expect(google_pay_card.prepaid).not_to be_nil
       expect(google_pay_card.prepaid_reloadable).not_to be_nil
       expect(google_pay_card.product_id).not_to be_nil
+      expect(google_pay_card.purchase).not_to be_nil
       expect(google_pay_card.token).not_to be_nil
     end
 
@@ -1043,19 +1051,23 @@ describe Braintree::Customer do
       expect(found_customer.payment_methods.size).to eq(1)
       google_pay_card = found_customer.google_pay_cards.first
       expect(google_pay_card).to be_a Braintree::GooglePayCard
-      expect(google_pay_card.token).not_to be_nil
-      expect(google_pay_card.expiration_year).not_to be_nil
-      expect(google_pay_card.is_network_tokenized?).to eq(true)
+      expect(google_pay_card.business).not_to be_nil
       expect(google_pay_card.commercial).not_to be_nil
+      expect(google_pay_card.consumer).not_to be_nil
+      expect(google_pay_card.corporate).not_to be_nil
       expect(google_pay_card.country_of_issuance).not_to be_nil
       expect(google_pay_card.debit).not_to be_nil
       expect(google_pay_card.durbin_regulated).not_to be_nil
+      expect(google_pay_card.expiration_year).not_to be_nil
       expect(google_pay_card.healthcare).not_to be_nil
+      expect(google_pay_card.is_network_tokenized?).to eq(true)
       expect(google_pay_card.issuing_bank).not_to be_nil
       expect(google_pay_card.payroll).not_to be_nil
       expect(google_pay_card.prepaid).not_to be_nil
       expect(google_pay_card.prepaid_reloadable).not_to be_nil
       expect(google_pay_card.product_id).not_to be_nil
+      expect(google_pay_card.purchase).not_to be_nil
+      expect(google_pay_card.token).not_to be_nil
     end
 
     it "returns associated venmo accounts" do
@@ -1750,6 +1762,57 @@ describe Braintree::Customer do
     end
   end
 
+  describe "account information inquiry" do
+    it "includes ani response when account information inquiry is sent in options" do
+      result = Braintree::Customer.create(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2027",
+          :cvv => "100",
+          :billing_address => {
+            :first_name => "John",
+            :last_name => "Doe",
+          },
+          :options => {
+            :account_information_inquiry => "send_data",
+            :verify_card => true,
+          },
+        },
+      )
+
+      expect(result).to be_success
+      verification = result.customer.credit_cards.first.verification
+      expect(verification.ani_first_name_response_code).not_to be_nil
+      expect(verification.ani_last_name_response_code).not_to be_nil
+    end
+
+    it "includes ani response after updating the options with account information inquiry" do
+      customer = Braintree::Customer.create!(
+        :first_name => "Joe",
+      )
+      updated_result = Braintree::Customer.update(
+        customer.id,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/2029",
+          :billing_address => {
+            :first_name => "John",
+            :last_name => "Doe",
+          },
+          :options => {
+            :account_information_inquiry => "send_data",
+            :verify_card => true,
+          },
+        },
+      )
+
+      expect(updated_result).to be_success
+      verification = updated_result.customer.credit_cards.first.verification
+      expect(verification.ani_first_name_response_code).not_to be_nil
+      expect(verification.ani_last_name_response_code).not_to be_nil
+    end
+  end
+
   describe "paypal" do
     context "future" do
       it "creates a customer with a future paypal account" do
@@ -1916,7 +1979,7 @@ describe Braintree::Customer do
     end
   end
 
-  it "returns prepaid_reloadable from VisaCheckoutCard" do
+  it "returns bin fields from VisaCheckoutCard" do
     result = Braintree::Customer.create(
       :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
     )
@@ -1926,6 +1989,10 @@ describe Braintree::Customer do
     expect(found_customer.visa_checkout_cards).not_to be_nil
     visa_checkout_card = found_customer.visa_checkout_cards.first
     expect(visa_checkout_card).to be_a Braintree::VisaCheckoutCard
+    expect(visa_checkout_card.business).not_to be_nil
+    expect(visa_checkout_card.consumer).not_to be_nil
+    expect(visa_checkout_card.corporate).not_to be_nil
     expect(visa_checkout_card.prepaid_reloadable).not_to be_nil
+    expect(visa_checkout_card.purchase).not_to be_nil
   end
 end

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -148,6 +148,16 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.details.bin).to eq("401288")
     end
 
+    it "returns bin_data with business set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-business-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.business).to eq(Braintree::CreditCard::Business::Yes)
+    end
+
     it "returns bin_data with commercial set to Yes" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-commercial-nonce")
 
@@ -158,6 +168,26 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::Yes)
     end
 
+    it "returns bin_data with consumer set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-consumer-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.consumer).to eq(Braintree::CreditCard::Consumer::Yes)
+    end
+
+    it "returns bin_data with corporate set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-corporate-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.corporate).to eq(Braintree::CreditCard::Corporate::Yes)
+    end
+
     it "returns bin_data with country_of_issuance set to CAN" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-country-of-issuance-cad-nonce")
 
@@ -240,6 +270,16 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Yes)
     end
 
+    it "returns bin_data with purchase set to Yes" do
+      result = Braintree::PaymentMethodNonce.find("fake-valid-purchase-nonce")
+
+      nonce = result.payment_method_nonce
+
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.purchase).to eq(Braintree::CreditCard::Purchase::Yes)
+    end
+
     it "returns bin_data with unknown indicators" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-unknown-indicators-nonce")
 
@@ -247,7 +287,10 @@ describe Braintree::PaymentMethodNonce do
 
       expect(result).to be_success
       expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.business).to eq(Braintree::CreditCard::Business::Unknown)
       expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::Unknown)
+      expect(nonce.bin_data.consumer).to eq(Braintree::CreditCard::Consumer::Unknown)
+      expect(nonce.bin_data.corporate).to eq(Braintree::CreditCard::Corporate::Unknown)
       expect(nonce.bin_data.country_of_issuance).to eq(Braintree::CreditCard::CountryOfIssuance::Unknown)
       expect(nonce.bin_data.debit).to eq(Braintree::CreditCard::Debit::Unknown)
       expect(nonce.bin_data.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Unknown)
@@ -257,6 +300,7 @@ describe Braintree::PaymentMethodNonce do
       expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Unknown)
       expect(nonce.bin_data.prepaid_reloadable).to eq(Braintree::CreditCard::PrepaidReloadable::Unknown)
       expect(nonce.bin_data.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
+      expect(nonce.bin_data.purchase).to eq(Braintree::CreditCard::Purchase::Unknown)
     end
 
     it "correctly raises and exception for a non existent token" do

data/spec/integration/braintree/payment_method_spec.rb

@@ -671,6 +671,30 @@ describe Braintree::PaymentMethod do
       end
     end
 
+      it "includes ani response when account information inquiry is sent in options" do
+          customer = Braintree::Customer.create!
+          nonce = nonce_for_new_payment_method(
+            :credit_card => {
+              :cvv => "123",
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2029",
+            },
+          )
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verify_card => true,
+              :account_information_inquiry => "send_data",
+            },
+          )
+
+          expect(result).to be_success
+          verification = result.payment_method.verification
+          expect(verification.ani_first_name_response_code).not_to be_nil
+          expect(verification.ani_last_name_response_code).not_to be_nil
+      end
+
     context "account_type" do
       it "verifies card with account_type debit" do
         nonce = nonce_for_new_payment_method(
@@ -1588,6 +1612,29 @@ describe Braintree::PaymentMethod do
         end
       end
 
+      it "includes ani response after updating the options with account information inquiry" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :cvv => "123",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2032",
+        )
+        update_result = Braintree::PaymentMethod.update(
+          credit_card.token,
+          :options => {
+            :verify_card => true,
+            :account_information_inquiry => "send_data",
+          },
+        )
+
+        expect(update_result).to be_success
+        verification = update_result.payment_method.verification
+        expect(verification.ani_first_name_response_code).not_to be_nil
+        expect(verification.ani_last_name_response_code).not_to be_nil
+      end
+
+
       context "verification_currency_iso_code" do
         it "validates verification_currency_iso_code and updates the credit card " do
           customer = Braintree::Customer.create!