braintree 2.74.0 → 4.12.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -0,0 +1,416 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::PaymentMethod do
+  describe "self.create" do
+    context "compliant merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration2_merchant_id"
+        Braintree::Configuration.public_key = "integration2_public_key"
+        Braintree::Configuration.private_key = "integration2_private_key"
+      end
+
+      context "plaid verified nonce" do
+        let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
+
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          result.should be_success
+          us_bank_account = result.payment_method
+          us_bank_account.should be_a(Braintree::UsBankAccount)
+          us_bank_account.routing_number.should == "011000015"
+          us_bank_account.last_4.should == "0000"
+          us_bank_account.account_type.should == "checking"
+          us_bank_account.account_holder_name.should == "PayPal, Inc."
+          us_bank_account.bank_name.should == "FEDERAL RESERVE BANK"
+          us_bank_account.default.should == true
+          us_bank_account.ach_mandate.text.should == "cl mandate text"
+          us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+          us_bank_account.verifications.count.should == 1
+          us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
+          us_bank_account.verifications.first.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::TokenizedCheck
+          us_bank_account.verifications.first.id.should_not be_empty
+          us_bank_account.verifications.first.verification_determined_at.should be_a Time
+          us_bank_account.verified.should == true
+
+          Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+        end
+
+        [
+          Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
+          Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        ].each do |method|
+          # we are temporarily skipping this test until we have a more stable CI env
+          xit "succeeds and verifies via #{method}" do
+            customer = Braintree::Customer.create.customer
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => nonce,
+              :customer_id => customer.id,
+              :options => {
+                :us_bank_account_verification_method => method,
+                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              },
+            )
+
+            result.should be_success
+            us_bank_account = result.payment_method
+            us_bank_account.should be_a(Braintree::UsBankAccount)
+            us_bank_account.routing_number.should == "011000015"
+            us_bank_account.last_4.should == "0000"
+            us_bank_account.account_type.should == "checking"
+            us_bank_account.account_holder_name.should == "PayPal, Inc."
+            us_bank_account.bank_name.should == "FEDERAL RESERVE BANK"
+            us_bank_account.default.should == true
+            us_bank_account.ach_mandate.text.should == "cl mandate text"
+            us_bank_account.ach_mandate.accepted_at.should be_a Time
+            us_bank_account.verified.should == true
+
+            us_bank_account.verifications.count.should == 2
+
+            us_bank_account.verifications.map(&:verification_method).should contain_exactly(
+              Braintree::UsBankAccountVerification::VerificationMethod::TokenizedCheck,
+              method,
+            )
+
+            us_bank_account.verifications.each do |verification|
+              verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
+              verification.id.should_not be_empty
+              verification.verification_determined_at.should be_a Time
+            end
+
+            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+          end
+        end
+      end
+
+      context "non plaid verified nonce" do
+        let(:nonce) { generate_non_plaid_us_bank_account_nonce }
+
+        it "succeeds and does not verify when no method provided" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          result.should be_success
+          us_bank_account = result.payment_method
+          us_bank_account.should be_a(Braintree::UsBankAccount)
+          us_bank_account.routing_number.should == "021000021"
+          us_bank_account.last_4.should == "0000"
+          us_bank_account.account_type.should == "checking"
+          us_bank_account.account_holder_name.should == "John Doe"
+          us_bank_account.bank_name.should =~ /CHASE/
+          us_bank_account.default.should == true
+          us_bank_account.ach_mandate.text.should == "cl mandate text"
+          us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+          us_bank_account.verifications.count.should == 0
+          us_bank_account.verified.should == false
+
+          Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+        end
+
+        [
+          Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
+          Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        ].each do |method|
+          it "succeeds and verifies via #{method}" do
+            customer = Braintree::Customer.create.customer
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => nonce,
+              :customer_id => customer.id,
+              :options => {
+                :us_bank_account_verification_method => method,
+                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              },
+            )
+
+            result.should be_success
+            us_bank_account = result.payment_method
+            us_bank_account.should be_a(Braintree::UsBankAccount)
+            us_bank_account.routing_number.should == "021000021"
+            us_bank_account.last_4.should == "0000"
+            us_bank_account.account_type.should == "checking"
+            us_bank_account.account_holder_name.should == "John Doe"
+            us_bank_account.bank_name.should =~ /CHASE/
+            us_bank_account.default.should == true
+            us_bank_account.ach_mandate.text.should == "cl mandate text"
+            us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+            us_bank_account.verifications.count.should == 1
+            us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
+            us_bank_account.verifications.first.verification_method.should == method
+            us_bank_account.verifications.first.id.should_not be_empty
+            us_bank_account.verifications.first.verification_determined_at.should be_a Time
+            us_bank_account.verified.should == true
+
+            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+          end
+        end
+      end
+
+      it "fails with invalid nonce" do
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => generate_invalid_us_bank_account_nonce,
+          :customer_id => customer.id,
+        )
+
+        result.should_not be_success
+        result.errors.for(:payment_method).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown
+      end
+    end
+
+    context "exempt merchant" do
+      context "plaid verified nonce" do
+        before do
+          Braintree::Configuration.merchant_id = "integration_merchant_id"
+          Braintree::Configuration.public_key = "integration_public_key"
+          Braintree::Configuration.private_key = "integration_private_key"
+        end
+
+        let(:nonce) { generate_valid_plaid_us_bank_account_nonce }
+
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+            },
+          )
+
+          result.should be_success
+          us_bank_account = result.payment_method
+          us_bank_account.should be_a(Braintree::UsBankAccount)
+          us_bank_account.routing_number.should == "011000015"
+          us_bank_account.last_4.should == "0000"
+          us_bank_account.account_type.should == "checking"
+          us_bank_account.account_holder_name.should == "PayPal, Inc."
+          us_bank_account.bank_name.should == "FEDERAL RESERVE BANK"
+          us_bank_account.default.should == true
+          us_bank_account.ach_mandate.text.should == "cl mandate text"
+          us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+          us_bank_account.verifications.count.should == 1
+          us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
+          us_bank_account.verifications.first.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::TokenizedCheck
+          us_bank_account.verifications.first.id.should_not be_empty
+          us_bank_account.verifications.first.verification_determined_at.should be_a Time
+          us_bank_account.verified.should == true
+
+          Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+        end
+      end
+
+      context "non plaid verified nonce" do
+        let(:nonce) { generate_non_plaid_us_bank_account_nonce }
+
+        # we are temporarily skipping this test until we have a more stable CI env
+        xit "succeeds and verifies via independent check" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+            },
+          )
+
+          result.should be_success
+          us_bank_account = result.payment_method
+          us_bank_account.should be_a(Braintree::UsBankAccount)
+          us_bank_account.routing_number.should == "021000021"
+          us_bank_account.last_4.should == "0000"
+          us_bank_account.account_type.should == "checking"
+          us_bank_account.account_holder_name.should == "John Doe"
+          us_bank_account.bank_name.should =~ /CHASE/
+          us_bank_account.default.should == true
+          us_bank_account.ach_mandate.text.should == "cl mandate text"
+          us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+          us_bank_account.verifications.count.should == 1
+          us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
+          us_bank_account.verifications.first.verification_method.should == Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck
+          us_bank_account.verifications.first.id.should_not be_empty
+          us_bank_account.verifications.first.verification_determined_at.should be_a Time
+          us_bank_account.verified.should == true
+
+          Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+        end
+      end
+
+      it "fails with invalid nonce" do
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => generate_invalid_us_bank_account_nonce,
+          :customer_id => customer.id,
+        )
+
+        result.should_not be_success
+        result.errors.for(:payment_method).on(:payment_method_nonce)[0].code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown
+      end
+    end
+  end
+
+  context "self.update" do
+    context "compliant merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration2_merchant_id"
+        Braintree::Configuration.public_key = "integration2_public_key"
+        Braintree::Configuration.private_key = "integration2_private_key"
+      end
+
+      context "unverified token" do
+        let(:payment_method) do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          ).payment_method
+        end
+
+        [
+          Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
+          Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        ].each do |method|
+          it "succeeds and verifies via #{method}" do
+            result = Braintree::PaymentMethod.update(
+              payment_method.token,
+              :options => {
+                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+                :us_bank_account_verification_method => method,
+              },
+            )
+
+            result.should be_success
+
+            us_bank_account = result.payment_method
+            us_bank_account.should be_a(Braintree::UsBankAccount)
+            us_bank_account.routing_number.should == "021000021"
+            us_bank_account.last_4.should == "0000"
+            us_bank_account.account_type.should == "checking"
+            us_bank_account.account_holder_name.should == "John Doe"
+            us_bank_account.bank_name.should =~ /CHASE/
+            us_bank_account.default.should == true
+            us_bank_account.ach_mandate.text.should == "cl mandate text"
+            us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+            us_bank_account.verifications.count.should == 1
+            us_bank_account.verifications.first.status.should == Braintree::UsBankAccountVerification::Status::Verified
+            us_bank_account.verifications.first.verification_method.should == method
+            us_bank_account.verifications.first.id.should_not be_empty
+            us_bank_account.verifications.first.verification_determined_at.should be_a Time
+            us_bank_account.verified.should == true
+
+            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+          end
+        end
+
+        it "fails with invalid verification method" do
+          result = Braintree::PaymentMethod.update(
+            payment_method.token,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :us_bank_account_verification_method => "blahblah",
+            },
+          )
+
+          result.should_not be_success
+          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+        end
+      end
+    end
+
+    context "exempt merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration_merchant_id"
+        Braintree::Configuration.public_key = "integration_public_key"
+        Braintree::Configuration.private_key = "integration_private_key"
+      end
+
+      context "unverified token" do
+        let(:payment_method) do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+            :customer_id => customer.id,
+            :options => {
+              :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+            },
+          ).payment_method
+        end
+
+        [
+          Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck,
+          Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+        ].each do |method|
+          it "succeeds and verifies via #{method}" do
+            result = Braintree::PaymentMethod.update(
+              payment_method.token,
+              :options => {
+                :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+                :us_bank_account_verification_method => method,
+              },
+            )
+
+            result.should be_success
+
+            us_bank_account = result.payment_method
+            us_bank_account.should be_a(Braintree::UsBankAccount)
+            us_bank_account.routing_number.should == "021000021"
+            us_bank_account.last_4.should == "0000"
+            us_bank_account.account_type.should == "checking"
+            us_bank_account.account_holder_name.should == "John Doe"
+            us_bank_account.bank_name.should =~ /CHASE/
+            us_bank_account.default.should == true
+            us_bank_account.ach_mandate.text.should == "cl mandate text"
+            us_bank_account.ach_mandate.accepted_at.should be_a Time
+
+            us_bank_account.verifications.count.should == 2
+            verification = us_bank_account.verifications.find do |verification|
+              verification.verification_method == method
+            end
+            verification.status.should == Braintree::UsBankAccountVerification::Status::Verified
+            verification.id.should_not be_empty
+            verification.verification_determined_at.should be_a Time
+            us_bank_account.verified.should == true
+
+            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+          end
+        end
+
+        it "fails with invalid verification method" do
+          result = Braintree::PaymentMethod.update(
+            payment_method.token,
+            :options => {
+              :us_bank_account_verification_method => "blahblah",
+            },
+          )
+
+          result.should_not be_success
+          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+        end
+      end
+    end
+  end
+end

