braintree 3.4.0 → 4.3.0

data/spec/integration/braintree/dispute_search_spec.rb

@@ -78,6 +78,31 @@ describe Braintree::Dispute, "search" do
       dispute = collection.disputes.first
     end
 
+    it "correctly returns chargeback protected disputes" do
+      collection = Braintree::Dispute.search do |search|
+        search.case_number.is "CASE-CHARGEBACK-PROTECTED"
+      end
+
+      expect(collection.disputes.count).to eq(1)
+      dispute = collection.disputes.first
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      expect(dispute.reason).to eq(Braintree::Dispute::Reason::Fraud)
+    end
+
+    it "correctly returns disputes by chargeback protection level flag" do
+      collection = Braintree::Dispute.search do |search|
+        search.chargeback_protection_level.in [
+          Braintree::Dispute::ChargebackProtectionLevel::Effortless
+        ]
+      end
+      expect(collection.disputes.count).to eq(1)
+      dispute = collection.disputes.first
+
+      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+      expect(dispute.reason).to eq(Braintree::Dispute::Reason::Fraud)
+    end
+
     it "correctly returns disputes by effective_date range" do
       effective_date = transaction.disputes.first.status_history.first.effective_date
 

data/spec/integration/braintree/merchant_account_spec.rb

@@ -41,7 +41,7 @@ VALID_APPLICATION_PARAMS = {
   :business => {
     :legal_name => "Joe's Bloggs",
     :dba_name => "Joe's Junkyard",
-    :tax_id => "123456789",
+    :tax_id => "423456789",
     :address => {
       :street_address => "456 Fake St",
       :postal_code => "48104",
@@ -371,7 +371,7 @@ describe Braintree::MerchantAccount do
       params[:individual][:address][:postal_code] = "60622"
       params[:business][:dba_name] = "James's Bloggs"
       params[:business][:legal_name] = "James's Bloggs Inc"
-      params[:business][:tax_id] = "123456789"
+      params[:business][:tax_id] = "423456789"
       params[:business][:address][:street_address] = "999 Fake St"
       params[:business][:address][:locality] = "Miami"
       params[:business][:address][:region] = "FL"
@@ -397,7 +397,7 @@ describe Braintree::MerchantAccount do
       result.merchant_account.individual_details.address_details.postal_code.should == "60622"
       result.merchant_account.business_details.dba_name.should == "James's Bloggs"
       result.merchant_account.business_details.legal_name.should == "James's Bloggs Inc"
-      result.merchant_account.business_details.tax_id.should == "123456789"
+      result.merchant_account.business_details.tax_id.should == "423456789"
       result.merchant_account.business_details.address_details.street_address.should == "999 Fake St"
       result.merchant_account.business_details.address_details.locality.should == "Miami"
       result.merchant_account.business_details.address_details.region.should == "FL"

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -32,6 +32,7 @@ describe Braintree::PaymentMethodNonce do
       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
+      result.payment_method_nonce.default?.should be_truthy
     end
 
     it "correctly raises and exception for a non existent token" do
@@ -67,6 +68,7 @@ describe Braintree::PaymentMethodNonce do
       payment_method_nonce.should_not be_nil
       payment_method_nonce.nonce.should_not be_nil
       payment_method_nonce.details.should_not be_nil
+      payment_method_nonce.default?.should be_truthy
     end
   end
 
@@ -79,33 +81,24 @@ describe Braintree::PaymentMethodNonce do
       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"
+      nonce.details.bin.should == "401288"
+      nonce.details.card_type.should == "Visa"
+      nonce.details.expiration_month.should == "12"
+      nonce.details.expiration_year.should == "2022"
+      nonce.details.is_network_tokenized?.should be_nil
+      nonce.details.last_two.should == "81"
+      nonce.details.payer_info.should be_nil
     end
 
     it "return paypal details if details exist" do
       result = Braintree::PaymentMethodNonce.find("fake-paypal-one-time-nonce")
       nonce = result.payment_method_nonce
-
-      nonce.details.fetch(:cobranded_card_label).should_not be_nil
-      nonce.details.fetch(:shipping_option_id).should_not be_nil
-      nonce.details.fetch(:billing_address).fetch(:recipient_name).should_not be_nil
-      nonce.details.fetch(:shipping_address).fetch(:recipient_name).should_not be_nil
-
-      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
-    end
-
-    it "return venmo details if details exist" do
-      result = Braintree::PaymentMethodNonce.find("fake-venmo-account-nonce")
-
-      nonce = result.payment_method_nonce
-
-      nonce.details.fetch(:last_two).should == "99"
-      nonce.details.fetch(:username).should == "venmojoe"
-      nonce.details.fetch(:venmo_user_id).should == "Venmo-Joe-1"
+      nonce.details.payer_info.billing_agreement_id.should be_nil
+      nonce.details.payer_info.country_code.should be_nil
+      nonce.details.payer_info.email.should_not be_nil
+      nonce.details.payer_info.first_name.should_not be_nil
+      nonce.details.payer_info.last_name.should_not be_nil
+      nonce.details.payer_info.payer_id.should_not be_nil
     end
 
     it "returns null 3ds_info if there isn't any" do
@@ -131,7 +124,7 @@ describe Braintree::PaymentMethodNonce do
       nonce = result.payment_method_nonce
       result.should be_success
       nonce.details.should_not be_nil
-      nonce.details[:bin].should == "401288"
+      nonce.details.bin.should == "401288"
     end
 
     it "returns bin_data with commercial set to Yes" do

data/spec/integration/braintree/payment_method_spec.rb

@@ -99,6 +99,15 @@ describe Braintree::PaymentMethod do
       apple_pay_card.expiration_month.to_i.should > 0
       apple_pay_card.expiration_year.to_i.should > 0
       apple_pay_card.customer_id.should == customer.id
+      apple_pay_card.commercial.should_not be_nil
+      apple_pay_card.country_of_issuance.should_not be_nil
+      apple_pay_card.debit.should_not be_nil
+      apple_pay_card.durbin_regulated.should_not be_nil
+      apple_pay_card.healthcare.should_not be_nil
+      apple_pay_card.issuing_bank.should_not be_nil
+      apple_pay_card.payroll.should_not be_nil
+      apple_pay_card.prepaid.should_not be_nil
+      apple_pay_card.product_id.should_not be_nil
     end
 
     it "creates a payment method from a fake google pay proxy card nonce" do
@@ -127,6 +136,15 @@ describe Braintree::PaymentMethod do
       google_pay_card.google_transaction_id.should == "google_transaction_id"
       google_pay_card.source_description.should == "Discover 1111"
       google_pay_card.customer_id.should == customer.id
+      google_pay_card.commercial.should_not be_nil
+      google_pay_card.country_of_issuance.should_not be_nil
+      google_pay_card.debit.should_not be_nil
+      google_pay_card.durbin_regulated.should_not be_nil
+      google_pay_card.healthcare.should_not be_nil
+      google_pay_card.issuing_bank.should_not be_nil
+      google_pay_card.payroll.should_not be_nil
+      google_pay_card.prepaid.should_not be_nil
+      google_pay_card.product_id.should_not be_nil
     end
 
     it "creates a payment method from a google pay network token nonce" do
@@ -155,6 +173,15 @@ describe Braintree::PaymentMethod do
       google_pay_card.google_transaction_id.should == "google_transaction_id"
       google_pay_card.source_description.should == "MasterCard 4444"
       google_pay_card.customer_id.should == customer.id
+      google_pay_card.commercial.should_not be_nil
+      google_pay_card.country_of_issuance.should_not be_nil
+      google_pay_card.debit.should_not be_nil
+      google_pay_card.durbin_regulated.should_not be_nil
+      google_pay_card.healthcare.should_not be_nil
+      google_pay_card.issuing_bank.should_not be_nil
+      google_pay_card.payroll.should_not be_nil
+      google_pay_card.prepaid.should_not be_nil
+      google_pay_card.product_id.should_not be_nil
     end
 
     it "creates a payment method from venmo account nonce" do
@@ -527,6 +554,58 @@ describe Braintree::PaymentMethod do
       found_credit_card.billing_address.street_address.should == "456 Xyz Way"
     end
 
+    it "includes risk data when skip_advanced_fraud_checking is false" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!
+
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+        )
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => false,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.payment_method.verification
+        expect(verification.risk_data).not_to be_nil
+      end
+    end
+
+    it "does not include risk data when skip_advanced_fraud_checking is true" do
+      with_fraud_protection_enterprise_merchant do
+        customer = Braintree::Customer.create!
+
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009",
+          },
+        )
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :skip_advanced_fraud_checking => true,
+          },
+        )
+
+        expect(result).to be_success
+        verification = result.payment_method.verification
+        expect(verification.risk_data).to be_nil
+      end
+    end
+
     context "account_type" do
       it "verifies card with account_type debit" do
         nonce = nonce_for_new_payment_method(
@@ -1368,6 +1447,58 @@ describe Braintree::PaymentMethod do
         updated_credit_card.expiration_date.should == "06/2013"
       end
 
+      it "includes risk data when skip_advanced_fraud_checking is false" do
+        with_fraud_protection_enterprise_merchant do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(
+            credit_card.token,
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :skip_advanced_fraud_checking => false
+            },
+          )
+
+          expect(update_result).to be_success
+          verification = update_result.payment_method.verification
+          expect(verification.risk_data).not_to be_nil
+        end
+      end
+
+      it "does not include risk data when skip_advanced_fraud_checking is true" do
+        with_fraud_protection_enterprise_merchant do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012",
+          )
+          update_result = Braintree::PaymentMethod.update(
+            credit_card.token,
+            :cvv => "456",
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "06/2013",
+            :options => {
+              :verify_card => true,
+              :skip_advanced_fraud_checking => true
+            },
+          )
+
+          expect(update_result).to be_success
+          verification = update_result.payment_method.verification
+          expect(verification.risk_data).to be_nil
+        end
+      end
+
       context "verification_currency_iso_code" do
         it "validates verification_currency_iso_code and updates the credit card " do
           customer = Braintree::Customer.create!

