braintree 2.69.1 → 2.70.0

data/README.rdoc

@@ -90,4 +90,4 @@ your system. To run unit tests use rake: <tt>rake test:unit</tt>.
 
 == License
 
-See the [LICENSE](LICENSE) file for more info.
+See the LICENSE[https://github.com/braintree/braintree_ruby/blob/master/LICENSE] file for more info.

data/lib/braintree.rb

@@ -55,6 +55,9 @@ require "braintree/error_result"
 require "braintree/errors"
 require "braintree/gateway"
 require "braintree/http"
+require "braintree/ideal_payment"
+require "braintree/ideal_payment_gateway"
+require "braintree/transaction/ideal_payment_details"
 require "braintree/merchant"
 require "braintree/merchant_gateway"
 require "braintree/merchant_account"

data/lib/braintree/error_codes.rb

@@ -290,6 +290,8 @@ module Braintree
       CustomerDoesNotHaveCreditCard = "91511"
       CustomerIdIsInvalid = "91510"
       HasAlreadyBeenRefunded = "91512"
+      IdealPaymentNotComplete = "815141"
+      IdealPaymentAlreadyConsumed = "815142"
       MerchantAccountDoesNotMatch3DSecureMerchantAccount = "91584"
       MerchantAccountDoesNotSupportMOTO = "91558"
       MerchantAccountDoesNotSupportRefunds = "91547"
@@ -401,6 +403,12 @@ module Braintree
       InconsistentCountry = "93612"
       PaymentMethodsAreInvalid = "93613"
       PaymentMethodsAreNotAllowed = "93615"
+      MerchantAccountExistsForCurrency = "93616"
+      CurrencyIsRequired = "93617"
+      CurrencyIsInvalid = "93618"
+      NoMerchantAccounts = "93619"
+      MerchantAccountExistsForId = "93620"
+      MerchantAccountNotAuthOnboarded = "93621"
     end
 
     module MerchantAccount

data/lib/braintree/gateway.rb

@@ -60,6 +60,10 @@ module Braintree
       UsBankAccountGateway.new(self)
     end
 
+    def ideal_payment
+      IdealPaymentGateway.new(self)
+    end
+
     def merchant
       MerchantGateway.new(self)
     end

data/lib/braintree/ideal_payment.rb

@@ -0,0 +1,46 @@
+module Braintree
+  class IdealPayment
+    include BaseModule
+
+    attr_reader :id, :ideal_transaction_id, :currency, :amount, :status, :order_id, :issuer, :approval_url, :iban_bank_account
+
+    def initialize(gateway, attributes) # :nodoc:
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes)
+      @iban_bank_account = IbanBankAccount.new(attributes[:iban_bank_account])
+    end
+
+    class << self
+      protected :new
+    end
+
+    def self._new(*args) # :nodoc:
+      self.new *args
+    end
+
+    def self.sale(ideal_payment_id, transaction_attributes)
+      Configuration.gateway.transaction.sale(transaction_attributes.merge(
+            :payment_method_nonce => ideal_payment_id,
+            :options => { :submit_for_settlement => true }
+          )
+        )
+    end
+
+    def self.sale!(ideal_payment_id, transaction_attributes)
+      return_object_or_raise(:transaction) { sale(ideal_payment_id, transaction_attributes) }
+    end
+
+    def self.find(ideal_payment_id)
+      Configuration.gateway.ideal_payment.find(ideal_payment_id)
+    end
+
+    class IbanBankAccount
+      include BaseModule
+      attr_reader :account_holder_name, :bic, :masked_iban, :iban_account_number_last_4, :iban_country, :description
+
+      def initialize(attributes) # :nodoc:
+        set_instance_variables_from_hash(attributes)
+      end
+    end
+  end
+end

data/lib/braintree/ideal_payment_gateway.rb