data/spec/integration/braintree/paypal_account_spec.rb

@@ -9,11 +9,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       result.should be_success
 
@@ -25,6 +25,7 @@ describe Braintree::PayPalAccount do
       paypal_account.created_at.should_not be_nil
       paypal_account.updated_at.should_not be_nil
       paypal_account.customer_id.should == customer.id
+      paypal_account.revoked_at.should be_nil
     end
 
     it "returns a PayPalAccount with a billing agreement id" do
@@ -34,7 +35,7 @@ describe Braintree::PayPalAccount do
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
         :customer_id => customer.id,
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result.should be_success
 
@@ -55,7 +56,7 @@ describe Braintree::PayPalAccount do
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
         :cvv => "100",
-        :token => "CREDIT_CARD_TOKEN"
+        :token => "CREDIT_CARD_TOKEN",
       )
 
       expect do
@@ -69,11 +70,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => payment_method_token
+        :token => payment_method_token,
       )
       result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
       result.should be_success
 
@@ -81,12 +82,12 @@ describe Braintree::PayPalAccount do
 
       subscription1 = Braintree::Subscription.create(
         :payment_method_token => token,
-        :plan_id => SpecHelper::TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id],
       ).subscription
 
       subscription2 = Braintree::Subscription.create(
         :payment_method_token => token,
-        :plan_id => SpecHelper::TriallessPlan[:id]
+        :plan_id => SpecHelper::TriallessPlan[:id],
       ).subscription
 
       paypal_account = Braintree::PayPalAccount.find(token)
