braintree 2.10.0 → 4.26.0

data/spec/integration/braintree/transaction_us_bank_account_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::Transaction do
+  describe "self.create us bank account" do
+    context "compliant merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration2_merchant_id"
+        Braintree::Configuration.public_key = "integration2_public_key"
+        Braintree::Configuration.private_key = "integration2_private_key"
+      end
+
+      context "not plaid-verified" do
+        let(:non_plaid_nonce) { generate_non_plaid_us_bank_account_nonce }
+        let(:invalid_nonce) { generate_invalid_us_bank_account_nonce }
+
+        context "nonce" do
+          it "sale fails for valid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :payment_method_nonce => non_plaid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::UsBankAccountNonceMustBePlaidVerified)
+          end
+
+          it "sale fails for invalid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :payment_method_nonce => invalid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown)
+          end
+        end
+
+        context "token" do
+          it "sale succeeds for verified token" do
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_plaid_nonce,
+              :customer_id => Braintree::Customer.create.customer.id,
+              :options => {
+                :us_bank_account_verification_method => "independent_check",
+                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              },
+            )
+            payment_method = result.payment_method
+
+            expect(payment_method.verifications.count).to eq(1)
+            payment_method.verifications.first.status == Braintree::UsBankAccountVerification::Status::Verified
+            payment_method.verifications.first.verification_method == Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck
+            expect(payment_method.verifications.first.id).not_to be_empty
+            expect(payment_method.verifications.first.verification_determined_at).to be_a Time
+            expect(payment_method.verified).to eq(true)
+
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :payment_method_token => payment_method.token,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+
+            expect(result.success?).to eq(true)
+          end
+
+          it "sale fails for unverified token" do
+            payment_method = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_plaid_nonce,
+              :customer_id => Braintree::Customer.create.customer.id,
+              :options => {
+                :verification_merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              },
+            ).payment_method
+
+            expect(payment_method.verifications.count).to eq(0)
+            expect(payment_method.verified).to eq(false)
+
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::AnotherUsBankMerchantAccountId,
+              :payment_method_token => payment_method.token,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction)[0].code).to eq(Braintree::ErrorCodes::Transaction::UsBankAccountNotVerified)
+          end
+        end
+      end
+    end
+
+    context "exempt merchant" do
+      before do
+        Braintree::Configuration.merchant_id = "integration_merchant_id"
+        Braintree::Configuration.public_key = "integration_public_key"
+        Braintree::Configuration.private_key = "integration_private_key"
+      end
+
+      context "not plaid-verified" do
+        let(:non_plaid_nonce) { generate_non_plaid_us_bank_account_nonce }
+        let(:invalid_nonce) { generate_invalid_us_bank_account_nonce }
+
+        context "nonce" do
+          it "sale succeeds for valid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_nonce => non_plaid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+            expect(result.success?).to eq(true)
+
+            transaction = result.transaction
+
+            expect(transaction.id).to match(/^\w{6,}$/)
+            expect(transaction.type).to eq("sale")
+            expect(transaction.amount).to eq(BigDecimal(Braintree::Test::TransactionAmounts::Authorize))
+            expect(transaction.status).to eq(Braintree::Transaction::Status::SettlementPending)
+            expect(transaction.us_bank_account_details.routing_number).to eq("021000021")
+            expect(transaction.us_bank_account_details.last_4).to eq("0000")
+            expect(transaction.us_bank_account_details.account_type).to eq("checking")
+            expect(transaction.us_bank_account_details.account_holder_name).to eq("John Doe")
+            expect(transaction.us_bank_account_details.bank_name).to match(/CHASE/)
+            expect(transaction.us_bank_account_details.ach_mandate.text).to eq("cl mandate text")
+            expect(transaction.us_bank_account_details.ach_mandate.accepted_at).to be_a Time
+          end
+
+          it "sale fails for invalid nonce" do
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_nonce => invalid_nonce,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+            expect(result.success?).to eq(false)
+            expect(result.errors.for(:transaction).on(:payment_method_nonce)[0].code).to eq(Braintree::ErrorCodes::Transaction::PaymentMethodNonceUnknown)
+          end
+        end
+
+        context "token" do
+          it "sale succeeds for unverified token" do
+            result = Braintree::PaymentMethod.create(
+              :payment_method_nonce => non_plaid_nonce,
+              :customer_id => Braintree::Customer.create.customer.id,
+              :options => {
+                :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              },
+            )
+            payment_method = result.payment_method
+
+            expect(payment_method.verifications.count).to eq(1)
+            payment_method.verifications.first.status == Braintree::UsBankAccountVerification::Status::Verified
+            payment_method.verifications.first.verification_method == Braintree::UsBankAccountVerification::VerificationMethod::IndependentCheck
+            expect(payment_method.verifications.first.id).not_to be_empty
+            expect(payment_method.verifications.first.verification_determined_at).to be_a Time
+            expect(payment_method.verified).to eq(true)
+
+            result = Braintree::Transaction.create(
+              :type => "sale",
+              :amount => Braintree::Test::TransactionAmounts::Authorize,
+              :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+              :payment_method_token => payment_method.token,
+              :options => {
+                :submit_for_settlement => true,
+              },
+            )
+
+            expect(result.success?).to eq(true)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/integration/braintree/us_bank_account_spec.rb

@@ -0,0 +1,113 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::UsBankAccount do
+  describe "self.find" do
+    it "returns a UsBankAccount" do
+      customer = Braintree::Customer.create!
+      nonce = generate_non_plaid_us_bank_account_nonce
+
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      )
+      expect(result).to be_success
+
+      us_bank_account = Braintree::UsBankAccount.find(result.payment_method.token)
+      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.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+    end
+
+    it "raises if the payment method token is not found" do
+      expect do
+        Braintree::UsBankAccount.find(generate_invalid_us_bank_account_nonce)
+      end.to raise_error(Braintree::NotFoundError)
+    end
+  end
+
+  context "self.sale" do
+    it "creates a transaction using a us bank account and returns a result object" do
+      customer = Braintree::Customer.create!
+      nonce = generate_non_plaid_us_bank_account_nonce
+
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      )
+      expect(result).to be_success
+
+      result = Braintree::UsBankAccount.sale(
+        result.payment_method.token,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        :amount => "100.00",
+      )
+
+      expect(result.success?).to eq(true)
+      expect(result.transaction.amount).to eq(BigDecimal("100.00"))
+      expect(result.transaction.type).to eq("sale")
+      us_bank_account = result.transaction.us_bank_account_details
+      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.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+    end
+  end
+
+  context "self.sale!" do
+    it "creates a transaction using a us bank account and returns a result object" do
+      customer = Braintree::Customer.create!
+      nonce = generate_non_plaid_us_bank_account_nonce
+
+      result = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      )
+      expect(result).to be_success
+
+      transaction = Braintree::UsBankAccount.sale!(
+        result.payment_method.token,
+        :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        :amount => "100.00",
+      )
+
+      expect(transaction.amount).to eq(BigDecimal("100.00"))
+      expect(transaction.type).to eq("sale")
+      us_bank_account = transaction.us_bank_account_details
+      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.ach_mandate.text).to eq("cl mandate text")
+      expect(us_bank_account.ach_mandate.accepted_at).to be_a Time
+    end
+
+    it "does not creates a transaction using a us bank account and returns raises an exception" do
+      expect do
+        Braintree::UsBankAccount.sale!(
+          generate_invalid_us_bank_account_nonce,
+          :merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+          :amount => "100.00",
+        )
+      end.to raise_error(Braintree::ValidationsFailed)
+    end
+  end
+end

data/spec/integration/braintree/us_bank_account_verification_search_spec.rb

@@ -0,0 +1,178 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require File.expand_path(File.dirname(__FILE__) + "/client_api/spec_helper")
+
+describe Braintree::UsBankAccountVerification, "search" do
+  it "correctly returns a result with no matches" do
+    collection = Braintree::UsBankAccountVerification.search do |search|
+      search.account_holder_name.is "thisnameisnotreal"
+    end
+
+    expect(collection.maximum_size).to eq(0)
+  end
+
+  let(:nonce) { generate_non_plaid_us_bank_account_nonce }
+
+  it "can search on text fields" do
+    customer = Braintree::Customer.create(
+      :email => "john.doe@example.com",
+    ).customer
+    payment_method = Braintree::PaymentMethod.create(
+      :payment_method_nonce => nonce,
+      :customer_id => customer.id,
+      :options => {
+        :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+      },
+    ).payment_method
+    verification = payment_method.verifications.first
+
+    search_criteria = {
+      :id => verification.id,
+      :account_holder_name => "John Doe",
+      :routing_number => "021000021",
+      :payment_method_token => payment_method.token,
+      :account_type => "checking",
+      :customer_id => customer.id,
+      :customer_email => "john.doe@example.com",
+    }
+
+    search_criteria.each do |criterion, value|
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.send(criterion).is value
+      end
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.send(criterion).is "invalid_attribute"
+      end
+      expect(collection).to be_empty
+    end
+
+    collection = Braintree::UsBankAccountVerification.search do |search|
+      search.id.is verification.id
+      search_criteria.each do |criterion, value|
+        search.send(criterion).is value
+      end
+    end
+
+    expect(collection.maximum_size).to eq(1)
+    expect(collection.first.id).to eq(verification.id)
+  end
+
+  describe "multiple value fields" do
+    it "searches on ids" do
+      customer = Braintree::Customer.create.customer
+
+      payment_method1 = Braintree::PaymentMethod.create(
+        :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      ).payment_method
+      verification1 = payment_method1.verifications.first
+
+      payment_method2 = Braintree::PaymentMethod.create(
+        :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      ).payment_method
+      verification2 = payment_method2.verifications.first
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.ids.in verification1.id, verification2.id
+      end
+
+      expect(collection.maximum_size).to eq(2)
+    end
+  end
+
+  context "range fields" do
+    it "searches on created_at" do
+      customer = Braintree::Customer.create.customer
+
+      payment_method = Braintree::PaymentMethod.create(
+        :payment_method_nonce => generate_non_plaid_us_bank_account_nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      ).payment_method
+      verification = payment_method.verifications.first
+
+      created_at = verification.created_at
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.created_at.between(
+          created_at - 60,
+          created_at + 60,
+        )
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.created_at >= created_at - 1
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.created_at <= created_at + 1
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.created_at.between(
+          created_at - 300,
+          created_at - 100,
+        )
+      end
+
+      expect(collection.maximum_size).to eq(0)
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.created_at.is created_at
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+    end
+  end
+
+  context "ends with fields" do
+    it "does ends_with search on account_number" do
+      customer = Braintree::Customer.create.customer
+
+      payment_method = Braintree::PaymentMethod.create(
+        :payment_method_nonce => nonce,
+        :customer_id => customer.id,
+        :options => {
+          :verification_merchant_account_id => SpecHelper::UsBankMerchantAccountId,
+        },
+      ).payment_method
+      verification = payment_method.verifications.first
+
+      collection = Braintree::UsBankAccountVerification.search do |search|
+        search.id.is verification.id
+        search.account_number.ends_with "0000"
+      end
+
+      expect(collection.maximum_size).to eq(1)
+      expect(collection.first.id).to eq(verification.id)
+    end
+  end
+end