braintree 2.74.0 → 4.12.0

data/spec/unit/braintree/transaction/sepa_direct_debit_account_details_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::SepaDirectDebitAccountDetails do
+  describe "initialize" do
+    let(:params) do
+      {
+        bank_reference_token: "a-reference-token",
+        capture_id: "a-capture-id",
+        debug_id: "a-debug-id",
+        global_id: "a-global-id",
+        last_4: "1234",
+        mandate_type: "ONE_OFF",
+        merchant_or_partner_customer_id: "12312312343",
+        paypal_v2_order_id: "a-paypal-v2-order-id",
+        refund_from_transaction_fee_amount: "2.34",
+        refund_from_transaction_fee_currency_iso_code: "EUR",
+        refund_id: "a-refund-id",
+        settlement_type: "INSTANT",
+        token: "a-token",
+        transaction_fee_amount: "12.34",
+        transaction_fee_currency_iso_code: "EUR",
+      }
+    end
+
+    subject do
+      described_class.new(params)
+    end
+
+    it "sets all fields" do
+      is_expected.to have_attributes(**params)
+    end
+  end
+end

data/spec/unit/braintree/transaction_gateway_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::TransactionGateway do
+  describe "Transaction Gateway" do
+    let(:gateway) do
+      config = Braintree::Configuration.new(
+        :merchant_id => "merchant_id",
+        :public_key => "public_key",
+        :private_key => "private_key",
+      )
+      Braintree::Gateway.new(config)
+    end
+
+    it "creates a transactionGateway gateway" do
+      result = Braintree::TransactionGateway.new(gateway)
+
+      result.inspect.should include("merchant_id")
+      result.inspect.should include("public_key")
+      result.inspect.should include("private_key")
+    end
+
+    describe "self.create" do
+      it "raises an exception if attributes contain an invalid key" do
+        expect do
+          transaction = Braintree::TransactionGateway.new(gateway)
+          transaction.create(:invalid_key => "val")
+        end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+      end
+    end
+
+    it "creates a transaction gateway signature" do
+      expect(Braintree::TransactionGateway._create_signature).to match([
+        :amount, :billing_address_id, :channel, :customer_id, :device_data, :discount_amount,
+        :merchant_account_id, :order_id, :payment_method_nonce, :payment_method_token,
+        :product_sku, :purchase_order_number, :service_fee_amount, :shared_billing_address_id,
+        :shared_customer_id, :shared_payment_method_nonce, :shared_payment_method_token,
+        :shared_shipping_address_id, :shipping_address_id, :shipping_amount,
+        :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,
+        :three_d_secure_token, :transaction_source, :type, :venmo_sdk_payment_method_code,
+        :sca_exemption, :currency_iso_code, :exchange_rate_quote_id,
+        {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
+        {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
+        {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number, {:payment_reader_card_details => [:encrypted_card_data, :key_serial_number]}, {:network_tokenization_attributes => [:cryptogram, :ecommerce_indicator, :token_requestor_id]}]},
+        {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
+        {
+          :billing => Braintree::AddressGateway._shared_signature
+        },
+        {
+          :shipping => Braintree::AddressGateway._shared_signature + [:shipping_method],
+        },
+        {
+          :three_d_secure_pass_thru => [
+            :eci_flag,
+            :cavv,
+            :xid,
+            :three_d_secure_version,
+            :authentication_response,
+            :directory_response,
+            :cavv_algorithm,
+            :ds_transaction_id,
+          ]
+        },
+        {:options => [
+          :hold_in_escrow,
+          :store_in_vault,
+          :store_in_vault_on_success,
+          :submit_for_settlement,
+          :add_billing_address_to_payment_method,
+          :store_shipping_address_in_vault,
+          :venmo_sdk_session,
+          :payee_id,
+          :payee_email,
+          :skip_advanced_fraud_checking,
+          :skip_avs,
+          :skip_cvv,
+          {:paypal => [:custom_field, :payee_id, :payee_email, :description, {:supplementary_data => :_any_key_}]},
+          {:three_d_secure => [:required]},
+          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]},
+          {:venmo => [:profile_id]},
+          {:credit_card => [:account_type]},
+        ]
+        },
+        {:external_vault => [
+          :status,
+          :previous_network_transaction_id,
+        ]},
+        {:custom_fields => :_any_key_},
+        {:descriptor => [:name, :phone, :url]},
+        {:paypal_account => [:email, :token, :paypal_data, :payee_id, :payee_email, :payer_id, :payment_id]},
+        {:industry => [
+          :industry_type,
+          {:data => [
+            :folio_number, :check_in_date, :check_out_date, :travel_package, :lodging_check_in_date, :lodging_check_out_date, :departure_date, :lodging_name, :room_rate, :room_tax,
+            :passenger_first_name, :passenger_last_name, :passenger_middle_initial, :passenger_title, :issued_date, :travel_agency_name, :travel_agency_code, :ticket_number,
+            :issuing_carrier_code, :customer_code, :fare_amount, :fee_amount, :tax_amount, :restricted_ticket, :no_show, :advanced_deposit, :fire_safe, :property_phone,
+            {:legs => [
+              :conjunction_ticket, :exchange_ticket, :coupon_number, :service_class, :carrier_code, :fare_basis_code, :flight_number, :departure_date, :departure_airport_code, :departure_time,
+              :arrival_airport_code, :arrival_time, :stopover_permitted, :fare_amount, :fee_amount, :tax_amount, :endorsement_or_restrictions,
+            ]},
+            {:additional_charges => [
+              :kind, :amount,
+            ]},
+          ]},
+        ]},
+        {:apple_pay_card => [:number, :cardholder_name, :cryptogram, :expiration_month, :expiration_year, :eci_indicator]},
+        {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]},
+        {:installments => [:count]},
+      ])
+    end
+  end
+end

