braintree 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fd29c86922c84315bcc22c0318136adefa3b5023ffec6b805578ad9e9f9be0d
-  data.tar.gz: f35f8eef6ccc321816005117c7bd0323a3b1d1e707ddc93ea082f43597ad75e6
+  metadata.gz: 78d503215e210019aebf40c5b4f0d42f8e98721a728016930efedc008c138ccc
+  data.tar.gz: 688dca23d5029e44cdb81915b2935bdf93d1b3b68f0e44703b46856d4a1abf6a
 SHA512:
-  metadata.gz: a286c7e29b1f24de08aa3da6818f6061904f1ab52f581c44b7ce80e37fc7ff42a54a5bdcf39a70255c53965a3e580965d07677a56053d643652a56d39aef1f80
-  data.tar.gz: 7b9f4bef3725bd17dac212babe68a9382a23bde7bacb458c5ca970c2137d374792a84247c222168f5e68518f22917891efd1720d90e2786e85e3a1ba40edd6e1
+  metadata.gz: 8a3a1935223a681e1b7935ef2e81bbe68448ebac245e3fe460892c423098c0db6c9cc9d05d25e11539fe392fdc34cef60e8a41e18a1ed1e95191729cf5aa624c
+  data.tar.gz: bb1137c11f4ab8e12fba995e6fb547222ceb99f13231b393a8f631b487f11d74661c6d461383614eccdbce9acbbd8d91890bf8bd3c759b8579e0ecbbcccc24ce

data/lib/braintree.rb

@@ -141,6 +141,8 @@ require "braintree/transaction/status_details"
 require "braintree/transaction/venmo_account_details"
 require "braintree/transaction/visa_checkout_card_details"
 require "braintree/transaction/samsung_pay_card_details"
+require "braintree/transaction/installment"
+require "braintree/transaction/installment/adjustment"
 require "braintree/unknown_payment_method"
 require "braintree/disbursement"
 require "braintree/dispute_search"

data/lib/braintree/credit_card_gateway.rb

@@ -79,7 +79,7 @@ module Braintree
 
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature
-      options = [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]
+      options = [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type,:verification_currency_iso_code]
       signature = [
         :billing_address_id, :cardholder_name, :cvv, :expiration_date, :expiration_month,
         :expiration_year, :number, :token, :venmo_sdk_payment_method_code, :device_data,

data/lib/braintree/error_codes.rb

@@ -68,6 +68,7 @@ module Braintree
       CardholderNameIsTooLong = "81723"
       CreditCardTypeIsNotAccepted = "81703"
       CreditCardTypeIsNotAcceptedBySubscriptionMerchantAccount = "81718"
+      CurrencyCodeNotSupportedByMerchantAccount = "91760"
       CustomerIdIsInvalid = "91705"
       CustomerIdIsRequired = "91704"
       CvvIsInvalid = "81707"
@@ -301,6 +302,7 @@ module Braintree
       CannotUpdateTransactionDetailsNotSubmittedForSettlement = "915129"
       ChannelIsTooLong = "91550"
       CreditCardIsRequired = "91508"
+      CurrencyCodeNotSupportedByMerchantAccount = "915214"
       CustomFieldIsInvalid = "91526"
       CustomFieldIsTooLong = "81527"
       CustomerDefaultPaymentMethodCardTypeIsNotAccepted = "81509"
@@ -354,6 +356,7 @@ module Braintree
       RefundAmountIsTooLarge = "91521"
       RefundAuthHardDeclined = "915200"
       RefundAuthSoftDeclined = "915201"
+      ScaExemptionInvalid = "915213"
       ServiceFeeAmountCannotBeNegative = "91554"
       ServiceFeeAmountFormatIsInvalid = "91555"
       ServiceFeeAmountIsTooLarge = "91556"
@@ -507,6 +510,7 @@ module Braintree
       end
 
       module ExternalVault
+        # NEXT_MAJOR_VERSION remove this validation error as it is no longer returned by the gateway
         CardTypeIsInvalid = "915178"
         PreviousNetworkTransactionIdIsInvalid = "915179"
         StatusIsInvalid = "915175"
@@ -775,6 +779,7 @@ module Braintree
     end
 
     module RiskData
+      # NEXT_MAJOR_VERSION Remove CustomerBrowserIsTooLong (this validation is no longer applied)
       CustomerBrowserIsTooLong = "94701"
       CustomerDeviceIdIsTooLong = "94702"
       CustomerLocationZipInvalidCharacters = "94703"

data/lib/braintree/payment_method_gateway.rb

@@ -19,7 +19,6 @@ module Braintree
 
     def _do_create(path, params=nil) # :nodoc:
       response = @config.http.post("#{@config.base_merchant_path}#{path}", params)
-
       if response[:api_error_response]
         ErrorResult.new(@gateway, response[:api_error_response])
       elsif response
@@ -152,6 +151,7 @@ module Braintree
         :make_default, :verification_merchant_account_id, :verify_card, :venmo_sdk_session,
         :verification_amount, :us_bank_account_verification_method,
         :verification_account_type,
+        :verification_currency_iso_code,
         :paypal => [
           :payee_email,
           :order_id,

data/lib/braintree/resource_collection.rb

@@ -22,9 +22,14 @@ module Braintree
       @ids.empty?
     end
 
-    # Returns the first item in the collection or nil if the collection is empty
-    def first
-      @paging_block.call([@ids.first]).first
+    # Returns the first or the first N items in the collection or nil if the collection is empty
+    def first(amount = 1)
+      return nil if @ids.empty?
+      return @paging_block.call([@ids.first]).first if amount == 1
+
+      @ids.first(amount).each_slice(@page_size).flat_map do |page_of_ids|
+        @paging_block.call(page_of_ids)
+      end
     end
 
     # Only the maximum size of a resource collection can be determined since the data on the server can change while

data/lib/braintree/test/credit_card.rb

@@ -36,6 +36,7 @@ module Braintree
       Hipercard = "6062820524845321"
 
       Visa = "4012888888881881"
+      VisaCountryOfIssuanceIE = "4023490000000008"
       VisaInternational = "4009348888881881" # :nodoc:
       VisaPrepaid = "4500600000000061"
 

data/lib/braintree/transaction.rb

@@ -121,6 +121,8 @@ module Braintree
     attr_reader :google_pay_details
     attr_reader :graphql_id
     attr_reader :id
+    attr_reader :installment_count
+    attr_reader :installments
     attr_reader :local_payment_details
     attr_reader :merchant_account_id
     attr_reader :network_response_code                  # Response code from the card network
@@ -143,9 +145,11 @@ module Braintree
     attr_reader :recurring
     attr_reader :refund_ids
     attr_reader :refunded_transaction_id
+    attr_reader :refunded_installments
     attr_reader :retrieval_reference_number
     attr_reader :risk_data
     attr_reader :samsung_pay_card_details
+    attr_reader :sca_exemption_requested
     attr_reader :service_fee_amount
     attr_reader :settlement_batch_id
     attr_reader :shipping_amount
@@ -305,7 +309,11 @@ module Braintree
       @us_bank_account_details = UsBankAccountDetails.new(attributes[:us_bank_account]) if attributes[:us_bank_account]
       @visa_checkout_card_details = VisaCheckoutCardDetails.new(attributes[:visa_checkout_card])
       @samsung_pay_card_details = SamsungPayCardDetails.new(attributes[:samsung_pay_card])
+      @sca_exemption_requested = attributes[:sca_exemption_requested]
       authorization_adjustments.map! { |attrs| AuthorizationAdjustment._new(attrs) } if authorization_adjustments
+
+      installments.map! { |attrs| Installment.new(attrs) } if installments
+      refunded_installments.map! { |attrs| Installment.new(attrs) } if refunded_installments
     end
 
     def inspect # :nodoc:

data/lib/braintree/transaction/installment.rb

@@ -0,0 +1,28 @@
+module Braintree
+  class Transaction
+    class Installment
+      include BaseModule
+
+      attr_reader :id
+      attr_reader :amount
+      attr_reader :projected_disbursement_date
+      attr_reader :actual_disbursement_date
+      attr_reader :adjustments
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+        @amount = Util.to_big_decimal(amount)
+        adjustments.map! { |attrs| Adjustment.new(attrs) } if adjustments
+      end
+
+      def inspect
+        attrs = [:id, :amount, :projected_disbursement_date, :actual_disbursement_date, :adjustments]
+        formatted_attrs = attrs.map do |attr|
+          "#{attr}: #{send(attr).inspect}"
+        end
+
+        "#<#{formatted_attrs.join(", ")}>"
+      end
+    end
+  end
+end

data/lib/braintree/transaction/installment/adjustment.rb

@@ -0,0 +1,33 @@
+module Braintree
+  class Transaction
+    class Installment
+      class Adjustment
+        include BaseModule
+
+        module Kind
+          Refund = "REFUND"
+          Dispute = "DISPUTE"
+        end
+
+        attr_reader :amount
+        attr_reader :kind
+        attr_reader :projected_disbursement_date
+        attr_reader :actual_disbursement_date
+
+        def initialize(attributes)
+          set_instance_variables_from_hash attributes unless attributes.nil?
+          @amount = Util.to_big_decimal(amount)
+        end
+
+        def inspect
+          attrs = [:amount, :kind, :projected_disbursement_date, :actual_disbursement_date]
+          formatted_attrs = attrs.map do |attr|
+            "#{attr}: #{send(attr).inspect}"
+          end
+
+          "#<#{formatted_attrs.join(", ")}>"
+        end
+      end
+    end
+  end
+end

data/lib/braintree/transaction_gateway.rb

@@ -180,6 +180,7 @@ module Braintree
         :shared_shipping_address_id, :shipping_address_id, :shipping_amount,
         :ships_from_postal_code, :tax_amount, :tax_exempt, :three_d_secure_authentication_id,
         :three_d_secure_token, :transaction_source, :type, :venmo_sdk_payment_method_code,
+        :sca_exemption, :currency_iso_code,
         {:line_items => [:quantity, :name, :description, :kind, :unit_amount, :unit_tax_amount, :total_amount, :discount_amount, :tax_amount, :unit_of_measure, :product_code, :commodity_code, :url]},
         {:risk_data => [:customer_browser, :customer_device_id, :customer_ip, :customer_location_zip, :customer_tenure]},
         {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number]},
@@ -245,7 +246,8 @@ module Braintree
           ]},
         ]},
         {:apple_pay_card => [:number, :cardholder_name, :cryptogram, :expiration_month, :expiration_year, :eci_indicator]},
-        {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]}
+        {:google_pay_card => [:number, :cryptogram, :google_transaction_id, :expiration_month, :expiration_year, :source_card_type, :source_card_last_four, :eci_indicator]},
+        {:installments => [:count]},
       ]
     end
 

data/lib/braintree/version.rb

@@ -1,7 +1,7 @@
 module Braintree
   module Version
     Major = 3
-    Minor = 1
+    Minor = 2
     Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"

data/spec/integration/braintree/customer_spec.rb

@@ -257,6 +257,92 @@ describe Braintree::Customer do
       result.credit_card_verification.status.should == Braintree::Transaction::Status::ProcessorDeclined
     end
 
+    it "can create a customer and a payment method at the same time after validating verification_currency_iso_code" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "USD"
+          }
+        }
+      )
+
+      result.success?.should == true
+      result.customer.first_name.should == "Mike"
+      result.customer.last_name.should == "Jones"
+      result.customer.credit_cards[0].bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+      result.customer.credit_cards[0].last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+      result.customer.credit_cards[0].expiration_date.should == "05/2010"
+      result.customer.credit_cards[0].unique_number_identifier.should =~ /\A\w{32}\z/
+      result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+    end
+
+    it "errors when verification_currency_iso_code is not supported by merchant account" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :cvv => "100",
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "GBP"
+          }
+        }
+      )
+      expect(result).to_not be_success
+      expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
+    it "validates verification_currency_iso_code of the given verification_merchant_account_id and creates customer" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "USD"
+          }
+        }
+      )
+      result.success?.should == true
+      result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+      result.customer.first_name.should == "Mike"
+      result.customer.last_name.should == "Jones"
+      result.customer.credit_cards[0].bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+      result.customer.credit_cards[0].last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+      result.customer.credit_cards[0].expiration_date.should == "05/2010"
+      result.customer.credit_cards[0].unique_number_identifier.should =~ /\A\w{32}\z/
+    end
+
+    it "validates verification_currency_iso_code of the given verification_merchant_account_id and returns error" do
+      result = Braintree::Customer.create(
+        :first_name => "Mike",
+        :last_name => "Jones",
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "05/2010",
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "GBP"
+          }
+        }
+      )
+      expect(result).to_not be_success
+      expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
+
     it "can create a customer, payment method, and billing address at the same time" do
       result = Braintree::Customer.create(
         :first_name => "Mike",
@@ -1347,6 +1433,87 @@ describe Braintree::Customer do
       result.errors.for(:customer).on(:email)[0].message.should == "Email is an invalid format."
     end
 
+    context "verification_currency_iso_code" do
+      it "can update the customer after validating verification_currency_iso_code" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe"
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => { :verify_card => true, :verification_currency_iso_code => "USD" }
+          }
+        )
+        result.success?.should == true
+        result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+      end
+
+      it "can update the customer after validating verification_currency_iso_code against the given verification_merchant_account_id" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe"
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => { :verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId, :verification_currency_iso_code => "USD" }
+          }
+        )
+        result.success?.should == true
+        result.customer.credit_cards[0].verification.currency_iso_code == "USD"
+        result.customer.credit_cards[0].verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+      end
+
+      it "throws error due to verification_currency_iso_code not matching against the currency configured in default merchant account" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe"
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => { :verify_card => true, :verification_currency_iso_code => "GBP" }
+          }
+        )
+        result.success?.should == false
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+
+      end
+
+      it "throws error due to verification_currency_iso_code not matching against the currency configured in the given verification merchant account" do
+        customer = Braintree::Customer.create!(
+          :first_name => "Joe"
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :first_name => "New Joe",
+          :credit_card => {
+            :cardholder_name => "New Joe Cardholder",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2009",
+            :options => { :verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId, :verification_currency_iso_code => "GBP" }
+          }
+        )
+        result.success?.should == false
+        expect(result.errors.for(:customer).for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code).to eq Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+
+      end
+    end
+
     context "verification_account_type" do
       it "updates the credit card with account_type credit" do
         customer = Braintree::Customer.create!

data/spec/integration/braintree/payment_method_spec.rb

@@ -849,6 +849,99 @@ describe Braintree::PaymentMethod do
         payment_method.should be_a Braintree::UnknownPaymentMethod
       end
     end
+
+    context "verification_currency_iso_code" do
+      it "validates verification_currency_iso_code against currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "USD"
+          }
+        )
+
+        result.should be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+      end
+
+      it "validates verification_currency_iso_code against currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "USD"
+          }
+        )
+
+        result.should be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+        result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+      end
+
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "GBP"
+          }
+        )
+        result.should_not be_success
+        result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+      end
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "GBP"
+          }
+        )
+
+        result.should_not be_success
+        result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+      end
+    end
   end
 
   describe "self.create!" do
@@ -1275,6 +1368,90 @@ describe Braintree::PaymentMethod do
         updated_credit_card.expiration_date.should == "06/2013"
       end
 
+      context "verification_currency_iso_code" do
+        it "validates verification_currency_iso_code and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "USD"}
+                                                         )
+          update_result.success?.should == true
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+        end
+
+        it "validates verification_currency_iso_code against the given verification_merchant_account_id and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "USD"}
+                                                         )
+          update_result.success?.should == true
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+          update_result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "GBP"}
+                                                         )
+          expect(update_result).to_not be_success
+          update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code of the given verification merchant account id" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "GBP"}
+                                                         )
+          expect(update_result).to_not be_success
+          update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+        end
+      end
+
+
       context "billing address" do
         it "creates a new billing address by default" do
           customer = Braintree::Customer.create!

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -13,7 +13,8 @@ describe Braintree::PaymentMethod do
       context "plaid verified nonce" do
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
@@ -49,7 +50,8 @@ describe Braintree::PaymentMethod do
           Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
           Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
         ].each do |method|
