braintree 2.45.0 → 2.46.0

data/lib/braintree.rb

@@ -32,6 +32,7 @@ require "braintree/client_token"
 require "braintree/client_token_gateway"
 require "braintree/coinbase_account"
 require "braintree/configuration"
+require "braintree/credentials_parser"
 require "braintree/credit_card"
 require "braintree/credit_card_gateway"
 require "braintree/credit_card_verification"
@@ -51,12 +52,16 @@ require "braintree/error_result"
 require "braintree/errors"
 require "braintree/gateway"
 require "braintree/http"
+require "braintree/merchant"
+require "braintree/merchant_gateway"
 require "braintree/merchant_account"
 require "braintree/merchant_account_gateway"
 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/oauth_gateway"
+require "braintree/oauth_credentials"
 require "braintree/payment_instrument_type"
 require "braintree/payment_method"
 require "braintree/payment_method_gateway"

data/lib/braintree/add_on_gateway.rb

@@ -3,10 +3,11 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def all
-      response = @config.http.get "/add_ons"
+      response = @config.http.get("#{@config.base_merchant_path}/add_ons")
       attributes_collection = response[:add_ons]
       attributes_collection.map do |attributes|
         AddOn._new(attributes)

data/lib/braintree/address_gateway.rb

@@ -3,6 +3,7 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def create(attributes)
@@ -13,7 +14,7 @@ module Braintree
       unless attributes[:customer_id] =~ /\A[0-9A-Za-z_-]+\z/
         raise ArgumentError, ":customer_id contains invalid characters"
       end
-      response = @config.http.post "/customers/#{attributes.delete(:customer_id)}/addresses", :address => attributes
+      response = @config.http.post("#{@config.base_merchant_path}/customers/#{attributes.delete(:customer_id)}/addresses", :address => attributes)
       if response[:address]
         SuccessfulResult.new(:address => Address._new(@gateway, response[:address]))
       elsif response[:api_error_response]
@@ -25,14 +26,14 @@ module Braintree
 
     def delete(customer_or_customer_id, address_id)
       customer_id = _determine_customer_id(customer_or_customer_id)
-      @config.http.delete("/customers/#{customer_id}/addresses/#{address_id}")
+      @config.http.delete("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}")
       SuccessfulResult.new
     end
 
     def find(customer_or_customer_id, address_id)
       customer_id = _determine_customer_id(customer_or_customer_id)
       raise ArgumentError if address_id.nil? || address_id.to_s.strip == ""
-      response = @config.http.get("/customers/#{customer_id}/addresses/#{address_id}")
+      response = @config.http.get("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}")
       Address._new(@gateway, response[:address])
     rescue NotFoundError
       raise NotFoundError, "address for customer #{customer_id.inspect} with id #{address_id.inspect} not found"
@@ -41,7 +42,7 @@ module Braintree
     def update(customer_or_customer_id, address_id, attributes)
       Util.verify_keys(AddressGateway._update_signature, attributes)
       customer_id = _determine_customer_id(customer_or_customer_id)
-      response = @config.http.put "/customers/#{customer_id}/addresses/#{address_id}", :address => attributes
+      response = @config.http.put("#{@config.base_merchant_path}/customers/#{customer_id}/addresses/#{address_id}", :address => attributes)
       if response[:address]
         SuccessfulResult.new(:address => Address._new(@gateway, response[:address]))
       elsif response[:api_error_response]

data/lib/braintree/client_token_gateway.rb

@@ -3,6 +3,7 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def generate(options={})
@@ -11,7 +12,7 @@ module Braintree
         Util.verify_keys(ClientTokenGateway._generate_signature, options)
         params = {:client_token => options}
       end
-      result = @config.http.post("/client_token", params)
+      result = @config.http.post("#{@config.base_merchant_path}/client_token", params)
 
       if result[:client_token]
         result[:client_token][:value]

data/lib/braintree/configuration.rb

@@ -7,6 +7,9 @@ module Braintree
       :merchant_id,
       :public_key,
       :private_key,
