braintree 4.14.0 → 4.18.0

data/lib/braintree/visa_checkout_card.rb

@@ -1,6 +1,6 @@
 module Braintree
   class VisaCheckoutCard
-    include BaseModule # :nodoc:
+    include BaseModule
     include Braintree::Util::TokenEquality
 
     attr_reader :billing_address
@@ -30,7 +30,7 @@ module Braintree
     attr_reader :updated_at
     attr_reader :verification
 
-    def initialize(gateway, attributes) # :nodoc:
+    def initialize(gateway, attributes)
       @gateway = gateway
       set_instance_variables_from_hash(attributes)
       @billing_address = attributes[:billing_address] ? Address._new(@gateway, attributes[:billing_address]) : nil
@@ -39,8 +39,8 @@ module Braintree
     end
 
     def _most_recent_verification(attributes)
-      verification = (attributes[:verifications] || []).sort_by { |verification| verification[:created_at] }.reverse.first
-      CreditCardVerification._new(verification) if verification
+      sorted_verifications = (attributes[:verifications] || []).sort_by { |verification| verification[:created_at] }.reverse.first
+      CreditCardVerification._new(sorted_verifications) if sorted_verifications
     end
 
     def default?
@@ -56,7 +56,7 @@ module Braintree
       @expired
     end
 
-    def inspect # :nodoc:
+    def inspect
       first = [:token]
       order = first + (self.class._attributes - first)
       nice_attributes = order.map do |attr|
@@ -73,7 +73,7 @@ module Braintree
       protected :new
     end
 
-    def self._attributes # :nodoc:
+    def self._attributes
       [
         :billing_address, :bin, :card_type, :cardholder_name, :created_at,
         :customer_id, :customer_location, :expiration_month, :expiration_year,
@@ -83,7 +83,7 @@ module Braintree
       ]
     end
 
-    def self._new(*args) # :nodoc:
+    def self._new(*args)
       self.new(*args)
     end
   end

data/lib/braintree/webhook_notification.rb

@@ -45,6 +45,7 @@ module Braintree
 
       RecipientUpdatedGrantedPaymentMethod = "recipient_updated_granted_payment_method"
 
+      SubscriptionBillingSkipped = "subscription_billing_skipped"
       SubscriptionCanceled = "subscription_canceled"
       SubscriptionChargedSuccessfully = "subscription_charged_successfully"
       SubscriptionChargedUnsuccessfully = "subscription_charged_unsuccessfully"
@@ -91,7 +92,7 @@ module Braintree
       Configuration.gateway.webhook_notification.verify(*args)
     end
 
-    def initialize(gateway, attributes) # :nodoc:
+    def initialize(gateway, attributes)
       @gateway = gateway
       set_instance_variables_from_hash(attributes)
       @error_result = ErrorResult.new(gateway, @subject[:api_error_response]) if @subject.has_key?(:api_error_response)
@@ -134,7 +135,7 @@ module Braintree
 
     class << self
       protected :new
-      def _new(*args) # :nodoc:
+      def _new(*args)
         self.new(*args)
       end
     end

data/lib/braintree/webhook_notification_gateway.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class WebhookNotificationGateway # :nodoc:
+  class WebhookNotificationGateway
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
@@ -27,7 +27,7 @@ module Braintree
       signature_pairs = signature_string.split("&")
       valid_pairs = signature_pairs.select { |pair| pair.include?("|") }.map { |pair| pair.split("|") }
 
-      valid_pairs.detect do |public_key, signature|
+      valid_pairs.detect do |public_key, _signature|
         public_key == @config.public_key
       end
     end
@@ -36,8 +36,8 @@ module Braintree
       public_key, signature = _matching_signature_pair(signature_string)
       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)
+      signature_matches = [payload, payload + "\n"].any? do |p|
+        payload_signature = Braintree::Digest.hexdigest(@config.private_key, p)
         Braintree::Digest.secure_compare(signature, payload_signature)
       end
       raise InvalidSignature, "signature does not match payload - one has been modified" unless signature_matches

data/lib/braintree/webhook_testing.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class WebhookTesting # :nodoc:
+  class WebhookTesting
     def self.sample_notification(*args)
       Configuration.gateway.webhook_testing.sample_notification(*args)
     end

