braintree 2.31.0 → 2.32.1

data/spec/integration/braintree/paypal_account_spec.rb

@@ -0,0 +1,188 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::PayPalAccount do
+  describe "self.find" do
+    it "returns a PayPalAccount" do
+      customer = Braintree::Customer.create!
+      payment_method_token = "paypal-account-#{Time.now.to_i}"
+
+      nonce = nonce_for_paypal_account(
+        :consent_code => "consent-code",
+        :token => payment_method_token
+      )
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+      result.should be_success
+
+      paypal_account = Braintree::PayPalAccount.find(payment_method_token)
+      paypal_account.should be_a(Braintree::PayPalAccount)
+      paypal_account.token.should == payment_method_token
+      paypal_account.email.should == "jane.doe@example.com"
+      paypal_account.image_url.should_not be_nil
+      paypal_account.created_at.should_not be_nil
+      paypal_account.updated_at.should_not be_nil
+    end
+
+    it "raises if the payment method token is not found" do
+      expect do
+        Braintree::PayPalAccount.find("nonexistant-paypal-account")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+
+    it "does not return a different payment method type" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+        :cvv => "100",
+        :token => "CREDIT_CARD_TOKEN"
+      )
+
+      expect do
+        Braintree::PayPalAccount.find("CREDIT_CARD_TOKEN")
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+
+  describe "self.update" do
+    it "updates a paypal account's token" do
+      customer = Braintree::Customer.create!
+      original_token = "paypal-account-#{Time.now.to_i}"
+      nonce = nonce_for_paypal_account(
+        :consent_code => "consent-code",
+        :token => original_token
+      )
+      original_result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      updated_token = "UPDATED_TOKEN-" + rand(36**3).to_s(36)
+      updated_result = Braintree::PayPalAccount.update(
+        original_token,
+        :token => updated_token
+      )
+
+      updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
+      updated_paypal_account.email.should == original_result.payment_method.email
+
+      expect do
+        Braintree::PayPalAccount.find(original_token)
+      end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{original_token}\" not found")
+    end
+
+    it "can make a paypal account the default payment method" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+        :options => {:make_default => true}
+      )
+      result.should be_success
+
+      nonce = nonce_for_paypal_account(:consent_code => "consent-code")
+      original_token = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      ).payment_method.token
+
+      updated_result = Braintree::PayPalAccount.update(
+        original_token,
+        :options => {:make_default => true}
+      )
+
+      updated_paypal_account = Braintree::PayPalAccount.find(original_token)
+      updated_paypal_account.should be_default
+    end
+
+    it "returns an error if a token for account is used to attempt an update" do
+      customer = Braintree::Customer.create!
+      first_token = "paypal-account-#{rand(36**3).to_s(36)}"
+      second_token = "paypal-account-#{rand(36**3).to_s(36)}"
+
+      first_nonce = nonce_for_paypal_account(
+        :consent_code => "consent-code",
+        :token => first_token
+      )
+      first_result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => first_nonce,
+        :customer_id => customer.id
+      )
+
+      second_nonce = nonce_for_paypal_account(
+        :consent_code => "consent-code",
+        :token => second_token
+      )
+      second_result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => second_nonce,
+        :customer_id => customer.id
+      )
+
+      updated_result = Braintree::PayPalAccount.update(
+        first_token,
+        :token => second_token
+      )
+
+      updated_result.should_not be_success
+      updated_result.errors.first.code.should == "92906"
+    end
+  end
+
+  context "self.delete" do
+    it "deletes a PayPal account" do
+      customer = Braintree::Customer.create!
+      token = "paypal-account-#{Time.now.to_i}"
+
+      nonce = nonce_for_paypal_account(
+        :consent_code => "consent-code",
+        :token => token
+      )
+      Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      result = Braintree::PayPalAccount.delete(token)
+
+      expect do
+        Braintree::PayPalAccount.find(token)
+      end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{token}\" not found")
+    end
+  end
+
+  context "self.sale" do
+    it "creates a transaction using a paypal account and returns a result object" do
+      customer = Braintree::Customer.create!(
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+      )
+
+      result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
+
+      result.success?.should == true
+      result.transaction.amount.should == BigDecimal.new("100.00")
+      result.transaction.type.should == "sale"
+      result.transaction.customer_details.id.should == customer.id
+      result.transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+    end
+  end
+
+  context "self.sale!" do
+    it "creates a transaction using a paypal account and returns a transaction" do
+      customer = Braintree::Customer.create!(
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+      )
+
+      transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")
+
+      transaction.amount.should == BigDecimal.new("100.00")
+      transaction.type.should == "sale"
+      transaction.customer_details.id.should == customer.id
+      transaction.paypal_details.token.should == customer.paypal_accounts[0].token
+    end
+  end
+end

data/spec/integration/braintree/subscription_spec.rb

@@ -64,26 +64,56 @@ describe Braintree::Subscription do
       result.subscription.id.should == new_id
     end
 
-    it "creates a subscription when given a payment_method_nonce" do
-      nonce = nonce_for_new_credit_card(
-        :credit_card => {
-          :number => Braintree::Test::CreditCardNumbers::Visa,
-          :expiration_month => "11",
-          :expiration_year => "2099",
-        },
-        :client_token_options => {
-          :customer_id => @credit_card.customer_id
-        }
-      )
-      result = Braintree::Subscription.create(
-        :payment_method_nonce => nonce,
-        :plan_id => SpecHelper::TriallessPlan[:id]
-      )
+    context "with payment_method_nonces" do
+      it "creates a subscription when given a credit card payment_method_nonce" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+          :client_token_options => {
+            :customer_id => @credit_card.customer_id
+          }
+        )
+        result = Braintree::Subscription.create(
+          :payment_method_nonce => nonce,
+          :plan_id => SpecHelper::TriallessPlan[:id]
+        )
 
-      result.success?.should == true
-      transaction = result.subscription.transactions[0]
-      transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
-      transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4, 4]
+        result.success?.should == true
+        transaction = result.subscription.transactions[0]
+        transaction.credit_card_details.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+        transaction.credit_card_details.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4, 4]
+      end
+
+      it "creates a subscription when given a paypal account payment_method_nonce" do
+        customer = Braintree::Customer.create!
+        payment_method_result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :customer_id => customer.id
+        )
+
+        result = Braintree::Subscription.create(
+          :payment_method_token => payment_method_result.payment_method.token,
+          :plan_id => SpecHelper::TriallessPlan[:id]
+        )
+
+        result.should be_success
+        transaction = result.subscription.transactions[0]
+        transaction.paypal_details.payer_email.should == "payer@example.com"
+      end
+
+      it "returns an error if the payment_method_nonce hasn't been vaulted" do
+        customer = Braintree::Customer.create!
+        result = Braintree::Subscription.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+          :plan_id => SpecHelper::TriallessPlan[:id]
+        )
+
+        result.should_not be_success
+        result.errors.for(:subscription).on(:payment_method_nonce).first.code.should == '91925'
+      end
     end
 
     context "billing_day_of_month" do
@@ -691,7 +721,7 @@ describe Braintree::Subscription do
     end
 
     it "allows changing the payment_method by payment_method_nonce" do
