braintree 2.98.0 → 4.23.0

data/spec/unit/braintree/xml/libxml_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Xml::Libxml do
   describe "self.parse" do
     it "typecasts integers" do
       xml = "<root><foo type=\"integer\">123</foo></root>"
-      Braintree::Xml::Libxml.parse(xml).should == {"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}}
+      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}})
     end
 
     it "works with dashes or underscores" do
@@ -14,7 +14,7 @@ describe Braintree::Xml::Libxml do
           <under_scores />
         </root>
       END
-      Braintree::Xml::Libxml.parse(xml).should == {"root"=>{"dash-es"=>{}, "under_scores"=>{}}}
+      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"dash-es"=>{}, "under_scores"=>{}}})
     end
 
     it "uses nil if nil=true, otherwise uses empty string" do
@@ -24,7 +24,7 @@ describe Braintree::Xml::Libxml do
           <an_empty_string></an_empty_string>
         </root>
       END
-      Braintree::Xml::Libxml.parse(xml).should == {"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}}
+      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}})
     end
 
     it "typecasts dates and times" do
@@ -33,7 +33,7 @@ describe Braintree::Xml::Libxml do
           <created-at type="datetime">2009-10-28T10:19:49Z</created-at>
         </root>
       END
-      Braintree::Xml::Libxml.parse(xml).should == {"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}}
+      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}})
     end
 
     it "builds an array if type=array" do
@@ -45,7 +45,7 @@ describe Braintree::Xml::Libxml do
           </customers>
         </root>
       END
