braintree 2.73.0 → 2.74.0

data/lib/braintree/webhook_notification.rb

@@ -35,9 +35,22 @@ module Braintree
 
       IdealPaymentComplete = "ideal_payment_complete"
       IdealPaymentFailed = "ideal_payment_failed"
+
+      ConnectedMerchantStatusTransitioned = "connected_merchant_status_transitioned"
+      ConnectedMerchantPayPalStatusChanged = "connected_merchant_paypal_status_changed"
     end
 
-    attr_reader :subscription, :kind, :timestamp, :transaction, :partner_merchant, :disbursement, :dispute, :account_updater_daily_report, :ideal_payment
+    attr_reader :subscription
+    attr_reader :kind
+    attr_reader :timestamp
+    attr_reader :transaction
+    attr_reader :partner_merchant
+    attr_reader :disbursement
+    attr_reader :dispute
+    attr_reader :account_updater_daily_report
+    attr_reader :ideal_payment
+    attr_reader :connected_merchant_status_transitioned
+    attr_reader :connected_merchant_paypal_status_changed
 
     def self.parse(signature, payload)
       Configuration.gateway.webhook_notification.parse(signature, payload)
@@ -59,6 +72,8 @@ module Braintree
       @dispute = Dispute._new(@subject[:dispute]) if @subject.has_key?(:dispute)
       @account_updater_daily_report = AccountUpdaterDailyReport._new(@subject[:account_updater_daily_report]) if @subject.has_key?(:account_updater_daily_report)
       @ideal_payment = Braintree::IdealPayment._new(gateway, @subject[:ideal_payment]) if @subject.has_key?(:ideal_payment)
+      @connected_merchant_status_transitioned = ConnectedMerchantStatusTransitioned._new(@subject[:connected_merchant_status_transitioned]) if @subject.has_key?(:connected_merchant_status_transitioned)
+      @connected_merchant_paypal_status_changed = ConnectedMerchantPayPalStatusChanged._new(@subject[:connected_merchant_paypal_status_changed]) if @subject.has_key?(:connected_merchant_paypal_status_changed)
     end
 
     def merchant_account

data/lib/braintree/webhook_testing_gateway.rb

@@ -59,6 +59,10 @@ module Braintree
         _subscription_charged_successfully(id)
       when Braintree::WebhookNotification::Kind::AccountUpdaterDailyReport
         _account_updater_daily_report_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::ConnectedMerchantStatusTransitioned
+        _auth_status_transitioned_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::ConnectedMerchantPayPalStatusChanged
+        _auth_paypal_status_changed_sample_xml(id)
       when Braintree::WebhookNotification::Kind::IdealPaymentComplete
         _ideal_payment_complete_sample_xml(id)
       when Braintree::WebhookNotification::Kind::IdealPaymentFailed
@@ -360,6 +364,26 @@ module Braintree
       XML
     end
 
+    def _auth_status_transitioned_sample_xml(id)
+      <<-XML
+        <connected-merchant-status-transitioned>
+          <merchant-public-id>#{id}</merchant-public-id>
+          <status>new_status</status>
+          <oauth-application-client-id>oauth_application_client_id</oauth-application-client-id>
+        </connected-merchant-status-transitioned>
+      XML
+    end
+
+    def _auth_paypal_status_changed_sample_xml(id)
+      <<-XML
+        <connected-merchant-paypal-status-changed>
+          <oauth-application-client-id>oauth_application_client_id</oauth-application-client-id>
+          <merchant-public-id>#{id}</merchant-public-id>
+          <action>link</action>
+        </connected-merchant-paypal-status-changed>
+        XML
+    end
+
     def _ideal_payment_complete_sample_xml(id)
 
       <<-XML

data/spec/httpsd.pid

@@ -1 +1 @@
-12403
+15408

data/spec/integration/braintree/client_api/spec_helper.rb

@@ -84,8 +84,13 @@ def generate_valid_us_bank_account_nonce()
 end
 
 def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
-  raw_client_token = Braintree::ClientToken.generate
+  raw_client_token = Braintree::ClientToken.generate(:merchant_account_id => "ideal_merchant_account")
   client_token = decode_client_token(raw_client_token)
+  client = ClientApiHttp.new(
+    Braintree::Configuration.instantiate,
+    :authorization_fingerprint => client_token["authorizationFingerprint"],
+  )
+  config = JSON.parse(client.get_configuration.body)
 
   token = client_token["braintree_api"]["access_token"]
   url = client_token["braintree_api"]["url"] + "/ideal-payments"
