braintree 2.101.0 → 3.0.1

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

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/document_upload_spec.rb

@@ -46,6 +46,18 @@ describe Braintree::DocumentUploadGateway do
       end
     end
 
+    it "returns file is empty error with empty file" do
+      filename = "#{File.dirname(__FILE__)}/../../fixtures/files/empty_file.png"
+      begin
+        File.open(filename, "w+") {}
+        file = File.new(filename, "r")
+        response = Braintree::DocumentUpload.create({:kind => Braintree::DocumentUpload::Kind::EvidenceDocument, :file => file})
+        response.errors.for(:document_upload).first.code.should == Braintree::ErrorCodes::DocumentUpload::FileIsEmpty
+      ensure
+        File.delete(filename)
+      end
+    end
+
     it "returns file too long error with file over 50 pages" do
       filename = "#{File.dirname(__FILE__)}/../../fixtures/files/too_long.pdf"
       file = File.new(filename, "r")

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"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
       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"]
+        result.supported_networks.should == ["visa", "mastercard", "amex", "discover", "maestro"]
       end
     end
 

data/spec/integration/braintree/payment_method_nonce_spec.rb

@@ -239,5 +239,82 @@ describe Braintree::PaymentMethodNonce do
         Braintree::PaymentMethodNonce.find("not_a_nonce")
       end.to raise_error(Braintree::NotFoundError)
     end
+
+    context "authentication insights" do
+      let(:indian_payment_token) { "india_visa_credit" }
+      let(:european_payment_token) { "european_visa_credit" }
+      let(:indian_merchant_token) { "india_three_d_secure_merchant_account" }
+      let(:european_merchant_token) { "european_three_d_secure_merchant_account" }
+
+      describe "self.create" do
+        it "raises an exception if hash includes an invalid key" do
+          expect do
+            Braintree::PaymentMethodNonce.create("european_visa_credit", :invalid_key => "foo")
+          end.to raise_error(ArgumentError, "invalid keys: invalid_key")
+        end
+      end
+
+      context "regulation environments" do
+        it "can get unregulated" do
+          expect(
+            request_authentication_insights(european_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "unregulated"
+        end
+
+        it "can get psd2" do
+          expect(
+            request_authentication_insights(european_merchant_token, european_payment_token)[:regulation_environment]
+          ).to eq "psd2"
+        end
+
+        it "can get rbi" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:regulation_environment]
+          ).to eq "rbi"
+        end
+      end
+
+      context "sca_indicator" do
+        it "can get unavailable" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token)[:sca_indicator]
+          ).to eq "unavailable"
+        end
+
+        it "can get sca_required" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2001})[:sca_indicator]
+          ).to eq "sca_required"
+        end
+
+        it "can get sca_optional" do
+          expect(
+            request_authentication_insights(indian_merchant_token, indian_payment_token, {amount: 2000, recurring_customer_consent: true, recurring_max_amount: 2000})[:sca_indicator]
+
+          ).to eq "sca_optional"
+        end
+      end
+
+      def request_authentication_insights(merchant_token, payment_method_token, options = {})
+        authentication_insight_options = {
+          amount: options[:amount],
+          recurring_customer_consent: options[:recurring_customer_consent],
+          recurring_max_amount: options[:recurring_max_amount],
+        }
+        nonce_request = {
+          merchant_account_id: merchant_token,
+          authentication_insight: true,
+          authentication_insight_options: authentication_insight_options,
+        }
+
+        result = Braintree::PaymentMethodNonce.create(
+          payment_method_token,
+          payment_method_nonce: nonce_request
+        )
+        result.should be_success
+
+        return result.payment_method_nonce.authentication_insight
+      end
+    end
   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
@@ -300,6 +273,50 @@ describe Braintree::PaymentMethod do
       result.credit_card_verification.amount.should == BigDecimal("100.00")
     end
 
