braintree 2.45.0 → 2.46.0

data/lib/braintree/successful_result.rb

@@ -2,7 +2,7 @@ module Braintree
   class SuccessfulResult
     include BaseModule
 
-    attr_reader :address, :credit_card, :customer, :merchant_account, :payment_method, :settlement_batch_summary, :subscription, :new_transaction, :transaction, :payment_method_nonce
+    attr_reader :address, :credit_card, :customer, :merchant_account, :payment_method, :settlement_batch_summary, :subscription, :new_transaction, :transaction, :payment_method_nonce, :credentials, :merchant
 
     def initialize(attributes = {}) # :nodoc:
       @attrs = attributes.keys

data/lib/braintree/testing_gateway.rb

@@ -4,34 +4,35 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
       @transaction_gateway = TransactionGateway.new(gateway)
     end
 
     def settle(transaction_id)
       check_environment
 
-      response = @config.http.put "/transactions/#{transaction_id}/settle"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/settle")
       @transaction_gateway._handle_transaction_response(response)
     end
 
     def settlement_confirm(transaction_id)
       check_environment
 
-      response = @config.http.put "/transactions/#{transaction_id}/settlement_confirm"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/settlement_confirm")
       @transaction_gateway._handle_transaction_response(response)
     end
 
     def settlement_decline(transaction_id)
       check_environment
 
-      response = @config.http.put "/transactions/#{transaction_id}/settlement_decline"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/settlement_decline")
       @transaction_gateway._handle_transaction_response(response)
     end
 
     def settlement_pending(transaction_id)
       check_environment
 
-      response = @config.http.put "/transactions/#{transaction_id}/settlement_pending"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/settlement_pending")
       @transaction_gateway._handle_transaction_response(response)
     end
 

data/lib/braintree/transaction.rb

@@ -18,6 +18,7 @@ module Braintree
     end
 
     module GatewayRejectionReason
+      ApplicationIncomplete = "application_incomplete"
       AVS          = "avs"
       AVSAndCVV    = "avs_and_cvv"
       CVV          = "cvv"

data/lib/braintree/transaction_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)
@@ -12,13 +13,13 @@ module Braintree
 
     def cancel_release(transaction_id)
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
-      response = @config.http.put "/transactions/#{transaction_id}/cancel_release"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/cancel_release")
       _handle_transaction_response(response)
     end
 
     def hold_in_escrow(transaction_id)
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
-      response = @config.http.put "/transactions/#{transaction_id}/hold_in_escrow"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/hold_in_escrow")
       _handle_transaction_response(response)
     end
 
@@ -54,14 +55,14 @@ module Braintree
 
     def find(id)
       raise ArgumentError if id.nil? || id.strip.to_s == ""
-      response = @config.http.get "/transactions/#{id}"
+      response = @config.http.get("#{@config.base_merchant_path}/transactions/#{id}")
       Transaction._new(@gateway, response[:transaction])
     rescue NotFoundError
       raise NotFoundError, "transaction with id #{id.inspect} not found"
     end
 
     def refund(transaction_id, amount = nil)
-      response = @config.http.post "/transactions/#{transaction_id}/refund", :transaction => {:amount => amount}
+      response = @config.http.post("#{@config.base_merchant_path}/transactions/#{transaction_id}/refund", :transaction => {:amount => amount})
       _handle_transaction_response(response)
     end
 
@@ -82,7 +83,7 @@ module Braintree
       search = TransactionSearch.new
       block.call(search) if block
 
-      response = @config.http.post "/transactions/advanced_search_ids", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/transactions/advanced_search_ids", {:search => search.to_hash})
 
       if response.has_key?(:search_results)
         ResourceCollection.new(response) { |ids| _fetch_transactions(search, ids) }
@@ -93,18 +94,18 @@ module Braintree
 
     def release_from_escrow(transaction_id)
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
-      response = @config.http.put "/transactions/#{transaction_id}/release_from_escrow"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/release_from_escrow")
       _handle_transaction_response(response)
     end
 
     def submit_for_settlement(transaction_id, amount = nil)
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
-      response = @config.http.put "/transactions/#{transaction_id}/submit_for_settlement", :transaction => {:amount => amount}
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/submit_for_settlement", :transaction => {:amount => amount})
       _handle_transaction_response(response)
     end
 
     def void(transaction_id)