-      nonce = nonce_for_new_credit_card(
+      nonce = nonce_for_new_payment_method(
         :credit_card => {
           :number => Braintree::Test::CreditCardNumbers::MasterCard,
           :expiration_date => "05/2010"

data/spec/integration/braintree/test_transaction_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::TestTransaction do
+  context "testing" do
+    it "changes transaction status to settled" do
+      sale_result = Braintree::Transaction.sale(
+        :amount => "100",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+        :submit_for_settlement => true
+      }
+      )
+      sale_result.success?.should == true
+      sale_result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+
+      settle_result = Braintree::TestTransaction.settle(sale_result.transaction.id)
+      settle_result.transaction.status.should == Braintree::Transaction::Status::Settled
+      settle_result.success?.should == true
+    end
+
+    it "changes transaction status to settlement_confirmed" do
+      sale_result = Braintree::Transaction.sale(
+        :amount => "100",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+          :submit_for_settlement => true
+        }
+      )
+      sale_result.success?.should == true
+      sale_result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+
+      settle_result = Braintree::TestTransaction.settlement_confirm(sale_result.transaction.id)
+      settle_result.transaction.status.should == Braintree::Transaction::Status::SettlementConfirmed
+      settle_result.success?.should == true
+    end
+
+    it "changes transaction status to settlement_declined" do
+      sale_result = Braintree::Transaction.sale(
+        :amount => "100",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+        :options => {
+          :submit_for_settlement => true
+        }
+      )
+      sale_result.success?.should == true
+      sale_result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+
+      settle_result = Braintree::TestTransaction.settlement_decline(sale_result.transaction.id)
+      settle_result.transaction.status.should == Braintree::Transaction::Status::SettlementDeclined
+      settle_result.success?.should == true
+    end
+
+    it "returns a validation error when invalid transition is specified" do
+      sale_result = Braintree::Transaction.sale(
+        :amount => "100",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+      )
+      sale_result.success?.should == true
+
+      settle_result = Braintree::TestTransaction.settlement_decline(sale_result.transaction.id)
+      settle_result.success?.should be_false
+      settle_result.errors.for(:transaction).on(:base).first.code.should == Braintree::ErrorCodes::Transaction::CannotSimulateTransactionSettlement
+    end
+  end
+
+  context "mistakenly testing in production" do
+    def in_prod
+      old_environment = Braintree::Configuration.environment
+      Braintree::Configuration.environment = :production
+      begin
+        yield
+      ensure
+        Braintree::Configuration.environment = old_environment
+      end
+    end
+
+
+    it "raises an exception if settle is called in a production environment" do
+      expect do
+        in_prod do
+          Braintree::TestTransaction.settle(nil)
+        end
+      end.to raise_error(Braintree::TestOperationPerformedInProduction)
+    end
+
+    it "raises an exception if settlement_decline is called in a production environment" do
+      expect do
+        in_prod do
+          Braintree::TestTransaction.settlement_decline(nil)
+        end
+      end.to raise_error(Braintree::TestOperationPerformedInProduction)
+    end
+
+    it "raises an exception if settlement_confirm is called in a production environment" do
+      expect do
+        in_prod do
+          Braintree::TestTransaction.settlement_confirm(nil)
+        end
+      end.to raise_error(Braintree::TestOperationPerformedInProduction)
+    end
+  end
+
+end

data/spec/integration/braintree/transaction_search_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
 
 describe Braintree::Transaction, "search" do
   context "advanced" do
@@ -127,6 +128,65 @@ describe Braintree::Transaction, "search" do
       collection.first.id.should == transaction.id
     end
 
+    it "searches on paypal transactions" do
+      transaction = Braintree::Transaction.sale!(
+        :amount => Braintree::Test::TransactionAmounts::Authorize,
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+      )
+
+      paypal_details = transaction.paypal_details
+
+      collection = Braintree::Transaction.search do |search|
+        search.paypal_payment_id.is paypal_details.payment_id
+        search.paypal_authorization_id.is paypal_details.authorization_id
+        search.paypal_payer_email.is paypal_details.payer_email
+      end
+
+      collection.maximum_size.should == 1
+      collection.first.id.should == transaction.id
+    end
+
+    context "SEPA bank account transactions" do
+      it "does" do
+        with_altpay_merchant do
+          config = Braintree::Configuration.instantiate
+          customer = Braintree::Customer.create.customer
+          raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id, :sepa_mandate_type => Braintree::SEPABankAccount::MandateType::Business)
+          client_token = decode_client_token(raw_client_token)
+          authorization_fingerprint = client_token["authorizationFingerprint"]
+          http = ClientApiHttp.new(
+            config,
+            :authorization_fingerprint => authorization_fingerprint
+          )
+
+          nonce = http.create_sepa_bank_account_nonce(
+            :accountHolderName => "Bob Holder",
+            :iban => "DE89370400440532013000",
+            :bic => "DEUTDEFF",
+            :locale => "en-US",
+            :billingAddress =>  {
+              :region => "Hesse",
+              :country_name => "Germany"
+            }
+          )
+          nonce.should_not == nil
+
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => nonce,
+            :merchant_account_id => "fake_sepa_ma"
+          )
+
+          collection = Braintree::Transaction.search do |search|
+            search.sepa_bank_account_iban.is  "DE89370400440532013000"
+          end
+
+          collection.maximum_size.should >= 1
+          collection.map(&:id).should include(transaction.id)
+        end
+      end
+    end
+
     context "multiple value fields" do
       it "searches on created_using" do
         transaction = Braintree::Transaction.sale!(

data/spec/integration/braintree/transaction_spec.rb

@@ -133,6 +133,136 @@ describe Braintree::Transaction do
           }
         )
         result.transaction.credit_card_details.prepaid.should == Braintree::CreditCard::Prepaid::Yes