@@ -0,0 +1,18 @@
+module Braintree
+  class IdealPaymentGateway
+    def initialize(gateway)
+      @gateway = gateway
+      @config = gateway.config
+      @config.assert_has_access_token_or_keys
+    end
+
+    def find(ideal_payment_id)
+      raise ArgumentError if ideal_payment_id.nil? || ideal_payment_id.to_s.strip == ""
+      response = @config.http.get("#{@config.base_merchant_path}/ideal_payments/#{ideal_payment_id}")
+      IdealPayment._new(@gateway, response[:ideal_payment])
+    rescue NotFoundError
+      raise NotFoundError, "ideal payment with ideal_payment_id #{ideal_payment_id.inspect} not found"
+    end
+
+  end
+end

data/lib/braintree/merchant_account_gateway.rb

@@ -25,6 +25,10 @@ module Braintree
       _do_update "/merchant_accounts/#{merchant_account_id}/update_via_api", :merchant_account => attributes
     end
 
+    def create_for_currency(params)
+      _create_for_currency(params)
+    end
+
     def _do_create(path, params=nil) # :nodoc:
       response = @config.http.post("#{@config.base_merchant_path}#{path}", params)
       if response[:api_error_response]
@@ -43,6 +47,20 @@ module Braintree
       end
     end
 
+    def _create_for_currency(params)
+      response = @config.http.post("#{@config.base_merchant_path}/merchant_accounts/create_for_currency", :merchant_account => params)
+
+      if response.has_key?(:response) && response[:response][:merchant_account]
+        Braintree::SuccessfulResult.new(
+          :merchant_account => MerchantAccount._new(@gateway, response[:response][:merchant_account])
+        )
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :merchant or :api_error_response"
+      end
+    end
+
     def self._detect_signature(attributes)
       if attributes.has_key?(:applicant_details)
         warn "[DEPRECATED] Passing :applicant_details to create is deprecated. Please use :individual, :business, and :funding."

data/lib/braintree/payment_instrument_type.rb

@@ -8,5 +8,6 @@ module Braintree
     AndroidPayCard = 'android_pay_card'
     VenmoAccount = 'venmo_account'
     UsBankAccount = 'us_bank_account'
+    IdealPayment = 'ideal_payment'
   end
 end

data/lib/braintree/payment_method.rb

@@ -14,8 +14,8 @@ module Braintree
       Configuration.gateway.payment_method.update(token, attributes)
     end
 
-    def self.delete(token)
-      Configuration.gateway.payment_method.delete(token)
+    def self.delete(token, options = {})
+      Configuration.gateway.payment_method.delete(token, options)
     end
 
     def self.grant(token, options = {})

data/lib/braintree/payment_method_gateway.rb

@@ -43,9 +43,11 @@ module Braintree
         raise UnexpectedError, "expected :payment_method or :api_error_response"
       end
     end
-
-    def delete(token)
-      @config.http.delete("#{@config.base_merchant_path}/payment_methods/any/#{token}")
+    
+    def delete(token, options = {})
+      Util.verify_keys(PaymentMethodGateway._delete_signature, options)
+      query_param = "?" + Util.hash_to_query_string(options) if not options.empty?
+      @config.http.delete("#{@config.base_merchant_path}/payment_methods/any/#{token}#{query_param}")
       SuccessfulResult.new
     end
 
@@ -135,6 +137,10 @@ module Braintree
     def self._update_signature # :nodoc:
       _signature(:update)
     end
+        
+    def self._delete_signature # :nodoc:
+      [:revoke_all_grants]
+    end
 
     def self._signature(type) # :nodoc:
       billing_address_params = AddressGateway._shared_signature

data/lib/braintree/transaction.rb

@@ -123,6 +123,7 @@ module Braintree
     attr_reader :facilitator_details
     attr_reader :three_d_secure_info
     attr_reader :us_bank_account_details
+    attr_reader :ideal_payment_details
 
     def self.create(attributes)
       Configuration.gateway.transaction.create(attributes)
@@ -269,6 +270,7 @@ module Braintree
       @facilitator_details = FacilitatorDetails.new(attributes[:facilitator_details]) if attributes[:facilitator_details]
       @three_d_secure_info = ThreeDSecureInfo.new(attributes[:three_d_secure_info]) if attributes[:three_d_secure_info]
       @us_bank_account_details = UsBankAccountDetails.new(attributes[:us_bank_account]) if attributes[:us_bank_account]
+      @ideal_payment_details = IdealPaymentDetails.new(attributes[:ideal_payment]) if attributes[:ideal_payment]
     end
 
     # True if <tt>other</tt> is a Braintree::Transaction with the same id.

data/lib/braintree/transaction/ideal_payment_details.rb

@@ -0,0 +1,13 @@
+module Braintree
+  class Transaction
+    class IdealPaymentDetails # :nodoc:
+      include BaseModule
+
+      attr_reader :ideal_payment_id, :ideal_transaction_id, :masked_iban, :bic, :image_url
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/transaction/paypal_details.rb

@@ -5,7 +5,7 @@ module Braintree
 
       attr_reader :custom_field, :payer_email, :payment_id, :authorization_id, :token,
         :image_url, :debug_id, :payee_email, :payer_id, :payer_first_name, :payer_last_name,
-        :seller_protection_status, :capture_id, :refund_id, :transaction_fee_amount,
+        :payer_status, :seller_protection_status, :capture_id, :refund_id, :transaction_fee_amount,
         :transaction_fee_currency_iso_code, :description
 
       def initialize(attributes)

data/lib/braintree/transaction_gateway.rb

@@ -170,6 +170,7 @@ module Braintree
           :store_shipping_address_in_vault,
           :venmo_sdk_session,
           :payee_email,
+          :skip_advanced_fraud_checking,
           :skip_avs,
           :skip_cvv,
           {:paypal => [:custom_field, :payee_email, :description, {:supplementary_data => :_any_key_}]},

data/lib/braintree/version.rb

@@ -1,8 +1,8 @@
 module Braintree
   module Version
     Major = 2
-    Minor = 69
-    Tiny = 1
+    Minor = 70
+    Tiny = 0
 
     String = "#{Major}.#{Minor}.#{Tiny}"
   end

data/spec/httpsd.pid

@@ -1 +1 @@
-31391
+2857

data/spec/integration/braintree/client_api/spec_helper.rb

@@ -59,6 +59,7 @@ end
 def generate_valid_us_bank_account_nonce()
   raw_client_token = Braintree::ClientToken.generate
   client_token = decode_client_token(raw_client_token)
+
   url = client_token["braintree_api"]["url"] + "/tokens"
   token = client_token["braintree_api"]["access_token"]
   payload = {
@@ -70,7 +71,7 @@ def generate_valid_us_bank_account_nonce()
       :postal_code => "94112"
     },
     :account_type => "checking",
-    :routing_number => "123456789",
+    :routing_number => "021000021",
     :account_number => "567891234",
     :account_holder_name => "Dan Schulman",
     :account_description => "PayPal Checking - 1234",
@@ -79,20 +80,25 @@ def generate_valid_us_bank_account_nonce()
     }
   }
 
-  uri = URI::parse(url)
-  connection = Net::HTTP.new(uri.host, uri.port)
-  connection.use_ssl = true
-  connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
-  resp = connection.start do |http|
-    request = Net::HTTP::Post.new(uri.path)
-    request["Content-Type"] = "application/json"
-    request["Braintree-Version"] = "2015-11-01"
-    request["Authorization"] = "Bearer #{token}"
-    request.body = payload.to_json
-    http.request(request)
-  end
+  json = _cosmos_post(token, url, payload)
+  json["data"]["id"]
+end
 
-  json = JSON.parse(resp.body)
+def generate_valid_ideal_payment_nonce(amount = Braintree::Test::TransactionAmounts::Authorize)
+  raw_client_token = Braintree::ClientToken.generate
+  client_token = decode_client_token(raw_client_token)
+
+  token = client_token["braintree_api"]["access_token"]
+  url = client_token["braintree_api"]["url"] + "/ideal-payments"
+  payload = {
+    :issuer => "RABONL2U",
+    :order_id => SpecHelper::DefaultOrderId,
+    :amount => amount,
+    :currency => "EUR",
+    :redirect_url => "https://braintree-api.com",
+  }
+
+  json = _cosmos_post(token, url, payload)
   json["data"]["id"]
 end
 
