braintree 4.14.0 → 4.15.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -23,22 +23,22 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should be_success
+          expect(result).to be_success
           us_bank_account = result.payment_method
-          us_bank_account.should be_a(Braintree::UsBankAccount)
-          us_bank_account.routing_number.should == "021000021"
-          us_bank_account.last_4.should == "0000"
-          us_bank_account.account_type.should == "checking"
-          us_bank_account.account_holder_name.should == "John Doe"
-          us_bank_account.bank_name.should =~ /CHASE/
-          us_bank_account.default.should == true
-          us_bank_account.ach_mandate.text.should == "cl mandate text"
-          us_bank_account.ach_mandate.accepted_at.should be_a Time
-
-          us_bank_account.verifications.count.should == 0
-          us_bank_account.verified.should == false
-
-          Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("021000021")
+          expect(us_bank_account.last_4).to eq("0000")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("John Doe")
+          expect(us_bank_account.bank_name).to match(/CHASE/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(0)
+          expect(us_bank_account.verified).to eq(false)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
         end
 
         [
@@ -56,26 +56,26 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to be_success
             us_bank_account = result.payment_method
-            us_bank_account.should be_a(Braintree::UsBankAccount)
-            us_bank_account.routing_number.should == "021000021"
-            us_bank_account.last_4.should == "0000"
-            us_bank_account.account_type.should == "checking"
-            us_bank_account.account_holder_name.should == "John Doe"
-            us_bank_account.bank_name.should =~ /CHASE/
-            us_bank_account.default.should == true
-            us_bank_account.ach_mandate.text.should == "cl mandate text"
-            us_bank_account.ach_mandate.accepted_at.should be_a Time
-
-            us_bank_account.verifications.count.should == 1
-            us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
-            us_bank_account.verifications.first.verification_method.should == method
-            us_bank_account.verifications.first.id.should_not be_empty
-            us_bank_account.verifications.first.verification_determined_at.should be_a Time
-            us_bank_account.verified.should == true
-
-            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(1)
+            expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(us_bank_account.verifications.first.verification_method).to eq(method)
+            expect(us_bank_account.verifications.first.id).not_to be_empty
+            expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
+
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
       end
@@ -87,8 +87,8 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
         )
 
-        result.should_not be_success
-        result.errors.for(:payment_method).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown
+        expect(result).not_to be_success
+        expect(result.errors.for(:payment_method).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown)
       end
     end
 
@@ -100,8 +100,8 @@ describe Braintree::PaymentMethod do
           :customer_id => customer.id,
         )
 
-        result.should_not be_success
-        result.errors.for(:payment_method).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown
+        expect(result).not_to be_success
+        expect(result.errors.for(:payment_method).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown)
       end
     end
   end
@@ -139,27 +139,27 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to be_success
 
             us_bank_account = result.payment_method
-            us_bank_account.should be_a(Braintree::UsBankAccount)
-            us_bank_account.routing_number.should == "021000021"
-            us_bank_account.last_4.should == "0000"
-            us_bank_account.account_type.should == "checking"
-            us_bank_account.account_holder_name.should == "John Doe"
-            us_bank_account.bank_name.should =~ /CHASE/
-            us_bank_account.default.should == true
-            us_bank_account.ach_mandate.text.should == "cl mandate text"
-            us_bank_account.ach_mandate.accepted_at.should be_a Time
-
-            us_bank_account.verifications.count.should == 1
-            us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
-            us_bank_account.verifications.first.verification_method.should == method
-            us_bank_account.verifications.first.id.should_not be_empty
-            us_bank_account.verifications.first.verification_determined_at.should be_a Time
-            us_bank_account.verified.should == true
-
-            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(1)
+            expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(us_bank_account.verifications.first.verification_method).to eq(method)
+            expect(us_bank_account.verifications.first.id).not_to be_empty
+            expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
+
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
 
@@ -172,8 +172,8 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should_not be_success
-          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:options).first.code).to eq(Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid)
         end
       end
     end
@@ -210,29 +210,29 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to be_success
 
             us_bank_account = result.payment_method
