braintree 4.14.0 → 4.16.0

data/spec/integration/braintree/payment_method_us_bank_account_spec.rb

@@ -23,22 +23,22 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should be_success
+          expect(result).to 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)
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("021000021")
+          expect(us_bank_account.last_4).to eq("0000")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("John Doe")
+          expect(us_bank_account.bank_name).to match(/CHASE/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(0)
+          expect(us_bank_account.verified).to eq(false)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
         end
 
         [
@@ -56,28 +56,100 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to 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)
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(1)
+            expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(us_bank_account.verifications.first.verification_method).to eq(method)
+            expect(us_bank_account.verifications.first.id).not_to be_empty
+            expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
+
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
+
+        it "succeeds and verifies with verification_add_ons for NetworkCheck with fake nonce" do
+          customer = Braintree::Customer.create.customer
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => Braintree::Test::Nonce::UsBankAccount,
+            :customer_id => customer.id,
+            :options => {
+              :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+              :verification_add_ons => Braintree::UsBankAccountVerification::VerificationAddOns::CustomerVerification,
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          expect(result).to be_success
+          us_bank_account = result.payment_method
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("123456789")
+          expect(us_bank_account.last_4).to eq("0000")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("Dan Schulman")
+          expect(us_bank_account.bank_name).to match(/Wells Fargo/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("example mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(1)
+          expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+          expect(us_bank_account.verifications.first.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck)
+          expect(us_bank_account.verifications.first.id).not_to be_empty
+          expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+          expect(us_bank_account.verifications.first.processor_response_code).to eq("1000")
+          expect(us_bank_account.verified).to eq(true)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
+        end
+
+        it "returns additional processor response for failed NetworkCheck" do
+          customer = Braintree::Customer.create.customer
+          invalid_nonce = generate_non_plaid_us_bank_account_nonce(account_number = "1000000005")
+          result = Braintree::PaymentMethod.create(
+            :payment_method_nonce => invalid_nonce,
+            :customer_id => customer.id,
+            :options => {
+              :us_bank_account_verification_method => Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck,
+              :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+            },
+          )
+
+          expect(result).to be_success
+          us_bank_account = result.payment_method
+          expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+          expect(us_bank_account.routing_number).to eq("021000021")
+          expect(us_bank_account.last_4).to eq("0005")
+          expect(us_bank_account.account_type).to eq("checking")
+          expect(us_bank_account.account_holder_name).to eq("John Doe")
+          expect(us_bank_account.bank_name).to match(/CHASE/)
+          expect(us_bank_account.default).to eq(true)
+          expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+          expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+          expect(us_bank_account.verifications.count).to eq(1)
+          expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::ProcessorDeclined)
+          expect(us_bank_account.verifications.first.verification_method).to eq(Braintree::UsBankAccountVerification::VerificationMethod::NetworkCheck)
+          expect(us_bank_account.verifications.first.id).not_to be_empty
+          expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+          expect(us_bank_account.verifications.first.processor_response_code).to eq("2061")
+          expect(us_bank_account.verifications.first.additional_processor_response).to eq("Invalid routing number")
+
+          expect(us_bank_account.verified).to eq(false)
+
+          expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
+        end
       end
 
       it "fails with invalid nonce" do
@@ -87,8 +159,8 @@ describe Braintree::PaymentMethod do
           :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
+        expect(result).not_to be_success
+        expect(result.errors.for(:payment_method).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown)
       end
     end
 
@@ -100,8 +172,8 @@ describe Braintree::PaymentMethod do
           :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
+        expect(result).not_to be_success
+        expect(result.errors.for(:payment_method).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::PaymentMethod::PaymentMethodNonceUnknown)
       end
     end
   end
@@ -139,27 +211,27 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to 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)
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(1)
+            expect(us_bank_account.verifications.first.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(us_bank_account.verifications.first.verification_method).to eq(method)
+            expect(us_bank_account.verifications.first.id).not_to be_empty
+            expect(us_bank_account.verifications.first.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
+
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
 
@@ -172,8 +244,8 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should_not be_success
-          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:options).first.code).to eq(Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid)
         end
       end
     end
@@ -210,29 +282,29 @@ describe Braintree::PaymentMethod do
               },
             )
 