@@ -95,6 +100,7 @@ def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmou
     :amount => amount,
     :currency => "EUR",
     :redirect_url => "https://braintree-api.com",
+    :route_id => config["ideal"]["routeId"]
   }
 
   json = _cosmos_post(token, url, payload)
@@ -183,6 +189,15 @@ class ClientApiHttp
     end
   end
 
+  def get_configuration
+    encoded_fingerprint = Braintree::Util.url_encode(@options[:authorization_fingerprint])
+    url = "/merchants/#{@config.merchant_id}/client_api/v1/configuration"
+    url += "?authorizationFingerprint=#{encoded_fingerprint}"
+    url += "&configVersion=3"
+
+    get(url)
+  end
+
   def get_payment_methods
     encoded_fingerprint = Braintree::Util.url_encode(@options[:authorization_fingerprint])
     url = "/merchants/#{@config.merchant_id}/client_api/v1/payment_methods?"

data/spec/integration/braintree/customer_spec.rb

@@ -1473,6 +1473,64 @@ describe Braintree::Customer do
       end
     end
 
+    context "limited use" do
+      it "creates a customer with payment_method_nonce and options->paypal->payee_email" do
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          }
+        )
+
+        result = Braintree::Customer.create(
+          :payment_method_nonce => nonce,
+          :options => {
+            :paypal => {
+              :payee_email => "payee@example.com",
+            },
+          },
+        )
+
+        result.should be_success
+      end
+
+      it "updates a customer with payment_method_nonce and options->paypal->payee_email" do
+        customer = Braintree::Customer.create!(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
+            }
+          }
+        )
+
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          }
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce,
+          :options => {
+            :paypal => {
+              :payee_email => "payee@example.com",
+            },
+          },
+        )
+
+        result.should be_success
+        result.customer.default_payment_method.token.should == paypal_account_token
+      end
+    end
+
     context "onetime" do
       it "does not create a customer with a onetime paypal account" do
         result = Braintree::Customer.create(

data/spec/integration/braintree/masterpass_card_spec.rb

@@ -0,0 +1,97 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::MasterpassCard do
+  it "can create from a payment method nonce" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
+      :customer_id => customer.id
+    )
+    result.should be_success
+
+    masterpass_card = result.payment_method
+    masterpass_card.should be_a(Braintree::MasterpassCard)
+    masterpass_card.billing_address.should_not be_nil
+    masterpass_card.bin.should_not be_nil
+    masterpass_card.card_type.should_not be_nil
+    masterpass_card.cardholder_name.should_not be_nil
+    masterpass_card.commercial.should_not be_nil
+    masterpass_card.country_of_issuance.should_not be_nil
+    masterpass_card.created_at.should_not be_nil
+    masterpass_card.customer_id.should_not be_nil
+    masterpass_card.customer_location.should_not be_nil
+    masterpass_card.debit.should_not be_nil
+    masterpass_card.default?.should_not be_nil
+    masterpass_card.durbin_regulated.should_not be_nil
+    masterpass_card.expiration_date.should_not be_nil
+    masterpass_card.expiration_month.should_not be_nil
+    masterpass_card.expiration_year.should_not be_nil
+    masterpass_card.expired?.should_not be_nil
+    masterpass_card.healthcare.should_not be_nil
+    masterpass_card.image_url.should_not be_nil
+    masterpass_card.issuing_bank.should_not be_nil
+    masterpass_card.last_4.should_not be_nil
+    masterpass_card.payroll.should_not be_nil
+    masterpass_card.prepaid.should_not be_nil
+    masterpass_card.product_id.should_not be_nil
+    masterpass_card.subscriptions.should_not be_nil
+    masterpass_card.token.should_not be_nil
+    masterpass_card.unique_number_identifier.should_not be_nil
+    masterpass_card.updated_at.should_not be_nil
+
+    customer = Braintree::Customer.find(customer.id)
+    customer.masterpass_cards.size.should == 1
+    customer.masterpass_cards.first.should == masterpass_card
+  end
+
+  it "can search for transactions" do
+    transaction_create_result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
+      :amount => '47.00',
+    )
+    transaction_create_result.should be_success
+    transaction_id = transaction_create_result.transaction.id
+
+    search_results = Braintree::Transaction.search do |search|
+      search.id.is transaction_id
+      search.payment_instrument_type.is Braintree::PaymentInstrumentType::MasterpassCard
+    end
+    search_results.first.id.should == transaction_id
+  end
+
+  it "can create transaction from nonce and vault" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::MasterpassDiscover,
+      :customer_id => customer.id,
+      :amount => '47.00',
+      :options => { :store_in_vault => true },
+    )
+    result.should be_success
+
+    masterpass_card_details = result.transaction.masterpass_card_details
+    masterpass_card_details.bin.should_not be_nil
+    masterpass_card_details.card_type.should_not be_nil
+    masterpass_card_details.cardholder_name.should_not be_nil
+    masterpass_card_details.commercial.should_not be_nil
+    masterpass_card_details.country_of_issuance.should_not be_nil
+    masterpass_card_details.customer_location.should_not be_nil
+    masterpass_card_details.debit.should_not be_nil
+    masterpass_card_details.durbin_regulated.should_not be_nil
+    masterpass_card_details.expiration_date.should_not be_nil
+    masterpass_card_details.expiration_month.should_not be_nil
+    masterpass_card_details.expiration_year.should_not be_nil
+    masterpass_card_details.healthcare.should_not be_nil
+    masterpass_card_details.image_url.should_not be_nil
+    masterpass_card_details.issuing_bank.should_not be_nil
+    masterpass_card_details.last_4.should_not be_nil
+    masterpass_card_details.payroll.should_not be_nil
+    masterpass_card_details.prepaid.should_not be_nil
+    masterpass_card_details.product_id.should_not be_nil
+    masterpass_card_details.token.should_not be_nil
+  end
+end
+