-            us_bank_account.should be_a(Braintree::UsBankAccount)
-            us_bank_account.routing_number.should == "021000021"
-            us_bank_account.last_4.should == "0000"
-            us_bank_account.account_type.should == "checking"
-            us_bank_account.account_holder_name.should == "John Doe"
-            us_bank_account.bank_name.should =~ /CHASE/
-            us_bank_account.default.should == true
-            us_bank_account.ach_mandate.text.should == "cl mandate text"
-            us_bank_account.ach_mandate.accepted_at.should be_a Time
-
-            us_bank_account.verifications.count.should == 2
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(2)
             verification = us_bank_account.verifications.find do |verification|
               verification.verification_method == method
             end
-            verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
-            verification.id.should_not be_empty
-            verification.verification_determined_at.should be_a Time
-            us_bank_account.verified.should == true
+            expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(verification.id).not_to be_empty
+            expect(verification.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
 
-            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
 
@@ -244,8 +244,8 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should_not be_success
-          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:options).first.code).to eq(Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid)
         end
       end
     end

data/spec/integration/braintree/paypal_account_spec.rb

@@ -15,17 +15,17 @@ describe Braintree::PayPalAccount do
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
       )
-      result.should be_success
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.should be_a(Braintree::PayPalAccount)
-      paypal_account.token.should == payment_method_token
-      paypal_account.email.should == "jane.doe@example.com"
-      paypal_account.image_url.should_not be_nil
-      paypal_account.created_at.should_not be_nil
-      paypal_account.updated_at.should_not be_nil
-      paypal_account.customer_id.should == customer.id
-      paypal_account.revoked_at.should be_nil
+      expect(paypal_account).to be_a(Braintree::PayPalAccount)
+      expect(paypal_account.token).to eq(payment_method_token)
+      expect(paypal_account.email).to eq("jane.doe@example.com")
+      expect(paypal_account.image_url).not_to be_nil
+      expect(paypal_account.created_at).not_to be_nil
+      expect(paypal_account.updated_at).not_to be_nil
+      expect(paypal_account.customer_id).to eq(customer.id)
+      expect(paypal_account.revoked_at).to be_nil
     end
 
     it "returns a PayPalAccount with a billing agreement id" do
@@ -37,10 +37,10 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
         :token => payment_method_token,
       )
-      result.should be_success
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.billing_agreement_id.should_not be_nil
+      expect(paypal_account.billing_agreement_id).not_to be_nil
     end
 
     it "raises if the payment method token is not found" do
@@ -76,7 +76,7 @@ describe Braintree::PayPalAccount do
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
       )
-      result.should be_success
+      expect(result).to be_success
 
       token = result.payment_method.token
 
@@ -91,7 +91,7 @@ describe Braintree::PayPalAccount do
       ).subscription
 
       paypal_account = Braintree::PayPalAccount.find(token)
-      paypal_account.subscriptions.map(&:id).sort.should == [subscription1.id, subscription2.id].sort
+      expect(paypal_account.subscriptions.map(&:id).sort).to eq([subscription1.id, subscription2.id].sort)
     end
   end
 
@@ -108,9 +108,9 @@ describe Braintree::PayPalAccount do
         },
       )
 
-      result.should be_success
-      result.paypal_account.billing_agreement_id.should == "some_billing_agreement_id"
-      result.paypal_account.email.should == "some@example.com"
+      expect(result).to be_success
+      expect(result.paypal_account.billing_agreement_id).to eq("some_billing_agreement_id")
+      expect(result.paypal_account.email).to eq("some@example.com")
     end
 
     it "throws an error if customer id is not specified" do
@@ -119,8 +119,8 @@ describe Braintree::PayPalAccount do
         :email => "some@example.com",
       )
 
-      result.success?.should == false
-      result.errors.first.code.should == "82905"
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.code).to eq("82905")
     end
 
     it "throws an error if billing agreement id is not specified" do
@@ -130,8 +130,8 @@ describe Braintree::PayPalAccount do
         :email => "some@example.com",
       )
 
-      result.success?.should == false
-      result.errors.map(&:code).should include("82902")
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include("82902")
     end
   end
 
@@ -143,7 +143,7 @@ describe Braintree::PayPalAccount do
         :billing_agreement_id => "first_billing_agreement_id",
         :email => "first@example.com",
       )
-      create_result.success?.should == true
+      expect(create_result.success?).to eq(true)
 
       update_result = Braintree::PayPalAccount.update(
         create_result.paypal_account.token,
@@ -151,11 +151,11 @@ describe Braintree::PayPalAccount do
         :email => "second@example.com",
       )
 
-      update_result.success?.should == true
+      expect(update_result.success?).to eq(true)
       paypal_account = update_result.paypal_account
 