-            result.should be_success
+            expect(result).to 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
+            expect(us_bank_account).to be_a(Braintree::UsBankAccount)
+            expect(us_bank_account.routing_number).to eq("021000021")
+            expect(us_bank_account.last_4).to eq("0000")
+            expect(us_bank_account.account_type).to eq("checking")
+            expect(us_bank_account.account_holder_name).to eq("John Doe")
+            expect(us_bank_account.bank_name).to match(/CHASE/)
+            expect(us_bank_account.default).to eq(true)
+            expect(us_bank_account.ach_mandate.text).to eq("cl mandate text")
+            expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+
+            expect(us_bank_account.verifications.count).to eq(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
+            expect(verification.status).to eq(Braintree::UsBankAccountVerification::Status::Verified)
+            expect(verification.id).not_to be_empty
+            expect(verification.verification_determined_at).to be_a Time
+            expect(us_bank_account.verified).to eq(true)
 
-            Braintree::PaymentMethod.find(us_bank_account.token).should be_a(Braintree::UsBankAccount)
+            expect(Braintree::PaymentMethod.find(us_bank_account.token)).to be_a(Braintree::UsBankAccount)
           end
         end
 
@@ -244,8 +316,8 @@ describe Braintree::PaymentMethod do
             },
           )
 
-          result.should_not be_success
-          result.errors.for(:options).first.code.should == Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid
+          expect(result).not_to be_success
+          expect(result.errors.for(:options).first.code).to eq(Braintree::ErrorCodes::PaymentMethod::Options::UsBankAccountVerificationMethodIsInvalid)
         end
       end
     end

data/spec/integration/braintree/paypal_account_spec.rb

@@ -15,17 +15,17 @@ describe Braintree::PayPalAccount do
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
       )
-      result.should be_success
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.should be_a(Braintree::PayPalAccount)
-      paypal_account.token.should == payment_method_token
-      paypal_account.email.should == "jane.doe@example.com"
-      paypal_account.image_url.should_not be_nil
-      paypal_account.created_at.should_not be_nil
-      paypal_account.updated_at.should_not be_nil
-      paypal_account.customer_id.should == customer.id
-      paypal_account.revoked_at.should be_nil
+      expect(paypal_account).to be_a(Braintree::PayPalAccount)
+      expect(paypal_account.token).to eq(payment_method_token)
+      expect(paypal_account.email).to eq("jane.doe@example.com")
+      expect(paypal_account.image_url).not_to be_nil
+      expect(paypal_account.created_at).not_to be_nil
+      expect(paypal_account.updated_at).not_to be_nil
+      expect(paypal_account.customer_id).to eq(customer.id)
+      expect(paypal_account.revoked_at).to be_nil
     end
 
     it "returns a PayPalAccount with a billing agreement id" do
@@ -37,10 +37,10 @@ describe Braintree::PayPalAccount do
         :customer_id => customer.id,
         :token => payment_method_token,
       )
-      result.should be_success
+      expect(result).to be_success
 
       paypal_account = Braintree::PayPalAccount.find(payment_method_token)
-      paypal_account.billing_agreement_id.should_not be_nil
+      expect(paypal_account.billing_agreement_id).not_to be_nil
     end
 
     it "raises if the payment method token is not found" do
@@ -76,7 +76,7 @@ describe Braintree::PayPalAccount do
         :payment_method_nonce => nonce,
         :customer_id => customer.id,
       )
-      result.should be_success
+      expect(result).to be_success
 
       token = result.payment_method.token
 
@@ -91,7 +91,7 @@ describe Braintree::PayPalAccount do
       ).subscription
 
       paypal_account = Braintree::PayPalAccount.find(token)
-      paypal_account.subscriptions.map(&:id).sort.should == [subscription1.id, subscription2.id].sort
+      expect(paypal_account.subscriptions.map(&:id).sort).to eq([subscription1.id, subscription2.id].sort)
     end
   end
 
@@ -108,9 +108,9 @@ describe Braintree::PayPalAccount do
         },
       )
 
-      result.should be_success
-      result.paypal_account.billing_agreement_id.should == "some_billing_agreement_id"
-      result.paypal_account.email.should == "some@example.com"
+      expect(result).to be_success
+      expect(result.paypal_account.billing_agreement_id).to eq("some_billing_agreement_id")
+      expect(result.paypal_account.email).to eq("some@example.com")
     end
 
     it "throws an error if customer id is not specified" do
@@ -119,8 +119,8 @@ describe Braintree::PayPalAccount do
         :email => "some@example.com",
       )
 
-      result.success?.should == false
-      result.errors.first.code.should == "82905"
+      expect(result.success?).to eq(false)
+      expect(result.errors.first.code).to eq("82905")
     end
 
     it "throws an error if billing agreement id is not specified" do
@@ -130,8 +130,8 @@ describe Braintree::PayPalAccount do
         :email => "some@example.com",
       )
 
-      result.success?.should == false
-      result.errors.map(&:code).should include("82902")
+      expect(result.success?).to eq(false)
+      expect(result.errors.map(&:code)).to include("82902")
     end
   end
 
@@ -143,7 +143,7 @@ describe Braintree::PayPalAccount do
         :billing_agreement_id => "first_billing_agreement_id",
         :email => "first@example.com",
       )
-      create_result.success?.should == true
+      expect(create_result.success?).to eq(true)
 
       update_result = Braintree::PayPalAccount.update(
         create_result.paypal_account.token,
@@ -151,11 +151,11 @@ describe Braintree::PayPalAccount do
         :email => "second@example.com",
       )
 
