braintree 2.104.1 → 3.4.0

data/lib/braintree/webhook_notification_gateway.rb

@@ -7,8 +7,8 @@ module Braintree
     end
 
     def parse(signature_string, payload)
-      raise InvalidSignature, 'signature cannot be nil' if signature_string.nil?
-      raise InvalidSignature, 'payload cannot be nil' if payload.nil?
+      raise InvalidSignature, "signature cannot be nil" if signature_string.nil?
+      raise InvalidSignature, "payload cannot be nil" if payload.nil?
       if payload =~ /[^A-Za-z0-9+=\/\n]/
         raise InvalidSignature, "payload contains illegal characters"
       end
@@ -18,7 +18,7 @@ module Braintree
     end
 
     def verify(challenge)
-      raise InvalidChallenge, 'challenge contains non-hex characters' unless challenge =~ /\A[a-f0-9]{20,32}\z/
+      raise InvalidChallenge, "challenge contains non-hex characters" unless challenge =~ /\A[a-f0-9]{20,32}\z/
       digest = Braintree::Digest.hexdigest(@config.private_key, challenge)
       "#{@config.public_key}|#{digest}"
     end
@@ -34,13 +34,13 @@ module Braintree
 
     def _verify_signature(signature_string, payload)
       public_key, signature = _matching_signature_pair(signature_string)
-      raise InvalidSignature, 'no matching public key' if public_key.nil?
+      raise InvalidSignature, "no matching public key" if public_key.nil?
 
       signature_matches = [payload, payload + "\n"].any? do |payload|
         payload_signature = Braintree::Digest.hexdigest(@config.private_key, payload)
         Braintree::Digest.secure_compare(signature, payload_signature)
       end
-      raise InvalidSignature, 'signature does not match payload - one has been modified' unless signature_matches
+      raise InvalidSignature, "signature does not match payload - one has been modified" unless signature_matches
     end
   end
 end

data/lib/braintree/webhook_testing_gateway.rb

@@ -78,17 +78,6 @@ module Braintree
         _auth_status_transitioned_sample_xml(id)
       when Braintree::WebhookNotification::Kind::ConnectedMerchantPayPalStatusChanged
         _auth_paypal_status_changed_sample_xml(id)
-        # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
-        # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.
-      when Braintree::WebhookNotification::Kind::IdealPaymentComplete
-        _ideal_payment_complete_sample_xml(id)
-        # NEXT_MAJOR_VERSION Remove this class as legacy Ideal has been removed/disabled in the Braintree Gateway
-        # DEPRECATED If you're looking to accept iDEAL as a payment method contact accounts@braintreepayments.com for a solution.
-      when Braintree::WebhookNotification::Kind::IdealPaymentFailed
-        _ideal_payment_failed_sample_xml(id)
-      # NEXT_MAJOR_VERSION remove GrantedPaymentInstrumentUpdate
-      when Braintree::WebhookNotification::Kind::GrantedPaymentInstrumentUpdate
-        _granted_payment_instrument_update_sample_xml(id)
       when Braintree::WebhookNotification::Kind::GrantorUpdatedGrantedPaymentMethod
         _granted_payment_instrument_update_sample_xml(id)
       when Braintree::WebhookNotification::Kind::RecipientUpdatedGrantedPaymentMethod
@@ -97,6 +86,8 @@ module Braintree
         _payment_method_revoked_by_customer_sample_xml(id)
       when Braintree::WebhookNotification::Kind::LocalPaymentCompleted
         _local_payment_completed_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::LocalPaymentReversed
+        _local_payment_reversed_sample_xml(id)
       else
         _subscription_sample_xml(id)
       end
@@ -867,38 +858,6 @@ module Braintree
       XML
     end
 
