braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/us_bank_account_verification_spec.rb

@@ -8,11 +8,16 @@ describe Braintree::UsBankAccountVerification do
         :status => Braintree::UsBankAccountVerification::Status::Verified,
         :verification_method => Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
         :verification_determined_at => "2018-02-28T12:01:01Z",
+        :additional_processor_response => "some_invalid_processor_response",
       )
     end
 
     it "has a status" do
-      verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
+      expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+    end
+
+    it "has additional processor response" do
+      expect(verification.additional_processor_response).to eq("some_invalid_processor_response")
     end
   end
 
@@ -67,27 +72,27 @@ describe Braintree::UsBankAccountVerification do
       first = Braintree::UsBankAccountVerification._new(:id => "123")
       second = Braintree::UsBankAccountVerification._new(:id => "123")
 
-      first.should == second
-      second.should == first
+      expect(first).to eq(second)
+      expect(second).to eq(first)
     end
 
     it "returns false for verifications with different ids" do
       first = Braintree::UsBankAccountVerification._new(:id => "123")
       second = Braintree::UsBankAccountVerification._new(:id => "124")
 
-      first.should_not == second
-      second.should_not == first
+      expect(first).not_to eq(second)
+      expect(second).not_to eq(first)
     end
 
     it "returns false when comparing to nil" do
-      Braintree::UsBankAccountVerification._new({}).should_not == nil
+      expect(Braintree::UsBankAccountVerification._new({})).not_to eq(nil)
     end
 
     it "returns false when comparing to non-verifications" do
       same_id_different_object = Object.new
       def same_id_different_object.id; "123"; end
       verification = Braintree::UsBankAccountVerification._new(:id => "123")
-      verification.should_not == same_id_different_object
+      expect(verification).not_to eq(same_id_different_object)
     end
   end
 end

data/spec/unit/braintree/util_spec.rb

@@ -6,18 +6,18 @@ describe Braintree::Util do
       original = {"a" => "b", "c" => "d"}
       new = Braintree::Util.symbolize_keys(original)
 
-      original["a"].should == "b"
-      new[:a].should == "b"
+      expect(original["a"]).to eq("b")
+      expect(new[:a]).to eq("b")
     end
 
     it "symbolizes nested keys" do
-      hash = {"a" => {"b" => {"c" => "d" }}}
-      Braintree::Util.symbolize_keys(hash).should == {:a => {:b => {:c => "d"}}}
+      hash = {"a" => {"b" => {"c" => "d"}}}
+      expect(Braintree::Util.symbolize_keys(hash)).to eq({:a => {:b => {:c => "d"}}})
     end
 
     it "symbolizes nested keys in arrays" do
-      hash = {"a" => ["b" => {"c" => "d" }]}
-      Braintree::Util.symbolize_keys(hash).should == {:a => [:b => {:c => "d"}]}
+      hash = {"a" => ["b" => {"c" => "d"}]}
+      expect(Braintree::Util.symbolize_keys(hash)).to eq({:a => [:b => {:c => "d"}]})
     end
   end
 
@@ -44,7 +44,7 @@ describe Braintree::Util do
             :nested_allowed => "ok",
             :nested_allowed2 => "also ok",
             :nested_invalid => "bad"
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: nested[nested_invalid], top_level_invalid")
     end
@@ -57,7 +57,7 @@ describe Braintree::Util do
           :custom_fields => {
             :custom_allowed => "ok",
             :custom_allowed2 => "also ok",
-          }
+          },
         )
       end.to_not raise_error
     end
@@ -70,7 +70,7 @@ describe Braintree::Util do
             :custom_fields => {
               :bad_nesting => "very bad"
             }
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: allowed[custom_fields][bad_nesting]")
     end
@@ -89,7 +89,7 @@ describe Braintree::Util do
               :super_deep_allowed => "yep",
               :real_deep_invalid => "nope"
             }
-          }
+          },
         )
       end.to raise_error(ArgumentError, "invalid keys: nested[deeply_allowed][real_deep_invalid], nested[nested_invalid], top_level_invalid")
     end
