braintree 2.104.0 → 3.3.0

data/spec/integration/braintree/dispute_search_spec.rb

@@ -82,7 +82,7 @@ describe Braintree::Dispute, "search" do
       effective_date = transaction.disputes.first.status_history.first.effective_date
 
       collection = Braintree::Dispute.search do |search|
-        search.effective_date.between(effective_date, Date.parse(effective_date).next_day.to_s)
+        search.effective_date.between(effective_date, effective_date.next_day)
       end
 
       expect(collection.disputes.count).to be >= 1
@@ -95,7 +95,7 @@ describe Braintree::Dispute, "search" do
       disbursement_date = transaction.disputes.first.status_history.first.disbursement_date
 
       collection = Braintree::Dispute.search do |search|
-        search.disbursement_date.between(disbursement_date, Date.parse(disbursement_date).next_day.to_s)
+        search.disbursement_date.between(disbursement_date, disbursement_date.next_day)
       end
 
       expect(collection.disputes.count).to be >= 1
@@ -109,7 +109,7 @@ describe Braintree::Dispute, "search" do
         search.received_date.between("03/03/2014", "03/05/2014")
       end
 
-      expect(collection.disputes.count).to eq(1)
+      expect(collection.disputes.count).to be >= 1
       dispute = collection.disputes.first
 
       expect(dispute.received_date).to eq(Date.new(2014, 3, 4))

data/spec/integration/braintree/dispute_spec.rb

@@ -141,7 +141,7 @@ describe Braintree::Dispute do
     end
 
     it "creates text evidence for the dispute with optional parameters" do
-      result = Braintree::Dispute.add_text_evidence(dispute.id, { content: "123456789", tag: "REFUND_ID", sequence_number: 7 })
+      result = Braintree::Dispute.add_text_evidence(dispute.id, { content: "123456789", category: "REFUND_ID", sequence_number: 7 })
 
       result.success?.should == true
       result.evidence.category.should == "REFUND_ID"
@@ -149,7 +149,6 @@ describe Braintree::Dispute do
       result.evidence.created_at.between?(Time.now - 10, Time.now).should == true
       result.evidence.id.should =~ /^\w{16,}$/
       result.evidence.sent_to_processor_at.should == nil
-      result.evidence.tag.should == "REFUND_ID"
       result.evidence.sequence_number.should == 7
     end
   end

data/spec/integration/braintree/merchant_spec.rb

@@ -305,7 +305,7 @@ describe Braintree::MerchantGateway do
       it "succeeds" do
         result = Braintree::Merchant.provision_raw_apple_pay
         result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro", "elo"]
       end
 
       it "is repeatable" do
@@ -313,7 +313,7 @@ describe Braintree::MerchantGateway do
         result.should be_success
         result = Braintree::Merchant.provision_raw_apple_pay
         result.should be_success
-        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro", "elo"]
       end
     end
 

data/spec/integration/braintree/payment_method_spec.rb

@@ -101,87 +101,60 @@ describe Braintree::PaymentMethod do
       apple_pay_card.customer_id.should == customer.id
     end
 
-    it "creates a payment method from a fake android pay proxy card nonce" do
+    it "creates a payment method from a fake google pay proxy card nonce" do
       customer = Braintree::Customer.create.customer
       token = SecureRandom.hex(16)
       result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
         :customer_id => customer.id,
         :token => token
       )
 
       result.should be_success
-      android_pay_card = result.payment_method
-      android_pay_card.should be_a(Braintree::AndroidPayCard)
-      android_pay_card.should_not be_nil
-      android_pay_card.token.should == token
-      android_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.expiration_month.to_i.should > 0
-      android_pay_card.expiration_year.to_i.should > 0
-      android_pay_card.default.should == true
-      android_pay_card.image_url.should =~ /android_pay/
-      android_pay_card.is_network_tokenized?.should == false
-      android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
-      android_pay_card.source_card_last_4.should == "1111"
-      android_pay_card.google_transaction_id.should == "google_transaction_id"
-      android_pay_card.source_description.should == "Discover 1111"
-      android_pay_card.customer_id.should == customer.id
+      google_pay_card = result.payment_method
+      google_pay_card.should be_a(Braintree::GooglePayCard)
+      google_pay_card.should_not be_nil
+      google_pay_card.token.should == token
+      google_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
+      google_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
+      google_pay_card.expiration_month.to_i.should > 0
+      google_pay_card.expiration_year.to_i.should > 0
+      google_pay_card.default.should == true
+      google_pay_card.image_url.should =~ /android_pay/
+      google_pay_card.is_network_tokenized?.should == false
+      google_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
+      google_pay_card.source_card_last_4.should == "1111"
+      google_pay_card.google_transaction_id.should == "google_transaction_id"
+      google_pay_card.source_description.should == "Discover 1111"
+      google_pay_card.customer_id.should == customer.id
     end
 