data/spec/integration/braintree/payment_method_spec.rb

@@ -246,7 +246,7 @@ describe Braintree::PaymentMethod do
     it "respects verify_card and verification_merchant_account_id when included outside of the nonce" do
       nonce = nonce_for_new_payment_method(
         :credit_card => {
-          :number => "4000111111111115",
+          :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
           :expiration_month => "11",
           :expiration_year => "2099",
         }
@@ -271,7 +271,7 @@ describe Braintree::PaymentMethod do
     it "respects verification amount when included outside of the nonce" do
       nonce = nonce_for_new_payment_method(
         :credit_card => {
-          :number => "4000111111111115",
+          :number => Braintree::Test::CreditCardNumbers::FailsSandboxVerification::Visa,
           :expiration_month => "11",
           :expiration_year => "2099",
         }
@@ -290,6 +290,7 @@ describe Braintree::PaymentMethod do
       result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
       result.credit_card_verification.processor_response_code.should == "2000"
       result.credit_card_verification.processor_response_text.should == "Do Not Honor"
+      result.credit_card_verification.amount.should == BigDecimal.new("100.00")
     end
 
     it "respects fail_on_duplicate_payment_method when included outside of the nonce" do
@@ -534,6 +535,32 @@ describe Braintree::PaymentMethod do
         found_paypal_account.should_not be_nil
       end
 
+      it "creates a limited use payment method from a paypal account nonce for a paypal intent==order payment" do
+        nonce = nonce_for_paypal_account(
+          :intent => "order",
+          :payment_token => "fake-payment-token",
+          :payer_id => "fake-payer-id",
+        )
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :paypal => {
+              :payee_email => "payee@example.com",
+            },
+          },
+        )
+
+        result.should be_success
+        result.payment_method.should be_a(Braintree::PayPalAccount)
+        result.payment_method.image_url.should_not be_nil
+        token = result.payment_method.token
+
+        found_paypal_account = Braintree::PayPalAccount.find(token)
+        found_paypal_account.should_not be_nil
+      end
+
       it "does not create a payment method from an unvalidated onetime paypal account nonce" do
         customer = Braintree::Customer.create.customer
         nonce = nonce_for_paypal_account(:access_token => "PAYPAL_ACCESS_TOKEN")
@@ -1101,6 +1128,7 @@ describe Braintree::PaymentMethod do
         update_result.success?.should == false
         update_result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
         update_result.credit_card_verification.gateway_rejection_reason.should be_nil
+        update_result.credit_card_verification.amount.should == BigDecimal("2.34")
       end
 
       it "can update the billing address" do

