braintree 4.14.0 → 4.15.0

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

data/spec/unit/braintree/subscription_search_spec.rb

@@ -6,14 +6,14 @@ module Braintree
       it "allows Active, Canceled, Expired, and PastDue" do
         search = SubscriptionSearch.new
 
-        lambda do
+        expect do
           search.status.in(
             Subscription::Status::Active,
             Subscription::Status::Canceled,
             Subscription::Status::Expired,
             Subscription::Status::PastDue,
           )
-        end.should_not raise_error
+        end.not_to raise_error
       end
     end
 
@@ -22,14 +22,14 @@ module Braintree
         search = SubscriptionSearch.new
         search.in_trial_period.is true
 
-        search.to_hash.should == {:in_trial_period => [true]}
+        expect(search.to_hash).to eq({:in_trial_period => [true]})
       end
 
       it "allows false" do
         search = SubscriptionSearch.new
         search.in_trial_period.is false
 
-        search.to_hash.should == {:in_trial_period => [false]}
+        expect(search.to_hash).to eq({:in_trial_period => [false]})
       end
     end
 
@@ -38,14 +38,14 @@ module Braintree
         search = SubscriptionSearch.new
         search.days_past_due.is "30"
 
-        search.to_hash.should == {:days_past_due => {:is => "30"}}
+        expect(search.to_hash).to eq({:days_past_due => {:is => "30"}})
       end
 
       it "coverts ints to strings" do
         search = SubscriptionSearch.new
         search.days_past_due.is 30
 
-        search.to_hash.should == {:days_past_due => {:is => "30"}}
+        expect(search.to_hash).to eq({:days_past_due => {:is => "30"}})
       end
     end
 
@@ -54,7 +54,7 @@ module Braintree
         search = SubscriptionSearch.new
         search.merchant_account_id.in "ma_id1", "ma_id2"
 
-        search.to_hash.should == {:merchant_account_id => ["ma_id1", "ma_id2"]}
+        expect(search.to_hash).to eq({:merchant_account_id => ["ma_id1", "ma_id2"]})
       end
     end
 
@@ -63,63 +63,63 @@ module Braintree
         search = SubscriptionSearch.new
         search.plan_id.starts_with "plan_"
 
-        search.to_hash.should == {:plan_id => {:starts_with => "plan_"}}
+        expect(search.to_hash).to eq({:plan_id => {:starts_with => "plan_"}})
       end
 
       it "ends_with" do
         search = SubscriptionSearch.new
         search.plan_id.ends_with "_id"
 
-        search.to_hash.should == {:plan_id => {:ends_with => "_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:ends_with => "_id"}})
       end
 
       it "is" do
         search = SubscriptionSearch.new
         search.plan_id.is "p_id"
 
-        search.to_hash.should == {:plan_id => {:is => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:is => "p_id"}})
       end
 
       it "is_not" do
         search = SubscriptionSearch.new
         search.plan_id.is_not "p_id"
 
-        search.to_hash.should == {:plan_id => {:is_not => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:is_not => "p_id"}})
       end
 
       it "contains" do
         search = SubscriptionSearch.new
         search.plan_id.contains "p_id"
 
-        search.to_hash.should == {:plan_id => {:contains => "p_id"}}
+        expect(search.to_hash).to eq({:plan_id => {:contains => "p_id"}})
       end
 
       it "in" do
         search = SubscriptionSearch.new
         search.plan_id.in ["plan1", "plan2"]
 
-        search.to_hash.should == {:plan_id => ["plan1", "plan2"]}
+        expect(search.to_hash).to eq({:plan_id => ["plan1", "plan2"]})
       end
     end
 
     context "days_past_due" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.days_past_due.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.days_past_due).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
     context "billing_cycles_remaining" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.billing_cycles_remaining.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.billing_cycles_remaining).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
     context "created_at" do
       it "is a range node" do
         search = SubscriptionSearch.new
-        search.created_at.should be_kind_of(Braintree::AdvancedSearch::RangeNode)
+        expect(search.created_at).to be_kind_of(Braintree::AdvancedSearch::RangeNode)
       end
     end
 
