braintree 2.83.0 → 2.84.0

data/lib/braintree/transaction_gateway.rb

@@ -1,5 +1,7 @@
 module Braintree
   class TransactionGateway # :nodoc:
+    include BaseModule
+
     def initialize(gateway)
       @gateway = gateway
       @config = gateway.config
@@ -17,12 +19,20 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+    def cancel_release!(*args)
+      return_object_or_raise(:transaction) { cancel_release(*args) }
+    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("#{@config.base_merchant_path}/transactions/#{transaction_id}/hold_in_escrow")
       _handle_transaction_response(response)
     end
 
+    def hold_in_escrow!(*args)
+      return_object_or_raise(:transaction) { hold_in_escrow(*args) }
+    end
+
     def _handle_transaction_response(response)
       if response[:transaction]
         SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
@@ -38,6 +48,10 @@ module Braintree
       _do_create "/transactions/#{transaction_id}/clone", :transaction_clone => attributes
     end
 
+    def clone_transaction!(*args)
+      return_object_or_raise(:transaction) { clone_transaction(*args) }
+    end
+
     # Deprecated
     def create_from_transparent_redirect(query_string)
       params = @gateway.transparent_redirect.parse_and_validate_query_string query_string
@@ -53,6 +67,10 @@ module Braintree
       create(attributes.merge(:type => 'credit'))
     end
 
+    def credit!(*args)
+      return_object_or_raise(:transaction) { credit(*args) }
+    end
+
     def find(id)
       raise ArgumentError if id.nil? || id.strip.to_s == ""
       response = @config.http.get("#{@config.base_merchant_path}/transactions/#{id}")
@@ -73,6 +91,10 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+    def refund!(*args)
+      return_object_or_raise(:transaction) { refund(*args) }
+    end
+
     def retry_subscription_charge(subscription_id, amount=nil, submit_for_settlement=false)
       attributes = {
         :amount => amount,
@@ -89,6 +111,10 @@ module Braintree
       create(attributes.merge(:type => 'sale'))
     end
 
+    def sale!(*args)
+      return_object_or_raise(:transaction) { sale(*args) }
+    end
+
     def search(&block)
       search = TransactionSearch.new
       block.call(search) if block
@@ -108,6 +134,10 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+    def release_from_escrow!(*args)
+      return_object_or_raise(:transaction) { release_from_escrow(*args) }
+    end
+
     def submit_for_settlement(transaction_id, amount = nil, options = {})
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
       Util.verify_keys(TransactionGateway._submit_for_settlement_signature, options)
@@ -116,6 +146,10 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+    def submit_for_settlement!(*args)
+      return_object_or_raise(:transaction) { submit_for_settlement(*args) }
+    end
+
     def update_details(transaction_id, options = {})
       raise ArgumentError, "transaction_id is invalid" unless transaction_id =~ /\A[0-9a-z]+\z/
       Util.verify_keys(TransactionGateway._update_details_signature, options)
@@ -131,11 +165,18 @@ module Braintree
       _handle_transaction_response(response)
     end
 
+    def submit_for_partial_settlement!(*args)
+      return_object_or_raise(:transaction) { submit_for_partial_settlement(*args) }
+    end
+
     def void(transaction_id)
       response = @config.http.put("#{@config.base_merchant_path}/transactions/#{transaction_id}/void")
       _handle_transaction_response(response)
     end
 
+    def void!(*args)
+      return_object_or_raise(:transaction) { void(*args) }
+    end
 
     def self._clone_signature # :nodoc:
       [:amount, :channel, {:options => [:submit_for_settlement]}]
@@ -180,7 +221,9 @@ module Braintree
           :skip_cvv,
           {:paypal => [:custom_field, :payee_email, :description, {:supplementary_data => :_any_key_}]},
           {:three_d_secure => [:required]},
-          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]}]
+          {:amex_rewards => [:request_id, :points, :currency_amount, :currency_iso_code]},
+          {:venmo => [:profile_id]}
+        ]
         },
         {:custom_fields => :_any_key_},
         {:descriptor => [:name, :phone, :url]},

