braintree 2.98.0 → 4.23.0

data/spec/integration/braintree/samsung_pay_card_spec.rb

@@ -1,14 +1,16 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
-describe Braintree::SamsungPayCard do
+# NEXT_MAJOR_VERSION remove these tests
+# SamsungPayCard has been deprecated
+xdescribe Braintree::SamsungPayCard do
   it "can create from payment method nonce" do
     customer = Braintree::Customer.create!
 
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :cardholder_name => 'Jenny Block',
+      :cardholder_name => "Jenny Block",
       :billing_address => {
           :first_name => "New First Name",
           :last_name => "New Last Name",
@@ -19,44 +21,44 @@ describe Braintree::SamsungPayCard do
           :region => "New State",
           :postal_code => "56789",
           :country_name => "United States of America"
-      }
+      },
     )
-    result.should be_success
+    expect(result).to be_success
 
     samsung_pay_card = result.payment_method
-    samsung_pay_card.should be_a(Braintree::SamsungPayCard)
-    samsung_pay_card.billing_address.should_not be_nil
-    samsung_pay_card.bin.should_not be_nil
-    samsung_pay_card.cardholder_name.should_not be_nil
-    samsung_pay_card.card_type.should_not be_nil
-    samsung_pay_card.commercial.should_not be_nil
-    samsung_pay_card.country_of_issuance.should_not be_nil
-    samsung_pay_card.created_at.should_not be_nil
-    samsung_pay_card.customer_id.should_not be_nil
-    samsung_pay_card.customer_location.should_not be_nil
-    samsung_pay_card.debit.should_not be_nil
-    samsung_pay_card.default?.should_not be_nil
-    samsung_pay_card.durbin_regulated.should_not be_nil
-    samsung_pay_card.expiration_date.should_not be_nil
-    samsung_pay_card.expiration_month.should_not be_nil
-    samsung_pay_card.expiration_year.should_not be_nil
-    samsung_pay_card.expired?.should_not be_nil
-    samsung_pay_card.healthcare.should_not be_nil
-    samsung_pay_card.image_url.should_not be_nil
-    samsung_pay_card.issuing_bank.should_not be_nil
-    samsung_pay_card.last_4.should_not be_nil
-    samsung_pay_card.payroll.should_not be_nil
-    samsung_pay_card.prepaid.should_not be_nil
-    samsung_pay_card.product_id.should_not be_nil
-    samsung_pay_card.source_card_last_4.should_not be_nil
-    samsung_pay_card.subscriptions.should_not be_nil
-    samsung_pay_card.token.should_not be_nil
-    samsung_pay_card.unique_number_identifier.should_not be_nil
-    samsung_pay_card.updated_at.should_not be_nil
+    expect(samsung_pay_card).to be_a(Braintree::SamsungPayCard)
+    expect(samsung_pay_card.billing_address).not_to be_nil
+    expect(samsung_pay_card.bin).not_to be_nil
+    expect(samsung_pay_card.cardholder_name).not_to be_nil
+    expect(samsung_pay_card.card_type).not_to be_nil
+    expect(samsung_pay_card.commercial).not_to be_nil
+    expect(samsung_pay_card.country_of_issuance).not_to be_nil
+    expect(samsung_pay_card.created_at).not_to be_nil
+    expect(samsung_pay_card.customer_id).not_to be_nil
+    expect(samsung_pay_card.customer_location).not_to be_nil
+    expect(samsung_pay_card.debit).not_to be_nil
+    expect(samsung_pay_card.default?).not_to be_nil
+    expect(samsung_pay_card.durbin_regulated).not_to be_nil
+    expect(samsung_pay_card.expiration_date).not_to be_nil
+    expect(samsung_pay_card.expiration_month).not_to be_nil
+    expect(samsung_pay_card.expiration_year).not_to be_nil
+    expect(samsung_pay_card.expired?).not_to be_nil
+    expect(samsung_pay_card.healthcare).not_to be_nil
+    expect(samsung_pay_card.image_url).not_to be_nil
+    expect(samsung_pay_card.issuing_bank).not_to be_nil
+    expect(samsung_pay_card.last_4).not_to be_nil
+    expect(samsung_pay_card.payroll).not_to be_nil
+    expect(samsung_pay_card.prepaid).not_to be_nil
+    expect(samsung_pay_card.product_id).not_to be_nil
+    expect(samsung_pay_card.source_card_last_4).not_to be_nil
+    expect(samsung_pay_card.subscriptions).not_to be_nil
+    expect(samsung_pay_card.token).not_to be_nil
+    expect(samsung_pay_card.unique_number_identifier).not_to be_nil
+    expect(samsung_pay_card.updated_at).not_to be_nil
 
     customer = Braintree::Customer.find(customer.id)