data/lib/braintree/webhook_testing_gateway.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class WebhookTestingGateway # :nodoc:
+  class WebhookTestingGateway
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
@@ -72,6 +72,8 @@ module Braintree
         _disbursement_exception_sample_xml(id)
       when Braintree::WebhookNotification::Kind::Disbursement
         _disbursement_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::SubscriptionBillingSkipped
+        _subscription_billing_skipped(id)
       when Braintree::WebhookNotification::Kind::SubscriptionChargedSuccessfully
         _subscription_charged_successfully(id)
       when Braintree::WebhookNotification::Kind::SubscriptionChargedUnsuccessfully
@@ -112,6 +114,21 @@ module Braintree
       XML
     end
 
+    def _subscription_billing_skipped(id)
+
+      <<-XML
+        <subscription>
+          <id>#{id}</id>
+          <transactions type="array">
+          </transactions>
+          <add_ons type="array">
+          </add_ons>
+          <discounts type="array">
+          </discounts>
+        </subscription>
+      XML
+    end
+
     def _subscription_charged_successfully(id)
 
       <<-XML

data/lib/braintree/xml/generator.rb

@@ -2,7 +2,7 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml
-    module Generator # :nodoc:
+    module Generator
       XML_TYPE_NAMES = {
         "Fixnum"     => "integer",
         "Bignum"     => "integer",

data/lib/braintree/xml/libxml.rb

@@ -2,7 +2,7 @@
 # under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
 module Braintree
   module Xml
-    module Libxml # :nodoc:
+    module Libxml
       LIB_XML_LIMIT = 30000000
 
       def self.parse(xml_string)

data/lib/braintree/xml/parser.rb

@@ -1,10 +1,10 @@
 # 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 Xml
     CONTENT_ROOT = "__content__"
 
-    module Parser # :nodoc:
+    module Parser
       XML_PARSING = {
         "datetime" => Proc.new { |time| ::Time.parse(time).utc },
         "integer"  => Proc.new { |integer| integer.to_i },
@@ -32,7 +32,7 @@ module Braintree
         case value.class.to_s
           when "Hash"
             if value["type"] == "array"
-              child_key, entries = value.detect { |k,v| k != "type" }   # child_key is throwaway
+              child_key, entries = value.detect { |k,_v| k != "type" }   # child_key is throwaway
               if entries.nil? || ((c = value[CONTENT_ROOT]) && c.strip.empty?)
                 []
               else

data/lib/braintree/xml/rexml.rb

@@ -1,8 +1,8 @@
 # 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:
+  module Xml
+    module Rexml
 
       CONTENT_KEY = "__content__".freeze
 

data/lib/braintree/xml.rb

@@ -1,5 +1,5 @@
 module Braintree
-  module Xml # :nodoc:
+  module Xml
     def self.hash_from_xml(xml)
       Parser.hash_from_xml(xml)
     end

data/lib/braintree.rb

@@ -3,7 +3,6 @@ require "bigdecimal"
 require "cgi"
 require "date"
 require "digest/sha1"
-require "enumerator"
 require "forwardable"
 require "logger"
 require "net/http"
@@ -91,6 +90,8 @@ require "braintree/merchant_account/individual_details"
 require "braintree/merchant_account/business_details"
 require "braintree/merchant_account/funding_details"
 require "braintree/merchant_account/address_details"
+require "braintree/meta_checkout_card"
+require "braintree/meta_checkout_token"
 require "braintree/oauth_gateway"
 require "braintree/oauth_credentials"
 require "braintree/payment_instrument_type"
@@ -153,6 +154,9 @@ require "braintree/transaction/installment/adjustment"
 require "braintree/transaction/payment_receipt"
 require "braintree/transaction/payment_receipt/card_present_data.rb"
 require "braintree/transaction/payment_receipt/merchant_address.rb"
+require "braintree/transaction/meta_checkout_card_details"
+require "braintree/transaction/meta_checkout_token_details"
+require "braintree/transaction/package_details"
 require "braintree/transaction/paypal_details"
 require "braintree/transaction/paypal_here_details"
 require "braintree/transaction/samsung_pay_card_details"

data/spec/integration/braintree/add_on_spec.rb

@@ -20,15 +20,15 @@ describe Braintree::AddOn do
       add_ons = Braintree::AddOn.all
       add_on = add_ons.select { |add_on| add_on.id == id }.first
 
-      add_on.should_not be_nil
-      add_on.amount.should == BigDecimal(expected[:amount])
-      add_on.created_at.should_not be_nil
-      add_on.description.should == expected[:description]
-      add_on.kind.should == expected[:kind]
-      add_on.name.should == expected[:name]
-      add_on.never_expires.should == expected[:never_expires]
-      add_on.number_of_billing_cycles.should == expected[:number_of_billing_cycles]
-      add_on.updated_at.should_not be_nil
+      expect(add_on).not_to be_nil
+      expect(add_on.amount).to eq(BigDecimal(expected[:amount]))
+      expect(add_on.created_at).not_to be_nil
+      expect(add_on.description).to eq(expected[:description])
+      expect(add_on.kind).to eq(expected[:kind])
+      expect(add_on.name).to eq(expected[:name])
+      expect(add_on.never_expires).to eq(expected[:never_expires])
+      expect(add_on.number_of_billing_cycles).to eq(expected[:number_of_billing_cycles])
+      expect(add_on.updated_at).not_to be_nil
     end
 
     it "raises with a helpful error if public_key and private_key are not set" do

data/spec/integration/braintree/address_spec.rb

@@ -18,21 +18,21 @@ describe Braintree::Address do
         :postal_code => "60622",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.customer_id.should == customer.id
-      result.address.first_name.should == "Ben"
-      result.address.last_name.should == "Moore"
-      result.address.company.should == "Moore Co."
-      result.address.street_address.should == "1811 E Main St"
-      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"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.customer_id).to eq(customer.id)
+      expect(result.address.first_name).to eq("Ben")
+      expect(result.address.last_name).to eq("Moore")
+      expect(result.address.company).to eq("Moore Co.")
+      expect(result.address.street_address).to eq("1811 E Main St")
+      expect(result.address.extended_address).to eq("Suite 200")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.phone_number).to eq("5551231234")
+      expect(result.address.postal_code).to eq("60622")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -43,11 +43,11 @@ describe Braintree::Address do
         :country_code_alpha3 => "ASM",
         :country_code_numeric => "16",
       )