data/spec/unit/braintree/transaction_search_spec.rb

@@ -1,19 +1,19 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::TransactionSearch do
-	it "overrides previous 'is' with new 'is' for the same field" do
-		search = Braintree::TransactionSearch.new
-		search.billing_company.is "one"
-		search.billing_company.is "two"
-		search.to_hash.should == {:billing_company => {:is => "two"}}
-	end
+  it "overrides previous 'is' with new 'is' for the same field" do
+    search = Braintree::TransactionSearch.new
+    search.billing_company.is "one"
+    search.billing_company.is "two"
+    search.to_hash.should == {:billing_company => {:is => "two"}}
+  end
 
-	it "overrides previous 'in' with new 'in' for the same field" do
-		search = Braintree::TransactionSearch.new
-		search.status.in Braintree::Transaction::Status::Authorized
-		search.status.in Braintree::Transaction::Status::SubmittedForSettlement
-		search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
-	end
+  it "overrides previous 'in' with new 'in' for the same field" do
+    search = Braintree::TransactionSearch.new
+    search.status.in Braintree::Transaction::Status::Authorized
+    search.status.in Braintree::Transaction::Status::SubmittedForSettlement
+    search.to_hash.should == {:status => [Braintree::Transaction::Status::SubmittedForSettlement]}
+  end
 
   it "raises if the operator 'is' is left off" do
     search = Braintree::TransactionSearch.new

data/spec/unit/braintree/transaction_spec.rb

@@ -17,45 +17,38 @@ describe Braintree::Transaction do
     end
   end
 
-  describe "self.create_from_transparent_redirect" do
-    it "raises an exception if the query string is forged" do
-      expect do
-        Braintree::Transaction.create_from_transparent_redirect("http_status=200&forged=query_string")
-      end.to raise_error(Braintree::ForgedQueryString)
-    end
-  end
-
   describe "self.find" do
     it "raises error if passed empty string" do
       expect do
         Braintree::Transaction.find("")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed empty string wth space" do
       expect do
         Braintree::Transaction.find(" ")
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
 
     it "raises error if passed nil" do
       expect do
         Braintree::Transaction.find(nil)
-      end.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError, "id can not be empty")
     end
   end
 
-  describe "self.create_transaction_url" do
-    it "returns the url" do
-      config = Braintree::Configuration.instantiate
-      Braintree::Transaction.create_transaction_url.should == "http#{config.ssl? ? 's' : ''}://#{config.server}:#{config.port}/merchants/integration_merchant_id/transactions/all/create_via_transparent_redirect_request"
+  describe "self.submit_for_settlement" do
+    it "raises an ArgumentError if transaction_id is an invalid format" do
+      expect do
+        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+      end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
 
-  describe "self.submit_for_settlement" do
+  describe "self.adjust_authorization" do
     it "raises an ArgumentError if transaction_id is an invalid format" do
       expect do
-        Braintree::Transaction.submit_for_settlement("invalid-transaction-id")
+        Braintree::Transaction.adjust_authorization("invalid-transaction-id", "10.00")
       end.to raise_error(ArgumentError, "transaction_id is invalid")
     end
   end
