braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/package_tracking_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+# NEXT_MAJOR_VERSION Remove paypal_tracking_id assertions, use paypal_tracker_id going forward
+describe Braintree::Transaction do
+    describe "self.package_tracking" do
+      let(:customer) { Braintree::Customer.create! }
+        it "returns validation error message from gateway api" do
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            },
+          )
+
+          expect(result.success?).to eq(true)
+
+          # Carrier name is required
+          invalidResult = Braintree::Transaction.package_tracking(result.transaction.id, {tracking_number: "tracking_number_1"})
+          expect(invalidResult.message).to eq("Carrier name is required.")
+
+           # Tracking number is required
+           invalidResult = Braintree::Transaction.package_tracking(result.transaction.id, {carrier: "UPS"})
+           expect(invalidResult.message).to eq("Tracking number is required.")
+        end
+
+        it "successfully calls gateway API and adds package tracking information" do
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            },
+          )
+
+          expect(result.success?).to eq(true)
+
+          # Create First Package with 2 products
+          firstPackageResult = Braintree::Transaction.package_tracking(
+            result.transaction.id,
+            {
+              carrier: "UPS",
+              notify_payer: true,
+              tracking_number: "tracking_number_1",
+              line_items: [
+                {
+                  product_code: "ABC 01",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                  upc_code: "51234567890",
+                  upc_type: "UPC-A",
+                  image_url: "https://example.com/image.png",
+                },
+                {
+                  product_code: "ABC 02",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                  upc_code: "51234567891",
+                  upc_type: "UPC-A",
+                  image_url: "https://example.com/image.png",
+                },
+              ],
+            },
+          )
+
+          # First package is shipped by the merchant
+          expect(firstPackageResult.success?).to eq(true)
+          expect(firstPackageResult.transaction.packages[0].id).not_to be_nil
+          expect(firstPackageResult.transaction.packages[0].carrier).to eq("UPS")
+          expect(firstPackageResult.transaction.packages[0].tracking_number).to eq("tracking_number_1")
+          expect(firstPackageResult.transaction.packages[0].paypal_tracker_id).to be_nil
+          expect(firstPackageResult.transaction.packages[0].paypal_tracking_id).to be_nil
+
+          # Create second package with 1 product
+          secondPackageResult = Braintree::Transaction.package_tracking(
+            result.transaction.id,
+            {
+              carrier: "FEDEX",
+              notify_payer: true,
+              tracking_number: "tracking_number_2",
+              line_items: [
+                {
+                  product_code: "ABC 03",
+                  name: "Best Product Ever",
+                  quantity: "1",
+                  description: "Best Description Ever",
+                },
+              ]
+            },
+          )
+
+          # Second package is shipped by the merchant
+          expect(secondPackageResult.success?).to eq(true)
+          expect(secondPackageResult.transaction.packages[1].id).not_to be_nil
+          expect(secondPackageResult.transaction.packages[1].carrier).to eq("FEDEX")
+          expect(secondPackageResult.transaction.packages[1].tracking_number).to eq("tracking_number_2")
+          expect(secondPackageResult.transaction.packages[1].paypal_tracker_id).to be_nil
+          expect(secondPackageResult.transaction.packages[1].paypal_tracking_id).to be_nil
+
+          # Find transaction gives both packages
+          transaction = Braintree::Transaction.find(result.transaction.id)
+          expect(transaction.packages.length).to eq(2)
+          expect(transaction.packages[0].id).not_to be_nil
+          expect(transaction.packages[0].carrier).to eq("UPS")
+          expect(transaction.packages[0].tracking_number).to eq("tracking_number_1")
+          #In test environment, since we do not have jobstream setup paypal tracker id is going to be nil, this is just to access we could access it
+          expect(transaction.packages[0].paypal_tracker_id).to be_nil
+          expect(transaction.packages[0].paypal_tracking_id).to be_nil
+
+          expect(transaction.packages[1].id).not_to be_nil
+          expect(transaction.packages[1].carrier).to eq("FEDEX")
+          expect(transaction.packages[1].tracking_number).to eq("tracking_number_2")
+          expect(transaction.packages[1].paypal_tracker_id).to be_nil
+          expect(transaction.packages[1].paypal_tracking_id).to be_nil
+        end
+
+        it "retrieves paypal_tracker_id successfully" do
+          transaction = Braintree::Transaction.find("package_tracking_tx")
+          expect(transaction.packages.length).to eq(2)
+          expect(transaction.packages[0].paypal_tracker_id).to eq("paypal_tracker_id_1")
+          expect(transaction.packages[0].paypal_tracking_id).to be_nil
+
+          expect(transaction.packages[1].paypal_tracker_id).to eq("paypal_tracker_id_2")
+          expect(transaction.packages[1].paypal_tracking_id).to be_nil
+        end
+    end
+end

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+require "date"
 
 describe Braintree::PaymentMethodNonce do
   let(:config) { Braintree::Configuration.instantiate }