data/spec/integration/braintree/visa_checkout_card_spec.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::VisaCheckoutCard do
+  it "can create from payment method nonce" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id
+    )
+    result.should be_success
+
+    visa_checkout_card = result.payment_method
+    visa_checkout_card.should be_a(Braintree::VisaCheckoutCard)
+    visa_checkout_card.call_id.should == "abc123"
+    visa_checkout_card.billing_address.should_not be_nil
+    visa_checkout_card.bin.should_not be_nil
+    visa_checkout_card.card_type.should_not be_nil
+    visa_checkout_card.cardholder_name.should_not be_nil
+    visa_checkout_card.commercial.should_not be_nil
+    visa_checkout_card.country_of_issuance.should_not be_nil
+    visa_checkout_card.created_at.should_not be_nil
+    visa_checkout_card.customer_id.should_not be_nil
+    visa_checkout_card.customer_location.should_not be_nil
+    visa_checkout_card.debit.should_not be_nil
+    visa_checkout_card.default?.should_not be_nil
+    visa_checkout_card.durbin_regulated.should_not be_nil
+    visa_checkout_card.expiration_date.should_not be_nil
+    visa_checkout_card.expiration_month.should_not be_nil
+    visa_checkout_card.expiration_year.should_not be_nil
+    visa_checkout_card.expired?.should_not be_nil
+    visa_checkout_card.healthcare.should_not be_nil
+    visa_checkout_card.image_url.should_not be_nil
+    visa_checkout_card.issuing_bank.should_not be_nil
+    visa_checkout_card.last_4.should_not be_nil
+    visa_checkout_card.payroll.should_not be_nil
+    visa_checkout_card.prepaid.should_not be_nil
+    visa_checkout_card.product_id.should_not be_nil
+    visa_checkout_card.subscriptions.should_not be_nil
+    visa_checkout_card.token.should_not be_nil
+    visa_checkout_card.unique_number_identifier.should_not be_nil
+    visa_checkout_card.updated_at.should_not be_nil
+
+    customer = Braintree::Customer.find(customer.id)
+    customer.visa_checkout_cards.size.should == 1
+    customer.visa_checkout_cards.first.should == visa_checkout_card
+  end
+
+  it "can create with verification" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::PaymentMethod.create(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id,
+      :options => { :verify_card => true }
+    )
+    result.should be_success
+    result.payment_method.verification.status.should == Braintree::CreditCardVerification::Status::Verified
+  end
+
+  it "can search for transactions" do
+    transaction_create_result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :amount => '47.00',
+    )
+    transaction_create_result.should be_success
+    transaction_id = transaction_create_result.transaction.id
+
+    search_results = Braintree::Transaction.search do |search|
+      search.id.is transaction_id
+      search.payment_instrument_type.is Braintree::PaymentInstrumentType::VisaCheckoutCard
+    end
+    search_results.first.id.should == transaction_id
+  end
+
+  it "can create transaction from nonce and vault" do
+    customer = Braintree::Customer.create!
+
+    result = Braintree::Transaction.sale(
+      :payment_method_nonce => Braintree::Test::Nonce::VisaCheckoutDiscover,
+      :customer_id => customer.id,
+      :amount => '47.00',
+      :options => { :store_in_vault => true },
+    )
+    result.should be_success
+
+    visa_checkout_card_details = result.transaction.visa_checkout_card_details
+    visa_checkout_card_details.call_id.should == "abc123"
+    visa_checkout_card_details.bin.should_not be_nil
+    visa_checkout_card_details.card_type.should_not be_nil
+    visa_checkout_card_details.cardholder_name.should_not be_nil
+    visa_checkout_card_details.commercial.should_not be_nil
+    visa_checkout_card_details.country_of_issuance.should_not be_nil
+    visa_checkout_card_details.customer_location.should_not be_nil
+    visa_checkout_card_details.debit.should_not be_nil
+    visa_checkout_card_details.durbin_regulated.should_not be_nil
+    visa_checkout_card_details.expiration_date.should_not be_nil
+    visa_checkout_card_details.expiration_month.should_not be_nil
+    visa_checkout_card_details.expiration_year.should_not be_nil
+    visa_checkout_card_details.healthcare.should_not be_nil
+    visa_checkout_card_details.image_url.should_not be_nil
+    visa_checkout_card_details.issuing_bank.should_not be_nil
+    visa_checkout_card_details.last_4.should_not be_nil
+    visa_checkout_card_details.payroll.should_not be_nil
+    visa_checkout_card_details.prepaid.should_not be_nil
+    visa_checkout_card_details.product_id.should_not be_nil
+    visa_checkout_card_details.token.should_not be_nil
+  end
+end