-    customer.samsung_pay_cards.size.should == 1
-    customer.samsung_pay_cards.first.should == samsung_pay_card
+    expect(customer.samsung_pay_cards.size).to eq(1)
+    expect(customer.samsung_pay_cards.first).to eq(samsung_pay_card)
   end
 
   it "returns cardholder_name and billing_address" do
@@ -65,7 +67,7 @@ describe Braintree::SamsungPayCard do
     result = Braintree::PaymentMethod.create(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :cardholder_name => 'Jenny Block',
+      :cardholder_name => "Jenny Block",
       :billing_address => {
           :first_name => "New First Name",
           :last_name => "New Last Name",
@@ -76,36 +78,36 @@ describe Braintree::SamsungPayCard do
           :region => "New State",
           :postal_code => "56789",
           :country_name => "United States of America"
-      }
+      },
     )
 
-    result.should be_success
-    result.payment_method.cardholder_name.should == 'Jenny Block'
+    expect(result).to be_success
+    expect(result.payment_method.cardholder_name).to eq("Jenny Block")
 
     address = result.payment_method.billing_address
-    address.first_name.should == "New First Name"
-    address.last_name.should == "New Last Name"
-    address.company.should == "New Company"
-    address.street_address.should == "123 New St"
-    address.extended_address.should == "Apt New"
-    address.locality.should == "New City"
-    address.region.should == "New State"
-    address.postal_code.should == "56789"
+    expect(address.first_name).to eq("New First Name")
+    expect(address.last_name).to eq("New Last Name")
+    expect(address.company).to eq("New Company")
+    expect(address.street_address).to eq("123 New St")
+    expect(address.extended_address).to eq("Apt New")
+    expect(address.locality).to eq("New City")
+    expect(address.region).to eq("New State")
+    expect(address.postal_code).to eq("56789")
   end
 
   it "can search for transactions" do
     transaction_create_result = Braintree::Transaction.sale(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
-      :amount => '47.00',
+      :amount => "47.00",
     )
-    transaction_create_result.should be_success
+    expect(transaction_create_result).to 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::SamsungPayCard
     end
-    search_results.first.id.should == transaction_id
+    expect(search_results.first.id).to eq(transaction_id)
   end
 
   it "can create transaction from nonce and vault" do
@@ -114,31 +116,31 @@ describe Braintree::SamsungPayCard do
     result = Braintree::Transaction.sale(
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :customer_id => customer.id,
-      :amount => '47.00',
-      :options => { :store_in_vault => true },
+      :amount => "47.00",
+      :options => {:store_in_vault => true},
     )
-    result.should be_success
+    expect(result).to be_success
 
     samsung_pay_card_details = result.transaction.samsung_pay_card_details
-    samsung_pay_card_details.bin.should_not be_nil
-    samsung_pay_card_details.card_type.should_not be_nil
-    samsung_pay_card_details.commercial.should_not be_nil
-    samsung_pay_card_details.country_of_issuance.should_not be_nil
-    samsung_pay_card_details.customer_location.should_not be_nil
-    samsung_pay_card_details.debit.should_not be_nil
-    samsung_pay_card_details.durbin_regulated.should_not be_nil
-    samsung_pay_card_details.expiration_date.should_not be_nil
-    samsung_pay_card_details.expiration_month.should_not be_nil
-    samsung_pay_card_details.expiration_year.should_not be_nil
-    samsung_pay_card_details.healthcare.should_not be_nil
-    samsung_pay_card_details.image_url.should_not be_nil
-    samsung_pay_card_details.issuing_bank.should_not be_nil
-    samsung_pay_card_details.last_4.should_not be_nil
-    samsung_pay_card_details.payroll.should_not be_nil
-    samsung_pay_card_details.prepaid.should_not be_nil
-    samsung_pay_card_details.product_id.should_not be_nil
-    samsung_pay_card_details.source_card_last_4.should_not be_nil
-    samsung_pay_card_details.source_card_last_4.should == '3333'
-    samsung_pay_card_details.token.should_not be_nil
+    expect(samsung_pay_card_details.bin).not_to be_nil
+    expect(samsung_pay_card_details.card_type).not_to be_nil
+    expect(samsung_pay_card_details.commercial).not_to be_nil
+    expect(samsung_pay_card_details.country_of_issuance).not_to be_nil
+    expect(samsung_pay_card_details.customer_location).not_to be_nil
+    expect(samsung_pay_card_details.debit).not_to be_nil
+    expect(samsung_pay_card_details.durbin_regulated).not_to be_nil
+    expect(samsung_pay_card_details.expiration_date).not_to be_nil
+    expect(samsung_pay_card_details.expiration_month).not_to be_nil
+    expect(samsung_pay_card_details.expiration_year).not_to be_nil
+    expect(samsung_pay_card_details.healthcare).not_to be_nil
+    expect(samsung_pay_card_details.image_url).not_to be_nil
+    expect(samsung_pay_card_details.issuing_bank).not_to be_nil
+    expect(samsung_pay_card_details.last_4).not_to be_nil
+    expect(samsung_pay_card_details.payroll).not_to be_nil
+    expect(samsung_pay_card_details.prepaid).not_to be_nil
+    expect(samsung_pay_card_details.product_id).not_to be_nil
+    expect(samsung_pay_card_details.source_card_last_4).not_to be_nil
+    expect(samsung_pay_card_details.source_card_last_4).to eq("3333")
+    expect(samsung_pay_card_details.token).not_to be_nil
   end
 end