@@ -12,26 +13,27 @@ describe Braintree::PaymentMethodNonce do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
 
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
-      result.should be_success
-      result.payment_method.should be_a(Braintree::CreditCard)
+      expect(result).to be_success
+      expect(result.payment_method).to be_a(Braintree::CreditCard)
       token = result.payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
+      expect(found_credit_card).not_to be_nil
 
       result = Braintree::PaymentMethodNonce.create(found_credit_card.token)
-      result.should be_success
-      result.payment_method_nonce.should_not be_nil
-      result.payment_method_nonce.nonce.should_not be_nil
-      result.payment_method_nonce.details.should_not be_nil
+      expect(result).to be_success
+      expect(result.payment_method_nonce).not_to be_nil
+      expect(result.payment_method_nonce.nonce).not_to be_nil
+      expect(result.payment_method_nonce.details).not_to be_nil
+      expect(result.payment_method_nonce.default?).to be_truthy
     end
 
     it "correctly raises and exception for a non existent token" do
@@ -49,24 +51,25 @@ describe Braintree::PaymentMethodNonce do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
 
       payment_method = Braintree::PaymentMethod.create!(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
-      payment_method.should be_a(Braintree::CreditCard)
+      expect(payment_method).to be_a(Braintree::CreditCard)
       token = payment_method.token
 
       found_credit_card = Braintree::CreditCard.find(token)
-      found_credit_card.should_not be_nil
+      expect(found_credit_card).not_to be_nil
 
       payment_method_nonce = Braintree::PaymentMethodNonce.create!(found_credit_card.token)
-      payment_method_nonce.should_not be_nil
-      payment_method_nonce.nonce.should_not be_nil
-      payment_method_nonce.details.should_not be_nil
+      expect(payment_method_nonce).not_to be_nil
+      expect(payment_method_nonce.nonce).not_to be_nil
+      expect(payment_method_nonce.details).not_to be_nil
+      expect(payment_method_nonce.default?).to be_truthy
     end
   end
 
@@ -76,32 +79,47 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.nonce.should == "fake-valid-nonce"
-      nonce.type.should == "CreditCard"
-      nonce.details.fetch(:last_two).should == "81"
-      nonce.details.fetch(:card_type).should == "Visa"
+      expect(result).to be_success
+      expect(nonce.nonce).to eq("fake-valid-nonce")
+      expect(nonce.type).to eq("CreditCard")
+      expect(nonce.details.bin).to eq("401288")
+      expect(nonce.details.card_type).to eq("Visa")
+      expect(nonce.details.expiration_month).to eq("12")
+      expect(nonce.details.expiration_year).to eq(Date.today.next_year.year.to_s)
+      expect(nonce.details.is_network_tokenized?).to be_nil
+      expect(nonce.details.last_two).to eq("81")
+      expect(nonce.details.payer_info).to be_nil
     end
 
-    it "return paypal details if details exist" do
-      result = Braintree::PaymentMethodNonce.find("fake-google-pay-paypal-nonce")
-
+    it "return meta_checkout_card_details nonce if exist" do
+      result = Braintree::PaymentMethodNonce.find(Braintree::Test::Nonce::MetaCheckoutCard)
       nonce = result.payment_method_nonce
-
-      nonce.details.fetch(:payer_info).fetch(:first_name).should_not be_nil
-      nonce.details.fetch(:payer_info).fetch(:last_name).should_not be_nil
-      nonce.details.fetch(:payer_info).fetch(:email).should_not be_nil
-      nonce.details.fetch(:payer_info).fetch(:payer_id).should_not be_nil
+      nonce.details.bin.should == "401288"
+      nonce.details.last_two.should == "81"
+      nonce.details.card_type.should == "Visa"
+      nonce.details.expiration_year.should == Date.today().next_year().year.to_s
+      nonce.details.expiration_month.should == "12"
     end
 
-    it "return venmo details if details exist" do
-      result = Braintree::PaymentMethodNonce.find("fake-venmo-account-nonce")
-
+    it "return meta_checkout_token_details nonce if exist" do
+      result = Braintree::PaymentMethodNonce.find(Braintree::Test::Nonce::MetaCheckoutToken)
       nonce = result.payment_method_nonce
+      nonce.details.bin.should == "401288"
+      nonce.details.last_two.should == "81"
+      nonce.details.card_type.should == "Visa"
+      nonce.details.expiration_year.should == Date.today().next_year().year.to_s
+      nonce.details.expiration_month.should == "12"
+    end
 
-      nonce.details.fetch(:last_two).should == "99"
-      nonce.details.fetch(:username).should == "venmojoe"
-      nonce.details.fetch(:venmo_user_id).should == "Venmo-Joe-1"
+    it "return paypal details if details exist" do
+      result = Braintree::PaymentMethodNonce.find("fake-paypal-one-time-nonce")
+      nonce = result.payment_method_nonce
+      expect(nonce.details.payer_info.billing_agreement_id).to be_nil
+      expect(nonce.details.payer_info.country_code).to be_nil
+      expect(nonce.details.payer_info.email).not_to be_nil
+      expect(nonce.details.payer_info.first_name).not_to be_nil
+      expect(nonce.details.payer_info.last_name).not_to be_nil
+      expect(nonce.details.payer_info.payer_id).not_to be_nil
     end
 
     it "returns null 3ds_info if there isn't any" do
@@ -110,24 +128,24 @@ describe Braintree::PaymentMethodNonce do
           :number => "4111111111111111",
           :expiration_month => "11",
           :expiration_year => "2099",
-        }
+        },
       )
 
       result = Braintree::PaymentMethodNonce.find(nonce)
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.three_d_secure_info.should be_nil
+      expect(result).to be_success
+      expect(nonce.three_d_secure_info).to be_nil
     end
 
     it "returns the bin" do
       result = Braintree::PaymentMethodNonce.find("fake-valid-visa-nonce")
 
       nonce = result.payment_method_nonce