data/lib/braintree/transparent_redirect.rb

@@ -8,28 +8,28 @@ module Braintree
       CreateTransaction = "create_transaction"
     end
 
-    def self.confirm(query_string)
-      Configuration.gateway.transparent_redirect.confirm(query_string)
+    def self.confirm(*args)
+      Configuration.gateway.transparent_redirect.confirm(*args)
     end
 
-    def self.create_credit_card_data(params)
-      Configuration.gateway.transparent_redirect.create_credit_card_data(params)
+    def self.create_credit_card_data(*args)
+      Configuration.gateway.transparent_redirect.create_credit_card_data(*args)
     end
 
-    def self.create_customer_data(params)
-      Configuration.gateway.transparent_redirect.create_customer_data(params)
+    def self.create_customer_data(*args)
+      Configuration.gateway.transparent_redirect.create_customer_data(*args)
     end
 
-    def self.transaction_data(params)
-      Configuration.gateway.transparent_redirect.transaction_data(params)
+    def self.transaction_data(*args)
+      Configuration.gateway.transparent_redirect.transaction_data(*args)
     end
 
-    def self.update_credit_card_data(params)
-      Configuration.gateway.transparent_redirect.update_credit_card_data(params)
+    def self.update_credit_card_data(*args)
+      Configuration.gateway.transparent_redirect.update_credit_card_data(*args)
     end
 
-    def self.update_customer_data(params)
-      Configuration.gateway.transparent_redirect.update_customer_data(params)
+    def self.update_customer_data(*args)
+      Configuration.gateway.transparent_redirect.update_customer_data(*args)
     end
 
     # Returns the URL to which Transparent Redirect Requests should be posted

data/lib/braintree/us_bank_account.rb

@@ -30,16 +30,16 @@ module Braintree
       self.new *args
     end
 
-    def self.find(token)
-      Configuration.gateway.us_bank_account.find(token)
+    def self.find(*args)
+      Configuration.gateway.us_bank_account.find(*args)
     end
 
     def self.sale(token, transaction_attributes)
       Configuration.gateway.transaction.sale(transaction_attributes.merge(
-            :payment_method_token => token,
-            :options => { :submit_for_settlement => true }
-          )
+          :payment_method_token => token,
+          :options => { :submit_for_settlement => true }
         )
+      )
     end
 
     def self.sale!(token, transaction_attributes)

data/lib/braintree/us_bank_account_gateway.rb

@@ -13,6 +13,5 @@ module Braintree
     rescue NotFoundError
       raise NotFoundError, "payment method with token #{token.inspect} not found"
     end
-
   end
 end

data/lib/braintree/version.rb

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

data/lib/braintree/webhook_notification.rb

@@ -56,12 +56,12 @@ module Braintree
     attr_reader :timestamp
     attr_reader :transaction
 
-    def self.parse(signature, payload)
-      Configuration.gateway.webhook_notification.parse(signature, payload)
+    def self.parse(*args)
+      Configuration.gateway.webhook_notification.parse(*args)
     end
 
-    def self.verify(challenge)
-      Configuration.gateway.webhook_notification.verify(challenge)
+    def self.verify(*args)
+      Configuration.gateway.webhook_notification.verify(*args)
     end
 
     def initialize(gateway, attributes) # :nodoc:

data/lib/braintree/webhook_testing.rb

@@ -1,7 +1,7 @@
 module Braintree
   class WebhookTesting # :nodoc:
-    def self.sample_notification(kind, id, source_merchant_id=nil)
-      Configuration.gateway.webhook_testing.sample_notification(kind, id, source_merchant_id)
+    def self.sample_notification(*args)
+      Configuration.gateway.webhook_testing.sample_notification(*args)
     end
   end
 end

data/spec/httpsd.pid

@@ -0,0 +1 @@
+1590

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

@@ -243,19 +243,4 @@ class ClientApiHttp
 
     post("/merchants/#{config.merchant_id}/client_api/v1/payment_methods/paypal_accounts", params)
   end