-    def _ideal_payment_complete_sample_xml(id)
-      <<-XML
-        <ideal-payment>
-          <id>#{id}</id>
-          <status>COMPLETE</status>
-          <issuer>ABCISSUER</issuer>
-          <order-id>ORDERABC</order-id>
-          <currency>EUR</currency>
-          <amount>10.00</amount>
-          <created-at>2016-11-29T23:27:34.547Z</created-at>
-          <approval-url>https://example.com</approval-url>
-          <ideal-transaction-id>1234567890</ideal-transaction-id>
-        </ideal-payment>
-      XML
-    end
-
-    def _ideal_payment_failed_sample_xml(id)
-      <<-XML
-        <ideal-payment>
-          <id>#{id}</id>
-          <status>FAILED</status>
-          <issuer>ABCISSUER</issuer>
-          <order-id>ORDERABC</order-id>
-          <currency>EUR</currency>
-          <amount>10.00</amount>
-          <created-at>2016-11-29T23:27:34.547Z</created-at>
-          <approval-url>https://example.com</approval-url>
-          <ideal-transaction-id>1234567890</ideal-transaction-id>
-        </ideal-payment>
-      XML
-    end
-
     def _granted_payment_instrument_update_sample_xml(id)
       <<-XML
         <granted-payment-instrument-update>
@@ -955,5 +914,13 @@ module Braintree
         </local-payment>
       XML
     end
+
+    def _local_payment_reversed_sample_xml(id)
+      <<-XML
+        <local-payment-reversed>
+          <payment-id>PAY-XYZ123</payment-id>
+        </local-payment-reversed>
+      XML
+    end
   end
 end

data/lib/braintree/xml/generator.rb

@@ -12,6 +12,7 @@ module Braintree
         "Date"       => "datetime",
         "DateTime"   => "datetime",
         "Time"       => "datetime",
