braintree 2.24.0 → 2.25.0

data/lib/braintree/transaction_gateway.rb

@@ -10,6 +10,28 @@ module Braintree
       _do_create "/transactions", :transaction => attributes
     end
 
+    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"
+      _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"
+      _handle_transaction_response(response)
+    end
+
+    def _handle_transaction_response(response)
+      if response[:transaction]
+        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
+      elsif response[:api_error_response]
+        ErrorResult.new(@gateway, response[:api_error_response])
+      else
+        raise UnexpectedError, "expected :transaction or :response"
+      end
+    end
+
     def clone_transaction(transaction_id, attributes)
       Util.verify_keys(TransactionGateway._clone_signature, attributes)
       _do_create "/transactions/#{transaction_id}/clone", :transaction_clone => attributes
@@ -40,13 +62,7 @@ module Braintree
 
     def refund(transaction_id, amount = nil)
       response = @config.http.post "/transactions/#{transaction_id}/refund", :transaction => {:amount => amount}
-      if response[:transaction]
-        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
-      elsif response[:api_error_response]
-        ErrorResult.new(@gateway, response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :transaction or :api_error_response"
-      end
+      _handle_transaction_response(response)
     end
 
     def retry_subscription_charge(subscription_id, amount=nil)
@@ -70,27 +86,21 @@ module Braintree
       ResourceCollection.new(response) { |ids| _fetch_transactions(search, ids) }
     end
 
+    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"
+      _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}
-      if response[:transaction]
-        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
-      elsif response[:api_error_response]
-        ErrorResult.new(@gateway, response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :transaction or :response"
-      end
+      _handle_transaction_response(response)
     end
 
     def void(transaction_id)
       response = @config.http.put "/transactions/#{transaction_id}/void"
-      if response[:transaction]
-        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
-      elsif response[:api_error_response]
-        ErrorResult.new(@gateway, response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :transaction or :api_error_response"
-      end
+      _handle_transaction_response(response)
     end
 
     def self._clone_signature # :nodoc:
@@ -101,7 +111,7 @@ module Braintree
       [
         :amount, :customer_id, :merchant_account_id, :order_id, :channel, :payment_method_token,
         :purchase_order_number, :recurring, :shipping_address_id, :type, :tax_amount, :tax_exempt,
-        :venmo_sdk_payment_method_code, :device_session_id, :device_data,
+        :venmo_sdk_payment_method_code, :device_session_id, :service_fee_amount, :device_data,
         {:credit_card => [:token, :cardholder_name, :cvv, :expiration_date, :expiration_month, :expiration_year, :number]},
         {:customer => [:id, :company, :email, :fax, :first_name, :last_name, :phone, :website]},
         {
@@ -110,7 +120,7 @@ module Braintree
         {
           :shipping => AddressGateway._shared_signature
         },
-        {:options => [:store_in_vault, :store_in_vault_on_success, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault, :venmo_sdk_session]},
+        {:options => [:hold_in_escrow, :store_in_vault, :store_in_vault_on_success, :submit_for_settlement, :add_billing_address_to_payment_method, :store_shipping_address_in_vault, :venmo_sdk_session]},
         {:custom_fields => :_any_key_},
         {:descriptor => [:name, :phone]}
       ]
@@ -118,13 +128,7 @@ module Braintree
 
     def _do_create(url, params=nil) # :nodoc:
       response = @config.http.post url, params
-      if response[:transaction]
-        SuccessfulResult.new(:transaction => Transaction._new(@gateway, response[:transaction]))
-      elsif response[:api_error_response]
-        ErrorResult.new(@gateway, response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :transaction or :api_error_response"
-      end
+      _handle_transaction_response(response)
     end
 
     def _fetch_transactions(search, ids) # :nodoc:

data/lib/braintree/version.rb

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

data/lib/braintree/webhook_notification.rb

@@ -10,9 +10,14 @@ module Braintree
       SubscriptionTrialEnded = "subscription_trial_ended"
       SubscriptionWentActive = "subscription_went_active"
       SubscriptionWentPastDue = "subscription_went_past_due"
+
+      SubMerchantAccountApproved = "sub_merchant_account_approved"
+      SubMerchantAccountDeclined = "sub_merchant_account_declined"
+      TransactionDisbursed = "transaction_disbursed"
+      PartnerUserCreated = "partner_user_created"
     end
 
-    attr_reader :subscription, :kind, :timestamp
+    attr_reader :subscription, :kind, :timestamp, :partner_credentials, :transaction
 
     def self.parse(signature, payload)
       Configuration.gateway.webhook_notification.parse(signature, payload)
@@ -25,7 +30,23 @@ module Braintree
     def initialize(gateway, attributes) # :nodoc:
       @gateway = gateway
       set_instance_variables_from_hash(attributes)
+      @error_result = ErrorResult.new(gateway, @subject[:api_error_response]) if @subject.has_key?(:api_error_response)
+      @merchant_account = MerchantAccount._new(gateway, @subject[:merchant_account]) if @subject.has_key?(:merchant_account)
+      @partner_credentials = OpenStruct.new(@subject[:partner_credentials]) if @subject.has_key?(:partner_credentials)
       @subscription = Subscription._new(gateway, @subject[:subscription]) if @subject.has_key?(:subscription)
+      @transaction = Transaction._new(gateway, @subject[:transaction]) if @subject.has_key?(:transaction)
+    end
+
+    def merchant_account
+      @error_result.nil? ? @merchant_account : @error_result.merchant_account
+    end
+
+    def errors
+      @error_result.errors if @error_result
+    end
+
+    def message
+      @error_result.message if @error_result
     end
 
     class << self

data/lib/braintree/webhook_testing_gateway.rb

@@ -12,19 +12,35 @@ module Braintree
       return signature_string, payload
     end
 
-    def _sample_xml(kind, id)
+    def _sample_xml(kind, data)
       <<-XML
         <notification>
           <timestamp type="datetime">#{Time.now.utc.iso8601}</timestamp>
           <kind>#{kind}</kind>
           <subject>
-            #{_subscription_sample_xml(id)}
+            #{_subject_sample_xml(kind, data)}
           </subject>
         </notification>
       XML
     end
 
+    def _subject_sample_xml(kind, id)
+      case kind
+      when Braintree::WebhookNotification::Kind::PartnerUserCreated
+        _partner_credentials_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::SubMerchantAccountApproved
+        _merchant_account_approved_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::SubMerchantAccountDeclined
+        _merchant_account_declined_sample_xml(id)
+      when Braintree::WebhookNotification::Kind::TransactionDisbursed
+        _transaction_disbursed_sample_xml(id)
+      else
+        _subscription_sample_xml(id)
+      end
+    end
+
     def _subscription_sample_xml(id)
+
       <<-XML
         <subscription>
           <id>#{id}</id>
@@ -37,5 +53,73 @@ module Braintree
         </subscription>
       XML
     end
+
+    def _partner_credentials_sample_xml(data)
+
+      <<-XML
+        <partner_credentials>
+          <merchant_public_id>public_id</merchant_public_id>
+          <public_key>public_key</public_key>
+          <private_key>private_key</private_key>
+          <partner_user_id>abc123</partner_user_id>
+        </partner_credentials>
+      XML
+    end
+
+    def _merchant_account_approved_sample_xml(id)
+
+      <<-XML
+        <merchant_account>
+          <id>#{id}</id>
+          <master_merchant_account>
+            <id>master_ma_for_#{id}</id>
+            <status>active</status>
+          </master_merchant_account>
+          <status>active</status>
+        </merchant_account>
+      XML
+    end
+
+    def _merchant_account_declined_sample_xml(id)
+
+      <<-XML
+          <api-error-response>
+              <message>Credit score is too low</message>
+              <errors>
+                  <errors type="array"/>
+                      <merchant-account>
+                          <errors type="array">
+                              <error>
+                                  <code>82621</code>
+                                  <message>Credit score is too low</message>
+                                  <attribute type="symbol">base</attribute>
+                              </error>
+                          </errors>
+                      </merchant-account>
+                  </errors>
+                  <merchant-account>
+                      <id>#{id}</id>
+                      <status>suspended</status>
+                      <master-merchant-account>
+                          <id>master_ma_for_#{id}</id>
+                          <status>suspended</status>
+                      </master-merchant-account>
+                  </merchant-account>
+          </api-error-response>
+      XML
+    end
+
+    def _transaction_disbursed_sample_xml(id)
+
+      <<-XML
+        <transaction>
+          <id>#{id}</id>
+          <amount>100</amount>
+          <disbursement-details>
+            <disbursement-date type="datetime">2013-07-09T18:23:29Z</disbursement-date>
+          </disbursement-details>
+        </transaction>
+      XML
+    end
   end
 end

data/lib/braintree/xml/generator.rb

@@ -13,10 +13,10 @@ module Braintree
         "Time"       => "datetime",
       }
 
-			XML_FORMATTING_NAMES = {
-				"BigDecimal" => "bigdecimal",
-				"Symbol"     => "symbol"
-			}.merge(XML_TYPE_NAMES)
+      XML_FORMATTING_NAMES = {
+        "BigDecimal" => "bigdecimal",
+        "Symbol"     => "symbol"
+      }.merge(XML_TYPE_NAMES)
 
       XML_FORMATTING = {
         "symbol"     => Proc.new { |symbol| symbol.to_s },

data/spec/httpsd.pid

@@ -1 +1 @@
-28977
+4742

data/spec/integration/braintree/customer_spec.rb

@@ -84,7 +84,7 @@ describe Braintree::Customer do
         found_customer = Braintree::Customer.find(result.customer.id)
         found_customer.first_name.should == first_name
         found_customer.last_name.should == last_name
-      elsif RUBY_VERSION =~ /^1.9/
+      else
         result.customer.first_name.should == "José"
         result.customer.first_name.bytes.map {|b| b.to_s(8)}.should == ["112", "157", "163", "303", "251"]
         result.customer.last_name.should == "Muñoz"
@@ -95,8 +95,6 @@ describe Braintree::Customer do
         found_customer.first_name.bytes.map {|b| b.to_s(8)}.should == ["112", "157", "163", "303", "251"]
         found_customer.last_name.should == "Muñoz"
         found_customer.last_name.bytes.map {|b| b.to_s(8)}.should == ["115", "165", "303", "261", "157", "172"]
-      else
-        raise "unknown ruby version: #{RUBY_VERSION.inspect}"
       end
     end
 
@@ -363,6 +361,22 @@ describe Braintree::Customer do
         result.customer.credit_cards.first.bin.should == "400934"
         result.customer.credit_cards.first.last_4.should == "1881"
       end
+
+      it "can create a customer with a venmo sdk session" do
+        result = Braintree::Customer.create(
+          :first_name => "Steve",
+          :last_name => "Hamlin",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "05/2010",
+            :options => {
+              :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
+            }
+          }
+        )
+        result.success?.should == true
+        result.customer.credit_cards.first.venmo_sdk?.should == true
+      end
     end
   end
 

data/spec/integration/braintree/merchant_account_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+
+VALID_APPLICATION_PARAMS = {
+  :applicant_details => {
+    :first_name => "Joe",
+    :last_name => "Bloggs",
+    :email => "joe@bloggs.com",
+    :phone => "312-555-1234",
+    :address => {
+      :street_address => "123 Credibility St.",
+      :postal_code => "60606",
+      :locality => "Chicago",
+      :region => "IL",
+    },
+    :date_of_birth => "10/9/1980",
+    :ssn => "123-00-1234",
+    :routing_number => "1234567890",
+    :account_number => "43759348798"
+  },
+  :tos_accepted => true,
+  :master_merchant_account_id => "sandbox_master_merchant_account"
+}
+
+describe Braintree::MerchantAccount do
+  describe "create" do
+    it "doesn't require an id" do
+      result = Braintree::MerchantAccount.create(VALID_APPLICATION_PARAMS)
+
+      result.should be_success
+      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
+      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+    end
+
+    it "allows an id to be passed" do
+      random_number = rand(10000)
+      sub_merchant_account_id = "sub_merchant_account_id#{random_number}"
+      result = Braintree::MerchantAccount.create(
+        VALID_APPLICATION_PARAMS.merge(
+          :id => sub_merchant_account_id
+        )
+      )
+
+      result.should be_success
+      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
+      result.merchant_account.id.should == sub_merchant_account_id
+      result.merchant_account.master_merchant_account.id.should == "sandbox_master_merchant_account"
+    end
+
+    it "handles unsuccessful results" do
+      result = Braintree::MerchantAccount.create({})
+      result.should_not be_success
+      result.errors.for(:merchant_account).on(:master_merchant_account_id).first.code.should == Braintree::ErrorCodes::MerchantAccount::MasterMerchantAccountIdIsRequired
+    end
+
+    it "requires all fields" do
+      result = Braintree::MerchantAccount.create(
+        :master_merchant_account_id => "sandbox_master_merchant_account"
+      )
+      result.should_not be_success
+      result.errors.for(:merchant_account).for(:applicant_details).on(:first_name).first.code.should == Braintree::ErrorCodes::MerchantAccount::ApplicantDetails::FirstNameIsRequired
+    end
+
+    it "accepts tax_id and business_name fields" do
+      params = VALID_APPLICATION_PARAMS.clone
+      params[:applicant_details][:company_name] = "Test Company"
+      params[:applicant_details][:tax_id] = "123456789"
+      result = Braintree::MerchantAccount.create(params)
+      result.should be_success
+      result.merchant_account.status.should == Braintree::MerchantAccount::Status::Pending
+    end
+  end
+end

data/spec/integration/braintree/transaction_spec.rb

@@ -887,6 +887,108 @@ describe Braintree::Transaction do
       end
     end
 
+    context "service fees" do
+      it "allows specifying service fees" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :service_fee_amount => "1.00"
+        )
+        result.success?.should == true
+        result.transaction.service_fee_amount.should == BigDecimal.new("1.00")
+      end
+
+      it "raises an error if transaction merchant account is a master" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :service_fee_amount => "1.00"
+        )
+        result.success?.should == false
+        expected_error_code = Braintree::ErrorCodes::Transaction::ServiceFeeAmountNotAllowedOnMasterMerchantAccount
+        result.errors.for(:transaction).on(:service_fee_amount)[0].code.should == expected_error_code
+      end
+
+      it "raises an error if no service fee is present on a sub merchant account transaction" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          }
+        )
+        result.success?.should == false
+        expected_error_code = Braintree::ErrorCodes::Transaction::SubMerchantAccountRequiresServiceFeeAmount
+        result.errors.for(:transaction).on(:merchant_account_id)[0].code.should == expected_error_code
+      end
+
+      it "raises an error if service fee amount is negative" do
+        result = Braintree::Transaction.create(
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :service_fee_amount => "-1.00"
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).on(:service_fee_amount)[0].code.should == Braintree::ErrorCodes::Transaction::ServiceFeeAmountCannotBeNegative
+      end
+
+      it "raises an error if service fee amount is invalid" do
+        result = Braintree::Transaction.create(
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :service_fee_amount => "invalid amount"
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).on(:service_fee_amount)[0].code.should == Braintree::ErrorCodes::Transaction::ServiceFeeAmountFormatIsInvalid
+      end
+    end
+
+    context "escrow" do
+      it "allows specifying transactions to be held for escrow" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :service_fee_amount => "10.00",
+          :options => {:hold_in_escrow => true}
+        )
+
+        result.success?.should == true
+        result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::HoldPending
+      end
+
+      it "raises an error if transaction merchant account is a master" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :service_fee_amount => "1.00",
+          :options => {:hold_in_escrow => true}
+        )
+        result.success?.should == false
+        expected_error_code = Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
+        result.errors.for(:transaction).on(:base)[0].code.should == expected_error_code
+      end
+    end
+
     describe "venmo_sdk" do
       it "can create a card with a venmo sdk payment method code" do
         result = Braintree::Transaction.create(
@@ -898,6 +1000,22 @@ describe Braintree::Transaction do
         result.transaction.credit_card_details.bin.should == "400934"
         result.transaction.credit_card_details.last_4.should == "1881"
       end
+
+      it "can create a transaction with venmo sdk session" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :options => {
+            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == true
+      end
     end
   end
 
@@ -1441,6 +1559,24 @@ describe Braintree::Transaction do
       result.success?.should == false
       result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotSubmitForSettlement
     end
+
+    context "service fees" do
+      it "returns an error result if amount submitted for settlement is less than service fee amount" do
+        transaction = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "06/2009"
+          },
+          :service_fee_amount => "1.00"
+        ).transaction
+        result = Braintree::Transaction.submit_for_settlement(transaction.id, "0.01")
+        result.success?.should == false
+        result.errors.for(:transaction).on(:amount)[0].code.should == Braintree::ErrorCodes::Transaction::SettlementAmountIsLessThanServiceFeeAmount
+      end
+    end
   end
 
   describe "self.submit_for_settlement!" do