-      update_result.success?.should == true
+      expect(update_result.success?).to eq(true)
       paypal_account = update_result.paypal_account
 
-      paypal_account.billing_agreement_id.should == "second_billing_agreement_id"
-      paypal_account.email.should == "second@example.com"
+      expect(paypal_account.billing_agreement_id).to eq("second_billing_agreement_id")
+      expect(paypal_account.email).to eq("second@example.com")
     end
 
     it "updates a paypal account's token" do
@@ -177,7 +177,7 @@ describe Braintree::PayPalAccount do
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(updated_token)
-      updated_paypal_account.email.should == original_result.payment_method.email
+      expect(updated_paypal_account.email).to eq(original_result.payment_method.email)
 
       expect do
         Braintree::PayPalAccount.find(original_token)
@@ -192,7 +192,7 @@ describe Braintree::PayPalAccount do
         :expiration_date => "05/2009",
         :options => {:make_default => true},
       )
-      result.should be_success
+      expect(result).to be_success
 
       nonce = nonce_for_paypal_account(:consent_code => "consent-code")
       original_token = Braintree::PaymentMethod.create(
@@ -206,7 +206,7 @@ describe Braintree::PayPalAccount do
       )
 
       updated_paypal_account = Braintree::PayPalAccount.find(original_token)
-      updated_paypal_account.should be_default
+      expect(updated_paypal_account).to be_default
     end
 
     it "returns an error if a token for account is used to attempt an update" do
@@ -237,8 +237,8 @@ describe Braintree::PayPalAccount do
         :token => second_token,
       )
 
-      updated_result.should_not be_success
-      updated_result.errors.first.code.should == "92906"
+      expect(updated_result).not_to be_success
+      expect(updated_result.errors.first.code).to eq("92906")
     end
   end
 
@@ -272,11 +272,11 @@ describe Braintree::PayPalAccount do
 
       result = Braintree::PayPalAccount.sale(customer.paypal_accounts[0].token, :amount => "100.00")
 
-      result.success?.should == true
-      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
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      expect(result.transaction.customer_details.id).to eq(customer.id)
+      expect(result.transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 
@@ -288,10 +288,10 @@ describe Braintree::PayPalAccount do
 
       transaction = Braintree::PayPalAccount.sale!(customer.paypal_accounts[0].token, :amount => "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
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      expect(transaction.customer_details.id).to eq(customer.id)
+      expect(transaction.paypal_details.token).to eq(customer.paypal_accounts[0].token)
     end
   end
 end

data/spec/integration/braintree/plan_spec.rb

@@ -26,26 +26,26 @@ describe Braintree::Plan do
 
       plans = Braintree::Plan.all
       plan = plans.select { |plan| plan.id == plan_token }.first
-      plan.should_not be_nil
-      plan.id.should == attributes[:id]
-      plan.billing_day_of_month.should == attributes[:billing_day_of_month]
-      plan.billing_frequency.should == attributes[:billing_frequency]
-      plan.currency_iso_code.should == attributes[:currency_iso_code]
-      plan.description.should == attributes[:description]
-      plan.name.should == attributes[:name]
-      plan.number_of_billing_cycles.should == attributes[:number_of_billing_cycles]
-      plan.price.should == Braintree::Util.to_big_decimal("1.00")
-      plan.trial_period.should == attributes[:trial_period]
-      plan.created_at.should_not be_nil
-      plan.updated_at.should_not be_nil
-      plan.add_ons.first.name.should == add_on_name
-      plan.discounts.first.name.should == discount_name
+      expect(plan).not_to be_nil
+      expect(plan.id).to eq(attributes[:id])
+      expect(plan.billing_day_of_month).to eq(attributes[:billing_day_of_month])
+      expect(plan.billing_frequency).to eq(attributes[:billing_frequency])
+      expect(plan.currency_iso_code).to eq(attributes[:currency_iso_code])
+      expect(plan.description).to eq(attributes[:description])
+      expect(plan.name).to eq(attributes[:name])
+      expect(plan.number_of_billing_cycles).to eq(attributes[:number_of_billing_cycles])
+      expect(plan.price).to eq(Braintree::Util.to_big_decimal("1.00"))
+      expect(plan.trial_period).to eq(attributes[:trial_period])
+      expect(plan.created_at).not_to be_nil
+      expect(plan.updated_at).not_to be_nil
+      expect(plan.add_ons.first.name).to eq(add_on_name)
+      expect(plan.discounts.first.name).to eq(discount_name)
     end
 
     it "returns an empty array if there are no plans" do
       gateway = Braintree::Gateway.new(SpecHelper::TestMerchantConfig)
       plans = gateway.plan.all
-      plans.should == []
+      expect(plans).to eq([])
     end
   end