braintree 2.98.0 → 4.23.0

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,77 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+# NEXT_MAJOR_VERSION Remove paypal_tracking_id assertions, use paypal_tracker_id going forward
+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", :paypal_tracker_id => "pp_tracking_number_1"},
+              {:id => "id2", :carrier => "FEDEX", :tracking_number => "tracking_number_2", :paypal_tracking_id => "pp_tracking_number_2", :paypal_tracker_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[0].paypal_tracker_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")
+          expect(transaction.packages[1].paypal_tracker_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

@@ -0,0 +1,45 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::PaymentMethodCustomerDataUpdatedMetadata do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::PaymentMethodCustomerDataUpdatedMetadata.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+
+      params = {
+        token: "a-token",
+        payment_method: {
+          venmo_account: {
+            venmo_user_id: "venmo-user-id",
+          },
+        },
+        datetime_updated: "2022-01-01T21:28:37Z",
+        enriched_customer_data: {
+          fields_updated: ["username"],
+          profile_data: {
+            username: "a-username",
+            first_name: "a-first-name",
+            last_name: "a-last-name",
+            phone_number: "a-phone-number",
+            email: "a-email",
+          },
+        },
+      }
+
+      payment_method_customer_data_updated = Braintree::PaymentMethodCustomerDataUpdatedMetadata._new(:gateway, params)
+
+      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

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonceDetailsPayerInfo do
+  let(:payment_method_nonce_details_payer_info) {
+    Braintree::PaymentMethodNonceDetailsPayerInfo.new(
+      :billing_agreement_id => "billing-agreement-id",
+      :country_code => "US",
+      :email => "test@example.com",
+      :first_name => "First",
+      :last_name => "Last",
+      :payer_id => "payer-id",
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      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
+      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

@@ -0,0 +1,51 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonceDetails do
+  let(:payment_method_nonce_details) {
+    Braintree::PaymentMethodNonceDetails.new(
+      :bank_reference_token => "a-bank-reference-token",
+      :bin => "bin",
+      :card_type => "American Express",
+      :expiration_month => "12",
+      :expiration_year => "2025",
+      :is_network_tokenized => true,
+      :last_4 => "abcd",
+      :last_two => "11",
+      :mandate_type => "ONE_OFF",
+      :merchant_or_partner_customer_id => "a-mp-customer-id",
+      :payer_info => {
+        :billing_agreement_id => "1234",
+        :country_code => "US",
+      },
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      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
+      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
+      expect(payment_method_nonce_details.is_network_tokenized?).to eq(true)
+    end
+  end
+end

data/spec/unit/braintree/payment_method_nonce_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::PaymentMethodNonce do
+  let(:payment_method_nonce) {
+    Braintree::PaymentMethodNonce._new(
+      :gateway,
+      :nonce => "some-nonce",
+      :type => "CreditCard",
+      :default => true,
+      :details => {
+        :bin => "some-bin"
+      },
+      :three_d_secure_info => {
+        :liability_shift_possible => false,
+        :liability_shifted => false
+      },
+      :bin_data => {
+        :country_of_issuance => "USA"
+      },
+    )
+  }
+
+  describe "#initialize" do
+    it "sets attributes" do
+      expect(payment_method_nonce.nonce).to eq("some-nonce")
+      expect(payment_method_nonce.type).to eq("CreditCard")
+      expect(payment_method_nonce.default).to be true
+      expect(payment_method_nonce.details.bin).to eq("some-bin")
+      expect(payment_method_nonce.three_d_secure_info.liability_shift_possible).to be false
+      expect(payment_method_nonce.three_d_secure_info.liability_shifted).to be false
+      expect(payment_method_nonce.bin_data.country_of_issuance).to eq("USA")
+    end
+  end
+
+  describe "default" do
+    it "is aliased to default?" do
+      expect(payment_method_nonce.default?).to be 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 }
+    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

@@ -4,11 +4,11 @@ describe Braintree::PayPalAccount do
   describe "self.create" do
     it "raises an exception if attributes contain an invalid key" do
       expect do
-        result = Braintree::PayPalAccount.create(
+        Braintree::PayPalAccount.create(
           :invalid_key => "bad stuff",
           :options => {
             :invalid_option => "bad option",
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: invalid_key, options[invalid_option]")
     end
@@ -17,18 +17,18 @@ describe Braintree::PayPalAccount do
   describe "self.update" do
     it "raises an exception if attributes contain an invalid key" do
       expect do
-        Braintree::PayPalAccount.update("some_token", :invalid_key => 'val')
+        Braintree::PayPalAccount.update("some_token", :invalid_key => "val")
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end
 
   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,17 @@ 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
+
+  describe "edit_paypal_vault_id" do
+    it "exposes edit_paypal_vault_id" do
+      mock_edit_paypal_vault_id = "ENCR-BA-ID1"
+      paypal_account = Braintree::PayPalAccount._new(:gateway, :edit_paypal_vault_id => mock_edit_paypal_vault_id)
+
+      expect(paypal_account.edit_paypal_vault_id).to eq(mock_edit_paypal_vault_id)
     end
   end
 end