+        "ActiveSupport::TimeWithZone" => "datetime"
       }
 
       XML_FORMATTING_NAMES = {
@@ -25,7 +26,7 @@ module Braintree
           date_or_time.respond_to?(:xmlschema) ? date_or_time.xmlschema : date_or_time.to_s
         end,
         "bigdecimal" => Proc.new do |bigdecimal|
-          str = bigdecimal.to_s('F')
+          str = bigdecimal.to_s("F")
           if str =~ /\.\d$/
             str += "0"
           end
@@ -61,15 +62,15 @@ module Braintree
             else
               type_name = XML_TYPE_NAMES[value.class.name]
 
-              attributes = ((value.nil? || type_name.nil?) ? {} : { :type => type_name })
+              attributes = ((value.nil? || type_name.nil?) ? {} : {:type => type_name})
               if value.nil?
                 attributes[:nil] = true
               end
 
-							formatting_name = XML_FORMATTING_NAMES[value.class.name]
+              formatting_name = XML_FORMATTING_NAMES[value.class.name]
               options[:builder].tag!(_xml_escape(key),
                 XML_FORMATTING[formatting_name] ? XML_FORMATTING[formatting_name].call(value) : value,
-                attributes
+                attributes,
               )
             end
           end

data/lib/braintree/xml/libxml.rb

@@ -1,3 +1,4 @@
+require "libxml"
 # Portions of this code were copied and modified from Ruby on Rails, released
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree

data/lib/braintree/xml/parser.rb

@@ -2,7 +2,7 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml # :nodoc:
-    CONTENT_ROOT = '__content__'
+    CONTENT_ROOT = "__content__"
 
     module Parser # :nodoc:
       XML_PARSING = {
@@ -11,90 +11,67 @@ module Braintree
         "boolean"  => Proc.new { |boolean| %w(1 true).include?(boolean.strip) },
       }
 
-      def self.hash_from_xml(xml, parser = _determine_parser)
-        standardized_hash_structure = parser.parse(xml)
-        with_underscores_in_keys = _unrename_keys(standardized_hash_structure)
-        typecasted_xml = _typecast_xml_value(with_underscores_in_keys)
-        Util.symbolize_keys(typecasted_xml)
+      def self.hash_from_xml(xml)
+        standardized_hash_structure = ::Braintree::Xml::Libxml.parse(xml)
+        transformed_xml = _transform_xml(standardized_hash_structure)
+        Util.symbolize_keys(transformed_xml)
       end
 
-      def self._determine_parser
-        # LibXML causes a segfault in Ruby 2.0.0. We need to fall back to Rexml to prevent this segfault.
-        if !RUBY_VERSION.start_with?("2.0") && defined?(::LibXML::XML) && ::LibXML::XML.respond_to?(:default_keep_blanks=)
-          ::Braintree::Xml::Libxml
-        else
-          ::Braintree::Xml::Rexml
-        end
-      end
-
-      def self._typecast_xml_value(value)
+      # Transform into standard Ruby types and convert all keys to snake_case instead of dash-case
+      def self._transform_xml(value)
         case value.class.to_s
-          when 'Hash'
-            if value['type'] == 'array'
-              child_key, entries = value.detect { |k,v| k != 'type' }   # child_key is throwaway
+          when "Hash"
+            if value["type"] == "array"
+              child_key, entries = value.detect { |k,v| k != "type" }   # child_key is throwaway
               if entries.nil? || ((c = value[CONTENT_ROOT]) && c.strip.empty?)
                 []
               else
                 case entries.class.to_s   # something weird with classes not matching here.  maybe singleton methods breaking is_a?
                 when "Array"
-                  entries.collect { |v| _typecast_xml_value(v) }
+                  entries.collect { |v| _transform_xml(v) }
                 when "Hash"
-                  [_typecast_xml_value(entries)]
+                  [_transform_xml(entries)]
                 else
                   raise "can't typecast #{entries.inspect}"
                 end
               end
             elsif value.has_key?(CONTENT_ROOT)
               content = value[CONTENT_ROOT]
-              if parser = XML_PARSING[value["type"]]
+              if (parser = XML_PARSING[value["type"]])
                 XML_PARSING[value["type"]].call(content)
               else
                 content
               end
-            elsif value['type'] == 'string' && value['nil'] != 'true'
+            elsif value["type"] == "string" && value["nil"] != "true"
               ""
             elsif value == {}
               ""
-            elsif value.nil? || value['nil'] == 'true'
+            elsif value.nil? || value["nil"] == "true"
               nil
             # If the type is the only element which makes it then
             # this still makes the value nil, except if type is
             # a XML node(where type['value'] is a Hash)
-            elsif value['type'] && value.size == 1 && !value['type'].is_a?(::Hash)
+            elsif value["type"] && value.size == 1 && !value["type"].is_a?(::Hash)
               raise "is this needed?"
               nil
             else
               xml_value = value.inject({}) do |h,(k,v)|
-                h[k] = _typecast_xml_value(v)
+                h[k.to_s.tr("-", "_")] = _transform_xml(v) # convert dashes to underscores in keys
                 h
               end
               xml_value
             end
-          when 'Array'
-            value.map! { |i| _typecast_xml_value(i) }
+          when "Array"
+            value.map! { |i| _transform_xml(i) }
             case value.length
               when 0 then nil
               when 1 then value.first
               else value
             end
-          when 'String'
+          when "String"
             value
           else
-            raise "can't typecast #{value.class.name} - #{value.inspect}"
-        end
-      end
-
-      def self._unrename_keys(params)
-        case params.class.to_s
-          when "Hash"
-            params.inject({}) do |h,(k,v)|
-              h[k.to_s.tr("-", "_")] = _unrename_keys(v)
-              h
-            end
-          when "Array"
-            params.map { |v| _unrename_keys(v) }
-          else
-            params
+            raise "can't transform #{value.class.name} - #{value.inspect}"
         end
       end
     end

data/spec/integration/braintree/add_on_spec.rb

@@ -35,7 +35,7 @@ describe Braintree::AddOn do
       gateway = Braintree::Gateway.new(
         :client_id => "client_id$#{Braintree::Configuration.environment}$integration_client_id",
         :client_secret => "client_secret$#{Braintree::Configuration.environment}$integration_client_secret",
-        :logger => Logger.new("/dev/null")
+        :logger => Logger.new("/dev/null"),
       )
 
       expect do

data/spec/integration/braintree/address_spec.rb

@@ -15,7 +15,7 @@ describe Braintree::Address do
         :locality => "Chicago",
         :region => "Illinois",
         :postal_code => "60622",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       result.success?.should == true
       result.address.customer_id.should == customer.id
@@ -39,7 +39,7 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_code_alpha2 => "AS",
         :country_code_alpha3 => "ASM",
-        :country_code_numeric => "16"
+        :country_code_numeric => "16",
       )
       result.success?.should == true
       result.address.country_name.should == "American Samoa"