-    it "creates a payment method from a android pay network token nonce" do
+    it "creates a payment method from a google pay network token nonce" do
       customer = Braintree::Customer.create.customer
       token = SecureRandom.hex(16)
       result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayMasterCard,
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
         :customer_id => customer.id,
         :token => token
       )
 
       result.should be_success
-      android_pay_card = result.payment_method
-      android_pay_card.should be_a(Braintree::AndroidPayCard)
-      android_pay_card.should_not be_nil
-      android_pay_card.token.should == token
-      android_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.expiration_month.to_i.should > 0
-      android_pay_card.expiration_year.to_i.should > 0
-      android_pay_card.default.should == true
-      android_pay_card.image_url.should =~ /android_pay/
-      android_pay_card.is_network_tokenized?.should == true
-      android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
-      android_pay_card.source_card_last_4.should == "4444"
-      android_pay_card.google_transaction_id.should == "google_transaction_id"
-      android_pay_card.source_description.should == "MasterCard 4444"
-      android_pay_card.customer_id.should == customer.id
-    end
-
-    it "creates a payment method from an amex express checkout card nonce" do
-      customer = Braintree::Customer.create.customer
-      token = SecureRandom.hex(16)
-      result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AmexExpressCheckout,
-        :customer_id => customer.id,
-        :token => token
-      )
-
-      result.should be_success
-      amex_express_checkout_card = result.payment_method
-      amex_express_checkout_card.should be_a(Braintree::AmexExpressCheckoutCard)
-      amex_express_checkout_card.should_not be_nil
-
-      amex_express_checkout_card.default.should == true
-      amex_express_checkout_card.card_type.should == "American Express"
-      amex_express_checkout_card.token.should == token
-      amex_express_checkout_card.bin.should =~ /\A\d{6}\z/
-      amex_express_checkout_card.expiration_month.should =~ /\A\d{2}\z/
-      amex_express_checkout_card.expiration_year.should =~ /\A\d{4}\z/
-      amex_express_checkout_card.card_member_number.should =~ /\A\d{4}\z/
-      amex_express_checkout_card.card_member_expiry_date.should =~ /\A\d{2}\/\d{2}\z/
-      amex_express_checkout_card.image_url.should include(".png")
-      amex_express_checkout_card.source_description.should =~ /\AAmEx \d{4}\z/
-      amex_express_checkout_card.customer_id.should == customer.id
+      google_pay_card = result.payment_method
+      google_pay_card.should be_a(Braintree::GooglePayCard)
+      google_pay_card.should_not be_nil
+      google_pay_card.token.should == token
+      google_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
+      google_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
+      google_pay_card.expiration_month.to_i.should > 0
+      google_pay_card.expiration_year.to_i.should > 0
+      google_pay_card.default.should == true
+      google_pay_card.image_url.should =~ /android_pay/
+      google_pay_card.is_network_tokenized?.should == true
+      google_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
+      google_pay_card.source_card_last_4.should == "4444"
+      google_pay_card.google_transaction_id.should == "google_transaction_id"
+      google_pay_card.source_description.should == "MasterCard 4444"
+      google_pay_card.customer_id.should == customer.id
     end
 
     it "creates a payment method from venmo account nonce" do
@@ -876,6 +849,99 @@ describe Braintree::PaymentMethod do
         payment_method.should be_a Braintree::UnknownPaymentMethod
       end
     end
+
+    context "verification_currency_iso_code" do
+      it "validates verification_currency_iso_code against currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "USD"
+          }
+        )
+
+        result.should be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+      end
+
+      it "validates verification_currency_iso_code against currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "USD"
+          }
+        )
+
+        result.should be_success
+        result.payment_method.verification.currency_iso_code  == "USD"
+        result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+      end
+
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in default merchant account" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_currency_iso_code => "GBP"
+          }
+        )
+        result.should_not be_success
+        result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+      end
+
+      it "errors with invalid presentment currency due to verification_currency_iso_code not matching with currency configured in verification_merchant_account_id" do
+        nonce = nonce_for_new_payment_method(
+          :credit_card => {
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_month => "11",
+            :expiration_year => "2099",
+          }
+        )
+        customer = Braintree::Customer.create!
+        result = Braintree::PaymentMethod.create(
+          :payment_method_nonce => nonce,
+          :customer_id => customer.id,
+          :options => {
+            :verify_card => true,
+            :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,
+            :verification_currency_iso_code => "GBP"
+          }
+        )
+
+        result.should_not be_success
+        result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+      end
+    end
   end
 
   describe "self.create!" do
