braintree 2.69.1 → 2.70.0

data/spec/integration/braintree/merchant_spec.rb

@@ -61,20 +61,14 @@ describe Braintree::MerchantGateway do
         )
       end
 
-      it "creates a paypal-only merchant that accepts multiple currencies" do
+      it "creates a US multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
           :country_code_alpha3 => "USA",
-          :payment_methods => ["paypal"],
-          :currencies => ["GBP", "USD"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          }
+          :payment_methods => ["credit_card", "paypal"],
+          :currencies => ["GBP", "USD"]
         )
 
-        result.should be_success
-
         merchant = result.merchant
         merchant.id.should_not be_nil
         merchant.email.should == "name@email.com"
@@ -102,27 +96,22 @@ describe Braintree::MerchantGateway do
         merchant_account.currency_iso_code.should == "GBP"
       end
 
-      it "allows creation of non-US merchant if onboarding application is internal" do
+      it "creates an EU multi currency merchant for paypal and credit_card" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "JPN",
-          :payment_methods => ["paypal"],
-          :paypal_account => {
-            :client_id => "paypal_client_id",
-            :client_secret => "paypal_client_secret",
-          }
+          :country_code_alpha3 => "GBR",
+          :payment_methods => ["credit_card", "paypal"],
+          :currencies => ["GBP", "USD"]
         )
 
-        result.should be_success
-
         merchant = result.merchant
         merchant.id.should_not be_nil
         merchant.email.should == "name@email.com"
         merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "JPN"
-        merchant.country_code_alpha2.should == "JP"
-        merchant.country_code_numeric.should == "392"
-        merchant.country_name.should == "Japan"
+        merchant.country_code_alpha3.should == "GBR"
+        merchant.country_code_alpha2.should == "GB"
+        merchant.country_code_numeric.should == "826"
+        merchant.country_name.should == "United Kingdom"
 
         credentials = result.credentials
         credentials.access_token.should_not be_nil
@@ -131,18 +120,24 @@ describe Braintree::MerchantGateway do
         credentials.token_type.should == "bearer"
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
+        merchant_accounts.count.should == 2
 
-        merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
+        merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
         merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "JPY"
+        merchant_account.currency_iso_code.should == "GBP"
+
+        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
+        merchant_account.default.should == false
+        merchant_account.currency_iso_code.should == "USD"
       end
 
-      it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
+
+      it "creates a paypal-only merchant that accepts multiple currencies" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "YEM",
+          :country_code_alpha3 => "USA",
           :payment_methods => ["paypal"],