@@ -52,7 +52,7 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!
       result = Braintree::Address.create(
         :customer_id => customer.id,
-        :country_name => "Åland"
+        :country_name => "Åland",
       )
       result.success?.should == true
       result.address.country_name.should == "Åland"
@@ -63,47 +63,47 @@ describe Braintree::Address do
       result = Braintree::Address.create(
         :customer_id => customer.id,
         :country_code_alpha2 => "AS",
-        :country_code_alpha3 => "USA"
+        :country_code_alpha3 => "USA",
       )
       result.success?.should == false
-      result.errors.for(:address).on(:base).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      result.errors.for(:address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error response given an invalid country_code_alpha2" do
       customer = Braintree::Customer.create!
       result = Braintree::Address.create(
         :customer_id => customer.id,
-        :country_code_alpha2 => "zz"
+        :country_code_alpha2 => "zz",
       )
       result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha2).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
+      result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_alpha3" do
       customer = Braintree::Customer.create!
       result = Braintree::Address.create(
         :customer_id => customer.id,
-        :country_code_alpha3 => "zzz"
+        :country_code_alpha3 => "zzz",
       )
       result.success?.should == false
-      result.errors.for(:address).on(:country_code_alpha3).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
+      result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_numeric" do
       customer = Braintree::Customer.create!
       result = Braintree::Address.create(
         :customer_id => customer.id,
-        :country_code_numeric => "zz"
+        :country_code_numeric => "zz",
       )
       result.success?.should == false
-      result.errors.for(:address).on(:country_code_numeric).map {|e| e.code}.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
+      result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns an error response if invalid" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       result = Braintree::Address.create(
         :customer_id => customer.id,
-        :country_name => "United States of Invalid"
+        :country_name => "United States of Invalid",
       )
       result.success?.should == false
       result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
@@ -132,7 +132,7 @@ describe Braintree::Address do
         :locality => "Bartlett",
         :region => "IL",
         :postal_code => "60623",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       address.customer_id.should == customer.id
       address.street_address.should == "1812 E Main St"
