braintree 4.9.0 → 4.11.0

data/spec/integration/braintree/credit_card_verification_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::CreditCardVerification, "search" do
 
@@ -11,7 +12,7 @@ describe Braintree::CreditCardVerification, "search" do
         },
         :options => {
           :amount => "10.00"
-        }
+        },
       }
 
       result = Braintree::CreditCardVerification.create(verification_params)
@@ -259,4 +260,126 @@ describe Braintree::CreditCardVerification, "search" do
       end
     end
   end
+
+  describe "intended transaction source" do
+    it "creates a new verification with intended transaction source installment" do
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "05/2029",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00"
+        },
+        :intended_transaction_source => "installment"
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      result.credit_card_verification.processor_response_code.should == "1000"
+      result.credit_card_verification.processor_response_text.should == "Approved"
+      result.credit_card_verification.processor_response_type.should == Braintree::ProcessorResponseTypes::Approved
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
+    end
+  end
+
+  context "three_d_secure" do
+    it "can create a verification with a three_d_secure_authentication_id" do
+      three_d_secure_authentication_id = SpecHelper.create_3ds_verification(
+        SpecHelper::ThreeDSecureMerchantAccountId,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_month => "12",
+        :expiration_year => "2029",
+      )
+
+      verification_params = {
+        :credit_card => {
+          :expiration_date => "12/2029",
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+        },
+        :three_d_secure_authentication_id => three_d_secure_authentication_id,
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      result.credit_card_verification.processor_response_code.should == "1000"
+      result.credit_card_verification.processor_response_text.should == "Approved"
+      result.credit_card_verification.processor_response_type.should == Braintree::ProcessorResponseTypes::Approved
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
+    end
+
+    it "can create a verification with a payment_method_nonce" do
+      nonce = nonce_for_new_payment_method(
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_month => "11",
+          :expiration_year => "2099",
+        },
+      )
+      nonce.should_not be_nil
+
+      verification_params = {
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+        },
+        :options => {
+          :amount => "10.00",
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+        },
+        :payment_method_nonce => nonce,
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      result.credit_card_verification.processor_response_code.should == "1000"
+      result.credit_card_verification.processor_response_text.should == "Approved"
+      result.credit_card_verification.processor_response_type.should == Braintree::ProcessorResponseTypes::Approved
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
+    end
+
+    it "can create a verification with a verification_three_d_secure_pass_thru" do
+      verification_params = {
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/12",
+        },
+        :options => {
+          :amount => "10.00",
+        },
+        :three_d_secure_pass_thru => {
+          :eci_flag => "02",
+          :cavv => "some_cavv",
+          :xid => "some_xid",
+          :three_d_secure_version => "1.0.2",
+          :authentication_response => "Y",
+          :directory_response => "Y",
+          :cavv_algorithm => "2",
+          :ds_transaction_id => "some_ds_id",
+        },
+      }
+
+      result = Braintree::CreditCardVerification.create(verification_params)
+
+      result.should be_success
+      result.credit_card_verification.id.should =~ /^\w{6,}$/
+      result.credit_card_verification.status.should == Braintree::CreditCardVerification::Status::Verified
+      result.credit_card_verification.processor_response_code.should == "1000"
+      result.credit_card_verification.processor_response_text.should == "Approved"
+      result.credit_card_verification.processor_response_type.should == Braintree::ProcessorResponseTypes::Approved
+      expect(result.credit_card_verification.network_transaction_id).not_to be_nil
+    end
+  end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -566,37 +566,6 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:custom_fields)[0].message.should == "Custom field is invalid: spouse_name."
     end
 