@@ -107,6 +113,23 @@ def generate_invalid_us_bank_account_nonce
   nonce += "_xxx"
 end
 
+def _cosmos_post(token, url, payload)
+  uri = URI::parse(url)
+  connection = Net::HTTP.new(uri.host, uri.port)
+  connection.use_ssl = true
+  connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+  resp = connection.start do |http|
+    request = Net::HTTP::Post.new(uri.path)
+    request["Content-Type"] = "application/json"
+    request["Braintree-Version"] = "2015-11-01"
+    request["Authorization"] = "Bearer #{token}"
+    request.body = payload.to_json
+    http.request(request)
+  end
+
+  JSON.parse(resp.body)
+end
+
 class ClientApiHttp
   attr_reader :config, :options
 

data/spec/integration/braintree/customer_spec.rb

@@ -910,12 +910,12 @@ describe Braintree::Customer do
 
       us_bank_account = found_customer.us_bank_accounts.first
       us_bank_account.should be_a(Braintree::UsBankAccount)
-      us_bank_account.routing_number.should == "123456789"
+      us_bank_account.routing_number.should == "021000021"
       us_bank_account.last_4.should == "1234"
       us_bank_account.account_type.should == "checking"
       us_bank_account.account_description.should == "PayPal Checking - 1234"
       us_bank_account.account_holder_name.should == "Dan Schulman"
-      us_bank_account.bank_name.should == "UNKNOWN"
+      us_bank_account.bank_name.should =~ /CHASE/
     end
 
     it "works for a blank customer" do