@@ -128,7 +128,7 @@ module Braintree
         search = SubscriptionSearch.new
         search.id.is "s_id"
 
-        search.to_hash.should == {:id => {:is => "s_id"}}
+        expect(search.to_hash).to eq({:id => {:is => "s_id"}})
       end
     end
   end

data/spec/unit/braintree/subscription_spec.rb

@@ -11,8 +11,8 @@ describe Braintree::Subscription do
 
   context "price" do
     it "accepts price as either a String or a BigDecimal" do
-      Braintree::Subscription._new(:gateway, default_params.merge(:price => "12.34")).price.should == BigDecimal("12.34")
-      Braintree::Subscription._new(:gateway, default_params.merge(:price => BigDecimal("12.34"))).price.should == BigDecimal("12.34")
+      expect(Braintree::Subscription._new(:gateway, default_params.merge(:price => "12.34")).price).to eq(BigDecimal("12.34"))
+      expect(Braintree::Subscription._new(:gateway, default_params.merge(:price => BigDecimal("12.34"))).price).to eq(BigDecimal("12.34"))
     end
 
     it "blows up if price is not a string or BigDecimal" do
@@ -42,7 +42,7 @@ describe Braintree::Subscription do
     end
 
     it "does not raise an error if subscription id does not respond to strip" do
-      Braintree::Http.stub(:new).and_return double(:get => {:subscription => default_params})
+      allow(Braintree::Http).to receive(:new).and_return double(:get => {:subscription => default_params})
       expect do
         Braintree::Subscription.find(8675309)
       end.to_not raise_error
@@ -51,11 +51,11 @@ describe Braintree::Subscription do
 
   describe "self.search" do
     it "only allows specified values for status" do
-      lambda do
+      expect do
         Braintree::Subscription.search do |search|
           search.status.in "Hammer"
         end
-      end.should raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -63,18 +63,18 @@ describe Braintree::Subscription do
     it "returns true for subscriptions with the same id" do
       subscription1 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription2 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
-      subscription1.should == subscription2
+      expect(subscription1).to eq(subscription2)
     end
 
     it "returns false for subscriptions with different ids" do
       subscription1 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
       subscription2 = Braintree::Subscription._new(:gateway, default_params.merge(:id => "not_123"))
-      subscription1.should_not == subscription2
+      expect(subscription1).not_to eq(subscription2)
     end
 
     it "returns false if not comparing to a subscription" do
       subscription = Braintree::Subscription._new(:gateway, default_params.merge(:id => "123"))
-      subscription.should_not == "not a subscription"
+      expect(subscription).not_to eq("not a subscription")
     end
   end
 end

data/spec/unit/braintree/successful_result_spec.rb

@@ -7,21 +7,21 @@ describe Braintree::SuccessfulResult do
         :transaction => "transaction_value",
         :credit_card => "credit_card_value",
       )
-      result.success?.should == true
-      result.transaction.should == "transaction_value"
-      result.credit_card.should == "credit_card_value"
+      expect(result.success?).to eq(true)
+      expect(result.transaction).to eq("transaction_value")
+      expect(result.credit_card).to eq("credit_card_value")
     end
 
     it "can be initialized without any values" do
       result = Braintree::SuccessfulResult.new
-      result.success?.should == true
+      expect(result.success?).to eq(true)
     end
   end
 
   describe "inspect" do
     it "is pretty" do
       result = Braintree::SuccessfulResult.new(:transaction => "transaction_value")
-      result.inspect.should == "#<Braintree::SuccessfulResult transaction:\"transaction_value\">"
+      expect(result.inspect).to eq("#<Braintree::SuccessfulResult transaction:\"transaction_value\">")
     end
   end
 end

data/spec/unit/braintree/three_d_secure_info_spec.rb

@@ -29,41 +29,41 @@ describe Braintree::ThreeDSecureInfo do
 
   describe "#initialize" do
     it "sets attributes" do