-    describe "venmo_sdk" do
-      it "can create a customer with a venmo sdk payment method code" do
-        result = Braintree::Customer.create(
-          :first_name => "Steve",
-          :last_name => "Hamlin",
-          :credit_card => {
-            :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::VisaPaymentMethodCode
-          },
-        )
-        result.success?.should == true
-        result.customer.credit_cards.first.bin.should == "400934"
-        result.customer.credit_cards.first.last_4.should == "1881"
-      end
-
-      it "can create a customer with a venmo sdk session" do
-        result = Braintree::Customer.create(
-          :first_name => "Steve",
-          :last_name => "Hamlin",
-          :credit_card => {
-            :number => Braintree::Test::CreditCardNumbers::MasterCard,
-            :expiration_date => "05/2010",
-            :options => {
-              :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
-            }
-          },
-        )
-        result.success?.should == true
-        result.customer.credit_cards.first.venmo_sdk?.should == false
-      end
-    end
-
     context "client API" do
       it "can create a customer with a payment method nonce" do
         nonce = nonce_for_new_payment_method(
@@ -1754,7 +1723,7 @@ describe Braintree::Customer do
     context "future" do
       it "creates a customer with a future paypal account" do
         result = Braintree::Customer.create(
-          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
         )
 
         result.should be_success

data/spec/integration/braintree/dispute_search_spec.rb

@@ -78,33 +78,42 @@ 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
-
-      # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
-      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
-      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
-      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(collection.disputes.count).to be > 0
 
       # NEXT_MAJOR_VERSION Remove this assertion when chargeback_protection_level is removed from the SDK
-      expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
-      expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
-      expect(dispute.reason).to eq(Braintree::Dispute::Reason::Fraud)
+      collection.disputes.each do |dispute|
+        expect(dispute.chargeback_protection_level).to eq(Braintree::Dispute::ChargebackProtectionLevel::Effortless)
+        expect(dispute.protection_level).to eq(Braintree::Dispute::ProtectionLevel::EffortlessCBP)
+      end
+    end
+
+    context "pre-dispute program" do
+      it "correctly returns disputes by pre-dispute program" do
+        collection = Braintree::Dispute.search do |search|
+          search.pre_dispute_program.in [
+            Braintree::Dispute::PreDisputeProgram::VisaRdr
+          ]
+        end
+
+        expect(collection.disputes.count).to eq(1)
+        dispute = collection.disputes.first
+        expect(dispute.pre_dispute_program).to eq(Braintree::Dispute::PreDisputeProgram::VisaRdr)
+      end
+
+      it "correctly returns disputes with no pre-dispute program" do
+        collection = Braintree::Dispute.search do |search|
+          search.pre_dispute_program.is Braintree::Dispute::PreDisputeProgram::None
+        end
+
+        expect(collection.disputes.count).to be > 1
+        expect(collection.disputes.map(&:pre_dispute_program).uniq).to eq([Braintree::Dispute::PreDisputeProgram::None])
+      end
     end
 
     it "correctly returns disputes by effective_date range" do

data/spec/integration/braintree/dispute_spec.rb

@@ -151,6 +151,33 @@ describe Braintree::Dispute do
       result.evidence.sent_to_processor_at.should == nil
       result.evidence.sequence_number.should == 7
     end
+
+    it "creates text evidence for the dispute with CARRIER_NAME shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "UPS", category: "CARRIER_NAME", sequence_number: 0})
+
+      result.success?.should == true
+      result.evidence.category.should == "CARRIER_NAME"
+      result.evidence.comment.should == "UPS"
+      result.evidence.sequence_number.should == 0
+    end
+
+    it "creates text evidence for the dispute with TRACKING_NUMBER shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "3", category: "TRACKING_NUMBER", sequence_number: 0})
+
+      result.success?.should == true
+      result.evidence.category.should == "TRACKING_NUMBER"
+      result.evidence.comment.should == "3"
+      result.evidence.sequence_number.should == 0
+    end
+
+    it "creates text evidence for the dispute with TRACKING_URL shipping tracking" do
+      result = Braintree::Dispute.add_text_evidence(dispute.id, {content: "https://example.com/tracking-number/abc12345", category: "TRACKING_URL", sequence_number: 1})
+
+      result.success?.should == true
+      result.evidence.category.should == "TRACKING_URL"
+      result.evidence.comment.should == "https://example.com/tracking-number/abc12345"
+      result.evidence.sequence_number.should == 1
+    end
   end
 
   describe "self.finalize" do

data/spec/integration/braintree/http_spec.rb

@@ -97,7 +97,7 @@ describe Braintree::Http do
     end
 
     describe "ssl_version" do
-      it "causes failed requests to sandbox with incompatible SSL version" do
+      xit "causes failed requests to sandbox with incompatible SSL version" do
         begin
           original_env = Braintree::Configuration.environment
           Braintree::Configuration.environment = :sandbox

data/spec/integration/braintree/paypal_account_spec.rb

@@ -267,7 +267,7 @@ describe Braintree::PayPalAccount do
   context "self.sale" do
     it "creates a transaction using a paypal account and returns a result object" do
       customer = Braintree::Customer.create!(
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
@@ -283,7 +283,7 @@ describe Braintree::PayPalAccount do
   context "self.sale!" do
     it "creates a transaction using a paypal account and returns a transaction" do
       customer = Braintree::Customer.create!(
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::SepaDirectDebitAccount do
+  before do
+    Braintree::Configuration.merchant_id = "integration_merchant_id"
+    Braintree::Configuration.public_key = "integration_public_key"
+    Braintree::Configuration.private_key = "integration_private_key"
+  end
+
+  let(:customer) { Braintree::Customer.create.customer }
+  let(:nonce) { Braintree::Test::Nonce::SepaDirectDebit }
+
+  let(:token) do
+    Braintree::PaymentMethod.create(
+      payment_method_nonce: nonce,
+      customer_id: customer.id,
+    ).payment_method.token
+  end
+
+  describe "self.find" do
+    subject do
+      described_class.find(token)
+    end
+
+    context "when payment method exists" do
+      it "returns a payment method" do
+        sepa_direct_debit_account = subject
+        sepa_direct_debit_account.should be_a(Braintree::SepaDirectDebitAccount)
+        sepa_direct_debit_account.last_4.should == "1234"
+        sepa_direct_debit_account.default.should == true
+        sepa_direct_debit_account.customer_id.should == customer.id
+        sepa_direct_debit_account.global_id.should_not be_empty
+        sepa_direct_debit_account.customer_global_id.should_not be_empty
+        sepa_direct_debit_account.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account.token.should_not be_empty
+        sepa_direct_debit_account.image_url.should_not be_empty
+        sepa_direct_debit_account.created_at.should be_a Time
+        sepa_direct_debit_account.updated_at.should be_a Time
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+
+    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],
+        ).subscription
+
+        subscription2 = Braintree::Subscription.create(
+          :payment_method_token => token,
+          :plan_id => SpecHelper::TriallessPlan[:id],
+        ).subscription
+
+        sepa_debit_account = Braintree::SepaDirectDebitAccount.find(token)
+        subscription_ids = sepa_debit_account.subscriptions.map { |h| h[:id] }.sort
+        expect(subscription_ids).to eq([subscription1.id, subscription2.id].sort)
+      end
+    end
+  end
+
+  describe "self.delete" do
+    subject do
+      described_class.delete(token)
+    end
+
+    context "when payment method exists" do
+      it "deletes a payment method" do
+        should be_success
+
+        expect {
+          described_class.find(token)
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::NotFoundError)
+      end
+    end
+  end
+
+  describe "self.sale" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        should be_success
+
+        transaction = subject.transaction
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to_not raise_error
+      end
+    end
+  end
+
+  describe "self.sale!" do
+    let(:params) do
+      {
+        amount: 1.23,
+      }
+    end
+
+    subject do
+      described_class.sale!(token, params)
+    end
+
+    context "when payment method exists" do
+      it "creates a transaction" do
+        transaction = subject
+        transaction.amount.should eq(1.23)
+        transaction.status.should == "settling"
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        sepa_direct_debit_account_details.should be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        sepa_direct_debit_account_details.bank_reference_token.should == "a-fake-bank-reference-token"
+        sepa_direct_debit_account_details.capture_id.should_not be_empty
+        sepa_direct_debit_account_details.debug_id.should be_nil
+        sepa_direct_debit_account_details.global_id.should_not be_empty
+        sepa_direct_debit_account_details.last_4.should == "1234"
+        sepa_direct_debit_account_details.mandate_type.should == "RECURRENT"
+        sepa_direct_debit_account_details.merchant_or_partner_customer_id.should == "a-fake-mp-customer-id"
+        sepa_direct_debit_account_details.paypal_v2_order_id.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_amount.should be_nil
+        sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code.should be_nil
+        sepa_direct_debit_account_details.refund_id.should be_nil
+        sepa_direct_debit_account_details.settlement_type.should be_nil
+        sepa_direct_debit_account_details.token.should == token
+        sepa_direct_debit_account_details.transaction_fee_amount.should == "0.01"
+        sepa_direct_debit_account_details.transaction_fee_currency_iso_code.should == "USD"
+      end
+    end
+
+    context "when payment method does not exist" do
+      let(:token) { "ABC123" }
+
+      it "not raises an error" do
+        expect {
+          subject
+        }.to raise_error(Braintree::ValidationsFailed)
+      end
+    end
+  end
+end

data/spec/integration/braintree/subscription_spec.rb

@@ -96,7 +96,7 @@ describe Braintree::Subscription do
       it "creates a subscription when given a paypal account payment_method_nonce" do
         customer = Braintree::Customer.create!
         payment_method_result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
           :customer_id => customer.id,
         )
 