@@ -1472,6 +1608,101 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "self.release_from_escrow" do
+    it "returns the transaction if successful" do
+      original_transaction = create_escrowed_transcation
+
+      result = Braintree::Transaction.release_from_escrow(original_transaction.id)
+      result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::ReleasePending
+    end
+
+    it "returns an error result if escrow_status is not HeldForEscrow" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :service_fee_amount => '1.00'
+      )
+
+      transaction.escrow_status.should be_nil
+
+      result = Braintree::Transaction.release_from_escrow(transaction.id)
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotReleaseFromEscrow
+    end
+  end
+
+  describe "self.release_from_escrow!" do
+    it "returns the transaction when successful" do
+      original_transaction = create_escrowed_transcation
+
+      transaction = Braintree::Transaction.release_from_escrow!(original_transaction.id)
+      transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::ReleasePending
+    end
+
+    it "raises an error when transaction is not successful" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        },
+        :service_fee_amount => '1.00'
+      )
+
+      transaction.escrow_status.should be_nil
+
+      expect do
+        Braintree::Transaction.release_from_escrow!(transaction.id)
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
+  describe "self.cancel_release" do
+    it "returns the transaction if successful" do
+      transaction = create_escrowed_transcation
+      result = Braintree::Transaction.release_from_escrow(transaction.id)
+      result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::ReleasePending
+
+      result = Braintree::Transaction.cancel_release(transaction.id)
+
+      result.success?.should be_true
+      result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::Held
+    end
+
+    it "returns an error result if escrow_status is not ReleasePending" do
+      transaction = create_escrowed_transcation
+
+      result = Braintree::Transaction.cancel_release(transaction.id)
+
+      result.success?.should be_false
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotCancelRelease
+    end
+  end
+
+  describe "self.cancel_release!" do
+    it "returns the transaction when release is cancelled" do
+      transaction = create_escrowed_transcation
+      result = Braintree::Transaction.release_from_escrow(transaction.id)
+      result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::ReleasePending
+
+      transaction = Braintree::Transaction.cancel_release!(transaction.id)
+
+      transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::Held
+    end
+
+    it "raises an error when release cannot be cancelled" do
+      transaction = create_escrowed_transcation
+
+      expect {
+        transaction = Braintree::Transaction.cancel_release!(transaction.id)
+      }.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
   describe "self.credit" do
     it "returns a successful result with type=credit if successful" do
       result = Braintree::Transaction.credit(
@@ -1530,6 +1761,22 @@ describe Braintree::Transaction do
       result.success?.should == true
       result.transaction.merchant_account_id.should == SpecHelper::DefaultMerchantAccountId
     end
+
+    it "disallows service fee on a credit" do
+      params = {
+        :transaction => {
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :service_fee_amount => "1.00"
+        }
+      }
+      result = Braintree::Transaction.credit(params[:transaction])
+      result.success?.should == false
+      result.errors.for(:transaction).on(:base).map(&:code).should include(Braintree::ErrorCodes::Transaction::ServiceFeeIsNotAllowedOnCredits)
+    end
   end
 
   describe "self.credit!" do
@@ -1792,6 +2039,76 @@ describe Braintree::Transaction do
     end
   end
 
+  describe "self.hold_in_escrow" do
+    it "returns the transaction if successful" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/12",
+        },
+        :service_fee_amount => "10.00"
+      )
+
+      result.transaction.escrow_status.should be_nil
+      result = Braintree::Transaction.hold_in_escrow(result.transaction.id)
+
+      result.success?.should be_true
+      result.transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::HoldPending
+    end
+
+    it "returns an error result if the transaction cannot be held in escrow" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+
+      result = Braintree::Transaction.hold_in_escrow(transaction.id)
+      result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotHoldInEscrow
+    end
+  end
+
+  describe "self.hold_in_escrow!" do
+    it "returns the transaction if successful" do
+      result = Braintree::Transaction.create(
+        :type => "sale",
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "12/12",
+        },
+        :service_fee_amount => "10.00"
+      )
+
+      result.transaction.escrow_status.should be_nil
+      transaction = Braintree::Transaction.hold_in_escrow!(result.transaction.id)
+
+      transaction.escrow_status.should == Braintree::Transaction::EscrowStatus::HoldPending
+    end
+
+    it "raises an error if the transaction cannot be held in escrow" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+        :credit_card => {
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2009"
+        }
+      )
+
+      expect do
+        Braintree::Transaction.hold_in_escrow!(transaction.id)
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+
   describe "self.void" do
     it "returns a successful result if successful" do
       transaction = Braintree::Transaction.sale!(
@@ -2137,4 +2454,76 @@ describe Braintree::Transaction do
     response = Braintree::Configuration.instantiate.http.put "/transactions/#{transaction.id}/settle"
     Braintree::Transaction.find(transaction.id)
   end
+
+  def create_escrowed_transcation
+    transaction = Braintree::Transaction.sale!(
+      :amount => Braintree::Test::TransactionAmounts::Authorize,
+      :merchant_account_id => SpecHelper::NonDefaultSubMerchantAccountId,
+      :credit_card => {
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009"
+      },
+        :service_fee_amount => '1.00',
+        :options => { :hold_in_escrow => true }
+    )
+
+    response = Braintree::Configuration.instantiate.http.put "/transactions/#{transaction.id}/settle"
+    response = Braintree::Configuration.instantiate.http.put "/transactions/#{transaction.id}/escrow"
+    Braintree::Transaction.find(transaction.id)
+  end
+
+  context "venmo sdk" do
+    describe "venmo_sdk_payment_method_code" do
+      it "can create a transaction with venmo_sdk_payment_method_code" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK.generate_test_payment_method_code(Braintree::Test::CreditCardNumbers::Visa)
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == true
+      end
+
+      it "errors when an invalid payment method code is passed" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :venmo_sdk_payment_method_code => Braintree::Test::VenmoSDK::InvalidPaymentMethodCode
+        )
+        result.success?.should == false
+        result.message.should == "Invalid VenmoSDK payment method code"
+        result.errors.first.code.should == "91727"
+      end
+    end
+
+    describe "venmo_sdk_session" do
+      it "can create a transaction and vault a card when a venmo_sdk_session is present" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :options => {
+            :venmo_sdk_session => Braintree::Test::VenmoSDK::Session
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == true
+      end
+
+      it "venmo_sdk boolean is false when an invalid session is passed" do
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2009"
+          },
+          :options => {
+            :venmo_sdk_session => Braintree::Test::VenmoSDK::InvalidSession
+          }
+        )
+        result.success?.should == true
+        result.transaction.credit_card_details.venmo_sdk?.should == false
+      end
+    end
+  end
 end