braintree 4.26.0 → 4.28.0

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/disbursement_spec.rb

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