-      three_d_secure_info.acs_transaction_id.should == "acs_id"
-      three_d_secure_info.cavv.should == "cavvvalue"
-      three_d_secure_info.ds_transaction_id.should == "dstrxid"
-      three_d_secure_info.eci_flag.should == "06"
-      three_d_secure_info.enrolled.should == "Y"
-      three_d_secure_info.liability_shift_possible.should == true
-      three_d_secure_info.liability_shifted.should == true
-      three_d_secure_info.pares_status.should == "Y"
-      three_d_secure_info.status.should == "authenticate_successful"
-      three_d_secure_info.three_d_secure_authentication_id.should == "auth_id"
-      three_d_secure_info.three_d_secure_transaction_id.should == "trans_id"
-      three_d_secure_info.three_d_secure_version.should == "1.0.2"
-      three_d_secure_info.xid.should == "xidvalue"
-      three_d_secure_info.lookup[:trans_status].should == "lookupstatus"
-      three_d_secure_info.lookup[:trans_status_reason].should == "lookupstatusreason"
-      three_d_secure_info.authentication[:trans_status].should == "authstatus"
-      three_d_secure_info.authentication[:trans_status_reason].should == "authstatusreason"
+      expect(three_d_secure_info.acs_transaction_id).to eq("acs_id")
+      expect(three_d_secure_info.cavv).to eq("cavvvalue")
+      expect(three_d_secure_info.ds_transaction_id).to eq("dstrxid")
+      expect(three_d_secure_info.eci_flag).to eq("06")
+      expect(three_d_secure_info.enrolled).to eq("Y")
+      expect(three_d_secure_info.liability_shift_possible).to eq(true)
+      expect(three_d_secure_info.liability_shifted).to eq(true)
+      expect(three_d_secure_info.pares_status).to eq("Y")
+      expect(three_d_secure_info.status).to eq("authenticate_successful")
+      expect(three_d_secure_info.three_d_secure_authentication_id).to eq("auth_id")
+      expect(three_d_secure_info.three_d_secure_transaction_id).to eq("trans_id")
+      expect(three_d_secure_info.three_d_secure_version).to eq("1.0.2")
+      expect(three_d_secure_info.xid).to eq("xidvalue")
+      expect(three_d_secure_info.lookup[:trans_status]).to eq("lookupstatus")
+      expect(three_d_secure_info.lookup[:trans_status_reason]).to eq("lookupstatusreason")
+      expect(three_d_secure_info.authentication[:trans_status]).to eq("authstatus")
+      expect(three_d_secure_info.authentication[:trans_status_reason]).to eq("authstatusreason")
     end
   end
 
   describe "inspect" do
     it "prints the attributes" do
