braintree 3.1.0 → 4.1.0

data/lib/braintree/xml/libxml.rb

@@ -1,4 +1,3 @@
-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,18 +11,28 @@ module Braintree
         "boolean"  => Proc.new { |boolean| %w(1 true).include?(boolean.strip) },
       }
 
-      def self.hash_from_xml(xml)
-        standardized_hash_structure = ::Braintree::Xml::Libxml.parse(xml)
+      def self.hash_from_xml(xml, parser = _determine_parser)
+        standardized_hash_structure = parser.parse(xml)
         transformed_xml = _transform_xml(standardized_hash_structure)
         Util.symbolize_keys(transformed_xml)
       end
 
+      def self._determine_parser
+        # If LibXML is not available, we fall back to REXML
+        # This allows us to be compatible with JRuby, which LibXML does not support
+        if defined?(::LibXML::XML) && ::LibXML::XML.respond_to?(:default_keep_blanks=)
+          ::Braintree::Xml::Libxml
+        else
+          ::Braintree::Xml::Rexml
+        end
+      end
+
       # 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
@@ -37,21 +47,21 @@ module Braintree
               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
@@ -61,14 +71,14 @@ module Braintree
               end
               xml_value
             end
-          when 'Array'
+          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 transform #{value.class.name} - #{value.inspect}"

data/lib/braintree/xml/rexml.rb

@@ -0,0 +1,70 @@
+# 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
+  module Xml # :nodoc:
+    module Rexml # :nodoc:
+
+      CONTENT_KEY = "__content__".freeze
+
+      def self.parse(string)
+        require "rexml/document" unless defined?(REXML::Document)
+        doc = REXML::Document.new(string)
+        _merge_element!({}, doc.root)
+      end
+
+      def self._merge_element!(hash, element)
+        _merge!(hash, element.name, _collapse(element))
+      end
+
+      def self._collapse(element)
+        hash = _get_attributes(element)
+
+        if element.has_elements?
+          element.each_element { |child| _merge_element!(hash, child) }
+          _merge_texts!(hash, element) unless _empty_content?(element)
+          hash
+        else
+          _merge_texts!(hash, element)
+        end
+      end
+
+      def self._merge_texts!(hash, element)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          _merge!(
+            hash,
+            CONTENT_KEY,
+            element.texts.map { |t| t.value }.join,
+          )
+        end
+      end
+
+      def self._merge!(hash, key, value)
+        if hash.has_key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      def self._get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n,v| attributes[n] = v }
+        attributes
+      end
+
+      def self._empty_content?(element)
+        element.texts.join.strip == ""
+      end
+    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

@@ -14,8 +14,9 @@ describe Braintree::Address do
         :extended_address => "Suite 200",
         :locality => "Chicago",
         :region => "Illinois",
+        :phone_number => "5551231234",
         :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
@@ -26,6 +27,7 @@ describe Braintree::Address do
       result.address.extended_address.should == "Suite 200"
       result.address.locality.should == "Chicago"
       result.address.region.should == "Illinois"
+      result.address.phone_number.should == "5551231234"
       result.address.postal_code.should == "60622"
       result.address.country_name.should == "United States of America"
       result.address.country_code_alpha2.should == "US"
@@ -39,7 +41,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 +54,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 +65,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."
@@ -131,14 +133,16 @@ describe Braintree::Address do
         :extended_address => "Suite 201",
         :locality => "Bartlett",
         :region => "IL",
+        :phone_number => "5551231234",
         :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"
       address.extended_address.should == "Suite 201"
       address.locality.should == "Bartlett"
       address.region.should == "IL"
+      address.phone_number.should == "5551231234"
       address.postal_code.should == "60623"
       address.country_name.should == "United States of America"
     end
@@ -148,7 +152,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 +230,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 +240,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 +258,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 +277,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 +308,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 +318,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 +333,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

data/spec/integration/braintree/advanced_search_spec.rb

