braintree 2.31.0 → 2.32.1

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

@@ -1,22 +1,58 @@
 require 'json'
 
-def nonce_for_new_credit_card(options)
+def decode_client_token(raw_client_token)
+  decoded_client_token_string = Base64.decode64(raw_client_token)
+  JSON.parse(decoded_client_token_string)
+end
+
+def nonce_for_new_payment_method(options)
+  client = _initialize_client(options)
+  response = client.add_payment_method(options)
+
+  _nonce_from_response(response)
+end
+
+def _initialize_client(options)
   client_token_options = options.delete(:client_token_options) || {}
-  client_token = Braintree::ClientToken.generate(client_token_options)
-  client = ClientApiHttp.new(Braintree::Configuration.instantiate,
-    :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+  raw_client_token = Braintree::ClientToken.generate(client_token_options)
+  client_token = decode_client_token(raw_client_token)
+
+  ClientApiHttp.new(Braintree::Configuration.instantiate,
+    :authorization_fingerprint => client_token["authorizationFingerprint"],
     :shared_customer_identifier => "fake_identifier",
     :shared_customer_identifier_type => "testing"
   )
+end
 
-  response = client.add_card(options)
+def _nonce_from_response(response)
   body = JSON.parse(response.body)
 
   if body["errors"] != nil
     raise body["errors"].inspect
   end
 
-  body["nonce"]
+  if body.has_key?("paypalAccounts")
+    body["paypalAccounts"][0]["nonce"]
+  else
+    body["creditCards"][0]["nonce"]
+  end
+end
+
+def nonce_for_paypal_account(paypal_account_details)
+  raw_client_token = Braintree::ClientToken.generate
+  client_token = decode_client_token(raw_client_token)
+  client = ClientApiHttp.new(Braintree::Configuration.instantiate,
+    :authorization_fingerprint => client_token["authorizationFingerprint"]
+  )
+
+  response = client.create_paypal_account(paypal_account_details)
+  body = JSON.parse(response.body)
+
+  if body["errors"] != nil
+    raise body["errors"].inspect
+  end
+
+  body["paypalAccounts"][0]["nonce"]
 end
 
 class ClientApiHttp
@@ -35,6 +71,10 @@ class ClientApiHttp
     _http_do(Net::HTTP::Post, path, params.to_json)
   end
 
+  def put(path, params)
+    _http_do(Net::HTTP::Put, path, params.to_json)
+  end
+
   def fingerprint=(fingerprint)
     @options[:authorization_fingerprint] = fingerprint
   end
@@ -59,9 +99,9 @@ class ClientApiHttp
     raise Braintree::SSLCertificateError
   end
 
-  def get_cards
+  def get_payment_methods
     encoded_fingerprint = Braintree::Util.url_encode(@options[:authorization_fingerprint])
-    url = "/merchants/#{@config.merchant_id}/client_api/nonces.json?"
+    url = "/merchants/#{@config.merchant_id}/client_api/v1/payment_methods?"
     url += "authorizationFingerprint=#{encoded_fingerprint}"
     url += "&sharedCustomerIdentifier=#{@options[:shared_customer_identifier]}"
     url += "&sharedCustomerIdentifierType=#{@options[:shared_customer_identifier_type]}"
@@ -69,12 +109,55 @@ class ClientApiHttp
     get(url)
   end
 
-  def add_card(params)
+  def add_payment_method(params)
     fingerprint = @options[:authorization_fingerprint]
     params[:authorizationFingerprint] = fingerprint
     params[:sharedCustomerIdentifier] = @options[:shared_customer_identifier]
     params[:sharedCustomerIdentifierType] = @options[:shared_customer_identifier_type]
 
-    post("/merchants/#{@config.merchant_id}/client_api/nonces.json", params)
+    payment_method_type = nil
+    if params.has_key?(:paypal_account)
+      payment_method_type = "paypal_accounts"
+    else
+      payment_method_type = "credit_cards"
+    end
+
+    post("/merchants/#{@config.merchant_id}/client_api/v1/payment_methods/#{payment_method_type}", params)
+  end
+
+  def create_credit_card(params)
+    params = {:credit_card => params}
+    params.merge!(
+      :authorization_fingerprint => @options[:authorization_fingerprint],
+      :shared_customer_identifier => "fake_identifier",
+      :shared_customer_identifier_type => "testing"
+    )
+
+    post("/merchants/#{config.merchant_id}/client_api/v1/payment_methods/credit_cards", params)
+  end
+
+  def create_paypal_account(params)
+    params = {:paypal_account => params}
+    params.merge!(
+      :authorization_fingerprint => @options[:authorization_fingerprint]
+    )
+
+    post("/merchants/#{config.merchant_id}/client_api/v1/payment_methods/paypal_accounts", params)
+  end
+
+  def create_sepa_bank_account_nonce(params)
+    foo = {
+      :authorization_fingerprint => @options[:authorization_fingerprint],
+      :shared_customer_identifier => "fake_identifier",
+      :shared_customer_identifier_type => "testing",
+
+      :sepa_mandate => params
+    }
+
+    response = post("/merchants/#{config.merchant_id}/client_api/v1/sepa_mandates", foo)
+
+    mrn = JSON.parse(response.body)['sepaMandates'][0]['mandateReferenceNumber']
+    accept_response = put("/merchants/#{config.merchant_id}/client_api/v1/sepa_mandates/#{mrn}/accept.json",foo)
+    JSON.parse(accept_response.body)['sepaBankAccounts'][0]['nonce']
   end
 end

data/spec/integration/braintree/credit_card_spec.rb

@@ -456,7 +456,7 @@ describe Braintree::CreditCard do
 
     context "client API" do
       it "adds credit card to an existing customer using a payment method nonce" do
-        nonce = nonce_for_new_credit_card(
+        nonce = nonce_for_new_payment_method(
           :credit_card => {
             :number => "4111111111111111",
             :expiration_month => "11",
@@ -1050,24 +1050,6 @@ describe Braintree::CreditCard do
     end
   end
 
-  describe "delete" do
-    it "deletes the credit card" do
-      customer = Braintree::Customer.create.customer
-      result = Braintree::CreditCard.create(
-        :customer_id => customer.id,
-        :number => Braintree::Test::CreditCardNumbers::Visa,
-        :expiration_date => "05/2012"
-      )
-
-      result.success?.should == true
-      credit_card = result.credit_card
-      credit_card.delete.should == true
-      expect do
-        Braintree::CreditCard.find(credit_card.token)
-      end.to raise_error(Braintree::NotFoundError)
-    end
-  end
-
   describe "self.expired" do
     it "can iterate over all items, and make sure they are all expired" do
       customer = Braintree::Customer.all.first
@@ -1161,12 +1143,30 @@ describe Braintree::CreditCard do
         Braintree::CreditCard.find("invalid-token")
       end.to raise_error(Braintree::NotFoundError, 'payment method with token "invalid-token" not found')
     end
+
+    it "raises a NotFoundError exception if searching for a PayPalAccount token" do
+      customer = Braintree::Customer.create!
+      paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+      paypal_nonce = nonce_for_paypal_account({
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token
+      })
+
+      Braintree::PaymentMethod.create({
+        :payment_method_nonce => paypal_nonce,
+        :customer_id => customer.id
+      })
+
+      expect do
+        Braintree::CreditCard.find(paypal_account_token)
+      end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{paypal_account_token}\" not found")
+    end
   end
 
   describe "self.from_nonce" do
     it "finds the payment method with the given nonce" do
       customer = Braintree::Customer.create!
-      nonce = nonce_for_new_credit_card(
+      nonce = nonce_for_new_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -1181,7 +1181,7 @@ describe Braintree::CreditCard do
     end
 
     it "does not find a payment method for an unlocked nonce that points to a shared credit card" do
-      nonce = nonce_for_new_credit_card(
+      nonce = nonce_for_new_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -1194,14 +1194,15 @@ describe Braintree::CreditCard do
     end
 
     it "does not find the payment method for a locked nonce" do
-      client_token = Braintree::ClientToken.generate
+      raw_client_token = Braintree::ClientToken.generate
+      client_token = decode_client_token(raw_client_token)
       client = ClientApiHttp.new(Braintree::Configuration.instantiate,
-        :authorization_fingerprint => JSON.parse(client_token)["authorizationFingerprint"],
+        :authorization_fingerprint => client_token["authorizationFingerprint"],
         :shared_customer_identifier => "fake_identifier",
         :shared_customer_identifier_type => "testing"
       )
 
-      client.add_card(
+      client.add_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",
@@ -1210,9 +1211,9 @@ describe Braintree::CreditCard do
         :share => true
       )
 
-      response = client.get_cards
+      response = client.get_payment_methods
       body = JSON.parse(response.body)
-      nonce = body["creditCards"].first["nonce"]
+      nonce = body["paymentMethods"].first["nonce"]
 
       expect do
         Braintree::CreditCard.from_nonce(nonce)
@@ -1221,7 +1222,7 @@ describe Braintree::CreditCard do
 
     it "does not find the payment method for a consumednonce" do
       customer = Braintree::Customer.create!
-      nonce = nonce_for_new_credit_card(
+      nonce = nonce_for_new_payment_method(
         :credit_card => {
           :number => "4111111111111111",
           :expiration_month => "11",

data/spec/integration/braintree/customer_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
@@ -169,4 +170,26 @@ describe Braintree::Transaction, "search" do
       collection.first.company.should == customer.company
     end
   end
+
+  it "can search by paypal_account_email" do
+    paypal_token = rand(36**3).to_s(36)
+    nonce = nonce_for_paypal_account(
+      :consent_code => "PAYPAL_CONSENT_CODE",
+      :token => paypal_token
+    )
+
+    customer_id = "UNIQUE_CUSTOMER_ID_" + rand(36**3).to_s(36)
+    customer = Braintree::Customer.create!(
+      :payment_method_nonce => nonce,
+      :id => customer_id
+    )
+
+    collection = Braintree::Customer.search do |search|
+      search.paypal_account_email.is "jane.doe@example.com"
+      search.id.is customer_id
+    end
+
+    collection.maximum_size.should == 1
+    collection.first.should == customer
+  end
 end

data/spec/integration/braintree/customer_spec.rb

@@ -383,7 +383,7 @@ describe Braintree::Customer do
 
     context "client API" do
       it "can create a customer with a payment method nonce" do
-        nonce = nonce_for_new_credit_card(
+        nonce = nonce_for_new_payment_method(
           :credit_card => {
             :number => "4111111111111111",
             :expiration_month => "11",
@@ -1135,4 +1135,86 @@ describe Braintree::Customer do
       customer.default_credit_card.should == default_credit_card
     end
   end
+
+  describe "paypal" do
+    context "future" do
+      it "creates a customer with a future paypal account" do
+        result = Braintree::Customer.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalFuturePayment
+        )
+
+        result.should be_success
+      end
+
+      it "updates a customer with a future paypal account" do
+        customer = Braintree::Customer.create!(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
+            }
+          }
+        )
+
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :consent_code => "PAYPAL_CONSENT_CODE",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          }
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce
+        )
+
+        result.should be_success
+        result.customer.default_payment_method.token.should == paypal_account_token
+      end
+    end
+
+    context "onetime" do
+      it "does not create a customer with a onetime paypal account" do
+        result = Braintree::Customer.create(
+          :payment_method_nonce => Braintree::Test::Nonce::PayPalOneTimePayment
+        )
+
+        result.should_not be_success
+      end
+
+      it "does not update a customer with a onetime paypal account" do
+        credit_card_token = rand(36**3).to_s(36)
+        customer = Braintree::Customer.create!(
+          :credit_card => {
+            :token => credit_card_token,
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "12/2015",
+            :options => {
+              :make_default => true
+            }
+          }
+        )
+
+        paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+        nonce = nonce_for_paypal_account(
+          :access_token => "PAYPAL_ACCESS_TOKEN",
+          :token => paypal_account_token,
+          :options => {
+            :make_default => true
+          }
+        )
+
+        result = Braintree::Customer.update(
+          customer.id,
+          :payment_method_nonce => nonce
+        )
+
+        result.should_not be_success
+        customer.default_payment_method.token.should == credit_card_token
+      end
+    end
+  end
 end

data/spec/integration/braintree/payment_method_spec.rb

@@ -0,0 +1,315 @@
+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
+    it "creates a payment method from a vaulted credit card nonce" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => 4111111111111111,
+        :expirationMonth => 12,
+        :expirationYear => 2020
+      )
+      response.code.should == "201"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+    end
+
+    it "creates a payment method from an unvalidated credit card nonce" do
+      config = Braintree::Configuration.instantiate
+      customer = Braintree::Customer.create.customer
+      raw_client_token = Braintree::ClientToken.generate(:customer_id => customer.id)
+      client_token = decode_client_token(raw_client_token)
+      authorization_fingerprint = client_token["authorizationFingerprint"]
+      http = ClientApiHttp.new(
+        config,
+        :authorization_fingerprint => authorization_fingerprint,
+        :shared_customer_identifier => "fake_identifier",
+        :shared_customer_identifier_type => "testing"
+      )
+
+      response = http.create_credit_card(
+        :number => "4111111111111111",
+        :expirationMonth => "12",
+        :expirationYear => "2020",
+        :options => {:validate => false}
+      )
+      response.code.should == "202"
+
+      nonce = JSON.parse(response.body)["creditCards"].first["nonce"]
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      result.should be_success
+      result.payment_method.should be_a(Braintree::CreditCard)
+      token = result.payment_method.token
+
+      found_credit_card = Braintree::CreditCard.find(token)
+      found_credit_card.should_not be_nil
+    end
+
+    it "allows passing the make_default option alongside the nonce" do
+      customer = Braintree::Customer.create!
+      result = Braintree::CreditCard.create(
+        :customer_id => customer.id,
+        :number => Braintree::Test::CreditCardNumbers::Visa,
+        :expiration_date => "05/2009",
+        :cvv => "100"
+      )
+      result.success?.should == true
+      original_payment_method = result.credit_card
+      original_payment_method.should be_default
+
+      nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {:make_default => true}
+      )
+
+      result.should be_success
+      new_payment_method = result.payment_method
+      new_payment_method.should be_default
+    end
+
+    it "overrides the token in the nonce" do
+      customer = Braintree::Customer.create!
+
+      first_token = "FIRST_TOKEN_#{rand(36**3).to_s(36)}"
+      second_token = "SECOND_TOKEN_#{rand(36**3).to_s(36)}"
+      nonce = nonce_for_paypal_account(
+        :consent_code => "PAYPAL_CONSENT_CODE",
+        :token => first_token
+      )
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :token => second_token
+      )
+
+      result.should be_success
+      payment_method = result.payment_method
+      payment_method.token.should ==  second_token
+    end
+
+    context "paypal" do
+      it "creates a payment method from an unvalidated future paypal account nonce" do
+        nonce = nonce_for_paypal_account(:consent_code => "PAYPAL_CONSENT_CODE")
+        customer = Braintree::Customer.create.customer
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        )
+
+        result.should be_success
+        result.payment_method.should be_a(Braintree::PayPalAccount)
+        result.payment_method.image_url.should_not be_nil
+        token = result.payment_method.token
+
+        found_paypal_account = Braintree::PayPalAccount.find(token)
+        found_paypal_account.should_not be_nil
+      end
+
+      it "does not create a payment method from an unvalidated onetime paypal account nonce" do
+        customer = Braintree::Customer.create.customer
+        nonce = nonce_for_paypal_account(:access_token => "PAYPAL_ACCESS_TOKEN")
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        )
+
+        result.should_not be_success
+        result.errors.first.code.should == "82902"
+      end
+
+      it "returns appropriate validation errors" do
+        customer = Braintree::Customer.create.customer
+        nonce = nonce_for_paypal_account(:token => "PAYPAL_TOKEN")
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        )
+
+        result.should_not be_success
+        errors = result.errors.map(&:code)
+        errors.should include("82901")
+        errors.should include("82902")
+      end
+    end
+
+    context "SEPA" do
+      it "returns the SEPA bank account behind the nonce" 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
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id
+        )
+
+        result.should be_success
+        result.payment_method.token.should_not == nil
+        result.payment_method.image_url.should_not be_nil
+      end
+    end
+  end
+
+  describe "self.find" do
+    context "credit cards" do
+      it "finds the payment method with the given token" do
+        customer = Braintree::Customer.create.customer
+        result = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        )
+        result.success?.should == true
+
+        credit_card = Braintree::PaymentMethod.find(result.credit_card.token)
+        credit_card.bin.should == Braintree::Test::CreditCardNumbers::Visa[0, 6]
+        credit_card.last_4.should == Braintree::Test::CreditCardNumbers::Visa[-4..-1]
+        credit_card.token.should == result.credit_card.token
+        credit_card.expiration_date.should == "05/2012"
+      end
+
+      it "returns associated subscriptions with the credit card" do
+        customer = Braintree::Customer.create.customer
+        credit_card = Braintree::CreditCard.create(
+          :customer_id => customer.id,
+          :number => Braintree::Test::CreditCardNumbers::Visa,
+          :expiration_date => "05/2012"
+        ).credit_card
+
+        subscription = Braintree::Subscription.create(
+          :payment_method_token => credit_card.token,
+          :plan_id => "integration_trialless_plan",
+          :price => "1.00"
+        ).subscription
+
+        found_card = Braintree::PaymentMethod.find(credit_card.token)
+        found_card.subscriptions.first.id.should == subscription.id
+        found_card.subscriptions.first.plan_id.should == "integration_trialless_plan"
+        found_card.subscriptions.first.payment_method_token.should == credit_card.token
+        found_card.subscriptions.first.price.should == BigDecimal.new("1.00")
+      end
+    end
+
+    context "paypal accounts" do
+      it "finds the payment method with the given token" do
+        customer = Braintree::Customer.create!
+        payment_method_token = "PAYMENT_METHOD_TOKEN_#{rand(36**3).to_s(36)}"
+        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::PaymentMethod.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"
+      end
+    end
+
+    it "raises a NotFoundError exception if payment method cannot be found" do
+      expect do
+        Braintree::PaymentMethod.find("invalid-token")
+      end.to raise_error(Braintree::NotFoundError, 'payment method with token "invalid-token" not found')
+    end
+  end
+
+  describe "self.delete" do
+    it "deletes a paypal account" do
+      customer = Braintree::Customer.create!
+      paypal_account_token = "PAYPAL_ACCOUNT_TOKEN_#{rand(36**3).to_s(36)}"
+      nonce = nonce_for_paypal_account(
+        :consent_code => "PAYPAL_CONSENT_CODE",
+        :token => paypal_account_token
+      )
+      Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      paypal_account = Braintree::PaymentMethod.find(paypal_account_token)
+      paypal_account.should be_a(Braintree::PayPalAccount)
+
+      result = Braintree::PaymentMethod.delete(paypal_account_token)
+
+      expect do
+        Braintree::PaymentMethod.find(paypal_account_token)
+      end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{paypal_account_token}\" not found")
+    end
+
+    it "deletes a credit card" do
+      token = "CREDIT_CARD_#{rand(36**3).to_s(36)}"
+      customer = Braintree::Customer.create!
+      nonce = nonce_for_new_payment_method({
+        :credit_card => {
+          :number => "4111111111111111",
+          :expiration_month => "11",
+          :expiration_year => "2099",
+          :token => token
+        },
+        :client_token_options => {:customer_id => customer.id}
+      })
+
+      Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id
+      )
+
+      Braintree::PaymentMethod.delete(token)
+
+      expect do
+        Braintree::PaymentMethod.find(token)
+      end.to raise_error(Braintree::NotFoundError, "payment method with token \"#{token}\" not found")
+    end
+  end
+end