braintree 4.23.0 → 4.34.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 => {
@@ -235,6 +257,13 @@ describe Braintree::CreditCardVerification, "search" do
         Braintree::CreditCardVerification.find("invalid-id")
       end.to raise_error(Braintree::NotFoundError, 'verification with id "invalid-id" not found')
     end
+
+    it "finds a verification and returns a payment_account_reference if the verification has one" do
+      verification = Braintree::CreditCardVerification.find("threedsecuredverification")
+
+      expect(verification.credit_card).not_to be_nil
+      expect(verification.credit_card).to have_key(:payment_account_reference)
+    end
   end
 
   describe "self.search" do
@@ -322,6 +351,126 @@ describe Braintree::CreditCardVerification, "search" do
         found_verification = Braintree::CreditCardVerification.find(verification_id)
         expect(found_verification.credit_card[:prepaid]).to eq(Braintree::CreditCard::Prepaid::Yes)
       end
+
+      it "returns prepaid_reloadable on a prepaid 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::PrepaidReloadable,
+          :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[: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

@@ -0,0 +1,154 @@
+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(:pwpp_gateway) do
+    Braintree::Gateway.new(
+      :environment => :development,
+      :merchant_id => "pwpp_multi_account_merchant",
+      :public_key => "pwpp_multi_account_merchant_public_key",
+      :private_key => "pwpp_multi_account_merchant_private_key",
+    )
+  end
+
+  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 = 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 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 = 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
+      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"
+      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")
+    end
+  end
+
+  describe "update" do
+    it "can update a customer session" do
+      session_id = "11EF-A1E7-A5F5EE5C-A2E5-AFD2801469FC"
+      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)
+
+      customer = build_customer_session_input
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+      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
+      update_input = Braintree::UpdateCustomerSessionInput.new(
+        session_id: session_id,
+        customer: customer,
+      )
+      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")
+    end
+  end
+
+  describe "customer recommendations" do
+    it "can get customer recommendations" do
+      customer = build_customer_session_input
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        session_id: "94f0b2db-5323-4d86-add3-paypal000000",
+        customer: customer,
+        purchase_units: build_purchase_units,
+        domain: "domain.com",
+      )
+
+      result = pwpp_gateway.customer_session.get_customer_recommendations(customer_recommendations_input)
+
+      expect(result.success?).to eq(true)
+      payload = result.customer_recommendations
+      expect(payload.session_id).to eq("94f0b2db-5323-4d86-add3-paypal000000")
+      expect(payload.is_in_paypal_network).to eq(true)
+
+      recommendation = payload.recommendations.payment_recommendations[0]
+      expect(recommendation.payment_option).to eq(Braintree::RecommendedPaymentOption::PAYPAL)
+      expect(recommendation.recommended_priority).to eq(1)
+    end
+
+    it "raises an error when not authorized" do
+      customer = build_customer_session_input
+      customer_recommendations_input = Braintree::CustomerRecommendationsInput.new(
+        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",
+      )
+
+      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
+    input_attributes = {customer: customer}
+    input_attributes[:session_id] = session_id if session_id
+
+    input = Braintree::CreateCustomerSessionInput.new(input_attributes)
+    pwpp_gateway.customer_session.create_customer_session(input)
+  end
+
+  def build_customer_session_input
+    {
+      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
+
+  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

@@ -4,7 +4,8 @@ require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Customer do
   describe "self.all" do
-    it "gets more than a page of customers" do
+    #Disabling test until we have a more stable CI
+    xit "gets more than a page of customers" do
       customers = Braintree::Customer.all
       expect(customers.maximum_size).to be > 100
 
@@ -990,18 +991,23 @@ 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.token).not_to be_nil
-      expect(apple_pay_card.expiration_year).not_to be_nil
-      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
+      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
+      expect(apple_pay_card.expiration_year).not_to be_nil
       expect(apple_pay_card.healthcare).not_to be_nil
       expect(apple_pay_card.issuing_bank).not_to be_nil
+      expect(apple_pay_card.payment_instrument_name).to eq("AmEx 41002")
       expect(apple_pay_card.payroll).not_to be_nil
       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
 
     it "returns associated google pay proxy cards" do
@@ -1015,18 +1021,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(false)
+      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(false)
       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 google pay network tokens" do
@@ -1040,18 +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
@@ -1746,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
@@ -1911,4 +1978,21 @@ describe Braintree::Customer do
       end
     end
   end
+
+  it "returns bin fields from VisaCheckoutCard" do
+    result = Braintree::Customer.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutVisa,
+    )
+    expect(result.success?).to eq(true)
+
+    found_customer = Braintree::Customer.find(result.customer.id)
+    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/disbursement_spec.rb

@@ -28,4 +28,4 @@ describe Braintree::Disbursement do
       expect(transaction.id).to eq("sub_merchant_transaction")
     end
   end
-end
+end

data/spec/integration/braintree/dispute_spec.rb

@@ -32,8 +32,8 @@ describe Braintree::Dispute do
 
       expect(result.success?).to eq(true)
 
-      refreshed_dispute = Braintree::Dispute.find(dispute.id)
-      expect(refreshed_dispute.status).to eq(Braintree::Dispute::Status::Accepted)
+      updated_dispute = Braintree::Dispute.find(dispute.id)
+      expect(updated_dispute.status).to eq(Braintree::Dispute::Status::Accepted)
 
       dispute_from_transaction = Braintree::Transaction.find(dispute.transaction.id).disputes[0]
       expect(dispute_from_transaction.status).to eq(Braintree::Dispute::Status::Accepted)
@@ -99,6 +99,17 @@ describe Braintree::Dispute do
       expect(result.evidence.category).to eq("GENERAL")
       expect(result.evidence.url).to include("bt_logo.png")
     end
+
+    it "reflects the updated remaining_file_evidence_storage" do
+      initial_storage = dispute.remaining_file_evidence_storage
+      expect(initial_storage).not_to be_nil
+
+      Braintree::Dispute.add_file_evidence(dispute.id, document_upload.id)
+
+      refreshed_dispute = Braintree::Dispute.find(dispute.id)
+      updated_storage = refreshed_dispute.remaining_file_evidence_storage
+      expect(updated_storage).to be < initial_storage
+    end
   end
 
   describe "self.add_text_evidence" do