+        result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::CreditCard
+      end
+    end
+
+    describe "industry data" do
+      it "accepts valid industry data" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "ABCDEFG",
+              :check_in_date => "2014-06-01",
+              :check_out_date => "2014-06-30"
+            }
+          }
+        )
+        result.success?.should be_true
+      end
+
+      it "returns errors if validations on industry data fails" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "foo bar",
+              :check_in_date => "2014-06-30",
+              :check_out_date => "2014-06-01"
+            }
+          }
+        )
+        result.success?.should be_false
+        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+      end
+    end
+
+    describe "industry data" do
+      it "accepts valid industry data" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "ABCDEFG",
+              :check_in_date => "2014-06-01",
+              :check_out_date => "2014-06-30"
+            }
+          }
+        )
+        result.success?.should be_true
+      end
+
+      it "returns errors if validations on industry data fails" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "foo bar",
+              :check_in_date => "2014-06-30",
+              :check_out_date => "2014-06-01"
+            }
+          }
+        )
+        result.success?.should be_false
+        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
+      end
+    end
+
+    describe "industry data" do
+      it "accepts valid industry data" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "ABCDEFG",
+              :check_in_date => "2014-06-01",
+              :check_out_date => "2014-06-30"
+            }
+          }
+        )
+        result.success?.should be_true
+      end
+
+      it "returns errors if validations on industry data fails" do
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => 1_00,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::CardTypeIndicators::Prepaid,
+            :expiration_date => "05/2009"
+          },
+          :industry => {
+            :industry_type => Braintree::Transaction::IndustryType::Lodging,
+            :data => {
+              :folio_number => "foo bar",
+              :check_in_date => "2014-06-30",
+              :check_out_date => "2014-06-01"
+            }
+          }
+        )
+        result.success?.should be_false
+        result.errors.for(:transaction).for(:industry).map { |e| e.code }.sort.should == ["93403", "93406"]
       end
     end
 
@@ -1099,8 +1229,8 @@ describe Braintree::Transaction do
     end
 
     context "client API" do
-      it "can create a transaction with a nonce" do
-        nonce = nonce_for_new_credit_card(
+      it "can create a transaction with a shared card nonce" do
+        nonce = nonce_for_new_payment_method(
           :credit_card => {
             :number => "4111111111111111",
             :expiration_month => "11",
@@ -1108,16 +1238,383 @@ describe Braintree::Transaction do
           },
           :share => true
         )
+        nonce.should_not be_nil
 
         result = Braintree::Transaction.create(
           :type => "sale",
           :amount => Braintree::Test::TransactionAmounts::Authorize,
           :payment_method_nonce => nonce
         )
+        result.success?.should == true
+      end
 
+      it "can create a transaction with a vaulted card nonce" do
+        customer = Braintree::Customer.create!
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => "4111111111111111",
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          },
+          :client_token_options => {
+            :customer_id => customer.id,
+          }
+        )
+        nonce.should_not be_nil
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => nonce
+        )
+        result.success?.should == true
+      end
+
+      it "can create a transaction with a vaulted PayPal account" do
+        customer = Braintree::Customer.create!
+        nonce = nonce_for_new_payment_method(
+          :paypal_account => {
+            :consent_code => "PAYPAL_CONSENT_CODE",
+          },
+          :client_token_options => {
+            :customer_id => customer.id,
+          }
+        )
+        nonce.should_not be_nil
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => nonce
+        )
+        result.success?.should == true
+      end
+
+      it "can create a transaction with a params nonce with PayPal account params" do
+        customer = Braintree::Customer.create!
+        nonce = nonce_for_new_payment_method(
+          :paypal_account => {
+            :consent_code => "PAYPAL_CONSENT_CODE",
+          }
+        )
+        nonce.should_not be_nil
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :payment_method_nonce => nonce
+        )
         result.success?.should == true
       end
     end
