braintree 4.14.0 → 4.15.0

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"}}}
+      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"}]}
+      expect(Braintree::Util.symbolize_keys(hash)).to eq({:a => [:b => {:c => "d"}]})
     end
   end
 
@@ -173,41 +173,41 @@ describe Braintree::Util do
 
   describe "self.replace_key" do
     it "replaces the target key with the replacement key" do
-      Braintree::Util.replace_key(
+      expect(Braintree::Util.replace_key(
         {:a => {:b => "some value"}},
         :b,
-        :c).should == {:a => {:c => "some value"}}
+        :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
-      Braintree::Util.replace_key(
+      expect(Braintree::Util.replace_key(
         {:some_key => "some value"},
         :not_found,
-        :new_key).should == {:some_key => "some value"}
+        :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(
+      expect(Braintree::Util._flatten_valid_keys(
         [:top_level, {:nested => [:nested_allowed, :nested_allowed2]}],
-      ).should == ["nested[nested_allowed2]", "nested[nested_allowed]", "top_level"]
+      )).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(
+      expect(Braintree::Util._flatten_valid_keys(
         [:top_level, {:nested => :_any_key_}],
-      ).should == ["nested[_any_key_]", "top_level"]
+      )).to eq(["nested[_any_key_]", "top_level"])
     end
   end
 
@@ -215,25 +215,25 @@ 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
@@ -246,24 +246,24 @@ describe Braintree::Util do
   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
 
@@ -388,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
@@ -408,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

@@ -8,9 +8,9 @@ describe Braintree::ValidationErrorCollection do
         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
 
@@ -23,9 +23,9 @@ describe Braintree::ValidationErrorCollection do
           }
         }
         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
@@ -47,7 +47,7 @@ describe Braintree::ValidationErrorCollection do
             :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
@@ -62,7 +62,7 @@ describe Braintree::ValidationErrorCollection do
             }
           },
         )
-        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"},
         ])
-        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,7 +94,7 @@ 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
@@ -104,7 +104,7 @@ describe Braintree::ValidationErrorCollection do
             :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
@@ -122,7 +122,7 @@ describe Braintree::ValidationErrorCollection do
             :errors => [{:attribute => "five", :code => 2, :message => "badder juju"}],
           },
         )
-        errors.deep_size.should == 5
+        expect(errors.deep_size).to eq(5)
       end
     end
 
@@ -142,7 +142,7 @@ describe Braintree::ValidationErrorCollection do
             :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
 
@@ -159,8 +159,8 @@ describe Braintree::ValidationErrorCollection do
             }
           },
         )
-        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
@@ -170,7 +170,7 @@ describe Braintree::ValidationErrorCollection do
             {: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

data/spec/unit/braintree/venmo_profile_data_spec.rb

@@ -22,11 +22,11 @@ describe Braintree::VenmoProfileData do
 
       payment_method_customer_data_updated = Braintree::VenmoProfileData._new(params)
 
-      payment_method_customer_data_updated.username.should eq("a-username")
-      payment_method_customer_data_updated.first_name.should eq("a-first-name")
-      payment_method_customer_data_updated.last_name.should eq("a-last-name")
-      payment_method_customer_data_updated.phone_number.should eq("12312312343")
-      payment_method_customer_data_updated.email.should eq("a-email")
+      expect(payment_method_customer_data_updated.username).to eq("a-username")
+      expect(payment_method_customer_data_updated.first_name).to eq("a-first-name")
+      expect(payment_method_customer_data_updated.last_name).to eq("a-last-name")
+      expect(payment_method_customer_data_updated.phone_number).to eq("12312312343")
+      expect(payment_method_customer_data_updated.email).to eq("a-email")
     end
   end
 end