houdini/spec/lib/insert/insert_payout_spec.rb

# frozen_string_literal: true

# License: AGPL-3.0-or-later WITH Web-Template-Output-Additional-Permission-3.0-or-later
require 'rails_helper'
require 'support/payments_for_a_payout'

describe InsertPayout do
  let(:bank_name) { 'CHASE *1234' }
  let(:supporter) { force_create(:supporter) }
  let(:user_email) { 'uzr@example.com' }
  let(:user_ip) { '8.8.8.8' }

  describe '.with_stripe' do
    describe 'param validation' do
      it 'basic param validation' do
        expect { InsertPayout.with_stripe(nil, nil, nil) }.to(raise_error do |error|
          expect(error).to be_a ParamValidation::ValidationError
          expect_validation_errors(error.data, [
                                     { key: :np_id, name: :required },
                                     { key: :np_id, name: :is_integer },
                                     { key: :stripe_account_id, name: :required },
                                     { key: :stripe_account_id, name: :not_blank },
                                     { key: :email, name: :required },
                                     { key: :email, name: :not_blank },
                                     { key: :user_ip, name: :required },
                                     { key: :user_ip, name: :not_blank },
                                     { key: :bank_name, name: :required },
                                     { key: :bank_name, name: :not_blank }
                                   ])
        end)
      end

      it 'validates nonprofit' do
        expect { InsertPayout.with_stripe(666, { stripe_account_id: 'valid', email: 'valid', user_ip: 'valid', bank_name: 'valid' }, nil) }.to(raise_error do |error|
          expect(error).to be_a ParamValidation::ValidationError
          expect_validation_errors(error.data, [{ key: :np_id }])
        end)
      end
    end

    context 'when valid' do
      let(:stripe_helper) { StripeMock.create_test_helper }

      before(:each) do
        Timecop.freeze(2020, 5, 4)
        StripeMock.start
      end

      after do
        StripeMock.stop
        Timecop.return
      end

      it 'handles no charges to payout' do
        np = force_create(:nonprofit)
        expect { InsertPayout.with_stripe(np.id, { stripe_account_id: 'valid', email: 'valid', user_ip: 'valid', bank_name: 'valid' }, nil) }.to(raise_error do |error|
          expect(error).to be_a ArgumentError
          expect(error.message).to eq 'No payments are available for disbursal on this account.'
        end)
      end
      let(:user) { force_create(:user) }

      # Test one basic charge, one charge with a partial refund, and one charge with a full refund

      # refunded payment
      # disputed payment

      # Charge which was after given date
      #
      # Already paid out charge
      # Already paid out dispute
      # already paid out refund

      context 'no date provided' do
        include_context 'payments for a payout' do
          let(:np) { force_create(:nonprofit, stripe_account_id: Stripe::Account.create['id'], vetted: true) }
          let(:date_for_marking) { Time.now }
          let(:ba) do
            InsertBankAccount.with_stripe(np, user, stripe_bank_account_token: StripeMock.generate_bank_token, name: bank_name)
          end
        end

        before(:each) do
          ba
        end
        let(:expected_totals) { { gross_amount: 5500, fee_total: -1200, net_amount: 4300, count: 8 } }
        it 'works without a date provided' do
          stripe_transfer_id = nil
          expect(Stripe::Transfer).to receive(:create).with({ amount: expected_totals[:net_amount],
                                                              currency: 'usd',
                                                              recipient: 'self' },
                                                            stripe_account: np.stripe_account_id)
                                                      .and_wrap_original { |m, *args|
                                        i = m.call(*args)
                                        stripe_transfer_id = i['id']
                                        i
                                      }
          all_payments
          result = InsertPayout.with_stripe(np.id, stripe_account_id: np.stripe_account_id,
                                                   email: user_email,
                                                   user_ip: user_ip,
                                                   bank_name: bank_name)

          expected_result = {
            net_amount: expected_totals[:net_amount],
            nonprofit_id: np.id,
            status: 'pending',
            fee_total: expected_totals[:fee_total],
            gross_amount: expected_totals[:gross_amount],
            email: user_email,
            count: expected_totals[:count],
            stripe_transfer_id: stripe_transfer_id,
            user_ip: user_ip,
            ach_fee: 0,
            bank_name: bank_name,
            updated_at: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
            created_at: Time.now.strftime('%Y-%m-%d %H:%M:%S')
          }.with_indifferent_access
          expect(Payout.count).to eq 1
          resulted_payout = Payout.first
          expect(result.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id)

          empty_db_attributes = { manual: nil, scheduled: nil, failure_message: nil }
          expect(resulted_payout.attributes.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id).merge(empty_db_attributes)

          # validate which charges are makred
          @expect_marked[:charges].each do |c|
            c.reload
            expect(c.status).to eq 'disbursed'
          end

          # validate which refunds are marked

          @expect_marked[:refunds].each do |r|
            r.reload
            expect(r.disbursed).to eq true
          end

          # validate which disputes are marked
          @expect_marked[:disputes].each do |d|
            d.reload
            expect(d.status).to eq 'lost_and_paid'
          end
          # validate payment payout records

          expect(resulted_payout.payments.pluck('payments.id')).to eq @expect_marked[:payouts_records].collect(&:id)
        end

        it 'fails properly when Stripe payout call fails' do
          StripeMock.prepare_error(Stripe::StripeError.new('Payout failed'), :new_transfer)

          all_payments
          result = InsertPayout.with_stripe(np.id, stripe_account_id: np.stripe_account_id,
                                                   email: user_email,
                                                   user_ip: user_ip,
                                                   bank_name: bank_name)

          expected_result = {
            net_amount: expected_totals[:net_amount],
            nonprofit_id: np.id,
            status: 'failed',
            fee_total: expected_totals[:fee_total],
            gross_amount: expected_totals[:gross_amount],
            email: user_email,
            count: expected_totals[:count],
            stripe_transfer_id: nil,
            user_ip: user_ip,
            ach_fee: 0,
            bank_name: bank_name,
            updated_at: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
            created_at: Time.now.strftime('%Y-%m-%d %H:%M:%S')
          }.with_indifferent_access

          expect(Payout.count).to eq 1
          resulted_payout = Payout.first
          expect(result.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id)

          empty_db_attributes = { manual: nil, scheduled: nil, failure_message: 'Payout failed' }
          expect(resulted_payout.attributes.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id).merge(empty_db_attributes)

          # validate which charges are makred
          @expect_marked[:charges].each do |c|
            c.reload
            expect(c.status).to eq 'available'
          end

          # validate which refunds are marked

          @expect_marked[:refunds].each do |r|
            r.reload
            expect(r.disbursed).to be_falsey
          end

          # validate which disputes are marked
          @expect_marked[:disputes].each do |d|
            d.reload
            expect(d.status).to eq 'lost'
          end
          # validate payment payout records

          expect(resulted_payout.payments.count).to eq 0
        end
      end

      context 'previous date provided' do
        include_context 'payments for a payout' do
          let(:np) { force_create(:nonprofit, stripe_account_id: Stripe::Account.create['id'], vetted: true) }
          let(:date_for_marking) { Time.now - 1.day }
          let(:ba) { InsertBankAccount.with_stripe(np, user, stripe_bank_account_token: StripeMock.generate_bank_token, name: bank_name) }
        end
        before(:each) do
          ba
        end

        let(:expected_totals) { { gross_amount: 3500, fee_total: -800, net_amount: 2700, count: 7 } }
        it 'works with date provided' do
          stripe_transfer_id = nil
          expect(Stripe::Transfer).to receive(:create).with({ amount: expected_totals[:net_amount],
                                                              currency: 'usd',
                                                              recipient: 'self' },
                                                            stripe_account: np.stripe_account_id)
                                                      .and_wrap_original { |m, *args|
                                        i = m.call(*args)
                                        stripe_transfer_id = i['id']
                                        i
                                      }
          all_payments
          result = InsertPayout.with_stripe(np.id, { stripe_account_id: np.stripe_account_id,
                                                     email: user_email,
                                                     user_ip: user_ip,
                                                     bank_name: bank_name }, date: Time.now - 1.day)

          expected_result = {
            net_amount: expected_totals[:net_amount],
            nonprofit_id: np.id,
            status: 'pending',
            fee_total: expected_totals[:fee_total],
            gross_amount: expected_totals[:gross_amount],
            email: user_email,
            count: expected_totals[:count],
            stripe_transfer_id: stripe_transfer_id,
            user_ip: user_ip,
            ach_fee: 0,
            bank_name: bank_name,
            updated_at: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
            created_at: Time.now.strftime('%Y-%m-%d %H:%M:%S')
          }.with_indifferent_access
          expect(Payout.count).to eq 1
          resulted_payout = Payout.first
          expect(result.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id)

          empty_db_attributes = { manual: nil, scheduled: nil, failure_message: nil }
          expect(resulted_payout.attributes.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id).merge(empty_db_attributes)

          # validate which charges are makred
          @expect_marked[:charges].each do |c|
            c.reload
            expect(c.status).to(eq('disbursed'), c.attributes.to_s)
          end

          # validate which refunds are marked
          @expect_marked[:refunds].each do |r|
            r.reload
            expect(r.disbursed).to eq true
          end

          # validate which disputes are marked
          @expect_marked[:disputes].each do |d|
            d.reload
            expect(d.status).to eq 'lost_and_paid'
          end
        end

        it 'fails properly when Stripe payout call fails' do
          StripeMock.prepare_error(Stripe::StripeError.new('Payout failed'), :new_transfer)

          all_payments
          result = InsertPayout.with_stripe(np.id, { stripe_account_id: np.stripe_account_id,
                                                     email: user_email,
                                                     user_ip: user_ip,
                                                     bank_name: bank_name }, date: Time.now - 1.day)

          expected_result = {
            net_amount: expected_totals[:net_amount],
            nonprofit_id: np.id,
            status: 'failed',
            fee_total: expected_totals[:fee_total],
            gross_amount: expected_totals[:gross_amount],
            email: user_email,
            count: expected_totals[:count],
            stripe_transfer_id: nil,
            user_ip: user_ip,
            ach_fee: 0,
            bank_name: bank_name,
            updated_at: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
            created_at: Time.now.strftime('%Y-%m-%d %H:%M:%S')
          }.with_indifferent_access

          expect(Payout.count).to eq 1
          resulted_payout = Payout.first
          expect(result.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id)

          empty_db_attributes = { manual: nil, scheduled: nil, failure_message: 'Payout failed' }
          expect(resulted_payout.attributes.with_indifferent_access).to eq expected_result.merge(id: resulted_payout.id).merge(empty_db_attributes)

          # validate which charges are makred
          @expect_marked[:charges].each do |c|
            c.reload
            expect(c.status).to eq 'available'
          end

          # validate which refunds are marked
          @expect_marked[:refunds].each do |r|
            r.reload
            expect(r.disbursed).to be_falsey
          end

          # validate which disputes are marked
          @expect_marked[:disputes].each do |d|
            d.reload
            expect(d.status).to eq 'lost'
          end
          # validate payment payout records

          expect(resulted_payout.payments.count).to eq 0
        end
      end
    end
  end
end