+          :currencies => ["GBP", "USD"],
           :paypal_account => {
             :client_id => "paypal_client_id",
             :client_secret => "paypal_client_secret",
@@ -155,10 +150,10 @@ describe Braintree::MerchantGateway do
         merchant.id.should_not be_nil
         merchant.email.should == "name@email.com"
         merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "YEM"
-        merchant.country_code_alpha2.should == "YE"
-        merchant.country_code_numeric.should == "887"
-        merchant.country_name.should == "Yemen"
+        merchant.country_code_alpha3.should == "USA"
+        merchant.country_code_alpha2.should == "US"
+        merchant.country_code_numeric.should == "840"
+        merchant.country_name.should == "United States of America"
 
         credentials = result.credentials
         credentials.access_token.should_not be_nil
@@ -167,25 +162,22 @@ describe Braintree::MerchantGateway do
         credentials.token_type.should == "bearer"
 
         merchant_accounts = merchant.merchant_accounts
-        merchant_accounts.count.should == 1
+        merchant_accounts.count.should == 2
 
         merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
         merchant_account.default.should == true
         merchant_account.currency_iso_code.should == "USD"
-      end
 
-      it "creates a paypal-only merchant via the non multi-currency flow if the oauth_application is not internal" do
-        gateway = Braintree::Gateway.new(
-          :client_id => "client_id$development$integration_client_id",
-          :client_secret => "client_secret$development$integration_client_secret",
-          :logger => Logger.new("/dev/null")
-        )
+        merchant_account = merchant_accounts.detect { |ma| ma.id == "GBP" }
+        merchant_account.default.should == false
+        merchant_account.currency_iso_code.should == "GBP"
+      end
 
-        result = gateway.merchant.create(
+      it "allows creation of non-US merchant if onboarding application is internal" do
+        result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
+          :country_code_alpha3 => "JPN",
           :payment_methods => ["paypal"],
-          :currencies => ["USD", "GBP"],
           :paypal_account => {
             :client_id => "paypal_client_id",
             :client_secret => "paypal_client_secret",
@@ -198,10 +190,10 @@ describe Braintree::MerchantGateway do
         merchant.id.should_not be_nil
         merchant.email.should == "name@email.com"
         merchant.company_name.should == "name@email.com"
-        merchant.country_code_alpha3.should == "USA"
-        merchant.country_code_alpha2.should == "US"
-        merchant.country_code_numeric.should == "840"
-        merchant.country_name.should == "United States of America"
+        merchant.country_code_alpha3.should == "JPN"
+        merchant.country_code_alpha2.should == "JP"
+        merchant.country_code_numeric.should == "392"
+        merchant.country_name.should == "Japan"
 
         credentials = result.credentials
         credentials.access_token.should_not be_nil
@@ -212,27 +204,45 @@ describe Braintree::MerchantGateway do
         merchant_accounts = merchant.merchant_accounts
         merchant_accounts.count.should == 1
 
-        merchant_account = merchant_accounts.first
+        merchant_account = merchant_accounts.detect { |ma| ma.id == "JPY" }
         merchant_account.default.should == true
-        merchant_account.currency_iso_code.should == "USD"
+        merchant_account.currency_iso_code.should == "JPY"
       end
 
-      it "returns error if valid payment_method other than paypal is passed" do
+      it "defaults to USD for non-US merchant if onboarding application is internal and country currency not supported" do
         result = @gateway.merchant.create(
           :email => "name@email.com",
-          :country_code_alpha3 => "USA",
-          :payment_methods => ["credit_card", "paypal"],
-          :currencies => ["USD", "GBP"],
+          :country_code_alpha3 => "YEM",
+          :payment_methods => ["paypal"],
           :paypal_account => {
             :client_id => "paypal_client_id",
             :client_secret => "paypal_client_secret",
           }
         )
 
-        result.should_not be_success
-        errors = result.errors.for(:merchant).on(:payment_methods)
+        result.should be_success
+
+        merchant = result.merchant
+        merchant.id.should_not be_nil
+        merchant.email.should == "name@email.com"
+        merchant.company_name.should == "name@email.com"
+        merchant.country_code_alpha3.should == "YEM"
+        merchant.country_code_alpha2.should == "YE"
+        merchant.country_code_numeric.should == "887"
+        merchant.country_name.should == "Yemen"
 
-        errors[0].code.should == Braintree::ErrorCodes::Merchant::PaymentMethodsAreNotAllowed
+        credentials = result.credentials
+        credentials.access_token.should_not be_nil
+        credentials.refresh_token.should_not be_nil
+        credentials.expires_at.should_not be_nil
+        credentials.token_type.should == "bearer"
+
+        merchant_accounts = merchant.merchant_accounts
+        merchant_accounts.count.should == 1
+
+        merchant_account = merchant_accounts.detect { |ma| ma.id == "USD" }
+        merchant_account.default.should == true
+        merchant_account.currency_iso_code.should == "USD"
       end
 
       it "returns error if invalid currency is passed" do

data/spec/integration/braintree/payment_method_spec.rb

@@ -492,12 +492,12 @@ describe Braintree::PaymentMethod do
         result.should be_success
         us_bank_account = result.payment_method
         us_bank_account.should be_a(Braintree::UsBankAccount)
-        us_bank_account.routing_number.should == "123456789"
+        us_bank_account.routing_number.should == "021000021"
         us_bank_account.last_4.should == "1234"
         us_bank_account.account_type.should == "checking"
         us_bank_account.account_description.should == "PayPal Checking - 1234"
         us_bank_account.account_holder_name.should == "Dan Schulman"
-        us_bank_account.bank_name.should == "UNKNOWN"
+        us_bank_account.bank_name.should =~ /CHASE/
         us_bank_account.default.should == true
         us_bank_account.ach_mandate.text.should == "cl mandate text"
         us_bank_account.ach_mandate.accepted_at.should be_a Time
@@ -902,7 +902,7 @@ describe Braintree::PaymentMethod do
       paypal_account = Braintree::PaymentMethod.find(paypal_account_token)
       paypal_account.should be_a(Braintree::PayPalAccount)
 
-      result = Braintree::PaymentMethod.delete(paypal_account_token)
+      result = Braintree::PaymentMethod.delete(paypal_account_token, {:revoke_all_grants => false})
       result.success?.should == true
 
       expect do

data/spec/integration/braintree/transaction_spec.rb

@@ -2123,12 +2123,12 @@ describe Braintree::Transaction do
         result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::UsBankAccount
         result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
         result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "123456789"
+        result.transaction.us_bank_account_details.routing_number.should == "021000021"
         result.transaction.us_bank_account_details.last_4.should == "1234"
         result.transaction.us_bank_account_details.account_type.should == "checking"
         result.transaction.us_bank_account_details.account_description.should == "PayPal Checking - 1234"
         result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should == "UNKNOWN"
+        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
         result.transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
         result.transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
       end
@@ -2149,12 +2149,12 @@ describe Braintree::Transaction do
         result.transaction.type.should == "sale"
         result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
         result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "123456789"
+        result.transaction.us_bank_account_details.routing_number.should == "021000021"
         result.transaction.us_bank_account_details.last_4.should == "1234"
         result.transaction.us_bank_account_details.account_type.should == "checking"
         result.transaction.us_bank_account_details.account_description.should == "PayPal Checking - 1234"
         result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should == "UNKNOWN"
+        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
         result.transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
         result.transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
 
@@ -2172,12 +2172,12 @@ describe Braintree::Transaction do
         result.transaction.type.should == "sale"
         result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
         result.transaction.status.should == Braintree::Transaction::Status::SettlementPending
-        result.transaction.us_bank_account_details.routing_number.should == "123456789"
+        result.transaction.us_bank_account_details.routing_number.should == "021000021"
         result.transaction.us_bank_account_details.last_4.should == "1234"
         result.transaction.us_bank_account_details.account_type.should == "checking"
         result.transaction.us_bank_account_details.account_description.should == "PayPal Checking - 1234"
         result.transaction.us_bank_account_details.account_holder_name.should == "Dan Schulman"
-        result.transaction.us_bank_account_details.bank_name.should == "UNKNOWN"
+        result.transaction.us_bank_account_details.bank_name.should =~ /CHASE/
         result.transaction.us_bank_account_details.ach_mandate.text.should == "cl mandate text"
         result.transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
       end
@@ -2196,6 +2196,53 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown
       end
     end
+
+    context "ideal payment nonce" do
+      it "returns a successful result for tansacting on an ideal payment nonce" do
+        valid_ideal_payment_id = generate_valid_ideal_payment_nonce
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :order_id => SpecHelper::DefaultOrderId,
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::IdealMerchantAccountId,
+          :payment_method_nonce => valid_ideal_payment_id,
+          :options => {
+            :submit_for_settlement => true,
+          }
+        )
+        result.success?.should == true
+        result.transaction.id.should =~ /^\w{6,}$/
+        result.transaction.type.should == "sale"
+        result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::IdealPayment
+        result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
+        result.transaction.status.should == Braintree::Transaction::Status::Settled
+        result.transaction.ideal_payment_details.ideal_payment_id.should =~ /^idealpayment_\w{6,}$/
+        result.transaction.ideal_payment_details.ideal_transaction_id.should =~ /^\d{16,}$/
+        result.transaction.ideal_payment_details.image_url.should start_with("https://")
+        result.transaction.ideal_payment_details.masked_iban.should_not be_empty
+        result.transaction.ideal_payment_details.bic.should_not be_empty
+      end
+
+      it "returns a failure if ideal payment is not complete" do
+        expired_payment_amount = "3.00"
+
+        incomplete_payment_id = generate_valid_ideal_payment_nonce(expired_payment_amount)
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :order_id => SpecHelper::DefaultOrderId,
+          :amount => expired_payment_amount,
+          :merchant_account_id => SpecHelper::IdealMerchantAccountId,
+          :payment_method_nonce => incomplete_payment_id,
+          :options => {
+            :submit_for_settlement => true,
+          }
+        )
+
+        result.success?.should == false
+        result.errors.for(:transaction).on(:ideal_payment)[0].code.should == Braintree::ErrorCodes::Transaction::IdealPaymentNotComplete
+      end
+    end
   end
 
   describe "self.create!" do
@@ -2651,6 +2698,21 @@ describe Braintree::Transaction do
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
 
+    it "skips advanced fraud checking if transaction[options][skip_advanced_fraud_checking] is set to true" do
+      result = Braintree::Transaction.sale(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :options => {
+          :skip_advanced_fraud_checking => true
+        }
+      )
+      result.success?.should == true
+      result.transaction.risk_data.id.should be_nil
+    end
+
     it "works with Apple Pay params" do
       params = {
         :amount => "3.12",
@@ -3937,6 +3999,7 @@ describe Braintree::Transaction do
         transaction.paypal_details.payer_id.should_not be_nil
         transaction.paypal_details.payer_first_name.should_not be_nil
         transaction.paypal_details.payer_last_name.should_not be_nil
+        transaction.paypal_details.payer_status.should_not be_nil
         transaction.paypal_details.seller_protection_status.should_not be_nil
         transaction.paypal_details.capture_id.should_not be_nil
         transaction.paypal_details.refund_id.should_not be_nil

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -15,12 +15,12 @@ describe Braintree::UsBankAccount do
 
       us_bank_account = Braintree::UsBankAccount.find(result.payment_method.token)
       us_bank_account.should be_a(Braintree::UsBankAccount)
-      us_bank_account.routing_number.should == "123456789"
+      us_bank_account.routing_number.should == "021000021"
       us_bank_account.last_4.should == "1234"
       us_bank_account.account_type.should == "checking"
       us_bank_account.account_description.should == "PayPal Checking - 1234"
       us_bank_account.account_holder_name.should == "Dan Schulman"
-      us_bank_account.bank_name.should == "UNKNOWN"
+      us_bank_account.bank_name.should =~ /CHASE/
       us_bank_account.ach_mandate.text.should == "cl mandate text"
       us_bank_account.ach_mandate.accepted_at.should be_a Time
     end
@@ -49,12 +49,12 @@ describe Braintree::UsBankAccount do
       result.transaction.amount.should == BigDecimal.new("100.00")
       result.transaction.type.should == "sale"
       us_bank_account = result.transaction.us_bank_account_details
-      us_bank_account.routing_number.should == "123456789"
+      us_bank_account.routing_number.should == "021000021"
       us_bank_account.last_4.should == "1234"
       us_bank_account.account_type.should == "checking"
       us_bank_account.account_description.should == "PayPal Checking - 1234"
       us_bank_account.account_holder_name.should == "Dan Schulman"
-      us_bank_account.bank_name.should == "UNKNOWN"
+      us_bank_account.bank_name.should =~ /CHASE/
       us_bank_account.ach_mandate.text.should == "cl mandate text"
       us_bank_account.ach_mandate.accepted_at.should be_a Time
     end
@@ -76,12 +76,12 @@ describe Braintree::UsBankAccount do
       transaction.amount.should == BigDecimal.new("100.00")
       transaction.type.should == "sale"
       us_bank_account = transaction.us_bank_account_details
-      us_bank_account.routing_number.should == "123456789"
+      us_bank_account.routing_number.should == "021000021"
       us_bank_account.last_4.should == "1234"
       us_bank_account.account_type.should == "checking"
       us_bank_account.account_description.should == "PayPal Checking - 1234"
       us_bank_account.account_holder_name.should == "Dan Schulman"
-      us_bank_account.bank_name.should == "UNKNOWN"
+      us_bank_account.bank_name.should =~ /CHASE/
       us_bank_account.ach_mandate.text.should == "cl mandate text"
       us_bank_account.ach_mandate.accepted_at.should be_a Time
     end

data/spec/spec_helper.rb

@@ -40,6 +40,7 @@ unless defined?(SPEC_HELPER_LOADED)
     FakeAmexDirectMerchantAccountId = "fake_amex_direct_usd"
     FakeVenmoAccountMerchantAccountId = "fake_first_data_venmo_account"
     UsBankMerhantAccountId = "us_bank_merchant_account"
+    IdealMerchantAccountId = "ideal_merchant_account"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",
@@ -81,6 +82,8 @@ unless defined?(SPEC_HELPER_LOADED)
     Discount11 = "discount_11"
     Discount15 = "discount_15"
 
+    DefaultOrderId = "ABC123"
+
     TestMerchantConfig = Braintree::Configuration.new(
                                                       :logger => Logger.new("/dev/null"),
                                                       :environment => Braintree::Configuration.environment,
@@ -107,6 +110,20 @@ unless defined?(SPEC_HELPER_LOADED)
       response[:three_d_secure_verification][:three_d_secure_token]
     end
 
+    def self.create_merchant(params={})
+      gateway = Braintree::Gateway.new(
+        :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
+        :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
+        :logger => Logger.new("/dev/null")
+      )
+
+      gateway.merchant.create({
+        :email => "name@email.com",
+        :country_code_alpha3 => "GBR",
+        :payment_methods => ["credit_card", "paypal"],
+      }.merge!(params))
+    end
+
     def self.stub_time_dot_now(desired_time)
       Time.class_eval do
         class << self
@@ -205,6 +222,6 @@ RSpec.configure do |config|
   end
 
   config.mock_with :rspec do |mock|
-    mock.syntax = :should
+    mock.syntax = [:should, :expect]
   end
 end

data/spec/unit/braintree/payment_method_spec.rb

@@ -27,6 +27,33 @@ describe Braintree::PaymentMethod do
     end
   end
 
+  describe "delete" do
+    let(:http_stub) { double('http_stub').as_null_object }
+    it "accepts revoke_all_grants option with value true" do
+      Braintree::Http.stub(:new).and_return http_stub
+      http_stub.should_receive(:delete).with("/merchants/integration_merchant_id/payment_methods/any/some_token?revoke_all_grants=true")
+      Braintree::PaymentMethod.delete("some_token", {:revoke_all_grants => true})
+    end
+
+    it "accepts revoke_all_grants option with value false" do
+      Braintree::Http.stub(:new).and_return http_stub
+      http_stub.should_receive(:delete).with("/merchants/integration_merchant_id/payment_methods/any/some_token?revoke_all_grants=false")
+      Braintree::PaymentMethod.delete("some_token", {:revoke_all_grants => false})
+    end
+
+    it "throws error when an invalid param is used for options" do
+      expect do
+        Braintree::PaymentMethod.delete("some_token", {:invalid_key => false})
+      end.to raise_error(ArgumentError)
+    end
+
+    it "accepts just the token, revoke_all_grants is optional" do
+      Braintree::Http.stub(:new).and_return http_stub
+      http_stub.should_receive(:delete).with("/merchants/integration_merchant_id/payment_methods/any/some_token")
+      Braintree::PaymentMethod.delete("some_token")
+    end
+  end
+
   describe "timestamps" do
     it "exposes created_at and updated_at" do
       now = Time.now