-          it "succeeds and verifies via #{method}" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "succeeds and verifies via #{method}" do
             customer = Braintree::Customer.create.customer
             result = Braintree::PaymentMethod.create(
               :payment_method_nonce => nonce,
@@ -183,7 +185,8 @@ describe Braintree::PaymentMethod do
 
         let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,
@@ -219,7 +222,8 @@ describe Braintree::PaymentMethod do
       context "non plaid verified nonce" do
         let(:nonce) { generate_non_plaid_us_bank_account_nonce }
 
-        it "succeeds and verifies via independent check" do
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
           customer = Braintree::Customer.create.customer
           result = Braintree::PaymentMethod.create(
             :payment_method_nonce => nonce,

data/spec/integration/braintree/transaction_spec.rb

@@ -159,7 +159,6 @@ describe Braintree::Transaction do
             }
           )
           result.success?.should == false
-          result.errors.for(:transaction).for(:risk_data).on(:customer_browser).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerBrowserIsTooLong
           result.errors.for(:transaction).for(:risk_data).on(:customer_device_id).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerDeviceIdIsTooLong
           result.errors.for(:transaction).for(:risk_data).on(:customer_location_zip).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerLocationZipInvalidCharacters
           result.errors.for(:transaction).for(:risk_data).on(:customer_tenure).map { |e| e.code }.should include Braintree::ErrorCodes::RiskData::CustomerTenureIsTooLong
@@ -182,6 +181,42 @@ describe Braintree::Transaction do
       end
     end
 
+    describe "sca_exemption" do
+      context "with a valid request" do
+        it "succeeds" do
+          requested_exemption = "low_value"
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::VisaCountryOfIssuanceIE,
+              :expiration_date => "05/2009"
+            },
+            :sca_exemption => requested_exemption,
+          )
+          expect(result).to be_success
+          expect(result.transaction.sca_exemption_requested).to eq(requested_exemption)
+        end
+      end
+
+      context "with an invalid request" do
+        it "returns an error" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :credit_card => {
+              :number => Braintree::Test::CreditCardNumbers::Visa,
+              :expiration_date => "05/2009"
+            },
+            :sca_exemption => "invalid_sca_exemption_value",
+          )
+          sca_exemption_invalid = Braintree::ErrorCodes::Transaction::ScaExemptionInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:transaction).map(&:code)).to eq([sca_exemption_invalid])
+        end
+      end
+    end
+
     describe "industry data" do
       context "for lodging" do
         it "accepts valid industry data" do
@@ -4270,7 +4305,7 @@ describe Braintree::Transaction do
         result.errors.for(:transaction).for(:external_vault).on(:status)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::StatusIsInvalid
       end
 