-      response = @config.http.put "/transactions/#{transaction_id}/void"
+      response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/void")
       _handle_transaction_response(response)
     end
 
@@ -146,14 +147,14 @@ 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)
       _handle_transaction_response(response)
     end
 
     def _fetch_transactions(search, ids) # :nodoc:
       search.ids.in ids
-      response = @config.http.post "/transactions/advanced_search", {:search => search.to_hash}
+      response = @config.http.post("#{@config.base_merchant_path}/transactions/advanced_search", {:search => search.to_hash})
       attributes = response[:credit_card_transactions]
       Util.extract_attribute_as_array(attributes, :transaction).map { |attrs| Transaction._new(@gateway, attrs) }
     end

data/lib/braintree/transaction_search.rb

@@ -11,6 +11,7 @@ module Braintree
       :billing_region,
       :billing_street_address,
       :credit_card_cardholder_name,
+      :credit_card_unique_identifier,
       :currency,
       :customer_company,
       :customer_email,
@@ -53,6 +54,8 @@ module Braintree
       CreditCard::CustomerLocation::US
     ]
     multiple_value_field :ids
+    multiple_value_field :payment_instrument_type
+    multiple_value_field :user
     multiple_value_field :merchant_account_id
     multiple_value_field :status, :allows => Transaction::Status::All
     multiple_value_field :source, :allows => [

data/lib/braintree/transparent_redirect_gateway.rb

@@ -10,6 +10,7 @@ module Braintree
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
+      @config.assert_has_access_token_or_keys
     end
 
     def confirm(query_string)

data/lib/braintree/version.rb

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

data/lib/braintree/webhook_notification_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 parse(signature_string, payload)

data/lib/braintree/webhook_testing_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 sample_notification(kind, id)

data/spec/httpsd.pid

@@ -1 +1 @@
-12094
+19187

data/spec/integration/braintree/add_on_spec.rb

@@ -30,5 +30,17 @@ describe Braintree::AddOn do
       add_on.number_of_billing_cycles.should == expected[:number_of_billing_cycles]
       add_on.updated_at.should_not be_nil
     end
+
+    it "raises with a helpful error if public_key and private_key are not set" do
+      gateway = Braintree::Gateway.new(
+        :client_id => "client_id$development$integration_client_id",
+        :client_secret => "client_secret$development$integration_client_secret",
+        :logger => Logger.new("/dev/null")
+      )
+
+      expect do
+        gateway.add_on.all
+      end.to raise_error(Braintree::ConfigurationError, /public_key and private_key are required/)
+    end
   end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -54,6 +54,37 @@ describe Braintree::Customer do
       result.customer.updated_at.between?(Time.now - 10, Time.now).should == true
     end
 
+    it "returns a successful result if successful using an access token" do
+      oauth_gateway = Braintree::Gateway.new(
+        :client_id => "client_id$development$integration_client_id",
+        :client_secret => "client_secret$development$integration_client_secret",
+        :logger => Logger.new("/dev/null")
+      )
+      access_token = Braintree::OAuthTestHelper.create_token(oauth_gateway, {
+        :merchant_public_id => "integration_merchant_id",
+        :scope => "read_write"
+      }).credentials.access_token
+
+      gateway = Braintree::Gateway.new(
+        :access_token => access_token,
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.customer.create(
+        :first_name => "Joe",
+        :last_name => "Brown",
+        :company => "ExampleCo",
+        :email => "joe@example.com",
+        :phone => "312.555.1234",
+        :fax => "614.555.5678",
+        :website => "www.example.com"
+      )
+      result.success?.should == true
+      result.customer.id.should =~ /^\d{6}$/
+      result.customer.first_name.should == "Joe"
+      result.customer.last_name.should == "Brown"
+    end
+
     it "supports creation with a device session ID and (optional) fraud_merchant_id" do
       result = Braintree::Customer.create(
         :credit_card => {

data/spec/integration/braintree/http_spec.rb

@@ -7,7 +7,8 @@ describe Braintree::Http do
         original_key = Braintree::Configuration.public_key
         Braintree::Configuration.public_key = "invalid_public_key"
         expect do
-          Braintree::Configuration.instantiate.http.get "/customers"
+          config = Braintree::Configuration.instantiate
+          config.http.get("#{config.base_merchant_path}/customers")
         end.to raise_error(Braintree::AuthenticationError)
       ensure
         Braintree::Configuration.public_key = original_key
@@ -16,7 +17,8 @@ describe Braintree::Http do
 
     it "raises an AuthorizationError if authorization fails" do
       expect do
-        Braintree::Configuration.instantiate.http.get "/users"
+        config = Braintree::Configuration.instantiate
+        config.http.get("#{config.base_merchant_path}/users")
       end.to raise_error(Braintree::AuthorizationError)
     end
   end
@@ -32,7 +34,7 @@ describe Braintree::Http do
           Braintree::Configuration.logger.level = Logger::INFO
           Braintree::Customer.all
           utc_or_gmt = Time.now.utc.strftime("%Z")
-          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /customers/advanced_search_ids 200")
+          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /merchants/integration_merchant_id/customers/advanced_search_ids 200")
         end
       ensure
         Braintree::Configuration.logger = old_logger
@@ -56,7 +58,7 @@ describe Braintree::Http do
           )
           result.success?.should == true
           utc_or_gmt = Time.now.utc.strftime("%Z")
-          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /payment_methods")
+          output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] POST /merchants/integration_merchant_id/payment_methods")
           output.string.should include("[Braintree]   <cardholder-name>Sam Jones</cardholder-name>")
           output.string.should include("[Braintree]   <number>401288******1881</number>")
           output.string.should include("[Braintree] [10/Oct/2009 13:55:36 #{utc_or_gmt}] 201 Created")
@@ -73,13 +75,15 @@ describe Braintree::Http do
       end
 
       it "sets the User-Agent header using the default user agent" do
-        response = Braintree::Configuration.instantiate.http.get "/test/headers"
+        config = Braintree::Configuration.instantiate
+        response = config.http.get("#{config.base_merchant_path}/test/headers")
         response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String}"
       end
 
       it "sets the User-Agent header using a customer user agent" do
         Braintree::Configuration.custom_user_agent = "ActiveMerchant 1.2.3"
-        response = Braintree::Configuration.instantiate.http.get "/test/headers"
+        config = Braintree::Configuration.instantiate
+        response = config.http.get("#{config.base_merchant_path}/test/headers")
         response[:headers][:HTTP_USER_AGENT].should == "Braintree Ruby Gem #{Braintree::Version::String} (ActiveMerchant 1.2.3)"
       end
     end

data/spec/integration/braintree/merchant_account_spec.rb

@@ -109,7 +109,6 @@ describe Braintree::MerchantAccount do
     context "funding destination" do
       it "accepts a bank" do
         params = VALID_APPLICATION_PARAMS.dup
-        params[:funding] = VALID_APPLICATION_PARAMS[:funding].dup
         params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::Bank
         result = Braintree::MerchantAccount.create(params)
 
@@ -118,9 +117,6 @@ describe Braintree::MerchantAccount do
 
       it "accepts an email" do
         params = VALID_APPLICATION_PARAMS.dup
-        params[:funding] = VALID_APPLICATION_PARAMS[:funding].dup
-        params[:funding].delete(:routing_number)
-        params[:funding].delete(:account_number)
         params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::Email
         params[:funding][:email] = "joebloggs@compuserve.com"
         result = Braintree::MerchantAccount.create(params)
@@ -130,9 +126,6 @@ describe Braintree::MerchantAccount do
 
       it "accepts a mobile_phone" do
         params = VALID_APPLICATION_PARAMS.dup
-        params[:funding] = VALID_APPLICATION_PARAMS[:funding].dup
-        params[:funding].delete(:routing_number)
-        params[:funding].delete(:account_number)
         params[:funding][:destination] = ::Braintree::MerchantAccount::FundingDestination::MobilePhone
         params[:funding][:mobile_phone] = "3125882300"
         result = Braintree::MerchantAccount.create(params)

data/spec/integration/braintree/merchant_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe Braintree::MerchantGateway do
+  describe "create" do
+    it "creates a merchant" do
+      gateway = Braintree::Gateway.new(
+        :client_id => "client_id$development$integration_client_id",
+        :client_secret => "client_secret$development$integration_client_secret",
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant.create(
+        :email => "name@email.com",
+        :country_code_alpha3 => "USA",
+        :payment_methods => ["credit_card", "paypal"]
+      )
+
+      result.should be_success
+
+      merchant = result.merchant
+      merchant.id.should_not be_nil
+      merchant.email.should == "name@email.com"
+      merchant.company_name.should == "name@email.com"
+      merchant.country_code_alpha3.should == "USA"
+      merchant.country_code_alpha2.should == "US"
+      merchant.country_code_numeric.should == "840"
+      merchant.country_name.should == "United States of America"
+
+      credentials = result.credentials
+      credentials.access_token.should start_with("access_token$")
+      credentials.expires_at.should_not be_nil
+      credentials.token_type.should == "bearer"
+      credentials.refresh_token.should be_nil
+    end
+
+    it "gives an error when using invalid payment_methods" do
+      gateway = Braintree::Gateway.new(
+        :client_id => "client_id$development$integration_client_id",
+        :client_secret => "client_secret$development$integration_client_secret",
+        :logger => Logger.new("/dev/null")
+      )
+
+      result = gateway.merchant.create(
+        :email => "name@email.com",
+        :country_code_alpha3 => "USA",
+        :payment_methods => ["fake_money"]
+      )
+
+      result.should_not be_success
+      errors = result.errors.for(:merchant).on(:payment_methods)
+
+      errors[0].code.should == Braintree::ErrorCodes::Merchant::PaymentMethodsAreInvalid
+    end
+  end
+end

data/spec/integration/braintree/oauth_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+
+describe "OAuth" do
+  before(:each) do
+    @gateway = Braintree::Gateway.new(
+      :client_id => "client_id$development$integration_client_id",
+      :client_secret => "client_secret$development$integration_client_secret",
+      :logger => Logger.new("/dev/null")
+    )
+  end
+
+  describe "create_token_from_code" do
+    it "creates an access token given a grant code" do
+      code = Braintree::OAuthTestHelper.create_grant(@gateway, {
+        :merchant_public_id => "integration_merchant_id",
+        :scope => "read_write"
+      })
+
+      result = @gateway.oauth.create_token_from_code(
+        :code => code,
+        :scope => "read_write"
+      )
+
+      result.should be_success
+      credentials = result.credentials
+      credentials.access_token.should_not be_nil
+      credentials.refresh_token.should_not be_nil
+      credentials.expires_at.should_not be_nil
+      credentials.token_type.should == "bearer"
+    end
+
+    it "returns validation errors for bad params" do
+      result = @gateway.oauth.create_token_from_code(
+        :code => "bad_code",
+        :scope => "read_write"
+      )
+
+      result.should_not be_success
+      errors = result.errors.for(:credentials).on(:code)[0].code.should == Braintree::ErrorCodes::OAuth::InvalidGrant
+      result.message.should =~ /Invalid grant: code not found/
+    end
+
+    it "raises with a helpful error if client_id and client_secret are not set" do
+      gateway = Braintree::Gateway.new(
+        :access_token => "access_token$development$integration_merchant_id$fb27c79dd",
+        :logger => Logger.new("/dev/null")
+      )
+
+      expect do
+        gateway.oauth.create_token_from_code(
+          :code => "some code",
+          :scope => "read_write"
+        )
+      end.to raise_error(Braintree::ConfigurationError, /client_id and client_secret are required/);
+    end
+  end
+
+  describe "create_token_from_refresh_token" do
+    it "creates an access token given a refresh token" do
+      code = Braintree::OAuthTestHelper.create_grant(@gateway, {
+        :merchant_public_id => "integration_merchant_id",
+        :scope => "read_write"
+      })
+      refresh_token = @gateway.oauth.create_token_from_code(
+        :code => code,
+        :scope => "read_write"
+      ).credentials.refresh_token
+
+      result = @gateway.oauth.create_token_from_refresh_token(
+        :refresh_token => refresh_token,
+        :scope => "read_write"
+      )
+
+      result.should be_success
+      credentials = result.credentials
+      credentials.access_token.should_not be_nil
+      credentials.refresh_token.should_not be_nil
+      credentials.expires_at.should_not be_nil
+      credentials.token_type.should == "bearer"
+    end
+  end
+
+  describe "connect_url" do
+    it "builds a connect url" do
+      url = @gateway.oauth.connect_url(
+        :merchant_id => "integration_merchant_id",
+        :redirect_uri => "http://bar.example.com",
+        :scope => "read_write",
+        :state => "baz_state",
+        :user => {
+          :country => "USA",
+          :email => "foo@example.com",
+          :first_name => "Bob",
+          :last_name => "Jones",
+          :phone => "555-555-5555",
+          :dob_year => "1970",
+          :dob_month => "01",
+          :dob_day => "01",
+          :street_address => "222 W Merchandise Mart",
+          :locality => "Chicago",
+          :region => "IL",
+          :postal_code => "60606"
+        },
+        :business => {
+          :name => "14 Ladders",
+          :registered_as => "14.0 Ladders",
+          :industry => "Ladders",
+          :description => "We sell the best ladders",
+          :street_address => "111 N Canal",
+          :locality => "Chicago",
+          :region => "IL",
+          :postal_code => "60606",
+          :country => "USA",
+          :annual_volume_amount => "1000000",
+          :average_transaction_amount => "100",
+          :maximum_transaction_amount => "10000",
+          :ship_physical_goods => true,
+          :fulfillment_completed_in => 7,
+          :currency => "USD",
+          :website => "http://example.com"
+        },
+        :payment_methods => ["credit_card", "paypal"]
+      )
+
+      uri = URI.parse(url)
+      uri.host.should == "localhost"
+      uri.path.should == "/oauth/connect"
+
+      query = CGI.parse(CGI.unescape(uri.query))
+      query["merchant_id"].should == ["integration_merchant_id"]
+      query["client_id"].should == ["client_id$development$integration_client_id"]
+      query["redirect_uri"].should == ["http://bar.example.com"]
+      query["scope"].should == ["read_write"]
+      query["state"].should == ["baz_state"]
+
+      query["user[country]"].should == ["USA"]
+      query["business[name]"].should == ["14 Ladders"]
+
+      query["user[email]"].should == ["foo@example.com"]
+      query["user[first_name]"].should == ["Bob"]
+      query["user[last_name]"].should == ["Jones"]
+      query["user[phone]"].should == ["555-555-5555"]
+      query["user[dob_year]"].should == ["1970"]
+      query["user[dob_month]"].should == ["01"]
+      query["user[dob_day]"].should == ["01"]
+      query["user[street_address]"].should == ["222 W Merchandise Mart"]
+      query["user[locality]"].should == ["Chicago"]
+      query["user[region]"].should == ["IL"]
+      query["user[postal_code]"].should == ["60606"]
+
+      query["business[name]"].should == ["14 Ladders"]
+      query["business[registered_as]"].should == ["14.0 Ladders"]
+      query["business[industry]"].should == ["Ladders"]
+      query["business[description]"].should == ["We sell the best ladders"]
+      query["business[street_address]"].should == ["111 N Canal"]
+      query["business[locality]"].should == ["Chicago"]
+      query["business[region]"].should == ["IL"]
+      query["business[postal_code]"].should == ["60606"]
+      query["business[country]"].should == ["USA"]
+      query["business[annual_volume_amount]"].should == ["1000000"]
+      query["business[average_transaction_amount]"].should == ["100"]
+      query["business[maximum_transaction_amount]"].should == ["10000"]
+      query["business[ship_physical_goods]"].should == ["true"]
+      query["business[fulfillment_completed_in]"].should == ["7"]
+      query["business[currency]"].should == ["USD"]
+      query["business[website]"].should == ["http://example.com"]
+
+      query["signature"][0].length.should == 64
+      query["algorithm"].should == ["SHA256"]
+    end
+
+    it "builds the query string with multiple payment_methods" do
+      url = @gateway.oauth.connect_url(
+        :merchant_id => "integration_merchant_id",
+        :redirect_uri => "http://bar.example.com",
+        :scope => "read_write",
+        :state => "baz_state",
+        :payment_methods => ["credit_card", "paypal"]
+      )
+
+      uri = URI.parse(url)
+      uri.host.should == "localhost"
+      uri.path.should == "/oauth/connect"
+
+      query = CGI.parse(CGI.unescape(uri.query))
+      query["payment_methods[]"].length.should == 2
+      query["payment_methods[]"].should include("paypal")
+      query["payment_methods[]"].should include("credit_card")
+    end
+  end
+end