@@ -6,7 +6,7 @@ describe Braintree::AdvancedSearch do
       :credit_card => {
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2010"
-      }
+      },
     ).credit_cards[0]
   end
 
@@ -16,13 +16,13 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -39,14 +39,14 @@ describe Braintree::AdvancedSearch do
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
         :price => "11",
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
         :price => "11",
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -63,13 +63,13 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -85,13 +85,13 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -107,13 +107,13 @@ describe Braintree::AdvancedSearch do
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription1_#{id}"
+        :id => "subscription1_#{id}",
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :id => "subscription2_#{id}"
+        :id => "subscription2_#{id}",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -131,13 +131,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "12"
+          :price => "12",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "12"
+          :price => "12",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -155,13 +155,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "13"
+          :price => "13",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "13"
+          :price => "13",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -179,13 +179,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "14"
+          :price => "14",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "14"
+          :price => "14",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -204,13 +204,13 @@ describe Braintree::AdvancedSearch do
           subscription1 = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
             :plan_id => SpecHelper::TriallessPlan[:id],
-            :price => "15"
+            :price => "15",
           ).subscription
 
           subscription2 = Braintree::Subscription.create(
             :payment_method_token => @credit_card.token,
             :plan_id => SpecHelper::TriallessPlan[:id],
-            :price => "15"
+            :price => "15",
           ).subscription
 
           Braintree::Subscription.cancel(subscription2.id)
@@ -229,13 +229,13 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "16"
+          :price => "16",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "16"
+          :price => "16",
         ).subscription
 
         Braintree::Subscription.cancel(subscription2.id)
@@ -266,19 +266,19 @@ describe Braintree::AdvancedSearch do
         subscription1 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
         subscription2 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
         subscription3 = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::AddOnDiscountPlan[:id],
-          :price => "17"
+          :price => "17",
         ).subscription
 
         plan_ids = [SpecHelper::TriallessPlan[:id], SpecHelper::TrialPlan[:id]]
@@ -307,13 +307,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "18"
+          :price => "18",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "18"
+          :price => "18",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -331,13 +331,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "19"
+          :price => "19",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "19"
+          :price => "19",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -355,13 +355,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "20"
+          :price => "20",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "20"
+          :price => "20",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -379,13 +379,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "21"
+          :price => "21",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "21"
+          :price => "21",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -403,13 +403,13 @@ describe Braintree::AdvancedSearch do
         trialless_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TriallessPlan[:id],
-          :price => "22"
+          :price => "22",
         ).subscription
 
         trial_subscription = Braintree::Subscription.create(
           :payment_method_token => @credit_card.token,
           :plan_id => SpecHelper::TrialPlan[:id],
-          :price => "22"
+          :price => "22",
         ).subscription
 
         collection = Braintree::Subscription.search do |search|
@@ -428,13 +428,13 @@ describe Braintree::AdvancedSearch do
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.01"
+        :price => "5.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -449,19 +449,19 @@ describe Braintree::AdvancedSearch do
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "4.99"
+        :price => "4.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.01"
+        :price => "5.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -477,19 +477,19 @@ describe Braintree::AdvancedSearch do
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "999.99"
+        :price => "999.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "1000.00"
+        :price => "1000.00",
       ).subscription
 
       subscription_501 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "1000.01"
+        :price => "1000.01",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|
@@ -505,19 +505,19 @@ describe Braintree::AdvancedSearch do
       subscription_499 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "4.99"
+        :price => "4.99",
       ).subscription
 
       subscription_500 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TriallessPlan[:id],
-        :price => "5.00"
+        :price => "5.00",
       ).subscription
 
       subscription_502 = Braintree::Subscription.create(
         :payment_method_token => @credit_card.token,
         :plan_id => SpecHelper::TrialPlan[:id],
-        :price => "5.02"
+        :price => "5.02",
       ).subscription
 
       collection = Braintree::Subscription.search do |search|