braintree 2.90.0 → 2.91.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"}],
+    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.inspect.should == "#<Braintree::ValidationErrorCollection errors:[(code1) message1], level1:[(code2) message2], level1/level2:[(code3) message3]>"
+        )
+        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/webhook_notification_spec.rb

@@ -392,6 +392,21 @@ describe Braintree::WebhookNotification do
         notification.subscription.transactions.first.status.should == Braintree::Transaction::Status::SubmittedForSettlement
         notification.subscription.transactions.first.amount.should == BigDecimal("49.99")
       end
+
+      it "builds a sample notification for a subscription charged unsuccessfully webhook" do
+        sample_notification = Braintree::WebhookTesting.sample_notification(
+          Braintree::WebhookNotification::Kind::SubscriptionChargedUnsuccessfully,
+          "my_id"
+        )
+
+        notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
+
+        notification.kind.should == Braintree::WebhookNotification::Kind::SubscriptionChargedUnsuccessfully
+        notification.subscription.id.should == "my_id"
+        notification.subscription.transactions.size.should == 1
+        notification.subscription.transactions.first.status.should == Braintree::Transaction::Status::Failed
+        notification.subscription.transactions.first.amount.should == BigDecimal("49.99")
+      end
     end
 
     it "includes a valid signature" do
@@ -439,6 +454,22 @@ describe Braintree::WebhookNotification do
     end
   end
 
+  context "local_payment_completed" do
+    it "builds a sample notification for a local_payment webhook" do
+      sample_notification = Braintree::WebhookTesting.sample_notification(
+        Braintree::WebhookNotification::Kind::LocalPaymentCompleted,
+        "my_id"
+      )
+
+      notification = Braintree::WebhookNotification.parse(sample_notification[:bt_signature], sample_notification[:bt_payload])
+      notification.kind.should == Braintree::WebhookNotification::Kind::LocalPaymentCompleted
+
+      local_payment_completed = notification.local_payment_completed
+      local_payment_completed.payment_id.should == 'PAY-XYZ123'
+      local_payment_completed.payer_id.should == 'ABCPAYER'
+    end
+  end
+
   describe "parse" do
     it "raises InvalidSignature error when the signature is nil" do
       expect do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 2.90.0
+  version: 2.91.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-25 00:00:00.000000000 Z
+date: 2018-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -89,9 +89,11 @@ files:
 - lib/braintree/facilitator_details.rb
 - lib/braintree/gateway.rb
 - lib/braintree/granted_payment_instrument_update.rb
+- lib/braintree/graphql_client.rb
 - lib/braintree/http.rb
 - lib/braintree/ideal_payment.rb
 - lib/braintree/ideal_payment_gateway.rb
+- lib/braintree/local_payment_completed.rb
 - lib/braintree/masterpass_card.rb
 - lib/braintree/merchant.rb
 - lib/braintree/merchant_account.rb
@@ -205,6 +207,7 @@ files:
 - spec/integration/braintree/dispute_spec.rb
 - spec/integration/braintree/document_upload_spec.rb
 - spec/integration/braintree/error_codes_spec.rb
+- spec/integration/braintree/graphql_client_spec.rb
 - spec/integration/braintree/http_spec.rb
 - spec/integration/braintree/ideal_payment_spec.rb
 - spec/integration/braintree/masterpass_card_spec.rb
@@ -256,6 +259,7 @@ files:
 - spec/unit/braintree/error_result_spec.rb
 - spec/unit/braintree/errors_spec.rb
 - spec/unit/braintree/http_spec.rb
+- spec/unit/braintree/local_payment_completed_spec.rb
 - spec/unit/braintree/merchant_account_spec.rb
 - spec/unit/braintree/modification_spec.rb
 - spec/unit/braintree/payment_method_spec.rb
@@ -291,7 +295,10 @@ files:
 homepage: https://www.braintreepayments.com/
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/braintree/braintree_ruby/issues
+  changelog_uri: https://github.com/braintree/braintree_ruby/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/braintree/braintree_ruby
 post_install_message: 
 rdoc_options: []
 require_paths: