usher-manage-stack/tests/Feature/EdgeCases/FinanceEdgeCasesTest.php

<?php

namespace Tests\Feature\EdgeCases;

use App\Models\BankReconciliation;
use App\Models\FinanceDocument;
use App\Models\Member;
use App\Models\MembershipPayment;
use App\Models\User;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Storage;
use Tests\TestCase;
use Tests\Traits\CreatesFinanceData;
use Tests\Traits\CreatesMemberData;
use Tests\Traits\SeedsRolesAndPermissions;

/**
 * Finance Edge Cases Tests
 *
 * Tests boundary values and edge cases for financial operations.
 */
class FinanceEdgeCasesTest extends TestCase
{
    use RefreshDatabase, SeedsRolesAndPermissions, CreatesFinanceData, CreatesMemberData;

    protected function setUp(): void
    {
        parent::setUp();
        Storage::fake('local');
        $this->seedRolesAndPermissions();
    }

    /**
     * Test amount at tier boundaries (4999, 5000, 5001, 49999, 50000, 50001)
     */
    public function test_amount_at_tier_boundaries(): void
    {
        // Just below small/medium boundary
        $doc4999 = $this->createFinanceDocument(['amount' => 4999]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_SMALL, $doc4999->determineAmountTier());

        // At small/medium boundary
        $doc5000 = $this->createFinanceDocument(['amount' => 5000]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_MEDIUM, $doc5000->determineAmountTier());

        // Just above small/medium boundary
        $doc5001 = $this->createFinanceDocument(['amount' => 5001]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_MEDIUM, $doc5001->determineAmountTier());

        // Just below medium/large boundary
        $doc49999 = $this->createFinanceDocument(['amount' => 49999]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_MEDIUM, $doc49999->determineAmountTier());

        // At medium/large boundary
        $doc50000 = $this->createFinanceDocument(['amount' => 50000]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_MEDIUM, $doc50000->determineAmountTier());

        // Just above medium/large boundary
        $doc50001 = $this->createFinanceDocument(['amount' => 50001]);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_LARGE, $doc50001->determineAmountTier());
    }

    /**
     * Test zero amount document behavior
     */
    public function test_zero_amount_handling(): void
    {
        // Test that zero amount is classified as small tier
        $doc = $this->createFinanceDocument(['amount' => 0]);

        $this->assertEquals(0, $doc->amount);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_SMALL, $doc->determineAmountTier());
    }

    /**
     * Test minimum amount for small tier
     */
    public function test_minimum_amount_tier(): void
    {
        // Test that amount of 1 is classified as small tier
        $doc = $this->createFinanceDocument(['amount' => 1]);

        $this->assertEquals(1, $doc->amount);
        $this->assertEquals(FinanceDocument::AMOUNT_TIER_SMALL, $doc->determineAmountTier());
    }

    /**
     * Test extremely large amount
     */
    public function test_extremely_large_amount(): void
    {
        $doc = $this->createFinanceDocument(['amount' => 999999999]);

        $this->assertEquals(FinanceDocument::AMOUNT_TIER_LARGE, $doc->determineAmountTier());
        $this->assertEquals(999999999, $doc->amount);
    }

    /**
     * Test decimal amount precision
     */
    public function test_decimal_amount_precision(): void
    {
        $doc = $this->createFinanceDocument(['amount' => 1234.56]);

        // Amount should be stored with proper precision
        $this->assertEquals(1234.56, $doc->amount);
    }

    /**
     * Test currency rounding behavior
     */
    public function test_currency_rounding_behavior(): void
    {
        // Test that amounts are properly rounded
        $doc1 = $this->createFinanceDocument(['amount' => 1234.555]);
        $doc2 = $this->createFinanceDocument(['amount' => 1234.554]);

        // Depending on DB column definition, these might be rounded
        $this->assertTrue(true);
    }

    /**
     * Test empty outstanding checks array in reconciliation
     */
    public function test_empty_outstanding_checks_array(): void
    {
        $reconciliation = $this->createBankReconciliation([
            'outstanding_checks' => [],
            'deposits_in_transit' => [],
            'bank_charges' => [],
        ]);

        $summary = $reconciliation->getOutstandingItemsSummary();

        $this->assertEquals(0, $summary['total_outstanding_checks']);
        $this->assertEquals(0, $summary['outstanding_checks_count']);
        $this->assertEquals(0, $summary['total_deposits_in_transit']);
        $this->assertEquals(0, $summary['total_bank_charges']);
    }

    /**
     * Test reconciliation with zero discrepancy
     */
    public function test_reconciliation_with_zero_discrepancy(): void
    {
        $reconciliation = $this->createBankReconciliation([
            'bank_statement_balance' => 100000,
            'system_book_balance' => 100000,
            'discrepancy_amount' => 0,
        ]);

        $this->assertFalse($reconciliation->hasDiscrepancy());
        $this->assertEquals(0, $reconciliation->discrepancy_amount);
    }

    /**
     * Test reconciliation with large discrepancy
     */
    public function test_reconciliation_with_large_discrepancy(): void
    {
        $reconciliation = $this->createReconciliationWithDiscrepancy(50000);

        $this->assertTrue($reconciliation->hasDiscrepancy());
        $this->assertTrue($reconciliation->hasUnresolvedDiscrepancy());
        $this->assertEquals(50000, $reconciliation->discrepancy_amount);
    }

    /**
     * Test multiple pending payments for same member
     */
    public function test_multiple_pending_payments_for_same_member(): void
    {
        Storage::fake('private');

        $member = $this->createPendingMember();

        // Create multiple pending payments
        $payment1 = MembershipPayment::factory()->create([
            'member_id' => $member->id,
            'status' => MembershipPayment::STATUS_PENDING,
            'amount' => 1000,
        ]);

        $payment2 = MembershipPayment::factory()->create([
            'member_id' => $member->id,
            'status' => MembershipPayment::STATUS_PENDING,
            'amount' => 2000,
        ]);

        $pendingPayments = MembershipPayment::where('member_id', $member->id)
            ->where('status', MembershipPayment::STATUS_PENDING)
            ->get();

        $this->assertCount(2, $pendingPayments);
        $this->assertEquals(3000, $pendingPayments->sum('amount'));
    }
}