@@ -101,7 +101,7 @@ describe Braintree::Util do
           :add_ons => {
             :update => [{:amount => 10}],
             :add => [{:amount => 5}]
-          }
+          },
         )
       end.to_not raise_error
     end
@@ -113,7 +113,7 @@ describe Braintree::Util do
           :add_ons => {
             :update => [{:foo => 10}],
             :add => [{:bar => 5}]
-          }
+          },
         )
       end.to raise_error(ArgumentError, /invalid keys: add_ons\[add\]\[bar\], add_ons\[update\]\[foo\]/)
     end
@@ -127,7 +127,7 @@ describe Braintree::Util do
         :custom_fields => {
           :custom_allowed => "ok",
           :custom_allowed2 => "also ok",
-        }
+        },
       )
       expect(response).to eq(true)
     end
@@ -147,7 +147,7 @@ describe Braintree::Util do
         :add_ons => {
           :update => [{:foo => 10}],
           :add => [{:bar => 5}]
-        }
+        },
       )
       expect(response).to eq(false)
     end
@@ -165,33 +165,49 @@ describe Braintree::Util do
             :super_deep_allowed => "yep",
             :real_deep_invalid => "nope"
           }
-        }
+        },
       )
       expect(response).to eq(false)
     end
   end
 
+  describe "self.replace_key" do
+    it "replaces the target key with the replacement key" do
+      expect(Braintree::Util.replace_key(
+        {:a => {:b => "some value"}},
+        :b,
+        :c)).to eq({:a => {:c => "some value"}})
+    end
+
+    it "returns hash with all of the original keys if the target key does not exist" do
+      expect(Braintree::Util.replace_key(
+        {:some_key => "some value"},
+        :not_found,
+        :new_key)).to eq({:some_key => "some value"})
+    end
+  end
+
   describe "self._flatten_hash_keys" do
     it "flattens hash keys" do
-      Braintree::Util._flatten_hash_keys(:nested => {
+      expect(Braintree::Util._flatten_hash_keys(:nested => {
         :nested_allowed => "ok",
         :nested_allowed2 => "also ok",
         :nested_invalid => "bad"
-      }).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "nested[nested_invalid]"]
+      })).to eq(["nested[nested_allowed2]", "nested[nested_allowed]", "nested[nested_invalid]"])
     end
   end
 
   describe "self._flatten_valid_keys" do
     it "flattens hash keys" do
-      Braintree::Util._flatten_valid_keys(
-        [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}]
-      ).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"]
+      expect(Braintree::Util._flatten_valid_keys(
+        [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}],
+      )).to eq(["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"])
     end
 
     it "allows wildcards with the :_any_key_ symbol" do
-      Braintree::Util._flatten_valid_keys(
-        [:top_level, {:nested => :_any_key_}]
-      ).should == ["nested[_any_key_]", "top_level"]
+      expect(Braintree::Util._flatten_valid_keys(
+        [:top_level, {:nested => :_any_key_}],
+      )).to eq(["nested[_any_key_]", "top_level"])
     end
   end
 
@@ -199,55 +215,55 @@ describe Braintree::Util do
     it "deletes the attribute from the hash" do
       hash = {:foo => ["x"], :bar => :baz}
       Braintree::Util.extract_attribute_as_array(hash, :foo)
-      hash.should == {:bar => :baz}
+      expect(hash).to eq({:bar => :baz})
     end
 
     it "puts the attribute in an array if it's not an array" do
       hash = {:foo => "x", :bar => :baz}
       result = Braintree::Util.extract_attribute_as_array(hash, :foo)
-      result.should == ["x"]
+      expect(result).to eq(["x"])
     end
 
     it "returns the value if it's already an array" do
       hash = {:foo => ["one", "two"], :bar => :baz}
       result = Braintree::Util.extract_attribute_as_array(hash, :foo)
-      result.should == ["one", "two"]
+      expect(result).to eq(["one", "two"])
     end
 
     it "returns empty array if the attribute is not in the hash" do
       hash = {:foo => ["one", "two"], :bar => :baz}
       result = Braintree::Util.extract_attribute_as_array(hash, :quz)