+
+    context "three_d_secure" do
+      it "can create a transaction with a three_d_secure token" do
+        three_d_secure_token = SpecHelper.create_3ds_verification(
+          SpecHelper::ThreeDSecureMerchantAccountId,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_month => "12",
+          :expiration_year => "2012"
+        )
+
+        result = Braintree::Transaction.create(
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_token => three_d_secure_token
+        )
+
+        result.success?.should == true
+      end
+
+      it "can create a transaction without a three_d_secure token" do
+        result = Braintree::Transaction.create(
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          }
+        )
+        result.success?.should == true
+      end
+
+      it "returns an error if sent a nil three_d_secure token" do
+        result = Braintree::Transaction.create(
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_token => nil
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTokenIsInvalid
+      end
+
+      it "returns an error if 3ds lookup data does not match txn data" do
+        three_d_secure_token = SpecHelper.create_3ds_verification(
+          SpecHelper::ThreeDSecureMerchantAccountId,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_month => "12",
+          :expiration_year => "2012"
+        )
+
+        result = Braintree::Transaction.create(
+          :merchant_account_id => SpecHelper::ThreeDSecureMerchantAccountId,
+          :type => "sale",
+          :amount => Braintree::Test::TransactionAmounts::Authorize,
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::MasterCard,
+            :expiration_date => "12/12",
+          },
+          :three_d_secure_token => three_d_secure_token
+        )
+        result.success?.should == false
+        result.errors.for(:transaction).on(:three_d_secure_token)[0].code.should == Braintree::ErrorCodes::Transaction::ThreeDSecureTransactionDataDoesntMatchVerify
+      end
+    end
+
+    context "paypal" do
+      context "using a vaulted paypal account payment_method_token" do
+        it "can create a transaction" do
+          payment_method_result = Braintree::PaymentMethod.create(
+            :customer_id => Braintree::Customer.create.customer.id,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+          )
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_token => payment_method_result.payment_method.token
+          )
+
+          result.should be_success
+          result.transaction.payment_instrument_type.should == Braintree::PaymentInstrumentType::PayPalAccount
+        end
+      end
+
+      context "future" do
+        it "can create a paypal transaction with a nonce without vaulting" do
+          payment_method_token = rand(36**3).to_s(36)
+          nonce = nonce_for_paypal_account(
+            :consent_code => "PAYPAL_CONSENT_CODE",
+            :token => payment_method_token
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => nonce
+          )
+
+          result.should be_success
+
+          expect do
+            Braintree::PaymentMethod.find(payment_method_token)
+          end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{payment_method_token}\" not found")
+        end
+
+        it "can create a paypal transaction and vault a paypal account" do
+          payment_method_token = rand(36**3).to_s(36)
+          nonce = nonce_for_paypal_account(
+            :consent_code => "PAYPAL_CONSENT_CODE",
+            :token => payment_method_token
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => nonce,
+            :options => {:store_in_vault => true}
+          )
+
+          result.success?.should == true
+
+          found_paypal_account = Braintree::PaymentMethod.find(payment_method_token)
+          found_paypal_account.should be_a(Braintree::PayPalAccount)
+          found_paypal_account.token.should == payment_method_token
+        end
+      end
+
+      context "onetime" do
+        it "can create a paypal transaction with a nonce" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+          )
+
+          result.should be_success
+        end
+
+        it "can create a paypal transaction and does not vault even if asked to" do
+          payment_method_token = rand(36**3).to_s(36)
+          nonce = nonce_for_paypal_account(
+            :access_token => "PAYPAL_ACCESS_TOKEN",
+            :token => payment_method_token
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => nonce,
+            :options => {:store_in_vault => true}
+          )
+
+          result.success?.should == true
+
+          expect do
+            Braintree::PaymentMethod.find(payment_method_token)
+          end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{payment_method_token}\" not found")
+        end
+      end
+
+      context "submit" do
+        it "submits for settlement if instructed to do so" do
+          result = Braintree::Transaction.sale(
+            :amount => "100",
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+          result.success?.should == true
+          result.transaction.status.should == Braintree::Transaction::Status::SubmittedForSettlement
+        end
+      end
+
+      context "void" do
+        it "successfully voids a paypal transaction that's been authorized" do
+          sale_transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+
+          void_transaction = Braintree::Transaction.void!(sale_transaction.id)
+          void_transaction.should == sale_transaction
+          void_transaction.status.should == Braintree::Transaction::Status::Voided
+        end
+
+        it "fails to void a paypal transaction that's been declined" do
+          sale_transaction = Braintree::Transaction.sale(
+            :amount => Braintree::Test::TransactionAmounts::Decline,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            }
+          ).transaction
+
+          expect do
+            Braintree::Transaction.void!(sale_transaction.id)
+          end.to raise_error(Braintree::ValidationsFailed)
+        end
+      end
+
+      describe "refund" do
+        context "partial refunds" do
+          it "allows partial refunds" do
+            transaction = create_paypal_transaction_for_refund
+
+            result = Braintree::Transaction.refund(transaction.id, transaction.amount / 2)
+            result.should be_success
+            result.transaction.type.should == "credit"
+          end
+
+          it "allows multiple partial refunds" do
+            transaction = create_paypal_transaction_for_refund
+
+            transaction_1 = Braintree::Transaction.refund(transaction.id, transaction.amount / 2).transaction
+            transaction_2 = Braintree::Transaction.refund(transaction.id, transaction.amount / 2).transaction
+
+            transaction = Braintree::Transaction.find(transaction.id)
+            transaction.refund_ids.sort.should == [transaction_1.id, transaction_2.id].sort
+          end
+        end
+
+        it "returns a successful result if successful" do
+          transaction = create_paypal_transaction_for_refund
+
+          result = Braintree::Transaction.refund(transaction.id)
+          result.success?.should == true
+          result.transaction.type.should == "credit"
+        end
+
+        it "assigns the refund_id on the original transaction" do
+          transaction = create_paypal_transaction_for_refund
+          refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
+          transaction = Braintree::Transaction.find(transaction.id)
+
+          transaction.refund_id.should == refund_transaction.id
+        end
+
+        it "assigns the refunded_transaction_id to the original transaction" do
+          transaction = create_paypal_transaction_for_refund
+          refund_transaction = Braintree::Transaction.refund(transaction.id).transaction
+
+          refund_transaction.refunded_transaction_id.should == transaction.id
+        end
+
+        it "returns an error if already refunded" do
+          transaction = create_paypal_transaction_for_refund
+          result = Braintree::Transaction.refund(transaction.id)
+          result.success?.should == true
+          result = Braintree::Transaction.refund(transaction.id)
+          result.success?.should == false
+          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::HasAlreadyBeenRefunded
+        end
+
+        it "returns an error result if unsettled" do
+          transaction = Braintree::Transaction.sale!(
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+            :options => {
+              :submit_for_settlement => true
+            }
+          )
+          result = Braintree::Transaction.refund(transaction.id)
+          result.success?.should == false
+          result.errors.for(:transaction).on(:base)[0].code.should == Braintree::ErrorCodes::Transaction::CannotRefundUnlessSettled
+        end
+      end
+
+      context "handling errors" do
+        it "handles bad unvalidated nonces" do
+          nonce = nonce_for_paypal_account(
+            :access_token => "PAYPAL_ACCESS_TOKEN",
+            :consent_code => "PAYPAL_CONSENT_CODE"
+          )
+
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => nonce
+          )
+
+          result.should_not be_success
+          result.errors.for(:transaction).for(:paypal_account).first.code.should == "82903"
+        end
+
+        it "handles non-existent nonces" do
+          result = Braintree::Transaction.create(
+            :type => "sale",
+            :amount => Braintree::Test::TransactionAmounts::Authorize,
+            :payment_method_nonce => "NON_EXISTENT_NONCE"
+          )
+
+          result.should_not be_success
+          result.errors.for(:transaction).first.code.should == "91565"
+        end
+      end
+    end
   end
 
   describe "self.create!" do