data/spec/integration/braintree/sepa_direct_debit_account_spec.rb

@@ -0,0 +1,194 @@
+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
+        expect(sepa_direct_debit_account).to be_a(Braintree::SepaDirectDebitAccount)
+        expect(sepa_direct_debit_account.last_4).to eq("1234")
+        expect(sepa_direct_debit_account.default).to eq(true)
+        expect(sepa_direct_debit_account.customer_id).to eq(customer.id)
+        expect(sepa_direct_debit_account.global_id).not_to be_empty
+        expect(sepa_direct_debit_account.customer_global_id).not_to be_empty
+        expect(sepa_direct_debit_account.bank_reference_token).to eq("a-fake-bank-reference-token")
+        expect(sepa_direct_debit_account.mandate_type).to eq("RECURRENT")
+        expect(sepa_direct_debit_account.merchant_or_partner_customer_id).to eq("a-fake-mp-customer-id")
+        expect(sepa_direct_debit_account.token).not_to be_empty
+        expect(sepa_direct_debit_account.image_url).not_to be_empty
+        expect(sepa_direct_debit_account.created_at).to be_a Time
+        expect(sepa_direct_debit_account.updated_at).to 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
+        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
+        is_expected.to 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
+        is_expected.to be_success
+
+        transaction = subject.transaction
+        expect(transaction.amount).to eq(1.23)
+        expect(transaction.status).to eq("settling")
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        expect(sepa_direct_debit_account_details).to be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        expect(sepa_direct_debit_account_details.bank_reference_token).to eq("a-fake-bank-reference-token")
+        expect(sepa_direct_debit_account_details.capture_id).not_to be_empty
+        expect(sepa_direct_debit_account_details.debug_id).to be_nil
+        expect(sepa_direct_debit_account_details.global_id).not_to be_empty
+        expect(sepa_direct_debit_account_details.last_4).to eq("1234")
+        expect(sepa_direct_debit_account_details.mandate_type).to eq("RECURRENT")
+        expect(sepa_direct_debit_account_details.merchant_or_partner_customer_id).to eq("a-fake-mp-customer-id")
+        expect(sepa_direct_debit_account_details.paypal_v2_order_id).to be_nil
+        expect(sepa_direct_debit_account_details.refund_from_transaction_fee_amount).to be_nil
+        expect(sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code).to be_nil
+        expect(sepa_direct_debit_account_details.refund_id).to be_nil
+        expect(sepa_direct_debit_account_details.settlement_type).to be_nil
+        expect(sepa_direct_debit_account_details.token).to eq(token)
+        expect(sepa_direct_debit_account_details.transaction_fee_amount).to eq("0.01")
+        expect(sepa_direct_debit_account_details.transaction_fee_currency_iso_code).to eq("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
+        expect(transaction.amount).to eq(1.23)
+        expect(transaction.status).to eq("settling")
+        sepa_direct_debit_account_details = transaction.sepa_direct_debit_account_details
+        expect(sepa_direct_debit_account_details).to be_a(Braintree::Transaction::SepaDirectDebitAccountDetails)
+        expect(sepa_direct_debit_account_details.bank_reference_token).to eq("a-fake-bank-reference-token")
+        expect(sepa_direct_debit_account_details.capture_id).not_to be_empty
+        expect(sepa_direct_debit_account_details.debug_id).to be_nil
+        expect(sepa_direct_debit_account_details.global_id).not_to be_empty
+        expect(sepa_direct_debit_account_details.last_4).to eq("1234")
+        expect(sepa_direct_debit_account_details.mandate_type).to eq("RECURRENT")
+        expect(sepa_direct_debit_account_details.merchant_or_partner_customer_id).to eq("a-fake-mp-customer-id")
+        expect(sepa_direct_debit_account_details.paypal_v2_order_id).to be_nil
+        expect(sepa_direct_debit_account_details.refund_from_transaction_fee_amount).to be_nil
+        expect(sepa_direct_debit_account_details.refund_from_transaction_fee_currency_iso_code).to be_nil
+        expect(sepa_direct_debit_account_details.refund_id).to be_nil
+        expect(sepa_direct_debit_account_details.settlement_type).to be_nil
+        expect(sepa_direct_debit_account_details.token).to eq(token)
+        expect(sepa_direct_debit_account_details.transaction_fee_amount).to eq("0.01")
+        expect(sepa_direct_debit_account_details.transaction_fee_currency_iso_code).to eq("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/settlement_batch_summary_spec.rb

@@ -5,14 +5,14 @@ describe Braintree::SettlementBatchSummary do
   describe "self.generate" do
     it "returns an empty collection if there is not data" do
       result = Braintree::SettlementBatchSummary.generate("1979-01-01")
-      result.should be_success
-      result.settlement_batch_summary.records.size.should be_zero
+      expect(result).to be_success
+      expect(result.settlement_batch_summary.records.size).to be_zero
     end
 
     it "returns an error response if the date cannot be parsed" do
       result = Braintree::SettlementBatchSummary.generate("NOT A DATE :(")
-      result.should_not be_success
-      result.errors.for(:settlement_batch_summary).on(:settlement_date).map {|e| e.code}.should include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
+      expect(result).not_to be_success
+      expect(result.errors.for(:settlement_batch_summary).on(:settlement_date).map { |e| e.code }).to include(Braintree::ErrorCodes::SettlementBatchSummary::SettlementDateIsInvalid)
     end
 
     it "returns transactions settled on a given day" do
@@ -23,16 +23,16 @@ describe Braintree::SettlementBatchSummary do
           :expiration_date => "05/2012",
           :cardholder_name => "Sergio Ramos"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
       result = Braintree::SettlementBatchSummary.generate(settlement_date)
 
-      result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
-      amex_records.first[:count].to_i.should >= 1
-      amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i
+      expect(result).to be_success
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:card_type] == Braintree::CreditCard::CardType::AmEx }
+      expect(amex_records.first[:count].to_i).to be >= 1
+      expect(amex_records.first[:amount_settled].to_i).to be >= Braintree::Test::TransactionAmounts::Authorize.to_i
     end
 
     it "can be grouped by a custom field" do