@@ -81,7 +74,7 @@ describe Braintree::Transaction do
           :website => "lednerllc.com",
           :phone => "1-999-652-4189 x56883",
           :fax => "012-161-8055"
-        }
+        },
       )
       transaction.customer_details.id.should == "123"
       transaction.customer_details.first_name.should == "Adam"
@@ -103,10 +96,10 @@ describe Braintree::Transaction do
           :settlement_currency_exchange_rate => "1",
           :funds_held => false,
           :success => true
-        }
+        },
       )
       disbursement = transaction.disbursement_details
-      disbursement.disbursement_date.should == "2013-04-03"
+      disbursement.disbursement_date.should == Date.parse("2013-04-03")
       disbursement.settlement_amount.should == "120.00"
       disbursement.settlement_currency_iso_code.should == "USD"
       disbursement.settlement_currency_exchange_rate.should == "1"
@@ -134,7 +127,7 @@ describe Braintree::Transaction do
           :product_id => "Unknown",
           :country_of_issuance => "Narnia",
           :issuing_bank => "Mr Tumnus"
-        }
+        },
       )
       transaction.credit_card_details.token.should == "mzg2"
       transaction.credit_card_details.bin.should == "411111"
@@ -154,6 +147,48 @@ describe Braintree::Transaction do
       transaction.credit_card_details.issuing_bank.should == "Mr Tumnus"
     end
 
+    it "sets up network token attributes in network_token_details" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_token => {
+          :token => "mzg2",
+          :bin => "411111",
+          :last_4 => "1111",
+          :card_type => "Visa",
+          :expiration_month => "08",
+          :expiration_year => "2009",
+          :customer_location => "US",
+          :prepaid => "Yes",
+          :healthcare => "Yes",
+          :durbin_regulated => "Yes",
+          :debit => "Yes",
+          :commercial => "No",
+          :payroll => "Unknown",
+          :product_id => "Unknown",
+          :country_of_issuance => "Narnia",
+          :issuing_bank => "Mr Tumnus",
+          :is_network_tokenized => true
+        },
+      )
+      transaction.network_token_details.token.should == "mzg2"
+      transaction.network_token_details.bin.should == "411111"
+      transaction.network_token_details.last_4.should == "1111"
+      transaction.network_token_details.card_type.should == "Visa"
+      transaction.network_token_details.expiration_month.should == "08"
+      transaction.network_token_details.expiration_year.should == "2009"
+      transaction.network_token_details.customer_location.should == "US"
+      transaction.network_token_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+      transaction.network_token_details.healthcare.should == Braintree::CreditCard::Healthcare::Yes
+      transaction.network_token_details.durbin_regulated.should == Braintree::CreditCard::DurbinRegulated::Yes
+      transaction.network_token_details.debit.should == Braintree::CreditCard::Debit::Yes
+      transaction.network_token_details.commercial.should == Braintree::CreditCard::Commercial::No
+      transaction.network_token_details.payroll.should == Braintree::CreditCard::Payroll::Unknown
+      transaction.network_token_details.product_id.should == Braintree::CreditCard::ProductId::Unknown
+      transaction.network_token_details.country_of_issuance.should == "Narnia"
+      transaction.network_token_details.issuing_bank.should == "Mr Tumnus"
+      transaction.network_token_details.is_network_tokenized?.should == true
+    end
+
     it "sets up three_d_secure_info" do
       transaction = Braintree::Transaction._new(
         :gateway,
@@ -162,7 +197,7 @@ describe Braintree::Transaction do
           :liability_shifted => true,
           :liability_shift_possible => true,
           :status => "authenticate_successful",
-        }
+        },
       )
 
       transaction.three_d_secure_info.enrolled.should == "Y"
@@ -171,33 +206,14 @@ describe Braintree::Transaction do
       transaction.three_d_secure_info.liability_shift_possible.should == true
     end
 