@@ -104,7 +105,7 @@ describe Braintree::PayPalAccount do
         :options => {
             :make_default => true,
             :fail_on_duplicate_payment_method => true,
-        }
+        },
       )
 
       result.should be_success
@@ -115,7 +116,7 @@ describe Braintree::PayPalAccount do
     it "throws an error if customer id is not specified" do
       result = Braintree::PayPalAccount.create(
         :billing_agreement_id => "some_billing_agreement_id",
-        :email => "some@example.com"
+        :email => "some@example.com",
       )
 
       result.success?.should == false
@@ -126,11 +127,11 @@ describe Braintree::PayPalAccount do
       customer = Braintree::Customer.create!
       result = Braintree::PayPalAccount.create(
         :customer_id => customer.id,
-        :email => "some@example.com"
+        :email => "some@example.com",
       )
 
       result.success?.should == false
-      result.errors.first.code.should == "82902"
+      result.errors.map(&:code).should include("82902")
     end
   end
 
@@ -140,14 +141,14 @@ describe Braintree::PayPalAccount do
       create_result = Braintree::PayPalAccount.create(
         :customer_id => customer.id,
         :billing_agreement_id => "first_billing_agreement_id",
-        :email => "first@example.com"
+        :email => "first@example.com",
       )
       create_result.success?.should == true
 
       update_result = Braintree::PayPalAccount.update(
         create_result.paypal_account.token,
         :billing_agreement_id => "second_billing_agreement_id",
-        :email => "second@example.com"
+        :email => "second@example.com",
       )
 
       update_result.success?.should == true
