braintree 4.14.0 → 4.18.0

data/spec/integration/braintree/samsung_pay_card_spec.rb

@@ -21,42 +21,42 @@ describe Braintree::SamsungPayCard do
           :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
@@ -79,18 +79,18 @@ describe Braintree::SamsungPayCard do
       },
     )
 
-    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
@@ -98,14 +98,14 @@ describe Braintree::SamsungPayCard do
       :payment_method_nonce => Braintree::Test::Nonce::SamsungPayDiscover,
       :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
@@ -117,28 +117,28 @@ describe Braintree::SamsungPayCard do
       :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

@@ -25,19 +25,19 @@ describe Braintree::SepaDirectDebitAccount do
     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
+        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
 
@@ -79,7 +79,7 @@ describe Braintree::SepaDirectDebitAccount do
 
     context "when payment method exists" do
       it "deletes a payment method" do
-        should be_success
+        is_expected.to be_success
 
         expect {
           described_class.find(token)
@@ -111,28 +111,28 @@ describe Braintree::SepaDirectDebitAccount do
 
     context "when payment method exists" do
       it "creates a transaction" do
-        should be_success
+        is_expected.to be_success
 
         transaction = subject.transaction
-        transaction.amount.should eq(1.23)
-        transaction.status.should == "settling"
+        expect(transaction.amount).to eq(1.23)
+        expect(transaction.status).to eq("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"
+        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
 
@@ -161,25 +161,25 @@ describe Braintree::SepaDirectDebitAccount do
     context "when payment method exists" do
       it "creates a transaction" do
         transaction = subject
-        transaction.amount.should eq(1.23)
-        transaction.status.should == "settling"
+        expect(transaction.amount).to eq(1.23)
+        expect(transaction.status).to eq("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"
+        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
 

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
@@ -29,10 +29,10 @@ describe Braintree::SettlementBatchSummary do
       settlement_date = result[:transaction][:settlement_batch_id].split("_").first
       result = Braintree::SettlementBatchSummary.generate(settlement_date)
 
-      result.should be_success
+      expect(result).to 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(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
@@ -52,11 +52,11 @@ describe Braintree::SettlementBatchSummary do
       settlement_date = result[:transaction][:settlement_batch_id].split("_").first
       result = Braintree::SettlementBatchSummary.generate(settlement_date, "store_me")
 
-      result.should be_success
+      expect(result).to 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(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