-      paypal_account.billing_agreement_id.should == "second_billing_agreement_id"
-      paypal_account.email.should == "second@example.com"
+      expect(paypal_account.billing_agreement_id).to eq("second_billing_agreement_id")
+      expect(paypal_account.email).to eq("second@example.com")
     end
 
     it "updates a paypal account's token" do
@@ -177,7 +177,7 @@ describe Braintree::PayPalAccount do
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
-      updated_paypal_account.email.should == original_result.payment_method.email
+      expect(updated_paypal_account.email).to eq(original_result.payment_method.email)
 
       expect do
         Braintree::PayPalAccount.find(original_token)
@@ -192,7 +192,7 @@ describe Braintree::PayPalAccount do
         :expiration_date => "05/2009",
         :options => {:make_default => true},
       )
-      result.should be_success
+      expect(result).to be_success
 
       nonce = nonce_for_paypal_account(:consent_code => "consent-code")
       original_token = Braintree::PaymentMethod.create(
@@ -206,7 +206,7 @@ describe Braintree::PayPalAccount do
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(original_token)
-      updated_paypal_account.should be_default
+      expect(updated_paypal_account).to be_default
     end
 
     it "returns an error if a token for account is used to attempt an update" do
@@ -237,8 +237,8 @@ describe Braintree::PayPalAccount do
         :token => second_token,
       )
 
-      updated_result.should_not be_success
-      updated_result.errors.first.code.should == "92906"
+      expect(updated_result).not_to be_success
+      expect(updated_result.errors.first.code).to eq("92906")
     end
   end
 
@@ -272,11 +272,11 @@ describe Braintree::PayPalAccount do
 
       result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      result.success?.should == true
-      result.transaction.amount.should == BigDecimal("100.00")
-      result.transaction.type.should == "sale"
-      result.transaction.customer_details.id.should == customer.id
-      result.transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 
@@ -288,10 +288,10 @@ describe Braintree::PayPalAccount do
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      transaction.amount.should == BigDecimal("100.00")
-      transaction.type.should == "sale"
-      transaction.customer_details.id.should == customer.id
-      transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 end

data/spec/integration/braintree/plan_spec.rb

@@ -26,26 +26,26 @@ describe Braintree::Plan do
 
       plans = Braintree::Plan.all
       plan = plans.select { |plan| plan.id == plan_token }.first
-      plan.should_not be_nil
-      plan.id.should == attributes[:id]
-      plan.billing_day_of_month.should == attributes[:billing_day_of_month]
-      plan.billing_frequency.should == attributes[:billing_frequency]
-      plan.currency_iso_code.should == attributes[:currency_iso_code]
-      plan.description.should == attributes[:description]
-      plan.name.should == attributes[:name]
-      plan.number_of_billing_cycles.should == attributes[:number_of_billing_cycles]
-      plan.price.should == Braintree::Util.to_big_decimal("1.00")
-      plan.trial_period.should == attributes[:trial_period]
-      plan.created_at.should_not be_nil
-      plan.updated_at.should_not be_nil
-      plan.add_ons.first.name.should == add_on_name
-      plan.discounts.first.name.should == discount_name
+      expect(plan).not_to be_nil
+      expect(plan.id).to eq(attributes[:id])
+      expect(plan.billing_day_of_month).to eq(attributes[:billing_day_of_month])
+      expect(plan.billing_frequency).to eq(attributes[:billing_frequency])
+      expect(plan.currency_iso_code).to eq(attributes[:currency_iso_code])
+      expect(plan.description).to eq(attributes[:description])
+      expect(plan.name).to eq(attributes[:name])
+      expect(plan.number_of_billing_cycles).to eq(attributes[:number_of_billing_cycles])
+      expect(plan.price).to eq(Braintree::Util.to_big_decimal("1.00"))
+      expect(plan.trial_period).to eq(attributes[:trial_period])
+      expect(plan.created_at).not_to be_nil
+      expect(plan.updated_at).not_to be_nil
+      expect(plan.add_ons.first.name).to eq(add_on_name)
+      expect(plan.discounts.first.name).to eq(discount_name)
     end
 
     it "returns an empty array if there are no plans" do
       gateway = Braintree::Gateway.new(SpecHelper::TestMerchantConfig)
       plans = gateway.plan.all
-      plans.should == []
+      expect(plans).to eq([])
     end
   end
 

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