braintree 2.74.0 → 4.12.0

data/spec/unit/braintree/validation_error_collection_spec.rb

@@ -2,174 +2,377 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 
 describe Braintree::ValidationErrorCollection 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" }]}
-      collection = Braintree::ValidationErrorCollection.new(hash)
-      error = collection[0]
-      error.attribute.should == "some model attribute"
-      error.code.should == 1
-      error.message.should == "bad juju"
+  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"}]}
+        collection = Braintree::ValidationErrorCollection.new(hash)
+        error = collection[0]
+        error.attribute.should == "some model attribute"
+        error.code.should == 1
+        error.message.should == "bad juju"
+      end
     end
-  end
 
-  describe "for" do
-    it "provides access to nested errors" do
-      hash = {
-        :errors => [{ :attribute => "some model attribute", :code => 1, :message => "bad juju" }],
-        :nested => {
-          :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
+    describe "for" do
+      it "provides access to nested errors" do
+        hash = {
+          :errors => [{:attribute => "some model attribute", :code => 1, :message => "bad juju"}],
+          :nested => {
+            :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"
+        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"
+      end
     end
-  end
 
-  describe "inspect" do
-    it "shows the errors at the current level" do
-      errors = Braintree::ValidationErrorCollection.new(:errors => [
-        {:attribute => "name", :code => "code1", :message => "message1"},
-        {:attribute => "name", :code => "code2", :message => "message2"}
-      ])
-      errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1, (code2) message2]>"
+    describe "inspect" do
+      it "shows the errors at the current level" do
+        errors = Braintree::ValidationErrorCollection.new(:errors => [
+          {:attribute => "name", :code => "code1", :message => "message1"},
+          {:attribute => "name", :code => "code2", :message => "message2"}
+        ])
+        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1, (code2) message2]>"
+      end
+
+      it "shows errors 1 level deep" do
+        errors = Braintree::ValidationErrorCollection.new(
+          :errors => [
+            {:attribute => "name", :code => "code1", :message => "message1"},
+          ],
+          :level1 => {
+            :errors => [{:attribute => "name", :code => "code2", :message => "message2"}]
+          },
+        )
+        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2]>"
+      end
+
+      it "shows errors 2 levels deep" do
+        errors = Braintree::ValidationErrorCollection.new(
+          :errors => [
+            {:attribute => "name", :code => "code1", :message => "message1"},
+          ],
+          :level1 => {
+            :errors => [{:attribute => "name", :code => "code2", :message => "message2"}],
+            :level2 => {
+              :errors => [{:attribute => "name", :code => "code3", :message => "message3"}],
+            }
+          },
+        )
+        errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>"
+      end
     end
 
-    it "shows errors 1 level deep" do
-      errors = Braintree::ValidationErrorCollection.new(
-        :errors => [
-          {:attribute => "name", :code => "code1", :message => "message1"},
-        ],
-        :level1 => {
-          :errors => [{:attribute => "name", :code => "code2", :message => "message2"}]
-        }
-      )
-      errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2]>"
+    describe "on" do
+      it "returns an array of errors on the given attribute" do
+        errors = Braintree::ValidationErrorCollection.new(:errors => [
+          {:attribute => "name", :code => 1, :message => "is too long"},
+          {: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]
+      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
+
+      end
     end
 
-    it "shows errors 2 levels deep" do
-      errors = Braintree::ValidationErrorCollection.new(
-        :errors => [
-          {:attribute => "name", :code => "code1", :message => "message1"},
-        ],
-        :level1 => {
-          :errors => [{:attribute => "name", :code => "code2", :message => "message2"}],
-          :level2 => {
-            :errors => [{:attribute => "name", :code => "code3", :message => "message3"}],
-          }
-        }
-      )
-      errors.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>"
+    describe "deep_size" do
+      it "returns the size for a non-nested collection" do
+        errors = Braintree::ValidationErrorCollection.new(:errors => [
+          {:attribute => "one", :code => 1, :message => "is too long"},
+          {:attribute => "two", :code => 2, :message => "contains invalid chars"},
+          {:attribute => "thr", :code => 3, :message => "is invalid"}
+        ])
+        errors.deep_size.should == 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"}],
+          :nested => {
+            :errors => [{:attribute => "number", :code => 2, :message => "badder juju"}]
+          },
+        )
+        errors.deep_size.should == 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"}],
+          :nested => {
+            :errors => [{:attribute => "three", :code => 2, :message => "badder juju"}],
+            :nested_again => {
+              :errors => [{:attribute => "four", :code => 2, :message => "badder juju"}]
+            }
+          },
+          :same_level => {
+            :errors => [{:attribute => "five", :code => 2, :message => "badder juju"}],
+          },
+        )
+        errors.deep_size.should == 5
+      end
     end