-      result.should == []
+      expect(result).to eq([])
     end
 
-		it "raises an UnexpectedError if nil data is provided" do
-			expect do
-				Braintree::Util.extract_attribute_as_array(nil, :abc)
-			end.to raise_error(Braintree::UnexpectedError, /Unprocessable entity due to an invalid request/)
-		end
+    it "raises an UnexpectedError if nil data is provided" do
+      expect do
+        Braintree::Util.extract_attribute_as_array(nil, :abc)
+      end.to raise_error(Braintree::UnexpectedError, /Unprocessable entity due to an invalid request/)
+    end
   end
 
   describe "self.hash_to_query_string" do
     it "generates a query string from the hash" do
       hash = {:foo => {:key_one => "value_one", :key_two => "value_two"}}
-      Braintree::Util.hash_to_query_string(hash).should == "foo%5Bkey_one%5D=value_one&foo%5Bkey_two%5D=value_two"
+      expect(Braintree::Util.hash_to_query_string(hash)).to eq("foo%5Bkey_one%5D=value_one&foo%5Bkey_two%5D=value_two")
     end
 
     it "works for nesting 2 levels deep" do
       hash = {:foo => {:nested => {:key_one => "value_one", :key_two => "value_two"}}}
-      Braintree::Util.hash_to_query_string(hash).should == "foo%5Bnested%5D%5Bkey_one%5D=value_one&foo%5Bnested%5D%5Bkey_two%5D=value_two"
+      expect(Braintree::Util.hash_to_query_string(hash)).to eq("foo%5Bnested%5D%5Bkey_one%5D=value_one&foo%5Bnested%5D%5Bkey_two%5D=value_two")
     end
   end
 
   describe "self.parse_query_string" do
     it "parses the query string" do
       query_string = "foo=bar%20baz&hash=a1b2c3"
-      Braintree::Util.parse_query_string(query_string).should == {:foo => "bar baz", :hash => "a1b2c3"}
+      expect(Braintree::Util.parse_query_string(query_string)).to eq({:foo => "bar baz", :hash => "a1b2c3"})
     end
 
     it "parses the query string when a key has an empty value" do
       query_string = "foo=bar%20baz&hash=a1b2c3&vat_number="
-      Braintree::Util.parse_query_string(query_string).should == {:foo => "bar baz", :hash => "a1b2c3", :vat_number => ""}
+      expect(Braintree::Util.parse_query_string(query_string)).to eq({:foo => "bar baz", :hash => "a1b2c3", :vat_number => ""})
     end
   end
 
@@ -259,7 +275,7 @@ describe Braintree::Util do
       "UNSUPPORTED_CLIENT" => Braintree::UpgradeRequiredError,
       "RESOURCE_LIMIT" => Braintree::TooManyRequestsError,
       "INTERNAL" => Braintree::ServerError,
-      "SERVICE_AVAILABILITY" => Braintree::DownForMaintenanceError,
+      "SERVICE_AVAILABILITY" => Braintree::ServiceUnavailableError,
     }
 
     errors.each do |graphQLError, exception|
@@ -321,6 +337,18 @@ describe Braintree::Util do
       end.to raise_error(Braintree::AuthorizationError)
     end
 
+    it "raises a NotFoundError if resource is not found" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(404)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "raises a RequestTimeoutError if the request times out" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(408)
+      end.to raise_error(Braintree::RequestTimeoutError)
+    end
+
     it "raises an UpgradeRequired if the client library is EOL'd" do
       expect do
         Braintree::Util.raise_exception_for_status_code(426)
@@ -339,10 +367,16 @@ describe Braintree::Util do
       end.to raise_error(Braintree::ServerError)
     end
 
-    it "raises a DownForMaintenanceError if the server is down for maintenance" do
+    it "raises a ServiceUnavailableError if the server is unavailable" do
       expect do
         Braintree::Util.raise_exception_for_status_code(503)