data/spec/integration/braintree/transaction_spec.rb

@@ -999,6 +999,34 @@ describe Braintree::Transaction do
       result.transaction.credit_card_details.expiration_date.should == "05/2011"
     end
 
+    it "accepts exchange_rate_quote_id" do
+      result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+          },
+          :exchange_rate_quote_id => "dummyExchangeRateQuoteId-Brainree-Ruby",
+      )
+      result.success?.should == true
+      result.transaction.credit_card_details.expiration_date.should == "05/2009"
+    end
+
+    it "returns an error if provided invalid exchange_rate_quote_id" do
+      result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+          },
+          :exchange_rate_quote_id => "a" * 4010,
+      )
+      result.success?.should == false
+      result.errors.for(:transaction).on(:exchange_rate_quote_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExchangeRateQuoteIdTooLong
+    end
+
     it "returns some error if customer_id is invalid" do
       result = Braintree::Transaction.create(
         :type => "sale",
@@ -4386,7 +4414,7 @@ describe Braintree::Transaction do
             :amount => "10.00",
           )
           result.success?.should == true
-          result.transaction.network_transaction_id.should be_nil
+          result.transaction.network_transaction_id.should_not be_nil
         end
 
         it "accepts blank previous_network_transaction_id" do
@@ -4403,7 +4431,7 @@ describe Braintree::Transaction do
             :amount => "10.00",
           )
           result.success?.should == true