-      context "Visa/Mastercard/Discover" do
+      context "Visa/Mastercard/Discover/AmEx" do
         it "accepts status" do
           result = Braintree::Transaction.create(
             :type => "sale",
@@ -4322,12 +4357,12 @@ describe Braintree::Transaction do
         end
       end
 
-      context "Non-(Visa/Mastercard/Discover) card types" do
+      context "Non-(Visa/Mastercard/Discover/AmEx) card types" do
         it "accepts status" do
           result = Braintree::Transaction.create(
             :type => "sale",
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
+              :number => Braintree::Test::CreditCardNumbers::JCBs[0],
               :expiration_date => "05/2009"
             },
             :external_vault => {
@@ -4343,7 +4378,7 @@ describe Braintree::Transaction do
           result = Braintree::Transaction.create(
             :type => "sale",
             :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
+              :number => Braintree::Test::CreditCardNumbers::JCBs[0],
               :expiration_date => "05/2009"
             },
             :external_vault => {
@@ -4355,25 +4390,7 @@ describe Braintree::Transaction do
           result.success?.should == true
           result.transaction.network_transaction_id.should be_nil
         end
-
-        it "rejects previous_network_transaction_id" do
-          result = Braintree::Transaction.create(
-            :type => "sale",
-            :credit_card => {
-              :number => Braintree::Test::CreditCardNumbers::AmExes[0],
-              :expiration_date => "05/2009"
-            },
-            :external_vault => {
-              :status => Braintree::Transaction::ExternalVault::Status::Vaulted,
-              :previous_network_transaction_id => "123456789012345",
-            },
-            :amount => "10.00",
-          )
-          result.success?.should == false
-          result.errors.for(:transaction).for(:external_vault).on(:previous_network_transaction_id)[0].code.should == Braintree::ErrorCodes::Transaction::ExternalVault::CardTypeIsInvalid
-        end
       end
-
     end
 
     context "account_type" do
@@ -4959,6 +4976,73 @@ describe Braintree::Transaction do
       result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::AmountIsRequired
     end
 
+    it "validates currency_iso_code and creates transaction" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :currency_iso_code => "USD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == true
+      result.transaction.currency_iso_code == "USD"
+    end
+
+    it "validates currency_iso_code and returns error" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :currency_iso_code => "CAD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:currency_iso_code)[0].code.should == Braintree::ErrorCodes::Transaction::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
+    it "validates currency_iso_code and creates transaction with specified merchant account" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :currency_iso_code => "USD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == true
+      result.transaction.currency_iso_code == "USD"
+      result.transaction.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+    end
+
+    it "validates currency_iso_code and returns error with specified merchant account" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :currency_iso_code => "CAD",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          }
+        }
+      }
+      result = Braintree::Transaction.sale(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:currency_iso_code)[0].code.should == Braintree::ErrorCodes::Transaction::CurrencyCodeNotSupportedByMerchantAccount
+    end
+
     it "skips advanced fraud checking if transaction[options][skip_advanced_fraud_checking] is set to true" do
       with_advanced_fraud_integration_merchant do
         result = Braintree::Transaction.sale(
@@ -6789,4 +6873,91 @@ describe Braintree::Transaction do
       transaction.processed_with_network_token?.should == false
     end
   end
+
+  describe "installments" do
+    it "creates a transaction with an installment count" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.installment_count).to eq(12)
+    end
+
+    it "creates a transaction with a installments during capture" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+        :options => {
+          :submit_for_settlement => true,
+        },
+      )
+
+      expect(result.success?).to eq(true)
+      transaction = result.transaction
+      expect(transaction.installment_count).to eq(12)
+
+      installments = transaction.installments
+      expect(installments.map(&:id)).to match_array((1..12).map { |i| "#{transaction.id}_INST_#{i}" })
+      expect(installments.map(&:amount)).to match_array([BigDecimal("8.33")] * 11 + [BigDecimal("8.38")])
+    end
+
+    it "can refund a transaction with installments" do
+      sale_result = Braintree::Transaction.create(
+        :type => "sale",
+        :merchant_account_id => SpecHelper::CardProcessorBRLMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :amount => "100.01",
+        :installments => {
+          :count => 12,
+        },
+        :options => {
+          :submit_for_settlement => true,
+        },
+      )
+
+      expect(sale_result.success?).to eq(true)
+      sale_transaction = sale_result.transaction
+
+      refund_result = Braintree::Transaction.refund(sale_transaction.id, "49.99")
+
+      expect(refund_result.success?).to eq(true)
+      refund_transaction = refund_result.transaction
+      installments = refund_transaction.refunded_installments
+
+      (1..11).each do |i|
+        installment = installments.find { |installment| installment.id == "#{sale_transaction.id}_INST_#{i}" }
+
+        expect(installment.amount).to eq(BigDecimal("8.33"))
+        expect(installment.adjustments.map(&:amount)).to match_array([BigDecimal("-4.16")])
+        expect(installment.adjustments.map(&:kind)).to match_array([Braintree::Transaction::Installment::Adjustment::Kind::Refund])
+      end
+
+      installment = installments.find { |installment| installment.id == "#{sale_transaction.id}_INST_12" }
+
+      expect(installment.amount).to eq(BigDecimal("8.38"))
+      expect(installment.adjustments.map(&:amount)).to match_array([BigDecimal("-4.23")])
+      expect(installment.adjustments.map(&:kind)).to match_array([Braintree::Transaction::Installment::Adjustment::Kind::Refund])
+    end
+  end
 end

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -14,7 +14,8 @@ describe Braintree::Transaction do
         let(:plaid_nonce) { generate_valid_plaid_us_bank_account_nonce }
 
         context "nonce" do