@@ -1509,7 +2006,7 @@ describe Braintree::Transaction do
 
     it "can specify the customer id and payment method token" do
       customer_id = "customer_#{rand(10**10)}"
-      payment_mehtod_token = "credit_card_#{rand(10**10)}"
+      payment_method_token = "credit_card_#{rand(10**10)}"
       result = Braintree::Transaction.sale(
         :amount => "100",
         :customer => {
@@ -1518,7 +2015,7 @@ describe Braintree::Transaction do
           :last_name => "Williams"
         },
         :credit_card => {
-          :token => payment_mehtod_token,
+          :token => payment_method_token,
           :number => "5105105105105100",
           :expiration_date => "05/2012"
         },
@@ -1530,8 +2027,8 @@ describe Braintree::Transaction do
       transaction = result.transaction
       transaction.customer_details.id.should == customer_id
       transaction.vault_customer.id.should == customer_id
-      transaction.credit_card_details.token.should == payment_mehtod_token
-      transaction.vault_credit_card.token.should == payment_mehtod_token
+      transaction.credit_card_details.token.should == payment_method_token
+      transaction.vault_credit_card.token.should == payment_method_token
     end
 
     it "can specify existing shipping address" do
@@ -2588,6 +3085,19 @@ describe Braintree::Transaction do
     Braintree::Transaction.find(transaction.id)
   end
 
+  def create_paypal_transaction_for_refund
+    transaction = Braintree::Transaction.sale!(
+      :amount => Braintree::Test::TransactionAmounts::Authorize,
+      :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment,
+      :options => {
+        :submit_for_settlement => true
+      }
+    )
+
+    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,
@@ -2596,8 +3106,8 @@ describe Braintree::Transaction do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009"
       },