-      three_d_secure_info.inspect.should == %(#<ThreeDSecureInfo acs_transaction_id: "acs_id", authentication: {:trans_status=>"authstatus", :trans_status_reason=>"authstatusreason"}, cavv: "cavvvalue", ds_transaction_id: "dstrxid", eci_flag: "06", enrolled: "Y", liability_shift_possible: true, liability_shifted: true, lookup: {:trans_status=>"lookupstatus", :trans_status_reason=>"lookupstatusreason"}, pares_status: "Y", status: "authenticate_successful", three_d_secure_authentication_id: "auth_id", three_d_secure_transaction_id: "trans_id", three_d_secure_version: "1.0.2", xid: "xidvalue">)
+      expect(three_d_secure_info.inspect).to eq(%(#<ThreeDSecureInfo acs_transaction_id: "acs_id", authentication: {:trans_status=>"authstatus", :trans_status_reason=>"authstatusreason"}, cavv: "cavvvalue", ds_transaction_id: "dstrxid", eci_flag: "06", enrolled: "Y", liability_shift_possible: true, liability_shifted: true, lookup: {:trans_status=>"lookupstatus", :trans_status_reason=>"lookupstatusreason"}, pares_status: "Y", status: "authenticate_successful", three_d_secure_authentication_id: "auth_id", three_d_secure_transaction_id: "trans_id", three_d_secure_version: "1.0.2", xid: "xidvalue">))
     end
   end
 
   describe "liability_shifted" do
     it "is aliased to liability_shifted?" do
-      three_d_secure_info.liability_shifted?.should == true
+      expect(three_d_secure_info.liability_shifted?).to eq(true)
     end
   end
 
   describe "liability_shift_possible" do
     it "is aliased to liability_shift_possible?" do
-      three_d_secure_info.liability_shift_possible?.should == true
+      expect(three_d_secure_info.liability_shift_possible?).to eq(true)
     end
   end
 end

data/spec/unit/braintree/transaction/credit_card_details_spec.rb

@@ -7,7 +7,7 @@ describe Braintree::Transaction::CreditCardDetails do
         :expiration_month => "08",
         :expiration_year => "2009",
       )
-      details.expiration_date.should == "08/2009"
+      expect(details.expiration_date).to eq("08/2009")
     end
   end
 
@@ -34,7 +34,7 @@ describe Braintree::Transaction::CreditCardDetails do
         :image_url => "example.com/visa.png",
         :unique_number_identifier => "abc123",
       )
-      details.inspect.should == %(#<token: "token", bin: "123456", last_4: "6789", card_type: "Visa", expiration_date: "05/2012", cardholder_name: "The Cardholder", customer_location: "US", prepaid: "Yes", healthcare: "No", durbin_regulated: "No", debit: "Yes", commercial: "Unknown", payroll: "Unknown", product_id: "Unknown", country_of_issuance: "Lilliput", issuing_bank: "Gulliver Bank", image_url: "example.com/visa.png", unique_number_identifier: "abc123">)
+      expect(details.inspect).to eq(%(#<token: "token", bin: "123456", last_4: "6789", card_type: "Visa", expiration_date: "05/2012", cardholder_name: "The Cardholder", customer_location: "US", prepaid: "Yes", healthcare: "No", durbin_regulated: "No", debit: "Yes", commercial: "Unknown", payroll: "Unknown", product_id: "Unknown", country_of_issuance: "Lilliput", issuing_bank: "Gulliver Bank", image_url: "example.com/visa.png", unique_number_identifier: "abc123">))
     end
   end
 
@@ -43,7 +43,7 @@ describe Braintree::Transaction::CreditCardDetails do
       details = Braintree::Transaction::CreditCardDetails.new(
         :bin => "510510", :last_4 => "5100",
       )
-      details.masked_number.should == "510510******5100"
+      expect(details.masked_number).to eq("510510******5100")
     end
   end
 
@@ -52,14 +52,14 @@ describe Braintree::Transaction::CreditCardDetails do
       details = Braintree::Transaction::CreditCardDetails.new(
         :is_network_tokenized => true,
       )
-      details.is_network_tokenized?.should == true
+      expect(details.is_network_tokenized?).to eq(true)
     end
 
     it "returns false if is_network_tokenized is false" do
       details = Braintree::Transaction::CreditCardDetails.new(
         :is_network_tokenized => false,
       )
-      details.is_network_tokenized?.should == false
+      expect(details.is_network_tokenized?).to eq(false)
     end
   end
 end

data/spec/unit/braintree/transaction/customer_details_spec.rb

@@ -13,7 +13,7 @@ describe Braintree::Transaction::CustomerDetails do
         :phone => "6145551234",
         :fax => "3125551234",
       )
-      details.inspect.should == %(#<id: "id", first_name: "Amy", last_name: "Smith", email: "amy.smith@example.com", company: "Smith Co.", website: "http://www.example.com", phone: "6145551234", fax: "3125551234">)
+      expect(details.inspect).to eq(%(#<id: "id", first_name: "Amy", last_name: "Smith", email: "amy.smith@example.com", company: "Smith Co.", website: "http://www.example.com", phone: "6145551234", fax: "3125551234">))
     end
   end
 end

data/spec/unit/braintree/transaction/deposit_details_spec.rb

@@ -6,13 +6,13 @@ describe Braintree::Transaction::DisbursementDetails do
       details = Braintree::Transaction::DisbursementDetails.new(
         :disbursement_date => Date.new(2013, 4, 1).to_s,
       )
-      details.valid?.should == true
+      expect(details.valid?).to eq(true)
     end
     it "returns true if disbursement details are initialized" do
       details = Braintree::Transaction::DisbursementDetails.new(
         :disbursement_date => nil,
       )
-      details.valid?.should == false
+      expect(details.valid?).to eq(false)
     end
   end
 end