-      result.success?.should == true
-      result.address.country_name.should == "American Samoa"
-      result.address.country_code_alpha2.should == "AS"
-      result.address.country_code_alpha3.should == "ASM"
-      result.address.country_code_numeric.should == "016"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("American Samoa")
+      expect(result.address.country_code_alpha2).to eq("AS")
+      expect(result.address.country_code_alpha3).to eq("ASM")
+      expect(result.address.country_code_numeric).to eq("016")
     end
 
     it "accepts utf-8 country names" do
@@ -56,8 +56,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :country_name => "Åland",
       )
-      result.success?.should == true
-      result.address.country_name.should == "Åland"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Åland")
     end
 
     it "returns an error response given inconsistent country codes" do
@@ -67,8 +67,8 @@ describe Braintree::Address do
         :country_code_alpha2 => "AS",
         :country_code_alpha3 => "USA",
       )
-      result.success?.should == false
-      result.errors.for(:address).on(:base).map { |e| e.code }.should include(Braintree::ErrorCodes::Address::InconsistentCountry)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:base).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::InconsistentCountry)
     end
 
     it "returns an error response given an invalid country_code_alpha2" do
@@ -77,8 +77,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :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)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha2).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha2IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_alpha3" do
@@ -87,8 +87,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :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)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_alpha3).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeAlpha3IsNotAccepted)
     end
 
     it "returns an error response given an invalid country_code_numeric" do
@@ -97,8 +97,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :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)
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_code_numeric).map { |e| e.code }).to include(Braintree::ErrorCodes::Address::CountryCodeNumericIsNotAccepted)
     end
 
     it "returns an error response if invalid" do
@@ -107,8 +107,8 @@ describe Braintree::Address do
         :customer_id => customer.id,
         :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."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
 
     it "allows -, _, A-Z, a-z, and 0-9 in customer_id without raising an ArgumentError" do
@@ -137,14 +137,14 @@ describe Braintree::Address do
         :postal_code => "60623",
         :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"