-          it "sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "sale succeeds" do
             result = Braintree::Transaction.create(
               :type => "sale",
               :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -41,7 +42,8 @@ describe Braintree::Transaction do
         end
 
         context "token" do
-          it "payment_method#create then sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "payment_method#create then sale succeeds" do
             payment_method = Braintree::PaymentMethod.create(
               :payment_method_nonce => plaid_nonce,
               :customer_id => Braintree::Customer.create.customer.id,
@@ -84,7 +86,8 @@ describe Braintree::Transaction do
             transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
           end
 
-          it "transaction#create store_in_vault then sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "transaction#create store_in_vault then sale succeeds" do
             result = Braintree::Transaction.create(
               :type => "sale",
               :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -233,7 +236,8 @@ describe Braintree::Transaction do
         let(:plaid_nonce) { generate_valid_plaid_us_bank_account_nonce }
 
         context "nonce" do
-          it "sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "sale succeeds" do
             result = Braintree::Transaction.create(
               :type => "sale",
               :amount => Braintree::Test::TransactionAmounts::Authorize,
@@ -260,7 +264,8 @@ describe Braintree::Transaction do
         end
 
         context "token" do
-          it "payment_method#create then sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "payment_method#create then sale succeeds" do
             result = Braintree::PaymentMethod.create(
               :payment_method_nonce => plaid_nonce,
               :customer_id => Braintree::Customer.create.customer.id,
@@ -305,7 +310,8 @@ describe Braintree::Transaction do
             transaction.us_bank_account_details.ach_mandate.accepted_at.should be_a Time
           end
 
-          it "transaction#create store_in_vault then sale succeeds" do
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "transaction#create store_in_vault then sale succeeds" do
             result = Braintree::Transaction.create(
               :type => "sale",
               :amount => Braintree::Test::TransactionAmounts::Authorize,

data/spec/spec_helper.rb

@@ -39,6 +39,7 @@ unless defined?(SPEC_HELPER_LOADED)
     AnotherUsBankMerchantAccountId = "another_us_bank_merchant_account"
     AdyenMerchantAccountId = "adyen_ma"
     HiperBRLMerchantAccountId = "hiper_brl"
+    CardProcessorBRLMerchantAccountId = "card_processor_brl"
 
     TrialPlan = {
       :description => "Plan for integration tests -- with trial",

data/spec/unit/braintree/credit_card_spec.rb

@@ -24,7 +24,7 @@ describe Braintree::CreditCard do
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code]},
         {:billing_address => [
           :company,
           :country_code_alpha2,
@@ -70,7 +70,7 @@ describe Braintree::CreditCard do
         :device_data,
         :payment_method_nonce,
         {:external_vault=>[:network_transaction_id]},
-        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+        {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code]},
         {:billing_address => [
           :company,
           :country_code_alpha2,

data/spec/unit/braintree/customer_spec.rb

@@ -100,7 +100,7 @@ describe Braintree::Customer do
           :device_data,
           :payment_method_nonce,
           {:external_vault=>[:network_transaction_id]},
-          {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type]},
+          {:options => [:make_default, :verification_merchant_account_id, :verify_card, :verification_amount, :venmo_sdk_session, :fail_on_duplicate_payment_method, :verification_account_type, :verification_currency_iso_code]},
           {:billing_address => [
             :company,
             :country_code_alpha2,
@@ -197,6 +197,7 @@ describe Braintree::Customer do
             :venmo_sdk_session,
             :fail_on_duplicate_payment_method,
             :verification_account_type,
+            :verification_currency_iso_code,
             :update_existing_token
           ]},
           {:billing_address => [

data/spec/unit/braintree/resource_collection_spec.rb

@@ -18,6 +18,35 @@ describe "Braintree::ResourceCollection" do
     end
   end
 
+  describe "#first" do
+    it 'returns nil with no results' do
+      values = %w(a b c d e)
+      collection = Braintree::ResourceCollection.new(:search_results => {:ids => [], :page_size => 2}) do |ids|
+        ids.map {|id| values[id] }
+      end
+
+      collection.first.should == nil
+    end
+
+    context 'with results' do
+      let(:collection) do
+        values = %w(a b c d e)
+
+        Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2}) do |ids|
+          ids.map {|id| values[id] }
+        end
+      end
+
+      it 'returns the first occourence' do
+        collection.first.should == 'a'
+      end
+
+      it 'returns the first N occourences' do
+        collection.first(4).should == ['a','b','c','d']
+      end
+    end
+  end
+
   describe "#ids" do
     it "returns a list of the resource collection ids" do
       collection = Braintree::ResourceCollection.new(:search_results => {:ids => [0,1,2,3,4], :page_size => 2})

data/spec/unit/braintree/transaction/installment_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+describe Braintree::Transaction::Installment do
+  describe "inspect" do
+    it "assigns all fields" do
+      adjustment_attributes = {
+        :amount => "0.98",
+        :kind => "REFUND",
+        :projected_disbursement_date => "2020-01-03 01:02:03Z",
+        :actual_disbursement_date => "2020-01-04 01:02:03Z",
+      }
+      installment_attributes = {
+        :id => "abc123",
+        :amount => "1.23",
+        :projected_disbursement_date => "2020-01-01 01:02:03Z",
+        :actual_disbursement_date => "2020-01-02 01:02:03Z",
+        :adjustments => [adjustment_attributes],
+      }
+
+      installment = Braintree::Transaction::Installment.new(installment_attributes)
+
+      expect(installment.inspect).to eq('#<id: "abc123", amount: 0.123e1, projected_disbursement_date: "2020-01-01 01:02:03Z", actual_disbursement_date: "2020-01-02 01:02:03Z", adjustments: [#<amount: 0.98e0, kind: "REFUND", projected_disbursement_date: "2020-01-03 01:02:03Z", actual_disbursement_date: "2020-01-04 01:02:03Z">]>')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: braintree
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Braintree
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-09 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -157,6 +157,8 @@ files:
 - lib/braintree/transaction/customer_details.rb
 - lib/braintree/transaction/disbursement_details.rb
 - lib/braintree/transaction/google_pay_details.rb
+- lib/braintree/transaction/installment.rb
+- lib/braintree/transaction/installment/adjustment.rb
 - lib/braintree/transaction/local_payment_details.rb
 - lib/braintree/transaction/paypal_details.rb
 - lib/braintree/transaction/paypal_here_details.rb
@@ -279,6 +281,7 @@ files:
 - spec/unit/braintree/transaction/credit_card_details_spec.rb
 - spec/unit/braintree/transaction/customer_details_spec.rb
 - spec/unit/braintree/transaction/deposit_details_spec.rb
+- spec/unit/braintree/transaction/installment_spec.rb
 - spec/unit/braintree/transaction/paypal_details_spec.rb
 - spec/unit/braintree/transaction_search_spec.rb
 - spec/unit/braintree/transaction_spec.rb