@@ -162,17 +163,17 @@ describe Braintree::PayPalAccount do
       original_token = random_payment_method_token
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => original_token
+        :token => original_token,
       )
       original_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       updated_token = "UPDATED_TOKEN-" + rand(36**3).to_s(36)
       updated_result = Braintree::PayPalAccount.update(
         original_token,
-        :token => updated_token
+        :token => updated_token,
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
@@ -189,19 +190,19 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
         :number => Braintree::Test::CreditCardNumbers::Visa,
         :expiration_date => "05/2009",
-        :options => {:make_default => true}
+        :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
+        :customer_id => customer.id,
       ).payment_method.token
 
       updated_result = Braintree::PayPalAccount.update(
         original_token,
-        :options => {:make_default => true}
+        :options => {:make_default => true},
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(original_token)
@@ -215,25 +216,25 @@ describe Braintree::PayPalAccount do
 
       first_nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => first_token
+        :token => first_token,
       )
       first_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => first_nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       second_nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => second_token
+        :token => second_token,
       )
       second_result = Braintree::PaymentMethod.create(
         :payment_method_nonce => second_nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       updated_result = Braintree::PayPalAccount.update(
         first_token,
-        :token => second_token
+        :token => second_token,
       )
 
       updated_result.should_not be_success
@@ -248,11 +249,11 @@ describe Braintree::PayPalAccount do
 
       nonce = nonce_for_paypal_account(
         :consent_code => "consent-code",
-        :token => token
+        :token => token,
       )
       Braintree::PaymentMethod.create(
         :payment_method_nonce => nonce,
-        :customer_id => customer.id
+        :customer_id => customer.id,
       )
 
       result = Braintree::PayPalAccount.delete(token)
@@ -266,13 +267,13 @@ describe Braintree::PayPalAccount do
   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
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       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.amount.should == BigDecimal("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
@@ -282,12 +283,12 @@ describe Braintree::PayPalAccount do
   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
+        :payment_method_nonce => Braintree::Test::Nonce::PayPalBillingAgreement,
       )
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      transaction.amount.should == BigDecimal.new("100.00")
+      transaction.amount.should == BigDecimal("100.00")
       transaction.type.should == "sale"
       transaction.customer_details.id.should == customer.id
       transaction.paypal_details.token.should == customer.paypal_accounts[0].token