braintree 4.14.0 → 4.18.0

data/spec/unit/braintree/meta_checkout_card_details_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction::MetaCheckoutCardDetails do
+    let(:attributes) do {
+
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::Transaction::MetaCheckoutCardDetails.new(attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/meta_checkout_card_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutCard do
+    let(:attributes) do {
+
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::MetaCheckoutCard._new(:gateway, attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/meta_checkout_token_details_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::Transaction::MetaCheckoutTokenDetails do
+    let(:attributes) do {
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z",
+        :cryptogram => "AlhlvxmN2ZKuAAESNFZ4GoABFA==",
+        :ecommerce_indicator => "07"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::Transaction::MetaCheckoutTokenDetails.new(attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+            card.cryptogram == "AlhlvxmN2ZKuAAESNFZ4GoABFA=="
+            card.ecommerce_indicator == "07"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::Transaction::MetaCheckoutTokenDetails.new(attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::Transaction::MetaCheckoutTokenDetails.new(attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/meta_checkout_token_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MetaCheckoutToken do
+    let(:attributes) do {
+        :bin => "abc1234",
+        :container_id => "a-container-id",
+        :card_type => "Visa",
+        :cardholder_name => "Meta Checkout Card CardHolder",
+        :commercial => "NO",
+        :country_of_issuance => "US",
+        :created_at => "2023-05-05T21:28:37Z",
+        :debit => "NO",
+        :durbin_regulated => "NO",
+        :expiration_month => "05",
+        :expiration_year => "2024",
+        :healthcare => "NO",
+        :last_4 => "1234",
+        :payroll => "NO",
+        :prepaid => "NO",
+        :token => "token1",
+        :unique_number_identifier => "abc1234",
+        :updated_at => "2023-05-05T21:28:37Z",
+        :cryptogram => "AlhlvxmN2ZKuAAESNFZ4GoABFA==",
+        :ecommerce_indicator => "07"
+    }
+    end
+
+    describe "unit tests" do
+        it "initializes with the correct attributes" do
+            card = Braintree::MetaCheckoutToken._new(:gateway, attributes)
+
+            card.bin.should == "abc1234"
+            card.container_id.should == "a-container-id"
+            card.card_type.should == "Visa"
+            card.cardholder_name.should == "Meta Checkout Card CardHolder"
+            card.commercial == "NO"
+            card.country_of_issuance == "US"
+            card.created_at == "2023-05-05T21:28:37Z"
+            card.updated_at == "2023-05-05T21:28:37Z"
+            card.debit == "NO"
+            card.payroll == "NO"
+            card.prepaid == "NO"
+            card.healthcare == "NO"
+            card.token == "token1"
+            card.unique_number_identifier == "abc1234"
+            card.expiration_month.should == "05"
+            card.expiration_year.should == "2024"
+            card.last_4.should == "1234"
+            card.cryptogram == "AlhlvxmN2ZKuAAESNFZ4GoABFA=="
+            card.ecommerce_indicator == "07"
+        end
+
+        it "sets expiration date correctly" do
+            card = Braintree::MetaCheckoutToken._new(:gateway, attributes)
+            card.expiration_date.should == "05/2024"
+        end
+
+        it "masks the card number correctly" do
+            card = Braintree::MetaCheckoutToken._new(:gateway, attributes)
+            card.masked_number.should == "abc1234******1234"
+        end
+    end
+end

data/spec/unit/braintree/modification_spec.rb

@@ -2,6 +2,6 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::Modification do
   it "converts string amount" do
-    Braintree::Modification._new(:amount => "100.00").amount.should == BigDecimal("100.00")
+    expect(Braintree::Modification._new(:amount => "100.00").amount).to eq(BigDecimal("100.00"))
   end
 end

data/spec/unit/braintree/package_tracking_spec.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "Package Tracking Unit Tests" do
+    describe "creates and validates requests" do
+        let(:gateway) do
+            config = Braintree::Configuration.new(
+              :merchant_id => "merchant_id",
+              :public_key => "public_key",
+              :private_key => "private_key",
+            )
+            Braintree::Gateway.new(config)
+        end
+
+          it "creates transaction gateway package tracking request signature" do
+            expect(Braintree::TransactionGateway._package_tracking_request_signature).to match(
+              [
+                :carrier,
+                {:line_items => [:commodity_code, :description, :discount_amount, :image_url, :kind, :name, :product_code, :quantity, :tax_amount, :total_amount, :unit_amount, :unit_of_measure, :unit_tax_amount, :upc_code, :upc_type, :url]},
+                :notify_payer, :tracking_number,
+              ],
+            )
+          end
+
+          it "raises an ArgumentError if transaction_id is an invalid format" do
+            expect do
+              Braintree::Transaction.package_tracking("invalid-transaction-id", {})
+            end.to raise_error(ArgumentError, "transaction_id is invalid")
+          end
+
+          it "raises an exception if attributes contain an invalid key" do
+            expect do
+                Braintree::Transaction.package_tracking("txn123", {:invalid_key => "random", :carrier => "UPS", :tracking_number => "123123"})
+            end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+          end
+    end
+
+    describe "handles response" do
+        it "parses the packages response correctly" do
+          transaction = Braintree::Transaction._new(
+            :gateway,
+            :shipments => [
+              {:id => "id1", :carrier => "UPS", :tracking_number => "tracking_number_1", :paypal_tracking_id => "pp_tracking_number_1"},
+              {:id => "id2", :carrier => "FEDEX", :tracking_number => "tracking_number_2", :paypal_tracking_id => "pp_tracking_number_2"}
+            ],
+          )
+          expect(transaction.packages.size).to eq(2)
+          expect(transaction.packages[0].id).to eq("id1")
+          expect(transaction.packages[0].carrier).to eq("UPS")
+          expect(transaction.packages[0].tracking_number).to eq("tracking_number_1")
+          expect(transaction.packages[0].paypal_tracking_id).to eq("pp_tracking_number_1")
+
+          expect(transaction.packages[1].id).to eq("id2")
+          expect(transaction.packages[1].carrier).to eq("FEDEX")
+          expect(transaction.packages[1].tracking_number).to eq("tracking_number_2")
+          expect(transaction.packages[1].paypal_tracking_id).to eq("pp_tracking_number_2")
+        end
+
+        it "doesn't blow up if no shipments are present in the transaction response" do
+            transaction = Braintree::Transaction._new(
+                :gateway,
+                :shipments => [],
+              )
+              expect(transaction.packages.size).to eq(0)
+        end
+
+        it "doesn't blow up if shipments tag is not present in the transaction response" do
+            transaction = Braintree::Transaction._new(
+                :gateway,
+                {},
+              )
+              expect(transaction.packages.size).to eq(0)
+        end
+    end
+end

data/spec/unit/braintree/payment_method_customer_data_updated_metadata_spec.rb

@@ -34,12 +34,12 @@ describe Braintree::PaymentMethodCustomerDataUpdatedMetadata do
 
       payment_method_customer_data_updated = Braintree::PaymentMethodCustomerDataUpdatedMetadata._new(:gateway, params)
 
-      payment_method_customer_data_updated.token.should eq("a-token")
-      payment_method_customer_data_updated.datetime_updated.should eq("2022-01-01T21:28:37Z")
-      payment_method_customer_data_updated.payment_method.should be_a(Braintree::VenmoAccount)
-      payment_method_customer_data_updated.enriched_customer_data.profile_data.first_name.should eq("a-first-name")
-      payment_method_customer_data_updated.enriched_customer_data.profile_data.last_name.should eq("a-last-name")
-      payment_method_customer_data_updated.enriched_customer_data.fields_updated.should eq(["username"])
+      expect(payment_method_customer_data_updated.token).to eq("a-token")
+      expect(payment_method_customer_data_updated.datetime_updated).to eq("2022-01-01T21:28:37Z")
+      expect(payment_method_customer_data_updated.payment_method).to be_a(Braintree::VenmoAccount)
+      expect(payment_method_customer_data_updated.enriched_customer_data.profile_data.first_name).to eq("a-first-name")
+      expect(payment_method_customer_data_updated.enriched_customer_data.profile_data.last_name).to eq("a-last-name")
+      expect(payment_method_customer_data_updated.enriched_customer_data.fields_updated).to eq(["username"])
     end
   end
 end

data/spec/unit/braintree/payment_method_nonce_details_payer_info_spec.rb

@@ -14,18 +14,18 @@ describe Braintree::PaymentMethodNonceDetailsPayerInfo do
 
   describe "#initialize" do
     it "sets attributes" do
-      payment_method_nonce_details_payer_info.billing_agreement_id.should == "billing-agreement-id"
-      payment_method_nonce_details_payer_info.country_code.should == "US"
-      payment_method_nonce_details_payer_info.email.should == "test@example.com"
-      payment_method_nonce_details_payer_info.first_name.should == "First"
-      payment_method_nonce_details_payer_info.last_name.should == "Last"
-      payment_method_nonce_details_payer_info.payer_id.should == "payer-id"
+      expect(payment_method_nonce_details_payer_info.billing_agreement_id).to eq("billing-agreement-id")
+      expect(payment_method_nonce_details_payer_info.country_code).to eq("US")
+      expect(payment_method_nonce_details_payer_info.email).to eq("test@example.com")
+      expect(payment_method_nonce_details_payer_info.first_name).to eq("First")
+      expect(payment_method_nonce_details_payer_info.last_name).to eq("Last")
+      expect(payment_method_nonce_details_payer_info.payer_id).to eq("payer-id")
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      payment_method_nonce_details_payer_info.inspect.should == %(#<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: \"billing-agreement-id\", country_code: \"US\", email: \"test@example.com\", first_name: \"First\", last_name: \"Last\", payer_id: \"payer-id\">)
+      expect(payment_method_nonce_details_payer_info.inspect).to eq(%(#<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: \"billing-agreement-id\", country_code: \"US\", email: \"test@example.com\", first_name: \"First\", last_name: \"Last\", payer_id: \"payer-id\">))
     end
   end
 end

data/spec/unit/braintree/payment_method_nonce_details_spec.rb

@@ -22,30 +22,30 @@ describe Braintree::PaymentMethodNonceDetails do
 
   describe "#initialize" do
     it "sets attributes" do
-      payment_method_nonce_details.bin.should == "bin"
-      payment_method_nonce_details.card_type.should == "American Express"
-      payment_method_nonce_details.expiration_month.should == "12"
-      payment_method_nonce_details.expiration_year.should == "2025"
-      payment_method_nonce_details.is_network_tokenized.should == true
-      payment_method_nonce_details.last_two.should == "11"
-      payment_method_nonce_details.payer_info.billing_agreement_id.should == "1234"
-      payment_method_nonce_details.payer_info.country_code.should == "US"
-      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.bank_reference_token.should == "a-bank-reference-token"
-      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.last_4.should == "abcd"
-      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.mandate_type.should == "ONE_OFF"
-      payment_method_nonce_details.sepa_direct_debit_account_nonce_details.merchant_or_partner_customer_id.should == "a-mp-customer-id"
+      expect(payment_method_nonce_details.bin).to eq("bin")
+      expect(payment_method_nonce_details.card_type).to eq("American Express")
+      expect(payment_method_nonce_details.expiration_month).to eq("12")
+      expect(payment_method_nonce_details.expiration_year).to eq("2025")
+      expect(payment_method_nonce_details.is_network_tokenized).to eq(true)
+      expect(payment_method_nonce_details.last_two).to eq("11")
+      expect(payment_method_nonce_details.payer_info.billing_agreement_id).to eq("1234")
+      expect(payment_method_nonce_details.payer_info.country_code).to eq("US")
+      expect(payment_method_nonce_details.sepa_direct_debit_account_nonce_details.bank_reference_token).to eq("a-bank-reference-token")
+      expect(payment_method_nonce_details.sepa_direct_debit_account_nonce_details.last_4).to eq("abcd")
+      expect(payment_method_nonce_details.sepa_direct_debit_account_nonce_details.mandate_type).to eq("ONE_OFF")
+      expect(payment_method_nonce_details.sepa_direct_debit_account_nonce_details.merchant_or_partner_customer_id).to eq("a-mp-customer-id")
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      payment_method_nonce_details.inspect.should == %(#<PaymentMethodNonceDetails bin: "bin", card_type: "American Express", expiration_month: "12", expiration_year: "2025", is_network_tokenized: true, last_two: "11", payer_info: #<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: "1234", country_code: "US", email: nil, first_name: nil, last_name: nil, payer_id: nil>, sepa_direct_debit_account_nonce_details: #<SepaDirectDebitAccountNonceDetailsbank_reference_token: "a-bank-reference-token", last_4: "abcd", mandate_type: "ONE_OFF", merchant_or_partner_customer_id: "a-mp-customer-id">>)
+      expect(payment_method_nonce_details.inspect).to eq(%(#<PaymentMethodNonceDetails bin: "bin", card_type: "American Express", expiration_month: "12", expiration_year: "2025", is_network_tokenized: true, last_two: "11", payer_info: #<PaymentMethodNonceDetailsPayerInfo billing_agreement_id: "1234", country_code: "US", email: nil, first_name: nil, last_name: nil, payer_id: nil>, sepa_direct_debit_account_nonce_details: #<SepaDirectDebitAccountNonceDetailsbank_reference_token: "a-bank-reference-token", last_4: "abcd", mandate_type: "ONE_OFF", merchant_or_partner_customer_id: "a-mp-customer-id">>))
     end
   end
 
   describe "is_network_tokenized" do
     it "is aliased to is_network_tokenized?" do
-      payment_method_nonce_details.is_network_tokenized?.should == true
+      expect(payment_method_nonce_details.is_network_tokenized?).to eq(true)
     end
   end
 end

data/spec/unit/braintree/payment_method_spec.rb

@@ -5,11 +5,11 @@ describe Braintree::PaymentMethod do
     it "handles an unknown payment method type" do
       unknown_response = {:unknown_payment_method => {:token => 1234, :default => true}}
       http_instance = double(:get => unknown_response)
-      Braintree::Http.stub(:new).and_return(http_instance)
+      allow(Braintree::Http).to receive(:new).and_return(http_instance)
       unknown_payment_method = Braintree::PaymentMethod.find("UNKNOWN_PAYMENT_METHOD_TOKEN")
 
-      unknown_payment_method.token.should == 1234
-      unknown_payment_method.default?.should be(true)
+      expect(unknown_payment_method.token).to eq(1234)
+      expect(unknown_payment_method.default?).to be(true)
     end
   end
 
@@ -17,27 +17,27 @@ describe Braintree::PaymentMethod do
     it "handles an unknown payment method type" do
       unknown_response = {:unknown_payment_method => {:token => 1234, :default => true}}
       http_instance = double(:put => unknown_response)
-      Braintree::Http.stub(:new).and_return(http_instance)
+      allow(Braintree::Http).to receive(:new).and_return(http_instance)
       result = Braintree::PaymentMethod.update(:unknown,
         {:options => {:make_default => true}})
 
-      result.should be_success
-      result.payment_method.token.should == 1234
-      result.payment_method.should be_instance_of(Braintree::UnknownPaymentMethod)
+      expect(result).to be_success
+      expect(result.payment_method.token).to eq(1234)
+      expect(result.payment_method).to be_instance_of(Braintree::UnknownPaymentMethod)
     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")
+      allow(Braintree::Http).to receive(:new).and_return http_stub
+      expect(http_stub).to 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")
+      allow(Braintree::Http).to receive(:new).and_return http_stub
+      expect(http_stub).to 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
 
@@ -48,8 +48,8 @@ describe Braintree::PaymentMethod do
     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")
+      allow(Braintree::Http).to receive(:new).and_return http_stub
+      expect(http_stub).to receive(:delete).with("/merchants/integration_merchant_id/payment_methods/any/some_token")
       Braintree::PaymentMethod.delete("some_token")
     end
   end
@@ -59,8 +59,8 @@ describe Braintree::PaymentMethod do
       now = Time.now
       paypal_account = Braintree::PayPalAccount._new(:gateway, :updated_at => now, :created_at => now)
 
-      paypal_account.created_at.should == now
-      paypal_account.updated_at.should == now
+      expect(paypal_account.created_at).to eq(now)
+      expect(paypal_account.updated_at).to eq(now)
     end
   end
 
@@ -84,21 +84,21 @@ describe Braintree::PaymentMethod do
     end
 
     it "does not raise an error if token does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::PaymentMethod.grant(8675309, :allow_vaulting => false)
       end.to_not raise_error
     end
 
     it "accepts all options as hash map" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::PaymentMethod.grant("$dummyToken", :allow_vaulting => false, :include_billing_postal_code => true)
       end.to_not raise_error
     end
 
     it "accepts only token as parameter" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::PaymentMethod.grant("$dummyToken")
       end.to_not raise_error
@@ -126,7 +126,7 @@ describe Braintree::PaymentMethod do
     end
 
     it "does not raise an error if token does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double.as_null_object
+      allow(Braintree::Http).to receive(:new).and_return double.as_null_object
       expect do
         Braintree::PaymentMethod.revoke(8675309)
       end.to_not raise_error

data/spec/unit/braintree/paypal_account_spec.rb

@@ -24,11 +24,11 @@ describe Braintree::PayPalAccount do
 
   describe "default?" do
     it "is true if the paypal account is the default payment method for the customer" do
-      Braintree::PayPalAccount._new(:gateway, :default => true).default?.should == true
+      expect(Braintree::PayPalAccount._new(:gateway, :default => true).default?).to eq(true)
     end
 
     it "is false if the paypal account is not the default payment methodfor the customer" do
-      Braintree::PayPalAccount._new(:gateway, :default => false).default?.should == false
+      expect(Braintree::PayPalAccount._new(:gateway, :default => false).default?).to eq(false)
     end
   end
 
@@ -37,8 +37,8 @@ describe Braintree::PayPalAccount do
       now = Time.now
       paypal_account = Braintree::PayPalAccount._new(:gateway, :updated_at => now, :created_at => now)
 
-      paypal_account.created_at.should == now
-      paypal_account.updated_at.should == now
+      expect(paypal_account.created_at).to eq(now)
+      expect(paypal_account.updated_at).to eq(now)
     end
   end
 end

data/spec/unit/braintree/resource_collection_spec.rb

@@ -10,11 +10,11 @@ describe "Braintree::ResourceCollection" do
 
       count = 0
       collection.each_with_index do |item, index|
-        item.should == values[index]
+        expect(item).to eq(values[index])
         count += 1
       end
 
-      count.should == 5
+      expect(count).to eq(5)
     end
   end
 
@@ -25,7 +25,7 @@ describe "Braintree::ResourceCollection" do
         ids.map { |id| values[id] }
       end
 
-      collection.first.should == nil
+      expect(collection.first).to eq(nil)
     end
 
     context "with results" do
@@ -38,11 +38,11 @@ describe "Braintree::ResourceCollection" do
       end
 
       it "returns the first occourence" do
-        collection.first.should == "a"
+        expect(collection.first).to eq("a")
       end
 
       it "returns the first N occourences" do
-        collection.first(4).should == ["a","b","c","d"]
+        expect(collection.first(4)).to eq(["a","b","c","d"])
       end
     end
   end
@@ -50,12 +50,12 @@ describe "Braintree::ResourceCollection" do
   describe "#ids" do
     it "returns a list of the resource collection ids" do
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2})
-      collection.ids.should == [0,1,2,3,4]
+      expect(collection.ids).to eq([0,1,2,3,4])
     end
   end
 
   it "returns an empty array when the collection is empty" do
     collection = Braintree::ResourceCollection.new(:search_results => {:page_size => 2})
-    collection.ids.should == []
+    expect(collection.ids).to eq([])
   end
 end

data/spec/unit/braintree/sepa_debit_account_nonce_details_spec.rb

@@ -23,7 +23,7 @@ describe Braintree::SepaDirectDebitAccountNonceDetails do
 
   describe "inspect" do
     it "prints the attributes" do
-      subject.inspect.should == %(#<SepaDirectDebitAccountNonceDetailsbank_reference_token: "a-bank-reference-token", last_4: "abcd", mandate_type: "ONE_OFF", merchant_or_partner_customer_id: "a-mp-customer-id">)
+      expect(subject.inspect).to eq(%(#<SepaDirectDebitAccountNonceDetailsbank_reference_token: "a-bank-reference-token", last_4: "abcd", mandate_type: "ONE_OFF", merchant_or_partner_customer_id: "a-mp-customer-id">))
     end
   end
 end

data/spec/unit/braintree/sha256_digest_spec.rb

@@ -5,7 +5,7 @@ describe Braintree::SHA256Digest do
     it "returns the sha256 hmac of the input string (test case 6 from RFC 2202)" do
       key = "secret-key"
       message = "secret-message"
-      Braintree::SHA256Digest.hexdigest(key, message).should == "68e7f2ecab71db67b1aca2a638f5122810315c3013f27c2196cd53e88709eecc"
+      expect(Braintree::SHA256Digest.hexdigest(key, message)).to eq("68e7f2ecab71db67b1aca2a638f5122810315c3013f27c2196cd53e88709eecc")
     end
   end
 end

data/spec/unit/braintree/signature_service_spec.rb

@@ -11,13 +11,13 @@ describe Braintree::SignatureService do
     it "signs the data with its key" do
       service = Braintree::SignatureService.new("my_key", FakeDigest)
 
-      service.sign(:foo => "foo bar").should == "foo=foo+bar_signed_with_my_key|foo=foo+bar"
+      expect(service.sign(:foo => "foo bar")).to eq("foo=foo+bar_signed_with_my_key|foo=foo+bar")
     end
   end
 
   describe "hash" do
     it "hashes the string with its key" do
-      Braintree::SignatureService.new("my_key", FakeDigest).hash("foo").should == "foo_signed_with_my_key"
+      expect(Braintree::SignatureService.new("my_key", FakeDigest).hash("foo")).to eq("foo_signed_with_my_key")
     end
   end
 end