+      expect(address.customer_id).to eq(customer.id)
+      expect(address.street_address).to eq("1812 E Main St")
+      expect(address.extended_address).to eq("Suite 201")
+      expect(address.locality).to eq("Bartlett")
+      expect(address.region).to eq("IL")
+      expect(address.phone_number).to eq("5551231234")
+      expect(address.postal_code).to eq("60623")
+      expect(address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed if invalid" do
@@ -162,7 +162,7 @@ describe Braintree::Address do
     it "deletes the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer.id, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer.id, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -171,7 +171,7 @@ describe Braintree::Address do
     it "deletes the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.delete(customer, address.id).success?.should == true
+      expect(Braintree::Address.delete(customer, address.id).success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)
@@ -182,13 +182,13 @@ describe Braintree::Address do
     it "finds the address given a customer and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer, address.id).should == address
+      expect(Braintree::Address.find(customer, address.id)).to eq(address)
     end
 
     it "finds the address given a customer id and an address id" do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
-      Braintree::Address.find(customer.id, address.id).should == address
+      expect(Braintree::Address.find(customer.id, address.id)).to eq(address)
     end
 
     it "raises a NotFoundError if it cannot be found because of customer id" do
@@ -242,16 +242,16 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      result.success?.should == true
-      result.address.street_address.should == "123 E New St"
-      result.address.extended_address.should == "New Suite 3"
-      result.address.locality.should == "Chicago"
-      result.address.region.should == "Illinois"
-      result.address.postal_code.should == "60621"
-      result.address.country_name.should == "United States of America"
-      result.address.country_code_alpha2.should == "US"
-      result.address.country_code_alpha3.should == "USA"
-      result.address.country_code_numeric.should == "840"
+      expect(result.success?).to eq(true)
+      expect(result.address.street_address).to eq("123 E New St")
+      expect(result.address.extended_address).to eq("New Suite 3")
+      expect(result.address.locality).to eq("Chicago")
+      expect(result.address.region).to eq("Illinois")
+      expect(result.address.postal_code).to eq("60621")
+      expect(result.address.country_name).to eq("United States of America")
+      expect(result.address.country_code_alpha2).to eq("US")
+      expect(result.address.country_code_alpha3).to eq("USA")
+      expect(result.address.country_code_numeric).to eq("840")
     end
 
     it "accepts country_codes" do
@@ -266,11 +266,11 @@ describe Braintree::Address do
         :country_name => "Azerbaijan",
       )
 
-      result.success?.should == true
-      result.address.country_name.should == "Azerbaijan"
-      result.address.country_code_alpha2.should == "AZ"
-      result.address.country_code_alpha3.should == "AZE"
-      result.address.country_code_numeric.should == "031"
+      expect(result.success?).to eq(true)
+      expect(result.address.country_name).to eq("Azerbaijan")
+      expect(result.address.country_code_alpha2).to eq("AZ")
+      expect(result.address.country_code_alpha3).to eq("AZE")
+      expect(result.address.country_code_numeric).to eq("031")
     end
 
     it "returns an error response if invalid" do
@@ -285,8 +285,8 @@ describe Braintree::Address do
         :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."
+      expect(result.success?).to eq(false)
+      expect(result.errors.for(:address).on(:country_name)[0].message).to eq("Country name is not an accepted country.")
     end
   end
 
@@ -320,13 +320,13 @@ describe Braintree::Address do
         :postal_code => "60621",
         :country_name => "United States of America",
       )
-      updated_address.should == address
-      updated_address.street_address.should == "123 E New St"
-      updated_address.extended_address.should == "New Suite 3"
-      updated_address.locality.should == "Chicago"
-      updated_address.region.should == "Illinois"
-      updated_address.postal_code.should == "60621"
-      updated_address.country_name.should == "United States of America"
+      expect(updated_address).to eq(address)
+      expect(updated_address.street_address).to eq("123 E New St")
+      expect(updated_address.extended_address).to eq("New Suite 3")
+      expect(updated_address.locality).to eq("Chicago")
+      expect(updated_address.region).to eq("Illinois")
+      expect(updated_address.postal_code).to eq("60621")
+      expect(updated_address.country_name).to eq("United States of America")
     end
 
     it "raises a ValidationsFailed invalid" do
@@ -352,7 +352,7 @@ describe Braintree::Address do
       customer = Braintree::Customer.create!(:last_name => "Wilson")
       address = Braintree::Address.create!(:customer_id => customer.id, :street_address => "123 E Main St")
       result = Braintree::Address.delete(customer.id, address.id)
-      result.success?.should == true
+      expect(result.success?).to eq(true)
       expect do
         Braintree::Address.find(customer.id, address.id)
       end.to raise_error(Braintree::NotFoundError)