-  end
 
-  describe "on" do
-    it "returns an array of errors on the given attribute" do
-      errors = Braintree::ValidationErrorCollection.new(:errors => [
-        {:attribute => "name", :code => 1, :message => "is too long"},
-        {: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]
+    describe "deep_errors" 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"}],
+          :nested => {
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
+            :nested_again => {
+              :errors => [{:attribute => "four", :code => 4, :message => "badder juju"}]
+            }
+          },
+          :same_level => {
+            :errors => [{:attribute => "five", :code => 5, :message => "badder juju"}],
+          },
+        )
+        errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
+      end
     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
+    describe "shallow_errors" 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"}],
+          :nested => {
+            :errors => [{:attribute => "three", :code => 3, :message => "badder juju"}],
+            :nested_again => {
+              :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]
+      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"}],
+        )
+        errors.shallow_errors.pop
+        errors.shallow_errors.map { |e| e.code }.should == [1, 2]
+      end
     end
   end
 
-  describe "deep_size" do
-    it "returns the size for a non-nested collection" do
-      errors = Braintree::ValidationErrorCollection.new(:errors => [
-        {:attribute => "one", :code => 1, :message => "is too long"},
-        {:attribute => "two", :code => 2, :message => "contains invalid chars"},
-        {:attribute => "thr", :code => 3, :message => "is invalid"}
-      ])
-      errors.deep_size.should == 3
+  context "graphql response" do
+    describe "initialize" do
+      it "builds an error object given an array of hashes" do
+        hash = {:errors => [{
+                  :message => "bad juju",
+                  :untracked_param => "don't look",
+                  :path=>["one", "two"],
+                  :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+                }]}
+        collection = Braintree::ValidationErrorCollection.new(hash)
+        error = collection[0]
+        error.attribute.should == "two"
+        error.code.should == 1
+        error.message.should == "bad juju"
+        !error.respond_to? :untracked_param
+      end
     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" }],
-        :nested => {
-          :errors => [{ :attribute => "number", :code => 2, :message => "badder juju"}]
+    describe "for" do
+      it "provides access to nested errors" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["one", "two"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          }],
+          :nested => {
+            :errors => [{
+              :message => "badder juju",
+              :path=>["nested_attribute"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+            }]
+          }
         }
-      )
-      errors.deep_size.should == 2
+        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"
+      end
     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" }],
-        :nested => {
-          :errors => [{ :attribute => "three", :code => 2, :message => "badder juju"}],
-          :nested_again => {
-            :errors => [{ :attribute => "four", :code => 2, :message => "badder juju"}]
+    describe "deep_size" do
+      it "returns the size for a non-nested collection" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["one", "two"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          },{
+            :message => "bad juju 2",
+            :path=>["three", "four"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+          },{
+            :message => "bad juju 3",
+            :path=>["five", "six"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+          }],
+        }
+        errors = Braintree::ValidationErrorCollection.new(hash)
+        errors.deep_size.should == 3
+      end
+
+      it "returns the size of nested errors as well" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["one", "two"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          }],
+          :nested => {
+            :errors => [{
+              :message => "badder juju",
+              :path=>["nested_attribute"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+            }]
           }
-        },
-        :same_level => {
-          :errors => [{ :attribute => "five", :code => 2, :message => "badder juju"}],
         }
-      )
-      errors.deep_size.should == 5
-    end
-  end
+        errors = Braintree::ValidationErrorCollection.new(hash)
+        errors.deep_size.should == 2
+      end
 