-          result.transaction.network_transaction_id.should be_nil
+          result.transaction.network_transaction_id.should_not be_nil
         end
       end
     end
@@ -5058,6 +5086,22 @@ describe Braintree::Transaction do
       result.errors.for(:transaction).on(:currency_iso_code)[0].code.should == Braintree::ErrorCodes::Transaction::CurrencyCodeNotSupportedByMerchantAccount
     end
 
+    it "validates tax_amount for Aib domestic sweden transaction and returns error" do
+      params = {
+          :transaction => {
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AibSwedenMaMerchantAccountId,
+              :credit_card => {
+                  :number => Braintree::Test::CreditCardNumbers::Visa,
+                  :expiration_date => "05/2030"
+              }
+          }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:tax_amount)[0].code.should == Braintree::ErrorCodes::Transaction::TaxAmountIsRequiredForAibSwedish
+    end
+
     it "skips advanced fraud checking if transaction[options][skip_advanced_fraud_checking] is set to true" do
       with_advanced_fraud_kount_integration_merchant do
         result = Braintree::Transaction.sale(
@@ -6984,6 +7028,42 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "Manual Key Entry" do
+    context "with correct encrypted payment reader card details" do
+      it "returns a success response" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :payment_reader_card_details => {
+              :encrypted_card_data => "8F34DFB312DC79C24FD5320622F3E11682D79E6B0C0FD881",
+              :key_serial_number => "FFFFFF02000572A00005",
+            },
+          },
+        )
+
+        expect(result).to be_success
+      end
+    end
+
+    context "with invalid encrypted payment reader card details" do
+      it "returns a failure response" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :payment_reader_card_details => {
+              :encrypted_card_data => "invalid",
+              :key_serial_number => "invalid",
+            },
+          },
+        )
+
+        expect(result).not_to be_success
+        expect(result.errors.for(:transaction).first.code)
+          .to eq(Braintree::ErrorCodes::Transaction::PaymentInstrumentNotSupportedByMerchantAccount)
+      end
+    end
+  end
+
   describe "Adjust Authorization" do
     let(:first_data_master_transaction_params) do
       {

data/spec/spec_helper.rb

@@ -3,6 +3,7 @@ unless defined?(SPEC_HELPER_LOADED)
   project_root = File.expand_path(File.dirname(__FILE__) + "/..")
   require "rubygems"
   require "bundler/setup"
+  require "libxml"
   require "rspec"
   require "pry"
 
@@ -41,6 +42,7 @@ unless defined?(SPEC_HELPER_LOADED)
     HiperBRLMerchantAccountId = "hiper_brl"
     CardProcessorBRLMerchantAccountId = "card_processor_brl"
     FakeFirstDataMerchantAccountId = "fake_first_data_merchant_account"
+    AibSwedenMaMerchantAccountId = "aib_swe_ma"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",

data/spec/unit/braintree/credit_card_spec.rb

@@ -11,7 +11,7 @@ describe Braintree::CreditCard do
 
   describe "self.create_signature" do
     it "should be what we expect" do
-      Braintree::CreditCardGateway._create_signature.should == [
+      expect(Braintree::CreditCardGateway._create_signature).to match([
         :billing_address_id,
         :cardholder_name,
         :cvv,
@@ -24,7 +24,7 @@ describe Braintree::CreditCard do
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code]},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -51,13 +51,13 @@ describe Braintree::CreditCard do
           :ds_transaction_id,
         ]},
         :customer_id,
-      ]
+      ])
     end
   end
 
   describe "self.update_signature" do
     it "should be what we expect" do
-      Braintree::CreditCardGateway._update_signature.should == [
+      expect(Braintree::CreditCardGateway._update_signature).to match([
         :billing_address_id,
         :cardholder_name,
         :cvv,
@@ -70,7 +70,7 @@ describe Braintree::CreditCard do
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code]},
+        {:options => match_array([:make_default, :skip_advanced_fraud_checking, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code])},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -97,7 +97,7 @@ describe Braintree::CreditCard do
           :cavv_algorithm,
           :ds_transaction_id,
         ]},
-      ]
+      ])
     end
   end