-      result.should be_success
-      nonce.details.should_not be_nil
-      nonce.details[:bin].should == "401288"
+      expect(result).to be_success
+      expect(nonce.details).not_to be_nil
+      expect(nonce.details.bin).to eq("401288")
     end
 
     it "returns bin_data with commercial set to Yes" do
@@ -135,9 +153,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.commercial.should == Braintree::CreditCard::Commercial::Yes
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::Yes)
     end
 
     it "returns bin_data with country_of_issuance set to CAN" do
@@ -145,9 +163,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.country_of_issuance.should == "CAN"
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.country_of_issuance).to eq("CAN")
     end
 
     it "returns bin_data with debit set to Yes" do
@@ -155,9 +173,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.debit.should == Braintree::CreditCard::Debit::Yes
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.debit).to eq(Braintree::CreditCard::Debit::Yes)
     end
 
     it "returns bin_data with durbin_regulated set to Yes" do
@@ -165,9 +183,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.durbin_regulated).to eq(Braintree::CreditCard::DurbinRegulated::Yes)
     end
 
     it "returns bin_data with healthcare set to Yes" do
@@ -175,10 +193,10 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.healthcare.should == Braintree::CreditCard::Healthcare::Yes
-      nonce.bin_data.product_id.should == "J3"
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.healthcare).to eq(Braintree::CreditCard::Healthcare::Yes)
+      expect(nonce.bin_data.product_id).to eq("J3")
     end
 
     it "returns bin_data with issuing_bank set to Network Only" do
@@ -186,9 +204,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.issuing_bank.should == "NETWORK ONLY"
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.issuing_bank).to eq("NETWORK ONLY")
     end
 
     it "returns bin_data with payroll set to Yes" do
@@ -196,10 +214,10 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.payroll.should == Braintree::CreditCard::Payroll::Yes
-      nonce.bin_data.product_id.should == "MSA"
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.payroll).to eq(Braintree::CreditCard::Payroll::Yes)
+      expect(nonce.bin_data.product_id).to eq("MSA")
     end
 
     it "returns bin_data with prepaid set to Yes" do
@@ -207,9 +225,9 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Yes)
     end
 
     it "returns bin_data with unknown indicators" do