-      end.to raise_error(Braintree::DownForMaintenanceError)
+      end.to raise_error(Braintree::ServiceUnavailableError)
+    end
+
+    it "raises a GatewayTimeoutError if the gateway times out" do
+      expect do
+        Braintree::Util.raise_exception_for_status_code(504)
+      end.to raise_error(Braintree::GatewayTimeoutError)
     end
 
     it "raises an UnexpectedError if some other code is returned" do
@@ -354,15 +388,15 @@ describe Braintree::Util do
 
   describe "self.to_big_decimal" do
     it "returns the BigDecimal when given a BigDecimal" do
-      Braintree::Util.to_big_decimal(BigDecimal("12.34")).should == BigDecimal("12.34")
+      expect(Braintree::Util.to_big_decimal(BigDecimal("12.34"))).to eq(BigDecimal("12.34"))
     end
 
     it "returns a BigDecimal when given a string" do
-      Braintree::Util.to_big_decimal("12.34").should == BigDecimal("12.34")
+      expect(Braintree::Util.to_big_decimal("12.34")).to eq(BigDecimal("12.34"))
     end
 
     it "returns nil when given nil" do
-      Braintree::Util.to_big_decimal(nil).should be_nil
+      expect(Braintree::Util.to_big_decimal(nil)).to be_nil
     end
 
     it "blows up when not given a String or BigDecimal" do
@@ -374,13 +408,13 @@ describe Braintree::Util do
 
   describe "self.url_encode" do
     it "url encodes the given text" do
-      Braintree::Util.url_encode("foo?bar").should == "foo%3Fbar"
+      expect(Braintree::Util.url_encode("foo?bar")).to eq("foo%3Fbar")
     end
   end
 
   describe "self.url_decode" do
     it "url decodes the given text" do
-      Braintree::Util.url_decode("foo%3Fbar").should == "foo?bar"
+      expect(Braintree::Util.url_decode("foo%3Fbar")).to eq("foo?bar")
     end
   end
 end

data/spec/unit/braintree/validation_error_collection_spec.rb

@@ -5,27 +5,27 @@ describe Braintree::ValidationErrorCollection do
   context "blue response" do
     describe "initialize" do
       it "builds an error object given an array of hashes" do
-        hash = {:errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }]}
+        hash = {:errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}]}
         collection = Braintree::ValidationErrorCollection.new(hash)
         error = collection[0]
-        error.attribute.should == "some model attribute"
-        error.code.should == 1
-        error.message.should == "bad juju"
+        expect(error.attribute).to eq("some model attribute")
+        expect(error.code).to eq(1)
+        expect(error.message).to eq("bad juju")
       end
     end
 
     describe "for" do
       it "provides access to nested errors" do
         hash = {
-          :errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }],
+          :errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
+            :errors => [{:attribute => "number", :code => 2, :message => "badder juju"}]
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.for(:nested).on(:number)[0].code.should == 2
-        errors.for(:nested).on(:number)[0].message.should == "badder juju"
-        errors.for(:nested).on(:number)[0].attribute.should == "number"
+        expect(errors.for(:nested).on(:number)[0].code).to eq(2)
+        expect(errors.for(:nested).on(:number)[0].message).to eq("badder juju")
+        expect(errors.for(:nested).on(:number)[0].attribute).to eq("number")
       end
     end
 
@@ -35,7 +35,7 @@ describe Braintree::ValidationErrorCollection do
           {:attribute => "name", :code => "code1", :message => "message1"},
           {:attribute => "name", :code => "code2", :message => "message2"}
         ])
-        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1, (code2) message2]>"
+        expect(errors.inspect).to eq("#<Braintree::ValidationErrorCollection errors:[(code1) message1, (code2) message2]>")
       end
 
       it "shows errors 1 level deep" do
@@ -45,9 +45,9 @@ describe Braintree::ValidationErrorCollection do
           ],
           :level1 => {
             :errors => [{:attribute => "name", :code => "code2", :message => "message2"}]
-          }
+          },
         )