+      :client_id,
+      :client_secret,
+      :access_token,
     ]
 
     WRITABLE_ATTRIBUTES = [
@@ -30,7 +33,7 @@ module Braintree
       attributes.each do |attribute|
         (class << self; self; end).send(:define_method, attribute) do
           attribute_value = instance_variable_get("@#{attribute}")
-          raise ConfigurationError.new(attribute.to_s, "needs to be set") unless attribute_value
+          raise ConfigurationError.new("Braintree::Configuration.#{attribute.to_s} needs to be set") unless attribute_value
           attribute_value
         end
       end
@@ -88,7 +91,36 @@ module Braintree
         instance_variable_set "@#{attr}", options[attr]
       end
 
-      @merchant_id = options[:merchant_id] || options[:partner_id]
+      _check_for_mixed_credentials(options)
+
+      parser = Braintree::CredentialsParser.new
+      if options[:client_id] || options[:client_secret]
+        parser.parse_client_credentials(options[:client_id], options[:client_secret])
+        @client_id = parser.client_id
+        @client_secret = parser.client_secret
+        @environment = parser.environment
+      elsif options[:access_token]
+        parser.parse_access_token(options[:access_token])
+        @access_token = parser.access_token
+        @environment = parser.environment
+        @merchant_id = parser.merchant_id
+      else
+        @merchant_id = options[:merchant_id] || options[:partner_id]
+      end
+    end
+
+    def _check_for_mixed_credentials(options)
+      if (options[:client_id] || options[:client_secret]) && (options[:public_key] || options[:private_key])
+        raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: client_id and client_secret mixed with public_key and private_key.")
+      end
+
+      if (options[:client_id] || options[:client_secret]) && (options[:access_token])
+        raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: client_id and client_secret mixed with access_token.")
+      end
+
+      if (options[:public_key] || options[:private_key]) && (options[:access_token])
+        raise ConfigurationError.new("Braintree::Gateway cannot be initialized with mixed credential types: public_key and private_key mixed with access_token.")
+      end
     end
 
     def api_version # :nodoc:
@@ -99,8 +131,12 @@ module Braintree
       "/merchants/#{merchant_id}"
     end
 
+    def base_url
+      "#{protocol}://#{server}:#{port}"
+    end
+
     def base_merchant_url # :nodoc:
-      "#{protocol}://#{server}:#{port}#{base_merchant_path}"
+      "#{base_url}#{base_merchant_path}"
     end
 
     def ca_file # :nodoc:
@@ -121,7 +157,7 @@ module Braintree
 
     def port # :nodoc:
       case @environment
-      when :development
+      when :development, :integration
         ENV['GATEWAY_PORT'] || 3000
       when :production, :qa, :sandbox
         443
@@ -142,7 +178,7 @@ module Braintree
 
     def server # :nodoc:
       case @environment
-      when :development
+      when :development, :integration
         "localhost"
       when :production
         "#{endpoint}.braintreegateway.com"
@@ -155,7 +191,7 @@ module Braintree
 
     def auth_url
       case @environment
-      when :development
+      when :development, :integration
         "http://auth.venmo.dev:9292"
       when :production
         "https://auth.venmo.com"
@@ -168,7 +204,7 @@ module Braintree
 
     def ssl? # :nodoc:
       case @environment
-      when :development
+      when :development, :integration
         false
       when :production, :qa, :sandbox
         true
@@ -190,6 +226,22 @@ module Braintree
       super.gsub(/@private_key=\".*\"/, '@private_key="[FILTERED]"')
     end
 
+    def client_credentials?
+      !client_id.nil?
+    end
+
+    def assert_has_client_credentials
+      if client_id.nil? || client_secret.nil?
+        raise ConfigurationError.new("Braintree::Gateway client_id and client_secret are required.")
+      end
+    end
+
+    def assert_has_access_token_or_keys
+      if (public_key.nil? || private_key.nil?) && access_token.nil?
+        raise ConfigurationError.new("Braintree::Gateway public_key and private_key are required.")
+      end
+    end
+
     def signature_service
       @signature_service ||= SignatureService.new(@private_key)
     end

data/lib/braintree/credentials_parser.rb

@@ -0,0 +1,40 @@
+module Braintree
+  class CredentialsParser
+    attr_reader :client_id, :client_secret, :access_token, :environment, :merchant_id
+
+    def parse_client_credentials(client_id, client_secret)
+      raise ConfigurationError.new("Missing client_id when constructing Braintree::Gateway") if client_id.nil?
+      raise ConfigurationError.new("Value passed for client_id is not a client_id") unless client_id.start_with?("client_id")
+
+      raise ConfigurationError.new("Missing client_secret when constructing Braintree::Gateway") if client_secret.nil?
+      raise ConfigurationError.new("Value passed for client_secret is not a client_secret") unless client_secret.start_with?("client_secret")
+      client_id_environment = parse_environment(client_id)
+      client_secret_environment = parse_environment(client_secret)
+
+      if client_id_environment != client_secret_environment
+        raise ConfigurationError.new("Mismatched credential environments: client_id environment is #{client_id_environment} and client_secret environment is #{client_secret_environment}")
+      end
+
+      @client_id = client_id
+      @client_secret = client_secret
+      @environment = client_id_environment
+    end
+
+    def parse_access_token(access_token)
+      raise ConfigurationError.new("Missing access_token when constructing Braintree::Gateway") if access_token.nil?
+      raise ConfigurationError.new("Value passed for access_token is not a valid access_token") unless access_token.start_with?("access_token")
+
+      @access_token = access_token
+      @environment = parse_environment(access_token)
+      @merchant_id = parse_merchant_id(access_token)
+    end
+
+    def parse_environment(credential)
+      credential.split("$")[1].to_sym
+    end
+
+    def parse_merchant_id(access_token)
+      access_token.split("$")[2]
+    end
+  end
+end

data/lib/braintree/credit_card_gateway.rb

@@ -3,6 +3,7 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def create(attributes)
@@ -25,24 +26,24 @@ module Braintree
     end
 
     def delete(token)
-      @config.http.delete("/payment_methods/credit_card/#{token}")
+      @config.http.delete("#{@config.base_merchant_path}/payment_methods/credit_card/#{token}")
     end
 
     def expired(options = {})
-      response = @config.http.post("/payment_methods/all/expired_ids")
+      response = @config.http.post("#{@config.base_merchant_path}/payment_methods/all/expired_ids")
       ResourceCollection.new(response) { |ids| _fetch_expired(ids) }
     end
 
     def expiring_between(start_date, end_date, options = {})
       formatted_start_date = start_date.strftime('%m%Y')
       formatted_end_date = end_date.strftime('%m%Y')
-      response = @config.http.post("/payment_methods/all/expiring_ids?start=#{formatted_start_date}&end=#{formatted_end_date}")
+      response = @config.http.post("#{@config.base_merchant_path}/payment_methods/all/expiring_ids?start=#{formatted_start_date}&end=#{formatted_end_date}")
       ResourceCollection.new(response) { |ids| _fetch_expiring_between(formatted_start_date, formatted_end_date, ids) }
     end
 
     def find(token)
       raise ArgumentError if token.nil? || token.to_s.strip == ""
-      response = @config.http.get "/payment_methods/credit_card/#{token}"
+      response = @config.http.get("#{@config.base_merchant_path}/payment_methods/credit_card/#{token}")
       CreditCard._new(@gateway, response[:credit_card])
     rescue NotFoundError
       raise NotFoundError, "payment method with token #{token.inspect} not found"
@@ -50,7 +51,7 @@ module Braintree
 
     def from_nonce(nonce)
       raise ArgumentError if nonce.nil? || nonce.to_s.strip == ""
-      response = @config.http.get "/payment_methods/from_nonce/#{nonce}"
+      response = @config.http.get("#{@config.base_merchant_path}/payment_methods/from_nonce/#{nonce}")
       CreditCard._new(@gateway, response[:credit_card])
     rescue NotFoundError
       raise NotFoundError, "nonce #{nonce.inspect} locked, consumed, or not found"
@@ -106,8 +107,8 @@ module Braintree
       return signature
     end
 
-    def _do_create(url, params=nil) # :nodoc:
-      response = @config.http.post url, params
+    def _do_create(path, params=nil) # :nodoc:
+      response = @config.http.post("#{@config.base_merchant_path}#{path}", params)
       if response[:credit_card]
         SuccessfulResult.new(:credit_card => CreditCard._new(@gateway, response[:credit_card]))
       elsif response[:api_error_response]
@@ -117,8 +118,8 @@ module Braintree
       end
     end
 
-    def _do_update(http_verb, url, params) # :nodoc:
-      response = @config.http.send http_verb, url, params
+    def _do_update(http_verb, path, params) # :nodoc:
+      response = @config.http.send(http_verb, "#{@config.base_merchant_path}#{path}", params)
       if response[:credit_card]
         SuccessfulResult.new(:credit_card => CreditCard._new(@gateway, response[:credit_card]))
       elsif response[:api_error_response]
@@ -129,14 +130,14 @@ module Braintree
     end
 
     def _fetch_expired(ids) # :nodoc:
-      response = @config.http.post("/payment_methods/all/expired", :search => {:ids => ids})
+      response = @config.http.post("#{@config.base_merchant_path}/payment_methods/all/expired", :search => {:ids => ids})
       attributes = response[:payment_methods]
       Util.extract_attribute_as_array(attributes, :credit_card).map { |attrs| CreditCard._new(@gateway, attrs) }
     end
 
     def _fetch_expiring_between(formatted_start_date, formatted_end_date, ids) # :nodoc:
       response = @config.http.post(
-        "/payment_methods/all/expiring?start=#{formatted_start_date}&end=#{formatted_end_date}",
+        "#{@config.base_merchant_path}/payment_methods/all/expiring?start=#{formatted_start_date}&end=#{formatted_end_date}",
         :search => {:ids => ids}
       )
       attributes = response[:payment_methods]

data/lib/braintree/credit_card_verification_gateway.rb

@@ -3,11 +3,12 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def find(id)
       raise ArgumentError if id.nil? || id.strip.to_s == ""
-      response = @config.http.get "/verifications/#{id}"
+      response = @config.http.get("#{@config.base_merchant_path}/verifications/#{id}")
       CreditCardVerification._new(response[:verification])
     rescue NotFoundError
       raise NotFoundError, "verification with id #{id.inspect} not found"
@@ -17,13 +18,13 @@ module Braintree
       search = CreditCardVerificationSearch.new
       block.call(search) if block
 
-      response = @config.http.post "/verifications/advanced_search_ids", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search_ids", {:search => search.to_hash})
       ResourceCollection.new(response) { |ids| _fetch_verifications(search, ids) }
     end
 
     def _fetch_verifications(search, ids)
       search.ids.in ids
-      response = @config.http.post "/verifications/advanced_search", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/verifications/advanced_search", {:search => search.to_hash})
       attributes = response[:credit_card_verifications]
       Util.extract_attribute_as_array(attributes, :verification).map { |attrs| CreditCardVerification._new(attrs) }
     end

data/lib/braintree/customer_gateway.rb

@@ -3,10 +3,11 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def all
-      response = @config.http.post "/customers/advanced_search_ids"
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search_ids")
       ResourceCollection.new(response) { |ids| _fetch_customers(CustomerSearch.new, ids) }
     end
 
@@ -27,14 +28,14 @@ module Braintree
     end
 
     def delete(customer_id)
-      @config.http.delete("/customers/#{customer_id}")
+      @config.http.delete("#{@config.base_merchant_path}/customers/#{customer_id}")
       SuccessfulResult.new
     end
 
     def find(customer_id)
       raise ArgumentError, "customer_id contains invalid characters" unless customer_id.to_s =~ /\A[\w-]+\z/
       raise ArgumentError, "customer_id cannot be blank" if customer_id.nil?|| customer_id.to_s.strip == ""
-      response = @config.http.get("/customers/#{customer_id}")
+      response = @config.http.get("#{@config.base_merchant_path}/customers/#{customer_id}")
       Customer._new(@gateway, response[:customer])
     rescue NotFoundError
       raise NotFoundError, "customer with id #{customer_id.inspect} not found"
@@ -44,12 +45,12 @@ module Braintree
       search = CustomerSearch.new
       block.call(search) if block
 
-      response = @config.http.post "/customers/advanced_search_ids", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search_ids", {:search => search.to_hash})
       ResourceCollection.new(response) { |ids| _fetch_customers(search, ids) }
     end
 
     def transactions(customer_id, options = {})
-      response = @config.http.post "/customers/#{customer_id}/transaction_ids"
+      response = @config.http.post("#{@config.base_merchant_path}/customers/#{customer_id}/transaction_ids")
       ResourceCollection.new(response) { |ids| _fetch_transactions(customer_id, ids) }
     end
 
@@ -80,8 +81,8 @@ module Braintree
       ]
     end
 
-    def _do_create(url, params=nil) # :nodoc:
-      response = @config.http.post url, params
+    def _do_create(path, params=nil) # :nodoc:
+      response = @config.http.post("#{@config.base_merchant_path}#{path}", params)
       if response[:customer]
         SuccessfulResult.new(:customer => Customer._new(@gateway, response[:customer]))
       elsif response[:api_error_response]
@@ -91,8 +92,8 @@ module Braintree
       end
     end
 
-    def _do_update(http_verb, url, params) # :nodoc:
-      response = @config.http.send http_verb, url, params
+    def _do_update(http_verb, path, params) # :nodoc:
+      response = @config.http.send(http_verb, "#{@config.base_merchant_path}#{path}", params)
       if response[:customer]
         SuccessfulResult.new(:customer => Customer._new(@gateway, response[:customer]))
       elsif response[:api_error_response]
@@ -104,13 +105,13 @@ module Braintree
 
     def _fetch_customers(search, ids) # :nodoc:
       search.ids.in ids
-      response = @config.http.post "/customers/advanced_search", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/customers/advanced_search", {:search => search.to_hash})
       attributes = response[:customers]
       Util.extract_attribute_as_array(attributes, :customer).map { |attrs| Customer._new(@gateway, attrs) }
     end
 
     def _fetch_transactions(customer_id, ids) # :nodoc:
-      response = @config.http.post "/customers/#{customer_id}/transactions", :search => {:ids => ids}
+      response = @config.http.post("#{@config.base_merchant_path}/customers/#{customer_id}/transactions", :search => {:ids => ids})
       attributes = response[:credit_card_transactions]
       Util.extract_attribute_as_array(attributes, :transaction).map do |transaction_attributes|
         Transaction._new @gateway, transaction_attributes