@@ -148,7 +148,7 @@ describe Braintree::Address do
       expect do
         Braintree::Address.create!(
           :customer_id => customer.id,
-          :country_name => "United States of Invalid"
+          :country_name => "United States of Invalid",
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
@@ -226,7 +226,7 @@ describe Braintree::Address do
         :locality => "Old Chicago",
         :region => "IL",
         :postal_code => "60620",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       result = Braintree::Address.update(
         customer.id,
@@ -236,7 +236,7 @@ describe Braintree::Address do
         :locality => "Chicago",
         :region => "Illinois",
         :postal_code => "60621",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       result.success?.should == true
       result.address.street_address.should == "123 E New St"
@@ -254,12 +254,12 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Miller")
       address = Braintree::Address.create!(
         :customer_id => customer.id,
-        :country_name => "Angola"
+        :country_name => "Angola",
       )
       result = Braintree::Address.update(
         customer.id,
         address.id,
-        :country_name => "Azerbaijan"
+        :country_name => "Azerbaijan",
       )
 
       result.success?.should == true
@@ -273,13 +273,13 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Miller")
       address = Braintree::Address.create!(
         :customer_id => customer.id,
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       result = Braintree::Address.update(
         customer.id,
         address.id,
         :street_address => "123 E New St",
-        :country_name => "United States of Invalid"
+        :country_name => "United States of Invalid",
       )
       result.success?.should == false
       result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
@@ -304,7 +304,7 @@ describe Braintree::Address do
         :locality => "Old Chicago",
         :region => "IL",
         :postal_code => "60620",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       updated_address = Braintree::Address.update!(
         customer.id,
@@ -314,7 +314,7 @@ describe Braintree::Address do
         :locality => "Chicago",
         :region => "Illinois",
         :postal_code => "60621",
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       updated_address.should == address
       updated_address.street_address.should == "123 E New St"
@@ -329,14 +329,14 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Miller")
       address = Braintree::Address.create!(
         :customer_id => customer.id,
-        :country_name => "United States of America"
+        :country_name => "United States of America",
       )
       expect do
         Braintree::Address.update!(
           customer.id,
           address.id,
           :street_address => "123 E New St",
-          :country_name => "United States of Invalid"
+          :country_name => "United States of Invalid",
         )
       end.to raise_error(Braintree::ValidationsFailed)
     end
@@ -347,98 +347,11 @@ describe Braintree::Address do
     it "deletes the address" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      address.delete.success?.should == true
+      result = Braintree::Address.delete(customer.id, address.id)
+      result.success?.should == true
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
     end
   end
-
-  describe "update" do
-    it "returns a success response and updates the address if valid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :street_address => "1812 E Old St",
-        :extended_address => "Suite Old 201",
-        :locality => "Old Chicago",
-        :region => "IL",
-        :postal_code => "60620",
-        :country_name => "United States of America"
-      )
-      result = address.update(
-        :street_address => "123 E New St",
-        :extended_address => "New Suite 3",
-        :locality => "Chicago",
-        :region => "Illinois",
-        :postal_code => "60621",
-        :country_name => "United States of America"
-      )
-      result.success?.should == true
-      result.address.should == address
-      address.street_address.should == "123 E New St"
-      address.extended_address.should == "New Suite 3"
-      address.locality.should == "Chicago"
-      address.region.should == "Illinois"
-      address.postal_code.should == "60621"
-      address.country_name.should == "United States of America"
-    end
-
-    it "returns an error response if invalid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :country_name => "United States of America"
-      )
-      result = address.update(
-        :street_address => "123 E New St",
-        :country_name => "United States of Invalid"
-      )
-      result.success?.should == false
-      result.errors.for(:address).on(:country_name)[0].message.should == "Country name is not an accepted country."
-    end
-  end
-
-  describe "update!" do
-    it "returns true and updates the address if valid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :street_address => "1812 E Old St",
-        :extended_address => "Suite Old 201",
-        :locality => "Old Chicago",
-        :region => "IL",
-        :postal_code => "60620",
-        :country_name => "United States of America"
-      )
-      address.update!(
-        :street_address => "123 E New St",
-        :extended_address => "New Suite 3",
-        :locality => "Chicago",
-        :region => "Illinois",
-        :postal_code => "60621",
-        :country_name => "United States of America"
-      ).should == address
-      address.street_address.should == "123 E New St"
-      address.extended_address.should == "New Suite 3"
-      address.locality.should == "Chicago"
-      address.region.should == "Illinois"
-      address.postal_code.should == "60621"
-      address.country_name.should == "United States of America"
-    end
-
-    it "raises a ValidationsFailed invalid" do
-      customer = Braintree::Customer.create!(:last_name => "Miller")
-      address = Braintree::Address.create!(
-        :customer_id => customer.id,
-        :country_name => "United States of America"
-      )
-      expect do
-        address.update!(
-          :street_address => "123 E New St",
-          :country_name => "United States of Invalid"
-        )
-      end.to raise_error(Braintree::ValidationsFailed)
-    end
-  end
 end