-      Braintree::Xml::Libxml.parse(xml).should == {"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}}
+      expect(Braintree::Xml::Libxml.parse(xml)).to eq({"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}})
     end
   end
 end

data/spec/unit/braintree/xml/parser_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Xml::Parser do
   describe "self.hash_from_xml" do
     it "typecasts integers" do
       xml = "<root><foo type=\"integer\">123</foo></root>"
-      xml.should parse_to(:root => {:foo => 123})
+      expect(xml).to parse_to(:root => {:foo => 123})
     end
 
     it "works with dashes or underscores" do
@@ -14,7 +14,7 @@ describe Braintree::Xml::Parser do
           <under_scores />
         </root>
       END
-      xml.should parse_to(:root=>{:dash_es=>"", :under_scores=>""})
+      expect(xml).to parse_to(:root=>{:dash_es=>"", :under_scores=>""})
     end
 
     it "uses nil if nil=true, otherwise uses empty string" do
@@ -24,7 +24,7 @@ describe Braintree::Xml::Parser do
           <an_empty_string></an_empty_string>
         </root>
       END
-      xml.should parse_to(:root => {:a_nil_value => nil, :an_empty_string => ""})
+      expect(xml).to parse_to(:root => {:a_nil_value => nil, :an_empty_string => ""})
     end
 
     it "typecasts datetimes" do
@@ -33,7 +33,7 @@ describe Braintree::Xml::Parser do
           <created-at type="datetime">2009-10-28T10:19:49Z</created-at>
         </root>
       END
-      xml.should parse_to(:root => {:created_at => Time.utc(2009, 10, 28, 10, 19, 49)})
+      expect(xml).to parse_to(:root => {:created_at => Time.utc(2009, 10, 28, 10, 19, 49)})
     end
 
     it "doesn't typecast dates" do
@@ -42,7 +42,7 @@ describe Braintree::Xml::Parser do
           <created-at type="date">2009-10-28</created-at>
         </root>
       END
-      xml.should parse_to(:root => {:created_at => "2009-10-28"})
+      expect(xml).to parse_to(:root => {:created_at => "2009-10-28"})
     end
 
     it "builds an array if type=array" do
@@ -54,27 +54,32 @@ describe Braintree::Xml::Parser do
           </customers>
         </root>
       END
-      xml.should parse_to(:root => {:customers => [{:name => "Adam"}, {:name => "Ben"}]})
+      expect(xml).to parse_to(:root => {:customers => [{:name => "Adam"}, {:name => "Ben"}]})
     end
 
-    it "parses using libxml when not using ruby 2.0" do
-      xml = "<root><foo type=\"integer\">123</foo></root>"
-      stub_const("RUBY_VERSION", "2.1.1")
-      ::Braintree::Xml::Libxml.should_receive(:parse).and_call_original
-
-      Braintree::Xml::Parser.hash_from_xml(xml)
+    it "parses an array" do
+      xml = <<-END
+        <root>
+          <customers type="array">
+            <customer><name>Adam</name><customer-id>1</customer-id></customer>
+            <customer><name>Ben</name><customer-id>2</customer-id></customer>
+          </customers>
+        </root>
+      END
+      expect(xml).to parse_to(:root => {:customers => [{:name => "Adam", :customer_id => "1"}, {:name => "Ben", :customer_id => "2"}]})
     end
 
-    it "parses using rexml when using ruby 2.0 to avoid Libxml segfault" do
-      segfault_prone_library_in_ruby_2_0 = ::Braintree::Xml::Libxml
-
-      xml = "<root><foo type=\"integer\">123</foo></root>"
-      stub_const("RUBY_VERSION", "2.0.0")
-
-      ::Braintree::Xml::Rexml.should_receive(:parse).and_call_original
-      segfault_prone_library_in_ruby_2_0.should_not_receive(:parse)
-
-      Braintree::Xml::Parser.hash_from_xml(xml)
+    it "parses nested objects" do
+      xml = <<-END
+        <root>
+          <paypal-details>
+            <deets type="array"><super-secrets><secret-code>1234</secret-code></super-secrets></deets>
+            <payer-email>abc@test.com</payer-email>
+            <payment-id>1234567890</payment-id>
+          </paypal-details>
+        </root>
+      END
+      expect(xml).to parse_to(:root => {:paypal_details => {:deets => [{:secret_code => "1234"}], :payer_email => "abc@test.com", :payment_id => "1234567890"}})
     end
   end
 end

data/spec/unit/braintree/xml/rexml_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Xml::Rexml do
   describe "self.parse" do
     it "typecasts integers" do
       xml = "<root><foo type=\"integer\">123</foo></root>"
-      Braintree::Xml::Rexml.parse(xml).should == {"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}}
+      expect(Braintree::Xml::Rexml.parse(xml)).to eq({"root"=>{"foo"=>{"__content__"=>"123", "type"=>"integer"}}})
     end
 
     it "works with dashes or underscores" do
@@ -14,7 +14,7 @@ describe Braintree::Xml::Rexml do
           <under_scores />
         </root>
       END
-      Braintree::Xml::Rexml.parse(xml).should == {"root"=>{"dash-es"=>{}, "under_scores"=>{}}}
+      expect(Braintree::Xml::Rexml.parse(xml)).to eq({"root"=>{"dash-es"=>{}, "under_scores"=>{}}})
     end
 
     it "uses nil if nil=true, otherwise uses empty string" do
@@ -24,7 +24,7 @@ describe Braintree::Xml::Rexml do
           <an_empty_string></an_empty_string>
         </root>
       END
-      Braintree::Xml::Rexml.parse(xml).should == {"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}}
+      expect(Braintree::Xml::Rexml.parse(xml)).to eq({"root"=>{"a_nil_value"=>{"nil"=>"true"}, "an_empty_string"=>{}}})
     end
 
     it "typecasts dates and times" do
@@ -33,7 +33,7 @@ describe Braintree::Xml::Rexml do
           <created-at type="datetime">2009-10-28T10:19:49Z</created-at>
         </root>
       END
-      Braintree::Xml::Rexml.parse(xml).should == {"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}}
+      expect(Braintree::Xml::Rexml.parse(xml)).to eq({"root"=>{"created-at"=>{"__content__"=>"2009-10-28T10:19:49Z", "type"=>"datetime"}}})
     end
 
     it "builds an array if type=array" do
@@ -45,7 +45,7 @@ describe Braintree::Xml::Rexml do
           </customers>
         </root>
       END
-      Braintree::Xml::Rexml.parse(xml).should == {"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}}
+      expect(Braintree::Xml::Rexml.parse(xml)).to eq({"root"=>{"customers"=>{"type"=>"array", "customer"=>[{"name"=>{"__content__"=>"Adam"}}, {"name"=>{"__content__"=>"Ben"}}]}}})
     end
   end
 end

data/spec/unit/braintree/xml_spec.rb

@@ -4,7 +4,7 @@ describe Braintree::Xml do
   describe "self.hash_from_xml" do
     it "typecasts integers" do
       hash = Braintree::Xml.hash_from_xml("<root><foo type=\"integer\">123</foo></root>")
-      hash.should == {:root => {:foo => 123}}
+      expect(hash).to eq({:root => {:foo => 123}})
     end
 
     it "works with dashes or underscores" do
@@ -16,7 +16,7 @@ describe Braintree::Xml do
       END
 
       hash = Braintree::Xml.hash_from_xml(xml)
-      hash.should == {:root => {:dash_es => "", :under_scores => ""}}
+      expect(hash).to eq({:root => {:dash_es => "", :under_scores => ""}})
     end
 
     it "uses nil if nil=true, otherwise uses empty string" do
@@ -27,7 +27,7 @@ describe Braintree::Xml do
         </root>
       END
       hash = Braintree::Xml.hash_from_xml(xml)
-      hash.should == {:root => {:a_nil_value => nil, :an_empty_string => ""}}
+      expect(hash).to eq({:root => {:a_nil_value => nil, :an_empty_string => ""}})
     end
 
     it "typecasts dates and times" do
@@ -36,7 +36,7 @@ describe Braintree::Xml do
           <created-at type="datetime">2009-10-28T10:19:49Z</created-at>
         </root>
       END
-      hash.should == {:root => {:created_at => Time.utc(2009, 10, 28, 10, 19, 49)}}
+      expect(hash).to eq({:root => {:created_at => Time.utc(2009, 10, 28, 10, 19, 49)}})
     end
 
     it "builds an array if type=array" do
@@ -48,7 +48,7 @@ describe Braintree::Xml do
           </customers>
         </root>
       END
-      hash.should == {:root => {:customers => [{:name => "Adam"}, {:name => "Ben"}]}}
+      expect(hash).to eq({:root => {:customers => [{:name => "Adam"}, {:name => "Ben"}]}})
     end
 
     it "turns 1 and true to boolean if type = boolean" do
@@ -61,10 +61,10 @@ describe Braintree::Xml do
           <uncasted-true>true</uncasted-true>
         </root>
       END
-      hash.should == {:root => {
+      expect(hash).to eq({:root => {
         :casted_true => true, :casted_one => true, :casted_anything => false, :casted_false => false,
         :uncasted_true => "true"
-      }}
+      }})
     end
 
     it "handles values that are arrays of hashes" do
@@ -75,13 +75,13 @@ describe Braintree::Xml do
           <elem><value>three</value></elem>
         </container>
       ")
-      hash.should == {:container => {:elem => [{:value => "one"}, {:value => "two"}, {:value => "three"}]}}
+      expect(hash).to eq({:container => {:elem => [{:value => "one"}, {:value => "two"}, {:value => "three"}]}})
     end
   end
 
   describe "self.hash_to_xml" do
     def verify_to_xml_and_back(hash)
-      Braintree::Xml.hash_from_xml(Braintree::Xml.hash_to_xml(hash)).should == hash
+      expect(Braintree::Xml.hash_from_xml(Braintree::Xml.hash_to_xml(hash))).to eq(hash)
     end
 
     it "works for a simple case" do
@@ -99,34 +99,34 @@ describe Braintree::Xml do
       verify_to_xml_and_back hash
     end
 
-		context "Integer" do
-			it "works for integers" do
-				hash = { :root => {:foo => 1 } }
-				Braintree::Xml.hash_to_xml(hash).should include("<foo type=\"integer\">1</foo>")
-			end
-		end
+    context "Integer" do
+      it "works for integers" do
+        hash = {:root => {:foo => 1}}
+        expect(Braintree::Xml.hash_to_xml(hash)).to include("<foo type=\"integer\">1</foo>")
+      end
+    end
 
-		context "BigDecimal" do
-			it "works for BigDecimals" do
-				hash = {:root => {:foo => BigDecimal("123.45")}}
-				Braintree::Xml.hash_to_xml(hash).should include("<foo>123.45</foo>")
-			end
+    context "BigDecimal" do
+      it "works for BigDecimals" do
+        hash = {:root => {:foo => BigDecimal("123.45")}}
+        expect(Braintree::Xml.hash_to_xml(hash)).to include("<foo>123.45</foo>")
+      end
 
-			it "works for BigDecimals with fewer than 2 digits" do
-				hash = {:root => {:foo => BigDecimal("1000.0")}}
-				Braintree::Xml.hash_to_xml(hash).should include("<foo>1000.00</foo>")
-			end
+      it "works for BigDecimals with fewer than 2 digits" do
+        hash = {:root => {:foo => BigDecimal("1000.0")}}
+        expect(Braintree::Xml.hash_to_xml(hash)).to include("<foo>1000.00</foo>")
+      end
 
-			it "works for BigDecimals with more than 2 digits" do
-				hash = {:root => {:foo => BigDecimal("12.345")}}
-				Braintree::Xml.hash_to_xml(hash).should include("<foo>12.345</foo>")
-			end
-		end
+      it "works for BigDecimals with more than 2 digits" do
+        hash = {:root => {:foo => BigDecimal("12.345")}}
+        expect(Braintree::Xml.hash_to_xml(hash)).to include("<foo>12.345</foo>")
+      end
+    end
 
-		it "works for symbols" do
-			hash = {:root => {:foo => :bar}}
-			Braintree::Xml.hash_to_xml(hash).should include("<foo>bar</foo>")
-		end
+    it "works for symbols" do
+      hash = {:root => {:foo => :bar}}
+      expect(Braintree::Xml.hash_to_xml(hash)).to include("<foo>bar</foo>")
+    end
 
     it "type casts booleans" do
       hash = {:root => {:string_true => "true", :bool_true => true, :bool_false => false, :string_false => "false"}}
@@ -145,7 +145,7 @@ describe Braintree::Xml do
 
     it "includes the encoding" do
       xml = Braintree::Xml.hash_to_xml(:root => {:root => "bar"})
-      xml.should include("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
+      expect(xml).to include("<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
     end
 
     it "works for only a root node and a string" do
@@ -154,13 +154,13 @@ describe Braintree::Xml do
     end
 
     it "escapes keys and values" do
-      hash = { "ke<y" => "val>ue" }
-      Braintree::Xml.hash_to_xml(hash).should include("<ke&lt;y>val&gt;ue</ke&lt;y>")
+      hash = {"ke<y" => "val>ue"}
+      expect(Braintree::Xml.hash_to_xml(hash)).to include("<ke&lt;y>val&gt;ue</ke&lt;y>")
     end
 
     it "escapes nested keys and values" do
-      hash = { "top<" => { "ke<y" => "val>ue" } }
-      Braintree::Xml.hash_to_xml(hash).gsub(/\s/, '').should include("<top&lt;><ke&lt;y>val&gt;ue</ke&lt;y></top&lt;>")
+      hash = {"top<" => {"ke<y" => "val>ue"}}
+      expect(Braintree::Xml.hash_to_xml(hash).gsub(/\s/, "")).to include("<top&lt;><ke&lt;y>val&gt;ue</ke&lt;y></top&lt;>")
     end
   end
 end

data/spec/unit/braintree_spec.rb

@@ -4,9 +4,9 @@ describe Braintree do
   it "doesn't produce warnings if loading braintree.rb twice" do
     lib_dir = File.expand_path(File.dirname(__FILE__) + "/../../lib")
     braintree_file = "#{lib_dir}/braintree.rb"
-    File.exist?(braintree_file).should == true
+    expect(File.exist?(braintree_file)).to eq(true)
     output = `ruby -r rubygems -I #{lib_dir} -e 'load #{braintree_file.inspect}; load #{braintree_file.inspect}' 2>&1`
     output = output.gsub(/^.*warning: constant ::Fixnum is deprecated.*\n/, "")
-    output.should == ""
+    expect(output).to eq("")
   end
 end