braintree 4.17.0 → 4.19.0

data/spec/integration/braintree/customer_spec.rb

@@ -924,11 +924,11 @@ describe Braintree::Customer do
           },
         ).credit_card
 
-        subscription = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => credit_card.token,
           :plan_id => "integration_trialless_plan",
           :price => "1.00",
-        ).subscription
+        )
 
         found_customer = Braintree::Customer.find(customer.id, {
           :association_filter_id => "customernoassociations"
@@ -958,11 +958,11 @@ describe Braintree::Customer do
           },
         ).credit_card
 
-        subscription = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => credit_card.token,
           :plan_id => "integration_trialless_plan",
           :price => "1.00",
-        ).subscription
+        )
 
         found_customer = Braintree::Customer.find(customer.id, {
          :association_filter_id =>  "customertoplevelassociations"
@@ -1132,7 +1132,7 @@ describe Braintree::Customer do
             :number => 4111111111111111,
             :expiration_date => "05/2060",
             :three_d_secure_pass_thru => {
-              :eci_flag => "02",
+              :eci_flag => "05",
               :cavv => "some_cavv",
               :xid => "some_xid",
               :three_d_secure_version => "1.0.2",
@@ -1167,7 +1167,7 @@ describe Braintree::Customer do
             :number => 4111111111111111,
             :expiration_date => "05/2060",
             :three_d_secure_pass_thru => {
-              :eci_flag => "02",
+              :eci_flag => "05",
               :cavv => "some_cavv",
               :xid => "some_xid",
               :authentication_response => "Y",
@@ -1233,7 +1233,7 @@ describe Braintree::Customer do
 
       token1 = random_payment_method_token
 
-      payment_method1 = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
         :token => token1,
@@ -1244,7 +1244,7 @@ describe Braintree::Customer do
 
       token2 = random_payment_method_token
 
-      payment_method2 = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::TransactableMasterCard,
         :token => token2,
@@ -1266,7 +1266,7 @@ describe Braintree::Customer do
 
       token1 = random_payment_method_token
 
-      payment_method1 = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::TransactableVisa,
         :token => token1,
@@ -1277,7 +1277,7 @@ describe Braintree::Customer do
 
       token2 = random_payment_method_token
 
-      payment_method2 = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::TransactableMasterCard,
         :token => token2,
@@ -1451,7 +1451,7 @@ describe Braintree::Customer do
         :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
         :credit_card => {
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "xx",
@@ -1475,7 +1475,7 @@ describe Braintree::Customer do
         :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
         :credit_card => {
           :three_d_secure_pass_thru => {
-            :eci_flag => "02",
+            :eci_flag => "05",
             :cavv => "some_cavv",
             :xid => "some_xid",
             :three_d_secure_version => "2.2.1",

data/spec/integration/braintree/dispute_search_spec.rb

@@ -74,7 +74,6 @@ describe Braintree::Dispute, "search" do
       end
 
       expect(collection.disputes.count).to be >= 2
-      dispute = collection.disputes.first
     end
 
     it "correctly returns disputes by chargeback protection level flag" do

data/spec/integration/braintree/dispute_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::Dispute do
   let(:document_upload) do
     file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
     response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
-    document_upload = response.document_upload
+    response.document_upload
   end
 
   let(:transaction) do

data/spec/integration/braintree/document_upload_spec.rb

@@ -67,7 +67,7 @@ describe Braintree::DocumentUploadGateway do
 
     it "returns invalid keys error if signature is invalid" do
       expect do
-        response = Braintree::DocumentUpload.create({:invalid_key => "do not add", :kind => Braintree::DocumentUpload::Kind::EvidenceDocument})
+        Braintree::DocumentUpload.create({:invalid_key => "do not add", :kind => Braintree::DocumentUpload::Kind::EvidenceDocument})
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end

data/spec/integration/braintree/http_spec.rb

@@ -255,7 +255,6 @@ describe Braintree::Http do
         old_logger = Braintree::Configuration.logger
         output = StringIO.new
         Braintree::Configuration.logger = Logger.new(output)
-        utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
         context.error = 19
         expect(Braintree::Configuration.instantiate.http._verify_ssl_certificate(false, context)).to eq(false)
@@ -270,7 +269,6 @@ describe Braintree::Http do
         old_logger = Braintree::Configuration.logger
         output = StringIO.new
         Braintree::Configuration.logger = Logger.new(output)
-        utc_or_gmt = Time.now.utc.strftime("%Z")
         context = OpenSSL::X509::StoreContext.new(OpenSSL::X509::Store.new)
         expect do
           Braintree::Configuration.instantiate.http._verify_ssl_certificate(true, context)

data/spec/integration/braintree/oauth_spec.rb

@@ -36,7 +36,7 @@ describe "OAuth" do
       )
 
       expect(result).not_to be_success
-      errors = expect(result.errors.for(:credentials).on(:code)[0].code).to eq(Braintree::ErrorCodes::OAuth::InvalidGrant)
+      expect(result.errors.for(:credentials).on(:code)[0].code).to eq(Braintree::ErrorCodes::OAuth::InvalidGrant)
       expect(result.message).to match(/Invalid grant: code not found/)
     end
 

data/spec/integration/braintree/package_tracking_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction do
+    describe "self.package_tracking" do
+        it "returns validation error message from gateway api" do
+            # Create Transaction
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :options => {
+              :submit_for_settlement => true
+            },
+            :paypal_account => {
+              :payer_id => "fake-payer-id",
+              :payment_id => "fake-payment-id",
+            },
+          )
+
+          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
+
+          # Create Transaction
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :options => {
+              :submit_for_settlement => true
+            },
+            :paypal_account => {
+              :payer_id => "fake-payer-id",
+              :payment_id => "fake-payment-id",
+            },
+          )
+
+          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")
+
+
+          # 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")
+
+          # Find transaction gives both packages
+          findTransaction = Braintree::Transaction.find(result.transaction.id)
+          expect(findTransaction.packages.length).to eq(2)
+        end
+    end
+end

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -97,7 +97,7 @@ describe Braintree::PaymentMethodNonce do
       nonce.details.bin.should == "401288"
       nonce.details.last_two.should == "81"
       nonce.details.card_type.should == "Visa"
-      nonce.details.expiration_year.should == "2024"
+      nonce.details.expiration_year.should == Date.today().next_year().year.to_s
       nonce.details.expiration_month.should == "12"
     end
 
@@ -107,7 +107,7 @@ describe Braintree::PaymentMethodNonce do
       nonce.details.bin.should == "401288"
       nonce.details.last_two.should == "81"
       nonce.details.card_type.should == "Visa"
-      nonce.details.expiration_year.should == "2024"
+      nonce.details.expiration_year.should == Date.today().next_year().year.to_s
       nonce.details.expiration_month.should == "12"
     end
 

data/spec/integration/braintree/payment_method_spec.rb

@@ -342,7 +342,7 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::Transactable,
         :three_d_secure_pass_thru => {
-          :eci_flag => "02",
+          :eci_flag => "05",
           :cavv => "some_cavv",
           :xid => "some_xid",
           :three_d_secure_version => "xx",
@@ -365,7 +365,7 @@ describe Braintree::PaymentMethod do
         :customer_id => customer.id,
         :payment_method_nonce => Braintree::Test::Nonce::Transactable,
         :three_d_secure_pass_thru => {
-          :eci_flag => "02",
+          :eci_flag => "05",
           :cavv => "some_cavv",
           :xid => "some_xid",
           :three_d_secure_version => "1.0.2",
@@ -390,15 +390,14 @@ describe Braintree::PaymentMethod do
       expect(result.success?).to eq(true)
 
       three_d_secure_info = result.payment_method.verification.three_d_secure_info
-      expect(three_d_secure_info.enrolled).to eq("Y")
+      expect(three_d_secure_info.status).to eq("authenticate_successful")
       expect(three_d_secure_info).to be_liability_shifted
       expect(three_d_secure_info).to be_liability_shift_possible
-      expect(three_d_secure_info.status).to eq("authenticate_successful")
-      expect(three_d_secure_info.cavv).to eq("cavv_value")
-      expect(three_d_secure_info.xid).to eq("xid_value")
-      expect(three_d_secure_info.eci_flag).to eq("05")
-      expect(three_d_secure_info.three_d_secure_version).to eq("1.0.2")
-      expect(three_d_secure_info.ds_transaction_id).to eq(nil)
+      expect(three_d_secure_info.enrolled).to be_a(String)
+      expect(three_d_secure_info.cavv).to be_a(String)
+      expect(three_d_secure_info.xid).to be_a(String)
+      expect(three_d_secure_info.eci_flag).to be_a(String)
+      expect(three_d_secure_info.three_d_secure_version).to be_a(String)
     end
 
     it "respects fail_on_duplicate_payment_method when included outside of the nonce" do
@@ -1409,7 +1408,6 @@ describe Braintree::PaymentMethod do
 
     it "raises a NotFoundError exception if payment method cannot be found" do
       token = make_token
-      customer = Braintree::Customer.create!
 
       expect do
         Braintree::PaymentMethod.delete(token)
@@ -1878,7 +1876,7 @@ describe Braintree::PaymentMethod do
         )
 
         updated_token = make_token
-        updated_result = Braintree::PaymentMethod.update(
+        Braintree::PaymentMethod.update(
           original_token,
           :token => updated_token,
         )
@@ -1907,7 +1905,7 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
         ).payment_method.token
 
-        updated_result = Braintree::PaymentMethod.update(
+        Braintree::PaymentMethod.update(
           original_token,
           :options => {:make_default => true},
         )
@@ -1925,7 +1923,7 @@ describe Braintree::PaymentMethod do
           :consent_code => "consent-code",
           :token => first_token,
         )
-        first_result = Braintree::PaymentMethod.create(
+        Braintree::PaymentMethod.create(
           :payment_method_nonce => first_nonce,
           :customer_id => customer.id,
         )
@@ -1934,7 +1932,7 @@ describe Braintree::PaymentMethod do
           :consent_code => "consent-code",
           :token => second_token,
         )
-        second_result = Braintree::PaymentMethod.create(
+        Braintree::PaymentMethod.create(
           :payment_method_nonce => second_nonce,
           :customer_id => customer.id,
         )

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -116,7 +116,7 @@ describe Braintree::PaymentMethod do
 
         it "returns additional processor response for failed NetworkCheck" do
           customer = Braintree::Customer.create.customer
-          invalid_nonce = generate_non_plaid_us_bank_account_nonce(account_number = "1000000005")
+          invalid_nonce = generate_non_plaid_us_bank_account_nonce("1000000005")
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => invalid_nonce,
             :customer_id => customer.id,
@@ -189,7 +189,7 @@ describe Braintree::PaymentMethod do
       context "unverified token" do
         let(:payment_method) do
           customer = Braintree::Customer.create.customer
-          result = Braintree::PaymentMethod.create(
+          Braintree::PaymentMethod.create(
             :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
             :customer_id => customer.id,
             :options => {
@@ -260,7 +260,7 @@ describe Braintree::PaymentMethod do
       context "unverified token" do
         let(:payment_method) do
           customer = Braintree::Customer.create.customer
-          result = Braintree::PaymentMethod.create(
+          Braintree::PaymentMethod.create(
             :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
             :customer_id => customer.id,
             :options => {

data/spec/integration/braintree/paypal_account_spec.rb

@@ -51,7 +51,7 @@ describe Braintree::PayPalAccount do
 
     it "does not return a different payment method type" do
       customer = Braintree::Customer.create!
-      result = Braintree::CreditCard.create(
+      Braintree::CreditCard.create(
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
@@ -171,7 +171,7 @@ describe Braintree::PayPalAccount do
       )
 
       updated_token = "UPDATED_TOKEN-" + rand(36**3).to_s(36)
-      updated_result = Braintree::PayPalAccount.update(
+      Braintree::PayPalAccount.update(
         original_token,
         :token => updated_token,
       )
@@ -200,7 +200,7 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
       ).payment_method.token
 
-      updated_result = Braintree::PayPalAccount.update(
+      Braintree::PayPalAccount.update(
         original_token,
         :options => {:make_default => true},
       )
@@ -218,7 +218,7 @@ describe Braintree::PayPalAccount do
         :consent_code => "consent-code",
         :token => first_token,
       )
-      first_result = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :payment_method_nonce => first_nonce,
         :customer_id => customer.id,
       )
@@ -227,7 +227,7 @@ describe Braintree::PayPalAccount do
         :consent_code => "consent-code",
         :token => second_token,
       )
-      second_result = Braintree::PaymentMethod.create(
+      Braintree::PaymentMethod.create(
         :payment_method_nonce => second_nonce,
         :customer_id => customer.id,
       )
@@ -256,7 +256,7 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
       )
 
-      result = Braintree::PayPalAccount.delete(token)
+      Braintree::PayPalAccount.delete(token)
 
       expect do
         Braintree::PayPalAccount.find(token)

data/spec/integration/braintree/plan_spec.rb

@@ -113,7 +113,6 @@ describe Braintree::Plan do
     end
 
     it "returns the updated plan if valid" do
-      new_id = rand(36**9).to_s(36)
       plan = Braintree::Plan.update!(@plan.id,
                                      :name => "updated name",
                                      :price => 99.88,

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -53,8 +53,6 @@ describe Braintree::SepaDirectDebitAccount do
 
     context "subscriptions" do
       it "returns subscriptions associated with a SEPA direct debit account" do
-        customer = Braintree::Customer.create!
-
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => token,
           :plan_id => SpecHelper::TriallessPlan[:id],

data/spec/integration/braintree/subscription_spec.rb

@@ -136,7 +136,6 @@ describe Braintree::Subscription do
       end
 
       it "returns an error if the payment_method_nonce hasn't been vaulted" do
-        customer = Braintree::Customer.create!
         result = Braintree::Subscription.create(
           :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
           :plan_id => SpecHelper::TriallessPlan[:id],
@@ -937,17 +936,17 @@ describe Braintree::Subscription do
 
       it "has validation errors on duplicate id" do
         duplicate_id = "new_id_#{rand(36**6).to_s(36)}"
-        duplicate = Braintree::Subscription.create(
+        Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
           :id => duplicate_id,
         )
-        result = Braintree::Subscription.update(
+        duplicate = Braintree::Subscription.update(
           @subscription.id,
           :id => duplicate_id,
         )
-        expect(result.success?).to eq(false)
-        expect(result.errors.for(:subscription).on(:id)[0].code).to eq(Braintree::ErrorCodes::Subscription::IdIsInUse)
+        expect(duplicate.success?).to eq(false)
+        expect(duplicate.errors.for(:subscription).on(:id)[0].code).to eq(Braintree::ErrorCodes::Subscription::IdIsInUse)
       end
 
       it "cannot update a canceled subscription" do
@@ -1203,7 +1202,7 @@ describe Braintree::Subscription do
 
     it "returns a validation error if record not found" do
       expect {
-        r = Braintree::Subscription.cancel("noSuchSubscription")
+        Braintree::Subscription.cancel("noSuchSubscription")
       }.to raise_error(Braintree::NotFoundError, 'subscription with id "noSuchSubscription" not found')
     end
 

data/spec/integration/braintree/transaction_line_item_spec.rb

@@ -18,6 +18,9 @@ describe Braintree::TransactionLineItem do
             :kind => "debit",
             :unit_amount => "45.1232",
             :total_amount => "45.15",
+            :upc_code => "11223344556677889",
+            :upc_type => "UPC-A",
+            :image_url => "https://google.com/image.png",
           },
         ],
       )
@@ -32,6 +35,9 @@ describe Braintree::TransactionLineItem do
       expect(line_item.kind).to eq("debit")
       expect(line_item.unit_amount).to eq(BigDecimal("45.1232"))
       expect(line_item.total_amount).to eq(BigDecimal("45.15"))
+      expect(line_item.upc_type).to eq("UPC-A")
+      expect(line_item.upc_code).to eq("11223344556677889")
+      expect(line_item.image_url).to eq("https://google.com/image.png")
     end
   end
 end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -640,7 +640,7 @@ describe Braintree::Transaction, "search" do
     context "invalid search" do
       it "raises an exception on invalid transaction type" do
         expect do
-          collection = Braintree::Transaction.search do |search|
+          Braintree::Transaction.search do |search|
             search.customer_id.is "9171566"
             search.type.is "settled"
           end
@@ -649,7 +649,7 @@ describe Braintree::Transaction, "search" do
 
       it "raises an exception on invalid debit network" do
         expect do
-          collection = Braintree::Transaction.search do |search|
+          Braintree::Transaction.search do |search|
             search.debit_network.is "invalid_network"
           end
         end.to raise_error(ArgumentError)
@@ -849,8 +849,6 @@ describe Braintree::Transaction, "search" do
 
       context "ach return response created at" do
         it "it finds records within date range of the custom field" do
-          reason_code = "any_reason_code"
-
           date_search = Braintree::Transaction.search do |search|
             search.ach_return_responses_created_at.between(DateTime.now - 1.0, DateTime.now + 1.0)
           end
@@ -859,8 +857,6 @@ describe Braintree::Transaction, "search" do
         end
 
         it "it does not find records not within date range of the custom field" do
-          reason_code = "any_reason_code"
-
           neg_date_search = Braintree::Transaction.search do |search|
            search.ach_return_responses_created_at.between(DateTime.now + 1.0, DateTime.now - 1.0)
           end
@@ -1488,7 +1484,7 @@ describe Braintree::Transaction, "search" do
     context "when the search times out" do
       it "raises a UnexpectedError" do
         expect {
-          collection = Braintree::Transaction.search do |search|
+          Braintree::Transaction.search do |search|
             search.amount.is(-10)
           end
         }.to raise_error(Braintree::UnexpectedError)