-  describe "deep_errors" 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" }],
-        :nested => {
-          :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+      it "returns the size of multiple nestings of errors" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["attribute1"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          }],
+          :nested => {
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute2"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+            },{
+              :message => "bad juju",
+              :path=>["attribute3"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"3"}
+            }],
+            :deeply_nested => {
+              :errors => [{
+                :message => "bad juju",
+                :path=>["attribute4"],
+                :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"4"}
+              }]
+            }
+          },
           :nested_again => {
-            :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute5"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"5"}
+            }]
           }
-        },
-        :same_level => {
-          :errors => [{ :attribute => "five", :code => 5, :message => "badder juju"}],
         }
-      )
-      errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
+        errors = Braintree::ValidationErrorCollection.new(hash)
+        errors.deep_size.should == 5
+      end
     end
-  end
 
-  describe "shallow_errors" 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" }],
-        :nested => {
-          :errors => [{ :attribute => "three", :code => 3, :message => "badder juju"}],
+    describe "deep_errors" do
+      it "returns errors from all levels" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["attribute1"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          }],
+          :nested => {
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute2"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+            },{
+              :message => "bad juju",
+              :path=>["attribute3"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"3"}
+            }],
+            :deeply_nested => {
+              :errors => [{
+                :message => "bad juju",
+                :path=>["attribute4"],
+                :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"4"}
+              }]
+            }
+          },
           :nested_again => {
-            :errors => [{ :attribute => "four", :code => 4, :message => "badder juju"}]
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute5"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"5"}
+            }]
           }
         }
-      )
-      errors.shallow_errors.map {|e| e.code}.should == [1, 2]
-      errors.for(:nested).shallow_errors.map {|e| e.code}.should == [3]
+        errors = Braintree::ValidationErrorCollection.new(hash)
+        errors.deep_errors.map { |e| e.code }.sort.should == [1, 2, 3, 4, 5]
+      end
     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" }]
-      )
-      errors.shallow_errors.pop
-      errors.shallow_errors.map {|e| e.code}.should == [1, 2]
+    describe "shallow_errors" do
+      it "returns errors on one level" do
+        hash = {
+          :errors => [{
+            :message => "bad juju",
+            :path=>["attribute1"],
+            :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"1"}
+          }],
+          :nested => {
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute2"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"2"}
+            },{
+              :message => "bad juju",
+              :path=>["attribute3"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"3"}
+            }],
+            :deeply_nested => {
+              :errors => [{
+                :message => "bad juju",
+                :path=>["attribute4"],
+                :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"4"}
+              }]
+            }
+          },
+          :nested_again => {
+            :errors => [{
+              :message => "bad juju",
+              :path=>["attribute5"],
+              :extensions=> {:errorClass=>"VALIDATION", :legacyCode=>"5"}
+            }]
+          }
+        }
+        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]
+      end
     end
   end
 end

data/spec/unit/braintree/venmo_profile_data_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::VenmoProfileData do
+  describe "self.new" do
+    it "is protected" do
+      expect do
+        Braintree::VenmoProfileData.new
+      end.to raise_error(NoMethodError, /protected method .new/)
+    end
+  end
+
+  describe "self._new" do
+    it "initializes the object with the appropriate attributes set" do
+
+      params = {
+        username: "a-username",
+        first_name: "a-first-name",
+        last_name: "a-last-name",
+        phone_number: "12312312343",
+        email: "a-email",
+      }
+
+      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")
+    end
+  end
+end