data/spec/integration/braintree/transaction_search_spec.rb

@@ -133,7 +133,7 @@ describe Braintree::Transaction, "search" do
     it "searches on users" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       collection = Braintree::Transaction.search do |search|
@@ -146,7 +146,7 @@ describe Braintree::Transaction, "search" do
     it "searches on paypal transactions" do
       transaction = Braintree::Transaction.sale!(
         :amount => Braintree::Test::TransactionAmounts::Authorize,
-        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       paypal_details = transaction.paypal_details
@@ -396,6 +396,38 @@ describe Braintree::Transaction, "search" do
         collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::LocalPayment
       end
 
+      it "searches by payment instrument type SepaDebitAccountDetail" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.payment_instrument_type.in ["SEPADebitAccountDetail"]
+        end
+
+        collection.first.id.should == transaction.id
+        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::SepaDirectDebitAccount
+      end
+
+      it "searches by paypal_v2_order_id" do
+        transaction = Braintree::Transaction.sale!(
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => Braintree::Test::Nonce::SepaDirectDebit,
+          :options => {:submit_for_settlement => true},
+        )
+
+        collection = Braintree::Transaction.search do |search|
+          search.id.is transaction.id
+          search.sepa_debit_paypal_v2_order_id.is transaction.sepa_direct_debit_account_details.paypal_v2_order_id
+        end
+
+        collection.first.id.should == transaction.id
+        collection.first.payment_instrument_type.should == Braintree::PaymentInstrumentType::SepaDirectDebitAccount
+      end
+
       it "searches by payment instrument type ApplePay" do
         transaction = Braintree::Transaction.sale!(
           :amount => Braintree::Test::TransactionAmounts::Authorize,