+    it "validates presence of three_d_secure_version in 3ds pass thru params" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :cavv => 'some_cavv',
+          :xid => 'some_xid',
+          :three_d_secure_version => 'xx',
+          :authentication_response => 'Y',
+          :directory_response => 'Y',
+          :cavv_algorithm => '2',
+          :ds_transaction_id => 'some_ds_transaction_id',
+        },
+        :options => {:verify_card => true}
+      )
+      expect(result).not_to be_success
+      error = result.errors.for(:verification).first
+      expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+      expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+    end
+
+    it "accepts three_d_secure pass thru params in the request" do
+      customer = Braintree::Customer.create!
+      result = Braintree::PaymentMethod.create(
+        :customer_id => customer.id,
+        :payment_method_nonce => Braintree::Test::Nonce::Transactable,
+        :three_d_secure_pass_thru => {
+          :eci_flag => '02',
+          :cavv => 'some_cavv',
+          :xid => 'some_xid',
+          :three_d_secure_version => '1.0.2',
+          :authentication_response => 'Y',
+          :directory_response => 'Y',
+          :cavv_algorithm => '2',
+          :ds_transaction_id => 'some_ds_transaction_id',
+        },
+        :options => {:verify_card => true}
+      )
+
+      expect(result).to be_success
+    end
+
     it "returns 3DS info on cc verification" do
       customer = Braintree::Customer.create.customer
       result = Braintree::PaymentMethod.create(
@@ -980,61 +997,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
 
@@ -1066,18 +1083,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
@@ -1169,6 +1186,71 @@ describe Braintree::PaymentMethod do
 
   describe "self.update" do
     context "credit cards" do
+      it "throws validation error when passing invalid  pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => 'xx',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true},
+        )
+        expect(update_result).to_not be_success
+        error = update_result.errors.for(:verification).first
+        expect(error.code).to eq(Braintree::ErrorCodes::Verification::ThreeDSecurePassThru::ThreeDSecureVersionIsInvalid)
+        expect(error.message).to eq("The version of 3D Secure authentication must be composed only of digits and separated by periods (e.g. `1.0.2`).")
+      end
+
+      it "updates the credit card with three_d_secure pass thru params" do
+        customer = Braintree::Customer.create!
+        credit_card = Braintree::CreditCard.create!(
+          :customer_id => customer.id,
+          :payment_method_nonce => Braintree::Test::Nonce::ThreeDSecureVisaFullAuthentication,
+          :options => {:verify_card => true},
+        )
+
+        update_result = Braintree::PaymentMethod.update(credit_card.token,
+          :cardholder_name => "New Holder",
+          :cvv => "456",
+          :number => Braintree::Test::CreditCardNumbers::MasterCard,
+          :expiration_date => "06/2013",
+          :three_d_secure_pass_thru => {
+            :eci_flag => '02',
+            :cavv => 'some_cavv',
+            :xid => 'some_xid',
+            :three_d_secure_version => '1.0.2',
+            :authentication_response => 'Y',
+            :directory_response => 'Y',
+            :cavv_algorithm => '2',
+            :ds_transaction_id => 'some_ds_transaction_id',
+          },
+          :options => {:verify_card => true},
+        )
+        update_result.success?.should == true
+        update_result.payment_method.should == credit_card
+        updated_credit_card = update_result.payment_method
+        updated_credit_card.cardholder_name.should == "New Holder"
+        updated_credit_card.bin.should == Braintree::Test::CreditCardNumbers::MasterCard[0, 6]
+        updated_credit_card.last_4.should == Braintree::Test::CreditCardNumbers::MasterCard[-4..-1]
+        updated_credit_card.expiration_date.should == "06/2013"
+      end
+
       it "updates the credit card" do
         customer = Braintree::Customer.create!
         credit_card = Braintree::CreditCard.create!(
@@ -1413,22 +1495,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!
@@ -1630,7 +1696,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
@@ -1645,7 +1711,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