-    it "sets up ideal_payment_details" do
-      transaction = Braintree::Transaction._new(
-        :gateway,
-        :ideal_payment => {
-          :ideal_payment_id => "idealpayment_abc_123",
-          :ideal_transaction_id => "1150000008857321",
-          :masked_iban => "12************7890",
-          :bic => "RABONL2U",
-          :image_url => "http://www.example.com/ideal.png"
-        }
-      )
-
-      transaction.ideal_payment_details.ideal_payment_id.should == "idealpayment_abc_123"
-      transaction.ideal_payment_details.ideal_transaction_id.should == "1150000008857321"
-      transaction.ideal_payment_details.masked_iban.should == "12************7890"
-      transaction.ideal_payment_details.bic.should == "RABONL2U"
-      transaction.ideal_payment_details.image_url.should == "http://www.example.com/ideal.png"
-    end
-
     it "sets up history attributes in status_history" do
       time = Time.utc(2010,1,14)
       transaction = Braintree::Transaction._new(
         :gateway,
         :status_history => [
-          { :timestamp => time, :amount => "12.00", :transaction_source => "API",
-            :user => "larry", :status => Braintree::Transaction::Status::Authorized },
-          { :timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
+          {:timestamp => time, :amount => "12.00", :transaction_source => "API",
+            :user => "larry", :status => Braintree::Transaction::Status::Authorized},
+          {:timestamp => Time.utc(2010,1,15), :amount => "12.00", :transaction_source => "API",
             :user => "curly", :status => "scheduled_for_settlement"}
         ])
       transaction.status_history.size.should == 2
@@ -209,16 +225,37 @@ describe Braintree::Transaction do
       transaction.status_history[1].user.should == "curly"
     end
 
+    it "sets up authorization_adjustments" do
+      timestamp = Time.utc(2010,1,14)
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :authorization_adjustments => [
+          {:timestamp => timestamp, :processor_response_code => "1000", :processor_response_text => "Approved", :amount => "12.00", :success => true},
+          {:timestamp => timestamp, :processor_response_code => "3000", :processor_response_text => "Processor Network Unavailable - Try Again", :amount => "12.34", :success => false},
+        ])
+      transaction.authorization_adjustments.size.should == 2
+      transaction.authorization_adjustments[0].amount.should == "12.00"
+      transaction.authorization_adjustments[0].success.should == true
+      transaction.authorization_adjustments[0].timestamp.should == timestamp
+      transaction.authorization_adjustments[0].processor_response_code.should == "1000"
+      transaction.authorization_adjustments[0].processor_response_text.should == "Approved"
+      transaction.authorization_adjustments[1].amount.should == "12.34"
+      transaction.authorization_adjustments[1].success.should == false
+      transaction.authorization_adjustments[1].timestamp.should == timestamp
+      transaction.authorization_adjustments[1].processor_response_code.should == "3000"
+      transaction.authorization_adjustments[1].processor_response_text.should == "Processor Network Unavailable - Try Again"
+    end
+
     it "handles receiving custom as an empty string" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :custom => "\n    "
+        :custom => "\n    ",
       )
     end
 
     it "accepts amount as either a String or a BigDecimal" do
-      Braintree::Transaction._new(:gateway, :amount => "12.34").amount.should == BigDecimal.new("12.34")
-      Braintree::Transaction._new(:gateway, :amount => BigDecimal.new("12.34")).amount.should == BigDecimal.new("12.34")
+      Braintree::Transaction._new(:gateway, :amount => "12.34").amount.should == BigDecimal("12.34")
+      Braintree::Transaction._new(:gateway, :amount => BigDecimal("12.34")).amount.should == BigDecimal("12.34")
     end
 
     it "blows up if amount is not a string or BigDecimal" do
@@ -230,23 +267,84 @@ describe Braintree::Transaction do
     it "handles nil risk_data" do
       transaction = Braintree::Transaction._new(
         :gateway,
-        :risk_data => nil
+        :risk_data => nil,
       )
       transaction.risk_data.should be_nil
     end
+
+    it "accepts network_transaction_id" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_transaction_id => "123456789012345",
+      )
+      transaction.network_transaction_id.should == "123456789012345"
+    end
+
+    it "accepts ach_return_code" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :ach_return_code => "R01",
+      )
+      expect(transaction.ach_return_code).to eq("R01")
+    end
+
+    it "accepts network_response code and network_response_text" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :network_response_code => "00",
+        :network_response_text => "Successful approval/completion or V.I.P. PIN verification is successful",
+      )
+      expect(transaction.network_response_code).to eq("00")
+      expect(transaction.network_response_text).to eq("Successful approval/completion or V.I.P. PIN verification is successful")
+    end
+
+    it "accepts merchant_advice_code and merchant_advice_text" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :merchant_advice_code => "01",
+        :merchant_advice_code_text => "New account information available",
+      )
+      expect(transaction.merchant_advice_code).to eq("01")
+      expect(transaction.merchant_advice_code_text).to eq("New account information available")
+    end
+
+    it "accepts sepa_direct_debit_return_code" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :sepa_direct_debit_return_code => "AM04",
+      )
+      expect(transaction.sepa_direct_debit_return_code).to eq("AM04")
+    end
+
+    it "accepts sepa_direct_debit_account_details" do
+      transaction = Braintree::Transaction._new(
+        :gateway,
+        :id => "123",
+        :type => "sale",
+        :amount => "12.34",
+        :status => "settled",
+        :sepa_debit_account_detail => {
+          :token => "1234",
+        },
+      )
+      details = transaction.sepa_direct_debit_account_details
+      details.token.should == "1234"
+    end
   end
 
   describe "inspect" do