@@ -46,17 +46,17 @@ describe Braintree::SettlementBatchSummary do
         :custom_fields => {
           :store_me => "1"
         },
-        :options => { :submit_for_settlement => true }
+        :options => {:submit_for_settlement => true},
       )
       result = SpecHelper.settle_transaction transaction.id
-      settlement_date = result[:transaction][:settlement_batch_id].split('_').first
-      result = Braintree::SettlementBatchSummary.generate(settlement_date, 'store_me')
+      settlement_date = result[:transaction][:settlement_batch_id].split("_").first
+      result = Braintree::SettlementBatchSummary.generate(settlement_date, "store_me")
 
-      result.should be_success
-      amex_records = result.settlement_batch_summary.records.select {|row| row[:store_me] == "1" }
-      amex_records.should_not be_empty
-      amex_records.first[:count].to_i.should >= 1
-      amex_records.first[:amount_settled].to_i.should >= Braintree::Test::TransactionAmounts::Authorize.to_i
+      expect(result).to be_success
+      amex_records = result.settlement_batch_summary.records.select { |row| row[:store_me] == "1" }
+      expect(amex_records).not_to be_empty
+      expect(amex_records.first[:count].to_i).to be >= 1
+      expect(amex_records.first[:amount_settled].to_i).to be >= Braintree::Test::TransactionAmounts::Authorize.to_i
     end
   end
 end