@@ -1024,61 +1090,61 @@ describe Braintree::PaymentMethod do
       end
     end
 
-    context "android pay cards" do
+    context "google pay cards" do
       it "finds the proxy card payment method with the given token" do
         customer = Braintree::Customer.create!
         payment_method_token = make_token
         result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
           :customer_id => customer.id,
           :token => payment_method_token
         )
         result.should be_success
 
-        android_pay_card = Braintree::PaymentMethod.find(payment_method_token)
-        android_pay_card.should be_a(Braintree::AndroidPayCard)
-        android_pay_card.should_not be_nil
-        android_pay_card.token.should == payment_method_token
-        android_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.expiration_month.to_i.should > 0
-        android_pay_card.expiration_year.to_i.should > 0
-        android_pay_card.default.should == true
-        android_pay_card.image_url.should =~ /android_pay/
-        android_pay_card.is_network_tokenized?.should == false
-        android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
-        android_pay_card.source_card_last_4.should == "1111"
-        android_pay_card.google_transaction_id.should == "google_transaction_id"
-        android_pay_card.source_description.should == "Discover 1111"
-        android_pay_card.customer_id.should == customer.id
+        google_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        google_pay_card.should be_a(Braintree::GooglePayCard)
+        google_pay_card.should_not be_nil
+        google_pay_card.token.should == payment_method_token
+        google_pay_card.card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_card.expiration_month.to_i.should > 0
+        google_pay_card.expiration_year.to_i.should > 0
+        google_pay_card.default.should == true
+        google_pay_card.image_url.should =~ /android_pay/
+        google_pay_card.is_network_tokenized?.should == false
+        google_pay_card.source_card_type.should == Braintree::CreditCard::CardType::Discover
+        google_pay_card.source_card_last_4.should == "1111"
+        google_pay_card.google_transaction_id.should == "google_transaction_id"
+        google_pay_card.source_description.should == "Discover 1111"
+        google_pay_card.customer_id.should == customer.id
       end
 
       it "finds the network token payment method with the given token" do
         customer = Braintree::Customer.create!
         payment_method_token = make_token
         result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => Braintree::Test::Nonce::AndroidPayMasterCard,
+          :payment_method_nonce => Braintree::Test::Nonce::GooglePayMasterCard,
           :customer_id => customer.id,
           :token => payment_method_token
         )
         result.should be_success
 
-        android_pay_card = Braintree::PaymentMethod.find(payment_method_token)
-        android_pay_card.should be_a(Braintree::AndroidPayCard)
-        android_pay_card.should_not be_nil
-        android_pay_card.token.should == payment_method_token
-        android_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.expiration_month.to_i.should > 0
-        android_pay_card.expiration_year.to_i.should > 0
-        android_pay_card.default.should == true
-        android_pay_card.image_url.should =~ /android_pay/
-        android_pay_card.is_network_tokenized?.should == true
-        android_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
-        android_pay_card.source_card_last_4.should == "4444"
-        android_pay_card.google_transaction_id.should == "google_transaction_id"
-        android_pay_card.source_description.should == "MasterCard 4444"
-        android_pay_card.customer_id.should == customer.id
+        google_pay_card = Braintree::PaymentMethod.find(payment_method_token)
+        google_pay_card.should be_a(Braintree::GooglePayCard)
+        google_pay_card.should_not be_nil
+        google_pay_card.token.should == payment_method_token
+        google_pay_card.card_type.should == Braintree::CreditCard::CardType::MasterCard
+        google_pay_card.virtual_card_type.should == Braintree::CreditCard::CardType::MasterCard
+        google_pay_card.expiration_month.to_i.should > 0
+        google_pay_card.expiration_year.to_i.should > 0
+        google_pay_card.default.should == true
+        google_pay_card.image_url.should =~ /android_pay/
+        google_pay_card.is_network_tokenized?.should == true
+        google_pay_card.source_card_type.should == Braintree::CreditCard::CardType::MasterCard
+        google_pay_card.source_card_last_4.should == "4444"
+        google_pay_card.google_transaction_id.should == "google_transaction_id"
+        google_pay_card.source_description.should == "MasterCard 4444"
+        google_pay_card.customer_id.should == customer.id
       end
     end
 