-    it "includes the id, type, amount, and status first" do
+    it "includes the id, type, amount, status, and processed_with_network_token?" do
       transaction = Braintree::Transaction._new(
         :gateway,
         :id => "1234",
         :type => "sale",
         :amount => "100.00",
-        :status => Braintree::Transaction::Status::Authorized
+        :status => Braintree::Transaction::Status::Authorized,
+        :processed_with_network_token => false,
       )
       output = transaction.inspect
       output.should include(%Q(#<Braintree::Transaction id: "1234", type: "sale", amount: "100.0", status: "authorized"))
+      output.should include(%Q(processed_with_network_token?: false))
     end
   end
 
@@ -300,8 +398,8 @@ describe Braintree::Transaction do
   end
 
   describe "sale" do
-    let(:mock_response) { {:transaction => {}}}
-    let(:http_stub) { double('http_stub').as_null_object }
+    let(:mock_response) { {:transaction => {}} }
+    let(:http_stub) { double("http_stub").as_null_object }
 
     RSpec::Matchers.define :skip_advanced_fraud_check_value_is do |value|
         match { |params| params[:transaction][:options][:skip_advanced_fraud_checking] == value }
@@ -319,7 +417,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => true
-        }
+        },
       )
     end
 
@@ -335,7 +433,7 @@ describe Braintree::Transaction do
         },
         :options => {
           :skip_advanced_fraud_checking => false
-        }
+        },
       )
     end
 
@@ -351,9 +449,27 @@ describe Braintree::Transaction do
         },
         :options => {
           :submit_for_settlement => false
-        }
+        },
       )
     end
   end
 
+  describe "processed_with_network_token?" do
+    it "is true if the transaction was processed with a network token" do
+      transaction = Braintree::Transaction._new(:gateway, :processed_with_network_token => true)
+      transaction.processed_with_network_token?.should == true
+    end
+
+    it "is false if the transaction was not processed with a network token" do
+      transaction = Braintree::Transaction._new(:gateway, :processed_with_network_token => false)
+      transaction.processed_with_network_token?.should == false
+    end
+  end
+
+  describe "gateway rejection reason" do
+    it "verifies excessive_retry mapping" do
+      transaction = Braintree::Transaction._new(:gateway, :gateway_rejection_reason => "excessive_retry")
+      transaction.gateway_rejection_reason.should == Braintree::Transaction::GatewayRejectionReason::ExcessiveRetry
+    end
+  end
 end

data/spec/unit/braintree/us_bank_account_verification_search_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+module Braintree
+  describe UsBankAccountVerificationSearch do
+    context "verification method" do
+      it "allows All verification methods" do
+        search = UsBankAccountVerificationSearch.new
+
+        lambda do
+          search.verification_method.in(
+            *Braintree::UsBankAccountVerification::VerificationMethod::All,
+          )
+        end.should_not raise_error
+      end
+    end
+
+    context "id" do
+      it "is" do
+        search = UsBankAccountVerificationSearch.new
+        search.id.is "v_id"
+
+        search.to_hash.should == {:id => {:is => "v_id"}}
+      end
+    end
+
+    context "ids" do
+      it "correctly builds a hash with ids" do
+        search = UsBankAccountVerificationSearch.new
+        search.ids.in("id1", "id2")
+
+        search.to_hash.should == {:ids => ["id1", "id2"]}
+      end
+    end
+
+    context "account_holder_name" do
+      it "is" do
+        search = UsBankAccountVerificationSearch.new
+        search.account_holder_name.is "v_account_holder_name"
+
+        search.to_hash.should == {:account_holder_name => {:is => "v_account_holder_name"}}
+      end
+    end
+
+    context "created_at" do
+      it "is a range node" do
+        search = UsBankAccountVerificationSearch.new
+        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+      end
+    end
+
+    context "account number" do
+      it "uses ends_with" do
+        search = UsBankAccountVerificationSearch.new
+        search.account_number.ends_with "1234"
+
+        search.to_hash.should == {:account_number => {:ends_with => "1234"}}
+      end
+    end
+  end
+end