-        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2]>"
+        expect(errors.inspect).to eq("#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2]>")
       end
 
       it "shows errors 2 levels deep" do
@@ -60,9 +60,9 @@ describe Braintree::ValidationErrorCollection do
             :level2 => {
               :errors => [{:attribute => "name", :code => "code3", :message => "message3"}],
             }
-          }
+          },
         )
-        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>"
+        expect(errors.inspect).to eq("#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>")
       end
     end
 
@@ -73,16 +73,16 @@ describe Braintree::ValidationErrorCollection do
           {:attribute => "name", :code => 2, :message => "contains invalid chars"},
           {:attribute => "not name", :code => 3, :message => "is invalid"}
         ])
-        errors.on("name").size.should == 2
-        errors.on("name").map{ |e| e.code }.should == [1, 2]
+        expect(errors.on("name").size).to eq(2)
+        expect(errors.on("name").map { |e| e.code }).to eq([1, 2])
       end
 
       it "has indifferent access" do
         errors = Braintree::ValidationErrorCollection.new(:errors => [
-          { :attribute => "name", :code => 3, :message => "is too long" },
+          {:attribute => "name", :code => 3, :message => "is too long"},
         ])
-        errors.on(:name).size.should == 1
-        errors.on(:name)[0].code.should == 3
+        expect(errors.on(:name).size).to eq(1)
+        expect(errors.on(:name)[0].code).to eq(3)
 
       end
     end
@@ -94,35 +94,35 @@ describe Braintree::ValidationErrorCollection do
           {:attribute => "two", :code => 2, :message => "contains invalid chars"},
           {:attribute => "thr", :code => 3, :message => "is invalid"}
         ])
-        errors.deep_size.should == 3
+        expect(errors.deep_size).to eq(3)
       end
 
       it "returns the size of nested errors as well" do
         errors = Braintree::ValidationErrorCollection.new(
-          :errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }],
+          :errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
-          }
+            :errors => [{:attribute => "number", :code => 2, :message => "badder juju"}]
+          },
         )
-        errors.deep_size.should == 2
+        expect(errors.deep_size).to eq(2)
       end
 
       it "returns the size of multiple nestings of errors" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 1, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 1, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 2, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 2, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 2, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 2, :message => "badder juju"}]
             }
           },
           :same_level => {
-            :errors => [{ :attribute => "five", :code => 2, :message => "badder juju"}],
-          }
+            :errors => [{:attribute => "five", :code => 2, :message => "badder juju"}],
+          },
         )
-        errors.deep_size.should == 5
+        expect(errors.deep_size).to eq(5)
       end
     end
 
@@ -130,19 +130,19 @@ describe Braintree::ValidationErrorCollection do
       it "returns errors from all levels" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 4, :message => "badder juju"}]
             }
           },
           :same_level => {
-            :errors => [{ :attribute => "five", :code => 5, :message => "badder juju"}],
-          }
+            :errors => [{:attribute => "five", :code => 5, :message => "badder juju"}],
+          },
         )
-        errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
+        expect(errors.deep_errors.map { |e| e.code }.sort).to eq([1, 2, 3, 4, 5])
       end
     end
 
@@ -150,27 +150,27 @@ describe Braintree::ValidationErrorCollection do
       it "returns errors on one level" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }],
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
           :nested => {
-            :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
             :nested_again => {
-              :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+              :errors => [{:attribute => "four", :code => 4, :message => "badder juju"}]
             }
-          }
+          },
         )
-        errors.shallow_errors.map {|e| e.code}.should == [1, 2]
-        errors.for(:nested).shallow_errors.map {|e| e.code}.should == [3]
+        expect(errors.shallow_errors.map { |e| e.code }).to eq([1, 2])
+        expect(errors.for(:nested).shallow_errors.map { |e| e.code }).to eq([3])
       end
 
       it "returns an clone of the real array" do
         errors = Braintree::ValidationErrorCollection.new(
           :errors => [
-            { :attribute => "one", :code => 1, :message => "bad juju" },
-            { :attribute => "two", :code => 2, :message => "bad juju" }]
+            {:attribute => "one", :code => 1, :message => "bad juju"},
+            {:attribute => "two", :code => 2, :message => "bad juju"}],
         )
         errors.shallow_errors.pop