@@ -217,17 +235,17 @@ describe Braintree::PaymentMethodNonce do
 
       nonce = result.payment_method_nonce
 
-      result.should be_success
-      nonce.bin_data.should_not be_nil
-      nonce.bin_data.commercial.should == Braintree::CreditCard::Commercial::Unknown
-      nonce.bin_data.country_of_issuance.should == Braintree::CreditCard::CountryOfIssuance::Unknown
-      nonce.bin_data.debit.should == Braintree::CreditCard::Debit::Unknown
-      nonce.bin_data.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Unknown
-      nonce.bin_data.healthcare.should == Braintree::CreditCard::Healthcare::Unknown
-      nonce.bin_data.issuing_bank.should == Braintree::CreditCard::IssuingBank::Unknown
-      nonce.bin_data.payroll.should == Braintree::CreditCard::Payroll::Unknown
-      nonce.bin_data.prepaid.should == Braintree::CreditCard::Prepaid::Unknown
-      nonce.bin_data.product_id.should == Braintree::CreditCard::ProductId::Unknown
+      expect(result).to be_success
+      expect(nonce.bin_data).not_to be_nil
+      expect(nonce.bin_data.commercial).to eq(Braintree::CreditCard::Commercial::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)
+      expect(nonce.bin_data.healthcare).to eq(Braintree::CreditCard::Healthcare::Unknown)
+      expect(nonce.bin_data.issuing_bank).to eq(Braintree::CreditCard::IssuingBank::Unknown)
+      expect(nonce.bin_data.payroll).to eq(Braintree::CreditCard::Payroll::Unknown)
+      expect(nonce.bin_data.prepaid).to eq(Braintree::CreditCard::Prepaid::Unknown)
+      expect(nonce.bin_data.product_id).to eq(Braintree::CreditCard::ProductId::Unknown)
     end
 
     it "correctly raises and exception for a non existent token" do
@@ -235,5 +253,82 @@ describe Braintree::PaymentMethodNonce do
         Braintree::PaymentMethodNonce.find("not_a_nonce")
       end.to raise_error(Braintree::NotFoundError)
     end
+
+    context "authentication insights" do
+      let(:indian_payment_token) { "india_visa_credit" }
+      let(:european_payment_token) { "european_visa_credit" }
+      let(:indian_merchant_token) { "india_three_d_secure_merchant_account" }
+      let(:european_merchant_token) { "european_three_d_secure_merchant_account" }
+
+      describe "self.create" do
+        it "raises an exception if hash includes an invalid key" do
+          expect do
+            Braintree::PaymentMethodNonce.create("european_visa_credit", :invalid_key => "foo")
+          end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+        end
+      end
+
+      context "regulation environments" do
+        it "can get unregulated" do
+          expect(
+            request_authentication_insights(european_merchant_token, indian_payment_token)[:regulation_environment],
+          ).to eq "unregulated"
+        end
+
+        it "can get psd2" do
+          expect(
+            request_authentication_insights(european_merchant_token, european_payment_token)[:regulation_environment],
+          ).to eq "psd2"
+        end
+
+        it "can get rbi" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:regulation_environment],
+          ).to eq "rbi"
+        end
+      end
+
+      context "sca_indicator" do
+        it "can get unavailable" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:sca_indicator],
+          ).to eq "unavailable"
+        end
+
+        it "can get sca_required" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2001})[:sca_indicator],
+          ).to eq "sca_required"
+        end
+
+        it "can get sca_optional" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2000, recurring_customer_consent: true, recurring_max_amount: 2000})[:sca_indicator],
+
+          ).to eq "sca_optional"
+        end
+      end
+
+      def request_authentication_insights(merchant_token, payment_method_token, options = {})
+        authentication_insight_options = {
+          amount: options[:amount],
+          recurring_customer_consent: options[:recurring_customer_consent],
+          recurring_max_amount: options[:recurring_max_amount],
+        }
+        nonce_request = {
+          merchant_account_id: merchant_token,
+          authentication_insight: true,
+          authentication_insight_options: authentication_insight_options,
+        }
+
+        result = Braintree::PaymentMethodNonce.create(
+          payment_method_token,
+          payment_method_nonce: nonce_request,
+        )
+        expect(result).to be_success
+
+        return result.payment_method_nonce.authentication_insight
+      end
+    end
   end
 end