@@ -1110,18 +1176,18 @@ describe Braintree::PaymentMethod do
   end
 
   describe "self.delete" do
-    it "deletes an android pay card" do
+    it "deletes an google pay card" do
       customer = Braintree::Customer.create!
 
       create_result = Braintree::PaymentMethod.create(
-        :payment_method_nonce => Braintree::Test::Nonce::AndroidPayDiscover,
+        :payment_method_nonce => Braintree::Test::Nonce::GooglePayDiscover,
         :customer_id => customer.id
       )
 
       token = create_result.payment_method.token
 
-      android_card = Braintree::PaymentMethod.find(token)
-      android_card.should be_a(Braintree::AndroidPayCard)
+      google_card = Braintree::PaymentMethod.find(token)
+      google_card.should be_a(Braintree::GooglePayCard)
 
       delete_result = Braintree::PaymentMethod.delete(token)
       delete_result.success?.should == true
@@ -1302,6 +1368,90 @@ describe Braintree::PaymentMethod do
         updated_credit_card.expiration_date.should == "06/2013"
       end
 
+      context "verification_currency_iso_code" do
+        it "validates verification_currency_iso_code and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "USD"}
+                                                         )
+          update_result.success?.should == true
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+        end
+
+        it "validates verification_currency_iso_code against the given verification_merchant_account_id and updates the credit card " do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "USD"}
+                                                         )
+          update_result.success?.should == true
+          update_result.payment_method.verification.currency_iso_code  == "USD"
+          update_result.payment_method.verification.merchant_account_id == SpecHelper::NonDefaultMerchantAccountId
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_currency_iso_code => "GBP"}
+                                                         )
+          expect(update_result).to_not be_success
+          update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+        end
+
+        it "throws validation error when passing invalid verification_currency_iso_code of the given verification merchant account id" do
+          customer = Braintree::Customer.create!
+          credit_card = Braintree::CreditCard.create!(
+            :cardholder_name => "Original Holder",
+            :customer_id => customer.id,
+            :cvv => "123",
+            :number => Braintree::Test::CreditCardNumbers::Visa,
+            :expiration_date => "05/2012"
+          )
+          update_result = Braintree::PaymentMethod.update(credit_card.token,
+                                                          :cardholder_name => "New Holder",
+                                                          :cvv => "456",
+                                                          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+                                                          :expiration_date => "06/2013",
+                                                          :options => {:verify_card => true, :verification_merchant_account_id => SpecHelper::NonDefaultMerchantAccountId,  :verification_currency_iso_code => "GBP"}
+                                                         )
+          expect(update_result).to_not be_success
+          update_result.errors.for(:credit_card).for(:options).on(:verification_currency_iso_code)[0].code.should == Braintree::ErrorCodes::CreditCard::CurrencyCodeNotSupportedByMerchantAccount
+        end
+      end
+
+
       context "billing address" do
         it "creates a new billing address by default" do
           customer = Braintree::Customer.create!
@@ -1522,22 +1672,6 @@ describe Braintree::PaymentMethod do
       end
     end
 
-    context "coinbase accounts" do
-      it "cannot create a payment method token with Coinbase" do
-        customer = Braintree::Customer.create!
-
-        nonce = Braintree::Test::Nonce::Coinbase
-        result = Braintree::PaymentMethod.create(
-          :payment_method_nonce => nonce,
-          :customer_id => customer.id
-        )
-
-        result.should_not be_success
-
-        result.errors.for(:coinbase_account).first.code.should == Braintree::ErrorCodes::PaymentMethod::PaymentMethodNoLongerSupported
-      end
-    end
-
     context "paypal accounts" do
       it "updates a paypal account's token" do
         customer = Braintree::Customer.create!
@@ -1739,7 +1873,7 @@ describe Braintree::PaymentMethod do
       it "raises an error if the token isn't found" do
         expect do
           @granting_gateway.payment_method.grant("not_a_real_token", false)
-        end.to raise_error
+        end.to raise_error(Braintree::NotFoundError)
       end
 
       it "returns a valid nonce with no options set" do
@@ -1754,7 +1888,7 @@ describe Braintree::PaymentMethod do
       it "raises an error if the token isn't found" do
         expect do
           @granting_gateway.payment_method.revoke("not_a_real_token")
-        end.to raise_error
+        end.to raise_error(Braintree::NotFoundError)
       end
 
       it "renders a granted nonce useless" do