data/spec/integration/braintree/ideal_payment_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::IdealPayment do
+  context "self.sale" do
+    it "creates a transaction using an Ideal payment token and returns a result object" do
+      ideal_payment_id = generate_valid_ideal_payment_nonce
+
+      result = Braintree::IdealPayment.sale(
+        ideal_payment_id,
+        :order_id => SpecHelper::DefaultOrderId,
+        :merchant_account_id => "ideal_merchant_account",
+        :amount => Braintree::Test::TransactionAmounts::Authorize
+      )
+
+      result.success?.should == true
+      result.transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
+      result.transaction.type.should == "sale"
+      ideal_payment_details = result.transaction.ideal_payment_details
+      ideal_payment_details.ideal_payment_id.should =~ /^idealpayment_\w{6,}$/
+      ideal_payment_details.ideal_transaction_id.should =~ /^\d{16,}$/
+      ideal_payment_details.image_url.should start_with("https://")
+      ideal_payment_details.masked_iban.should_not be_empty
+      ideal_payment_details.bic.should_not be_empty
+    end
+  end
+
+  context "self.sale!" do
+    it "creates a transaction using an ideal payment and returns a result object" do
+      ideal_payment_id = generate_valid_ideal_payment_nonce
+
+      transaction = Braintree::IdealPayment.sale!(
+        ideal_payment_id,
+        :order_id => SpecHelper::DefaultOrderId,
+        :merchant_account_id => "ideal_merchant_account",
+        :amount => Braintree::Test::TransactionAmounts::Authorize
+      )
+
+      transaction.amount.should == BigDecimal.new(Braintree::Test::TransactionAmounts::Authorize)
+      transaction.type.should == "sale"
+      ideal_payment_details = transaction.ideal_payment_details
+      ideal_payment_details.ideal_payment_id.should =~ /^idealpayment_\w{6,}$/
+      ideal_payment_details.ideal_transaction_id.should =~ /^\d{16,}$/
+      ideal_payment_details.image_url.should start_with("https://")
+      ideal_payment_details.masked_iban.should_not be_empty
+      ideal_payment_details.bic.should_not be_empty
+    end
+
+    it "does not create a transaction using an ideal payment and returns raises an exception" do
+      expect do
+        Braintree::IdealPayment.sale!(
+          "invalid_nonce",
+          :merchant_account_id => "ideal_merchant_account",
+          :amount => Braintree::Test::TransactionAmounts::Authorize
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  context "self.find" do
+    it "finds the Ideal payment with an id" do
+      ideal_payment_id = generate_valid_ideal_payment_nonce
+      ideal_payment = Braintree::IdealPayment.find(ideal_payment_id)
+
+      ideal_payment.id.should =~ /^idealpayment_\w{6,}$/
+      ideal_payment.ideal_transaction_id.should =~ /^\d{16,}$/
+      ideal_payment.currency.should_not be_empty
+      ideal_payment.amount.should_not be_empty
+      ideal_payment.status.should_not be_empty
+      ideal_payment.order_id.should_not be_empty
+      ideal_payment.issuer.should_not be_empty
+      ideal_payment.approval_url.should start_with("https://")
+      ideal_payment.iban_bank_account.account_holder_name.should_not be_empty
+      ideal_payment.iban_bank_account.bic.should_not be_empty
+      ideal_payment.iban_bank_account.masked_iban.should_not be_empty
+      ideal_payment.iban_bank_account.iban_account_number_last_4.should =~ /^\d{4}$/
+      ideal_payment.iban_bank_account.iban_country.should_not be_empty
+      ideal_payment.iban_bank_account.description.should_not be_empty
+    end
+
+    it "raises if the Ideal payment is not found" do
+      expect do
+        Braintree::IdealPayment.find("idealpayment_nxyqkq_s654wq_92jr64_mnr4kr_yjz")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+end

data/spec/integration/braintree/merchant_account_spec.rb

@@ -135,6 +135,109 @@ describe Braintree::MerchantAccount do
     end
   end
 
+  describe "create_for_currency" do
+    it "creates a new merchant account for currency" do
+      result = SpecHelper::create_merchant
+      result.should be_success
+
+      gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant_account.create_for_currency(
+        :currency => "JPY"
+      )
+      result.should be_success
+      result.merchant_account.currency_iso_code.should == "JPY"
+    end
+
+    it "returns error if a merchant account already exists for that currency" do
+      result = SpecHelper::create_merchant
+      result.should be_success
+
+      gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant_account.create_for_currency(
+        :currency => "USD"
+      )
+      result.should be_success
+
+      result = gateway.merchant_account.create_for_currency(
+        :currency => "USD"
+      )
+      result.should_not be_success
+
+      errors = result.errors.for(:merchant).on(:currency)
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::MerchantAccountExistsForCurrency
+    end
+
+    it "returns error if no currency is provided" do
+      result = SpecHelper::create_merchant
+      result.should be_success
+
+      gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant_account.create_for_currency(
+        :currency => nil
+      )
+      result.should_not be_success
+
+      errors = result.errors.for(:merchant).on(:currency)
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsRequired
+
+      result = gateway.merchant_account.create_for_currency({})
+      result.should_not be_success
+
+      errors = result.errors.for(:merchant).on(:currency)
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsRequired
+    end
+
+    it "returns error if a currency is not supported" do
+      result = SpecHelper::create_merchant
+      result.should be_success
+
+      gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant_account.create_for_currency(
+        :currency => "FAKE_CURRENCY"
+      )
+      result.should_not be_success
+
+      errors = result.errors.for(:merchant).on(:currency)
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::CurrencyIsInvalid
+    end
+
+    it "returns error if id is passed and already taken" do
+      result = SpecHelper::create_merchant
+      result.should be_success
+
+      gateway = Braintree::Gateway.new(
+        :access_token => result.credentials.access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      merchant = result.merchant
+      result = gateway.merchant_account.create_for_currency(
+        :currency => "USD",
+        :id => merchant.merchant_accounts.first.id
+      )
+      result.should_not be_success
+
+      errors = result.errors.for(:merchant).on(:id)
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::MerchantAccountExistsForId
+    end
+  end
+
   describe "find" do
     it "finds the merchant account with the given token" do
       result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)