-        errors.shallow_errors.map {|e| e.code}.should == [1, 2]
+        expect(errors.shallow_errors.map { |e| e.code }).to eq([1, 2])
       end
     end
   end
@@ -186,9 +186,9 @@ describe Braintree::ValidationErrorCollection do
                 }]}
         collection = Braintree::ValidationErrorCollection.new(hash)
         error = collection[0]
-        error.attribute.should == "two"
-        error.code.should == 1
-        error.message.should == "bad juju"
+        expect(error.attribute).to eq("two")
+        expect(error.code).to eq(1)
+        expect(error.message).to eq("bad juju")
         !error.respond_to? :untracked_param
       end
     end
@@ -210,9 +210,9 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.for(:nested).on(:nested_attribute)[0].code.should == 2
-        errors.for(:nested).on(:nested_attribute)[0].message.should == "badder juju"
-        errors.for(:nested).on(:nested_attribute)[0].attribute.should == "nested_attribute"
+        expect(errors.for(:nested).on(:nested_attribute)[0].code).to eq(2)
+        expect(errors.for(:nested).on(:nested_attribute)[0].message).to eq("badder juju")
+        expect(errors.for(:nested).on(:nested_attribute)[0].attribute).to eq("nested_attribute")
       end
     end
 
@@ -234,7 +234,7 @@ describe Braintree::ValidationErrorCollection do
           }],
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.deep_size.should == 3
+        expect(errors.deep_size).to eq(3)
       end
 
       it "returns the size of nested errors as well" do
@@ -253,7 +253,7 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.deep_size.should == 2
+        expect(errors.deep_size).to eq(2)
       end
 
       it "returns the size of multiple nestings of errors" do
@@ -290,7 +290,7 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.deep_size.should == 5
+        expect(errors.deep_size).to eq(5)
       end
     end
 
@@ -329,7 +329,7 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
+        expect(errors.deep_errors.map { |e| e.code }.sort).to eq([1, 2, 3, 4, 5])
       end
     end
 
@@ -368,10 +368,10 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         errors = Braintree::ValidationErrorCollection.new(hash)
-        errors.shallow_errors.map {|e| e.code}.should == [1]
-        errors.for(:nested).shallow_errors.map {|e| e.code}.should == [2,3]
-        errors.for(:nested).for(:deeply_nested).shallow_errors.map {|e| e.code}.should == [4]
-        errors.for(:nested_again).shallow_errors.map {|e| e.code}.should == [5]
+        expect(errors.shallow_errors.map { |e| e.code }).to eq([1])
+        expect(errors.for(:nested).shallow_errors.map { |e| e.code }).to eq([2,3])
+        expect(errors.for(:nested).for(:deeply_nested).shallow_errors.map { |e| e.code }).to eq([4])
+        expect(errors.for(:nested_again).shallow_errors.map { |e| e.code }).to eq([5])
       end
     end
   end

data/spec/unit/braintree/validation_error_spec.rb

@@ -4,16 +4,16 @@ describe Braintree::ValidationError do
   describe "initialize" do
     it "works" do
       error = Braintree::ValidationError.new :attribute => "some model attribute", :code => 1, :message => "bad juju"
-      error.attribute.should == "some model attribute"
-      error.code.should == 1
-      error.message.should == "bad juju"
+      expect(error.attribute).to eq("some model attribute")
+      expect(error.code).to eq(1)
+      expect(error.message).to eq("bad juju")
     end
   end
 
   describe "inspect" do
     it "is pretty" do
       error = Braintree::ValidationError.new :attribute => "number", :code => "123456", :message => "Number is bad juju."
-      error.inspect.should == "#<Braintree::ValidationError (123456) Number is bad juju.>"
+      expect(error.inspect).to eq("#<Braintree::ValidationError (123456) Number is bad juju.>")
     end
   end
 end