-
-  def create_europe_bank_account_nonce(params)
-    foo = {
-      :authorization_fingerprint => @options[:authorization_fingerprint],
-      :shared_customer_identifier => "fake_identifier",
-      :shared_customer_identifier_type => "testing",
-
-      :sepa_mandate => params
-    }
-
-    response = post("/merchants/#{config.merchant_id}/client_api/v1/sepa_mandates", foo)
-
-    mrn = JSON.parse(response.body)['europeBankAccounts'][0]['sepaMandates'][0]['mandateReferenceNumber']
-    JSON.parse(response.body)['europeBankAccounts'][0]['nonce']
-  end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -823,6 +823,79 @@ describe Braintree::Customer do
       found_customer.credit_cards.first.subscriptions.first.price.should == BigDecimal.new("1.00")
     end
 
+    context "when given an association filter id" do
+      it "filters out all filterable associations" do
+        customer = Braintree::Customer.create(
+          :custom_fields => {
+            :store_me => "custom value"
+          }
+        ).customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :street_address => "1 E Main St",
+            :locality => "Chicago",
+            :region => "Illinois",
+            :postal_code => "60622",
+            :country_name => "United States of America"
+          }
+        ).credit_card
+
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => credit_card.token,
+          :plan_id => "integration_trialless_plan",
+          :price => "1.00"
+        ).subscription
+
+        found_customer = Braintree::Customer.find(customer.id, {
+          :association_filter_id => "customernoassociations"
+        })
+        found_customer.credit_cards.length.should == 0
+        found_customer.payment_methods.length.should == 0
+        found_customer.addresses.length.should == 0
+        found_customer.custom_fields.should == {}
+      end
+
+      it "filters out nested filterable associations" do
+        customer = Braintree::Customer.create(
+          :custom_fields => {
+            :store_me => "custom value"
+          }
+        ).customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012",
+          :billing_address => {
+            :street_address => "1 E Main St",
+            :locality => "Chicago",
+            :region => "Illinois",
+            :postal_code => "60622",
+            :country_name => "United States of America"
+          }
+        ).credit_card
+
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => credit_card.token,
+          :plan_id => "integration_trialless_plan",
+          :price => "1.00"
+        ).subscription
+
+        found_customer = Braintree::Customer.find(customer.id, {
+         :association_filter_id =>  "customertoplevelassociations"
+        })
+
+        found_customer.credit_cards.length.should == 1
+        found_customer.credit_cards.first.subscriptions.length.should == 0
+        found_customer.payment_methods.length.should == 1
+        found_customer.payment_methods.first.subscriptions.length.should == 0
+        found_customer.addresses.length.should == 1
+        found_customer.custom_fields.length.should == 1
+      end
+    end
+
     it "returns associated ApplePayCards" do
       result = Braintree::Customer.create(
         :payment_method_nonce => Braintree::Test::Nonce::ApplePayAmEx

data/spec/integration/braintree/dispute_search_spec.rb

@@ -2,6 +2,37 @@ require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
 require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Dispute, "search" do
+  let(:customer) do
+    result = Braintree::Customer.create(
+      :first_name => "Jen",
+      :last_name => "Smith",
+      :company => "Braintree",
+      :email => "jen@example.com",
+      :phone => "312.555.1234",
+      :fax => "614.555.5678",
+      :website => "www.example.com"
+    )
+
+    result.customer
+  end
+
+  let(:transaction) do
+    result = Braintree::Transaction.sale(
+      :amount => '10.00',
+      :credit_card => {
+        :expiration_date => '01/2020',
+        :number => Braintree::Test::CreditCardNumbers::Disputes::Chargeback
+      },
+      :customer_id => customer.id,
+      :merchant_account_id => "14LaddersLLC_instant",
+      :options => {
+        :submit_for_settlement => true
+      }
+    )
+
+    result.transaction
+  end
+
   context "advanced" do
     it "correctly returns a result with no matches" do
       collection = Braintree::Dispute.search do |search|
@@ -23,6 +54,18 @@ describe Braintree::Dispute, "search" do
       expect(dispute.status).to eq(Braintree::Dispute::Status::Open)
     end
 
+    it "correctly returns a single dispute by customer_id" do
+      collection = Braintree::Dispute.search do |search|
+        search.customer_id.is transaction.customer_details.id
+      end
+
+      expect(collection.disputes.count).to eq(1)
+      dispute = collection.disputes.first
+
+      expect(dispute.id).to eq(transaction.disputes.first.id)
+      expect(dispute.status).to eq(Braintree::Dispute::Status::Open)
+    end
+
     it "correctly returns disputes by multiple reasons" do
       collection = Braintree::Dispute.search do |search|
         search.reason.in [
@@ -35,6 +78,32 @@ describe Braintree::Dispute, "search" do
       dispute = collection.disputes.first
     end
 
+    it "correctly returns disputes by effective_date range" do
+      effective_date = transaction.disputes.first.status_history.first.effective_date
+
+      collection = Braintree::Dispute.search do |search|
+        search.effective_date.between(effective_date, Date.parse(effective_date).next_day.to_s)
+      end
+
+      expect(collection.disputes.count).to be >= 1
+
+      dispute_ids = collection.disputes.map { |d| d.id }
+      expect(dispute_ids).to include(transaction.disputes.first.id)
+    end
+
+    it "correctly returns disputes by disbursement_date range" do
+      disbursement_date = transaction.disputes.first.status_history.first.disbursement_date
+
+      collection = Braintree::Dispute.search do |search|
+        search.disbursement_date.between(disbursement_date, Date.parse(disbursement_date).next_day.to_s)
+      end
+
+      expect(collection.disputes.count).to be >= 1
+
+      dispute_ids = collection.disputes.map { |d| d.id }
+      expect(dispute_ids).to include(transaction.disputes.first.id)
+    end
+
     it "correctly returns disputes by received_date range" do
       collection = Braintree::Dispute.search do |search|
         search.received_date.between("03/03/2014", "03/05/2014")

data/spec/integration/braintree/document_upload_spec.rb

@@ -52,4 +52,17 @@ describe Braintree::DocumentUploadGateway do
       end.to raise_error(ArgumentError, "invalid keys: invalid_key")
     end
   end
+
+  describe "create!" do
+    it "returns successful with valid request" do
+      file = File.new("#{File.dirname(__FILE__)}/../../fixtures/files/bt_logo.png", "r")
+      document_upload = Braintree::DocumentUpload.create!({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+
+      document_upload.id.should_not be_nil
+      document_upload.content_type.should == "image/png"
+      document_upload.kind.should == Braintree::DocumentUpload::Kind::EvidenceDocument
+      document_upload.name.should == "bt_logo.png"
+      document_upload.size.should == 2443
+    end
+  end
 end

data/spec/integration/braintree/merchant_account_spec.rb

@@ -217,6 +217,15 @@ describe Braintree::MerchantAccount do
     end
   end
 
+  describe "create!" do
+    it "creates a merchant account with the new parameters and doesn't require an id" do
+      merchant_account = Braintree::MerchantAccount.create!(VALID_APPLICATION_PARAMS)
+
+      merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
+      merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+    end
+  end
+
   describe "create_for_currency" do
     it "creates a new merchant account for currency" do
       result = SpecHelper::create_merchant
@@ -579,4 +588,17 @@ describe Braintree::MerchantAccount do
       result.errors.for(:merchant_account).for(:funding).on(:mobile_phone).map(&:code).should == [Braintree::ErrorCodes::MerchantAccount::Funding::MobilePhoneIsRequired]
     end
   end
+
+  describe "update!" do
+    it "updates the Merchant Account info" do
+      params = VALID_APPLICATION_PARAMS.clone
+      params.delete(:tos_accepted)
+      params.delete(:master_merchant_account_id)
+      params[:individual][:first_name] = "John"
+      params[:individual][:last_name] = "Doe"
+      merchant_account = Braintree::MerchantAccount.update!("sandbox_sub_merchant_account", params)
+      merchant_account.individual_details.first_name.should == "John"
+      merchant_account.individual_details.last_name.should == "Doe"
+    end
+  end
 end