-        :service_fee_amount => '1.00',
-        :options => { :hold_in_escrow => true }
+      :service_fee_amount => '1.00',
+      :options => { :hold_in_escrow => true }
     )
 
     response = Braintree::Configuration.instantiate.http.put "/transactions/#{transaction.id}/settle"
@@ -2659,4 +3169,69 @@ describe Braintree::Transaction do
       end
     end
   end
+
+  context "paypal" do
+    it "can create a transaction for a paypal account" do
+      result = Braintree::Transaction.sale(
+        :amount => "10.00",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+      )
+      result.success?.should == true
+      result.transaction.paypal_details.payer_email.should == "payer@example.com"
+      result.transaction.paypal_details.payment_id.should match(/PAY-\w+/)
+      result.transaction.paypal_details.authorization_id.should match(/SALE-\w+/)
+      result.transaction.paypal_details.image_url.should_not be_nil
+    end
+
+    it "can vault a paypal account on a transaction" do
+      result = Braintree::Transaction.sale(
+        :amount => "10.00",
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :options => {
+          :store_in_vault => true
+        }
+      )
+      result.success?.should == true
+      result.transaction.paypal_details.token.should_not be_nil
+      result.transaction.paypal_details.payer_email.should == "payer@example.com"
+      result.transaction.paypal_details.payment_id.should match(/PAY-\w+/)
+      result.transaction.paypal_details.authorization_id.should match(/SALE-\w+/)
+    end
+
+    it "can create a transaction from a vaulted paypal account" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment,
+        :customer_id => customer.id
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::PayPalAccount)
+      payment_method_token = result.payment_method.token
+
+      result = Braintree::Transaction.sale(
+        :amount => "100",
+        :customer_id => customer.id,
+        :payment_method_token => payment_method_token
+      )
+
+      result.should be_success
+      result.transaction.paypal_details.token.should == payment_method_token
+      result.transaction.paypal_details.payer_email.should == "payer@example.com"
+      result.transaction.paypal_details.payment_id.should match(/PAY-\w+/)
+      result.transaction.paypal_details.authorization_id.should match(/SALE-\w+/)
+    end
+
+    context "validation failure" do
+      it "returns a validation error if consent code and access token are omitted" do
+        nonce = nonce_for_paypal_account(:token => "TOKEN")
+        result = Braintree::Transaction.sale(
+          :amount => "10.00",
+          :payment_method_nonce => nonce
+        )
+        result.should_not be_success
+        result.errors.for(:transaction).for(:paypal_account).first.code.should == Braintree::ErrorCodes::PayPalAccount::IncompletePayPalAccount
+      end
+    end
+  end
 end