wip tests

app/Filament/Company/Pages/Reports/TrialBalance.php

 
     protected function initializeDefaultFilters(): void
     {
-        if (empty($this->getFilterState('trialBalanceType'))) {
-            $this->setFilterState('trialBalanceType', 'regular');
+        if (empty($this->getFilterState('reportType'))) {
+            $this->setFilterState('reportType', 'standard');
         }
     }
 
         return $form
             ->columns(4)
             ->schema([
-                Select::make('trialBalanceType')
-                    ->label('Trial Balance Type')
+                Select::make('reportType')
+                    ->label('Report Type')
                     ->options([
-                        'regular' => 'Regular',
+                        'standard' => 'Standard',
                         'postClosing' => 'Post-Closing',
                     ])
                     ->selectablePlaceholder(false),
                 DateRangeSelect::make('dateRange')
-                    ->label('As of Date')
+                    ->label('As of')
                     ->selectablePlaceholder(false)
                     ->endDateField('asOfDate'),
                 $this->getAsOfDateFormComponent(),
 
     protected function buildReport(array $columns): ReportDTO
     {
-        return $this->reportService->buildTrialBalanceReport($this->getFilterState('trialBalanceType'), $this->getFormattedAsOfDate(), $columns);
+        return $this->reportService->buildTrialBalanceReport($this->getFilterState('reportType'), $this->getFormattedAsOfDate(), $columns);
     }
 
     protected function getTransformer(ReportDTO $reportDTO): ExportableReport

app/Models/User.php

     {
         return $this->hasMany(Department::class, 'manager_id');
     }
+
+    public function switchCompany(mixed $company): bool
+    {
+        if (! $this->belongsToCompany($company)) {
+            return false;
+        }
+
+        $this->forceFill([
+            'current_company_id' => $company->id,
+        ])->save();
+
+        $this->setRelation('currentCompany', $company);
+
+        session(['current_company_id' => $company->id]);
+
+        return true;
+    }
 }

app/Scopes/CurrentCompanyScope.php

      */
     public function apply(Builder $builder, Model $model): void
     {
-        if (app()->runningInConsole()) {
+        $companyId = session('current_company_id');
+
+        if (! $companyId && app()->runningInConsole()) {
             return;
         }
 
-        $companyId = session('current_company_id');
-
         if (! $companyId && Auth::check() && Auth::user()->currentCompany) {
             $companyId = Auth::user()->currentCompany->id;
             session(['current_company_id' => $companyId]);

app/Services/ReportService.php

         return new ReportDTO($accountCategories, $formattedReportTotalBalances, $columns);
     }
 
-    private function calculateTrialBalance(AccountCategory $category, int $endingBalance): array
+    public function calculateTrialBalance(AccountCategory $category, int $endingBalance): array
     {
         if ($category->isNormalDebitBalance()) {
             if ($endingBalance >= 0) {
 
     public function buildIncomeStatementReport(string $startDate, string $endDate, array $columns = []): ReportDTO
     {
-        $accounts = $this->accountService->getAccountBalances($startDate, $endDate)->get();
+        // Query only relevant accounts and sort them at the query level
+        $revenueAccounts = $this->accountService->getAccountBalances($startDate, $endDate)
+            ->where('category', AccountCategory::Revenue)
+            ->orderByRaw('LENGTH(code), code')
+            ->get();
+
+        $cogsAccounts = $this->accountService->getAccountBalances($startDate, $endDate)
+            ->whereRelation('subtype', 'name', 'Cost of Goods Sold')
+            ->orderByRaw('LENGTH(code), code')
+            ->get();
+
+        $expenseAccounts = $this->accountService->getAccountBalances($startDate, $endDate)
+            ->where('category', AccountCategory::Expense)
+            ->whereRelation('subtype', 'name', '!=', 'Cost of Goods Sold')
+            ->orderByRaw('LENGTH(code), code')
+            ->get();
 
         $accountCategories = [];
         $totalRevenue = 0;
-        $cogs = 0;
+        $totalCogs = 0;
         $totalExpenses = 0;
 
+        // Define category groups
         $categoryGroups = [
-            'Revenue' => [
-                'accounts' => $accounts->where('category', AccountCategory::Revenue),
+            AccountCategory::Revenue->getPluralLabel() => [
+                'accounts' => $revenueAccounts,
                 'total' => &$totalRevenue,
             ],
             'Cost of Goods Sold' => [
-                'accounts' => $accounts->where('subtype.name', 'Cost of Goods Sold'),
-                'total' => &$cogs,
+                'accounts' => $cogsAccounts,
+                'total' => &$totalCogs,
             ],
-            'Expenses' => [
-                'accounts' => $accounts->where('category', AccountCategory::Expense)->where('subtype.name', '!=', 'Cost of Goods Sold'),
+            AccountCategory::Expense->getPluralLabel() => [
+                'accounts' => $expenseAccounts,
                 'total' => &$totalExpenses,
             ],
         ];
 
+        // Process each category group
         foreach ($categoryGroups as $label => $group) {
             $categoryAccounts = [];
             $netMovement = 0;
 
-            foreach ($group['accounts']->sortBy('code', SORT_NATURAL) as $account) {
-                $category = null;
-
-                if ($label === 'Revenue') {
-                    $category = AccountCategory::Revenue;
-                } elseif ($label === 'Expenses') {
-                    $category = AccountCategory::Expense;
-                } elseif ($label === 'Cost of Goods Sold') {
-                    // COGS is treated as part of Expenses, so we use AccountCategory::Expense
-                    $category = AccountCategory::Expense;
-                }
+            foreach ($group['accounts'] as $account) {
+                // Use the category type based on label
+                $category = match ($label) {
+                    AccountCategory::Revenue->getPluralLabel() => AccountCategory::Revenue,
+                    AccountCategory::Expense->getPluralLabel(), 'Cost of Goods Sold' => AccountCategory::Expense,
+                    default => null
+                };
 
                 if ($category !== null) {
                     $accountBalances = $this->calculateAccountBalances($account, $category);
 
             $accountCategories[$label] = new AccountCategoryDTO(
                 $categoryAccounts,
-                $this->formatBalances(['net_movement' => $netMovement]),
+                $this->formatBalances(['net_movement' => $netMovement])
             );
         }
 
-        $grossProfit = $totalRevenue - $cogs;
+        // Calculate gross and net profit
+        $grossProfit = $totalRevenue - $totalCogs;
         $netProfit = $grossProfit - $totalExpenses;
         $formattedReportTotalBalances = $this->formatBalances(['net_movement' => $netProfit]);
 

composer.json

         "laravel/sail": "^1.26",
         "mockery/mockery": "^1.6",
         "nunomaduro/collision": "^8.0",
-        "phpunit/phpunit": "^10.5",
+        "pestphp/pest": "^3.0",
+        "pestphp/pest-plugin-livewire": "^3.0",
         "spatie/laravel-ignition": "^2.4",
         "spatie/laravel-ray": "^1.36"
     },

database/factories/Accounting/TransactionFactory.php

                 ->where('company_id', $company->id)
                 ->where('id', '<>', $accountIdForBankAccount)
                 ->inRandomOrder()
-                ->firstOrFail();
+                ->first();
+
+            // If no matching account is found, use a fallback
+            if (! $account) {
+                $account = Account::where('company_id', $company->id)
+                    ->where('id', '<>', $accountIdForBankAccount)
+                    ->inRandomOrder()
+                    ->firstOrFail(); // Ensure there is at least some account
+            }
 
             return [
                 'company_id' => $company->id,

database/factories/CompanyFactory.php

 namespace Database\Factories;
 
 use App\Models\Company;
+use App\Models\Setting\CompanyProfile;
 use App\Models\User;
+use App\Services\CompanyDefaultService;
+use Database\Factories\Accounting\TransactionFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
+use Illuminate\Support\Facades\DB;
 
 class CompanyFactory extends Factory
 {
             'personal_company' => true,
         ];
     }
+
+    public function withCompanyProfile(): self
+    {
+        return $this->afterCreating(function (Company $company) {
+            CompanyProfile::factory()->forCompany($company)->create();
+        });
+    }
+
+    /**
+     * Set up default settings for the company after creation.
+     */
+    public function withCompanyDefaults(): self
+    {
+        return $this->afterCreating(function (Company $company) {
+            DB::transaction(function () use ($company) {
+                $countryCode = $company->profile->country;
+                $companyDefaultService = app(CompanyDefaultService::class);
+                $companyDefaultService->createCompanyDefaults($company, $company->owner, 'USD', $countryCode, 'en');
+            });
+        });
+    }
+
+    public function withTransactions(int $count = 2000): self
+    {
+        return $this->afterCreating(function (Company $company) use ($count) {
+            $defaultBankAccount = $company->default->bankAccount;
+
+            TransactionFactory::new()
+                ->forCompanyAndBankAccount($company, $defaultBankAccount)
+                ->count($count)
+                ->createQuietly([
+                    'created_by' => $company->user_id,
+                    'updated_by' => $company->user_id,
+                ]);
+        });
+    }
 }

database/factories/Setting/CompanyProfileFactory.php

 namespace Database\Factories\Setting;
 
 use App\Enums\Setting\EntityType;
-use App\Faker\PhoneNumber;
 use App\Faker\State;
+use App\Models\Company;
 use App\Models\Setting\CompanyProfile;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
      */
     public function definition(): array
     {
+        $countryCode = $this->faker->countryCode;
+
         return [
             'address' => $this->faker->streetAddress,
             'zip_code' => $this->faker->postcode,
+            'state_id' => $this->faker->state($countryCode),
+            'country' => $countryCode,
+            'phone_number' => $this->faker->phoneNumberForCountryCode($countryCode),
             'email' => $this->faker->email,
             'entity_type' => $this->faker->randomElement(EntityType::class),
         ];
     }
 
-    public function withCountry(string $code): static
+    public function withCountry(string $code): self
     {
-        /** @var PhoneNumber $phoneFaker */
-        $phoneFaker = $this->faker;
-
-        /** @var State $stateFaker */
-        $stateFaker = $this->faker;
-
         return $this->state([
             'country' => $code,
-            'state_id' => $stateFaker->state($code),
-            'phone_number' => $phoneFaker->phoneNumberForCountryCode($code),
+            'state_id' => $this->faker->state($code),
+            'phone_number' => $this->faker->phoneNumberForCountryCode($code),
+        ]);
+    }
+
+    public function forCompany(Company $company): self
+    {
+        return $this->state([
+            'company_id' => $company->id,
+            'created_by' => $company->owner->id,
+            'updated_by' => $company->owner->id,
         ]);
     }
 }

database/factories/UserFactory.php

 namespace Database\Factories;
 
 use App\Models\Company;
-use App\Models\Setting\CompanyProfile;
 use App\Models\User;
-use App\Services\CompanyDefaultService;
-use Database\Factories\Accounting\TransactionFactory;
 use Illuminate\Database\Eloquent\Factories\Factory;
-use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Hash;
 use Illuminate\Support\Str;
 use Wallo\FilamentCompanies\FilamentCompanies;
     /**
      * Indicate that the user should have a personal company.
      */
-    public function withPersonalCompany(): static
+    public function withPersonalCompany(?callable $callback = null): static
     {
         if (! FilamentCompanies::hasCompanyFeatures()) {
             return $this->state([]);
         }
 
-        $countryCode = $this->faker->countryCode;
-
-        return $this->afterCreating(function (User $user) use ($countryCode) {
+        return $this->has(
             Company::factory()
-                ->has(
-                    CompanyProfile::factory()
-                        ->withCountry($countryCode)
-                        ->state([
-                            'created_by' => $user->id,
-                            'updated_by' => $user->id,
-                        ]),
-                    'profile'
-                )
-                ->afterCreating(function (Company $company) use ($user, $countryCode) {
-                    DB::transaction(function () use ($company, $user, $countryCode) {
-                        $companyDefaultService = app()->make(CompanyDefaultService::class);
-                        $companyDefaultService->createCompanyDefaults($company, $user, 'USD', $countryCode, 'en');
-
-                        $defaultBankAccount = $company->default->bankAccount;
-
-                        TransactionFactory::new()
-                            ->forCompanyAndBankAccount($company, $defaultBankAccount)
-                            ->count(2000)
-                            ->createQuietly([
-                                'created_by' => $user->id,
-                                'updated_by' => $user->id,
-                            ]);
-                    });
-                })
-                ->create([
+                ->withCompanyProfile()
+                ->withCompanyDefaults()
+                ->state(fn (array $attributes, User $user) => [
                     'name' => $user->name . '\'s Company',
                     'user_id' => $user->id,
                     'personal_company' => true,
-                ]);
-        });
+                ])
+                ->when(is_callable($callback), $callback),
+            'ownedCompanies'
+        );
     }
 }

database/seeders/DatabaseSeeder.php

 namespace Database\Seeders;
 
 use App\Models\User;
+use Database\Factories\CompanyFactory;
 use Illuminate\Database\Seeder;
 
 class DatabaseSeeder extends Seeder
     {
         // Create a single admin user and their personal company
         $adminUser = User::factory()
-            ->withPersonalCompany()  // Ensures the user has a personal company created alongside
+            ->withPersonalCompany(function (CompanyFactory $factory) {
+                return $factory->withTransactions();
+            })
             ->create([
                 'name' => 'Admin',
                 'email' => 'admin@gmail.com',

database/seeders/TestDatabaseSeeder.php

+<?php
+
+namespace Database\Seeders;
+
+use App\Models\User;
+use Illuminate\Database\Seeder;
+
+class TestDatabaseSeeder extends Seeder
+{
+    public function run(): void
+    {
+        User::factory()
+            ->withPersonalCompany()
+            ->createQuietly([
+                'name' => 'Test Company Owner',
+                'email' => 'test@gmail.com',
+                'password' => bcrypt('password'),
+                'current_company_id' => 1,
+            ]);
+    }
+}

phpunit.xml

         <env name="APP_MAINTENANCE_DRIVER" value="file"/>
         <env name="BCRYPT_ROUNDS" value="4"/>
         <env name="CACHE_STORE" value="array"/>
-        <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
-        <!-- <env name="DB_DATABASE" value=":memory:"/> -->
+        <env name="DB_CONNECTION" value="mysql"/>
+        <env name="DB_DATABASE" value="erpsaas_test"/>
         <env name="MAIL_MAILER" value="array"/>
         <env name="PULSE_ENABLED" value="false"/>
         <env name="QUEUE_CONNECTION" value="sync"/>

tests/Feature/CompanySetupAndBehaviorTest.php

+<?php
+
+use App\Models\Accounting\Transaction;
+
+it('initially assigns a personal company to the test user', function () {
+    $testUser = $this->testUser;
+    $testCompany = $this->testCompany;
+
+    expect($testUser)->not->toBeNull()
+        ->and($testCompany)->not->toBeNull()
+        ->and($testCompany->personal_company)->toBeTrue()
+        ->and($testUser->currentCompany->id)->toBe($testCompany->id);
+});
+
+it('can create a new company and switches to it automatically', function () {
+    $testUser = $this->testUser;
+    $testCompany = $this->testCompany;
+
+    $newCompany = createCompany('New Company');
+
+    expect($newCompany)->not->toBeNull()
+        ->and($newCompany->name)->toBe('New Company')
+        ->and($newCompany->personal_company)->toBeFalse()
+        ->and($testUser->currentCompany->id)->toBe($newCompany->id)
+        ->and($newCompany->id)->not->toBe($testCompany->id);
+});
+
+it('returns data for the current company based on the CurrentCompanyScope', function () {
+    $testUser = $this->testUser;
+    $testCompany = $this->testCompany;
+
+    Transaction::factory()
+        ->forCompanyAndBankAccount($testCompany, $testCompany->default->bankAccount)
+        ->count(10)
+        ->create();
+
+    $newCompany = createCompany('New Company');
+
+    expect($testUser->currentCompany->id)
+        ->toBe($newCompany->id)
+        ->not->toBe($testCompany->id);
+
+    Transaction::factory()
+        ->forCompanyAndBankAccount($newCompany, $newCompany->default->bankAccount)
+        ->count(5)
+        ->create();
+
+    expect(Transaction::count())->toBe(5);
+
+    $testUser->switchCompany($testCompany);
+
+    expect($testUser->currentCompany->id)->toBe($testCompany->id)
+        ->and(Transaction::count())->toBe(10);
+});
+
+it('validates that company default settings are non-null', function () {
+    $testCompany = $this->testCompany;
+
+    expect($testCompany->profile->country)->not->toBeNull()
+        ->and($testCompany->profile->email)->not->toBeNull()
+        ->and($testCompany->default->currency_code)->toBe('USD')
+        ->and($testCompany->locale->language)->toBe('en')
+        ->and($testCompany->default->bankAccount->account->name)->toBe('Cash on Hand');
+});

tests/Feature/ExampleTest.php

 <?php
 
-namespace Tests\Feature;
+it('returns a successful response', function () {
+    $response = $this->get('/');
 
-// use Illuminate\Foundation\Testing\RefreshDatabase;
-use Tests\TestCase;
-
-class ExampleTest extends TestCase
-{
-    /**
-     * A basic test example.
-     */
-    public function test_the_application_returns_a_successful_response(): void
-    {
-        $response = $this->get('/');
-
-        $response->assertStatus(200);
-    }
-}
+    $response->assertStatus(200);
+});

tests/Feature/Reports/TrialBalanceReportTest.php

+<?php
+
+use App\Contracts\ExportableReport;
+use App\Enums\Accounting\AccountCategory;
+use App\Filament\Company\Pages\Reports\TrialBalance;
+use App\Models\Accounting\Transaction;
+use App\Services\AccountService;
+use App\Services\ReportService;
+use Filament\Facades\Filament;
+use Illuminate\Support\Carbon;
+
+use function Pest\Livewire\livewire;
+
+it('correctly builds a standard trial balance report', function () {
+    $testUser = $this->testUser;
+    $testCompany = $this->testCompany;
+    $defaultBankAccount = $testCompany->default->bankAccount;
+
+    $fiscalYearStartDate = $testCompany->locale->fiscalYearStartDate();
+    $fiscalYearEndDate = $testCompany->locale->fiscalYearEndDate();
+    $defaultEndDate = Carbon::parse($fiscalYearEndDate);
+    $defaultAsOfDate = $defaultEndDate->isFuture() ? now()->endOfDay() : $defaultEndDate->endOfDay();
+
+    $defaultDateRange = 'FY-' . now()->year;
+    $defaultReportType = 'standard';
+
+    // Create transactions for the company
+    Transaction::factory()
+        ->forCompanyAndBankAccount($testCompany, $defaultBankAccount)
+        ->count(10)
+        ->create();
+
+    // Instantiate services
+    $accountService = app(AccountService::class);
+    $reportService = app(ReportService::class);
+
+    // Calculate balances
+    $asOfStartDate = $accountService->getEarliestTransactionDate();
+    $netMovement = $accountService->getNetMovement($defaultBankAccount->account, $asOfStartDate, $defaultAsOfDate);
+    $netMovementAmount = $netMovement->getAmount();
+
+    // Verify trial balance calculations
+    $trialBalance = $reportService->calculateTrialBalance($defaultBankAccount->account->category, $netMovementAmount);
+    expect($trialBalance)->toMatchArray([
+        'debit_balance' => max($netMovementAmount, 0),
+        'credit_balance' => $netMovementAmount < 0 ? abs($netMovementAmount) : 0,
+    ]);
+
+    $formattedBalances = $reportService->formatBalances($trialBalance);
+
+    $accountCategoryPluralLabels = array_map(fn ($category) => $category->getPluralLabel(), AccountCategory::getOrderedCategories());
+
+    Filament::setTenant($testCompany);
+
+    $component = livewire(TrialBalance::class)
+        ->assertFormSet([
+            'deferredFilters.reportType' => $defaultReportType,
+            'deferredFilters.dateRange' => $defaultDateRange,
+            'deferredFilters.asOfDate' => $defaultAsOfDate->toDateTimeString(),
+        ])
+        ->assertSet('filters', [
+            'reportType' => $defaultReportType,
+            'dateRange' => $defaultDateRange,
+            'asOfDate' => $defaultAsOfDate->toDateString(),
+        ])
+        ->call('applyFilters')
+        ->assertSeeTextInOrder($accountCategoryPluralLabels)
+        ->assertDontSeeText('Retained Earnings')
+        ->assertSeeTextInOrder([
+            $formattedBalances->debitBalance,
+            $formattedBalances->creditBalance,
+        ]);
+
+    /** @var ExportableReport $report */
+    $report = $component->report;
+
+    $columnLabels = array_map(static fn ($column) => $column->getLabel(), $report->getColumns());
+
+    $component->assertSeeTextInOrder($columnLabels);
+
+    $categories = $report->getCategories();
+
+    foreach ($categories as $category) {
+        $header = $category->header;
+        $data = $category->data;
+        $summary = $category->summary;
+
+        $component->assertSeeTextInOrder($header);
+
+        foreach ($data as $row) {
+            $flatRow = [];
+
+            foreach ($row as $value) {
+                if (is_array($value)) {
+                    $flatRow[] = $value['name'];
+                } else {
+                    $flatRow[] = $value;
+                }
+            }
+
+            $component->assertSeeTextInOrder($flatRow);
+        }
+
+        $component->assertSeeTextInOrder($summary);
+    }
+
+    $overallTotals = $report->getOverallTotals();
+    $component->assertSeeTextInOrder($overallTotals);
+});
+
+it('correctly builds a post-closing trial balance report', function () {
+    $testUser = $this->testUser;
+    $testCompany = $this->testCompany;
+    $defaultBankAccount = $testCompany->default->bankAccount;
+
+    $fiscalYearStartDate = $testCompany->locale->fiscalYearStartDate();
+    $fiscalYearEndDate = $testCompany->locale->fiscalYearEndDate();
+    $defaultEndDate = Carbon::parse($fiscalYearEndDate);
+    $defaultAsOfDate = $defaultEndDate->isFuture() ? now()->endOfDay() : $defaultEndDate->endOfDay();
+
+    $defaultDateRange = 'FY-' . now()->year;
+    $defaultReportType = 'postClosing';
+
+    // Create transactions for the company
+    Transaction::factory()
+        ->forCompanyAndBankAccount($testCompany, $defaultBankAccount)
+        ->count(10)
+        ->create();
+
+    // Instantiate services
+    $accountService = app(AccountService::class);
+    $reportService = app(ReportService::class);
+
+    // Calculate balances
+    $asOfStartDate = $accountService->getEarliestTransactionDate();
+    $netMovement = $accountService->getNetMovement($defaultBankAccount->account, $asOfStartDate, $defaultAsOfDate);
+    $netMovementAmount = $netMovement->getAmount();
+
+    // Verify trial balance calculations
+    $trialBalance = $reportService->calculateTrialBalance($defaultBankAccount->account->category, $netMovementAmount);
+    expect($trialBalance)->toMatchArray([
+        'debit_balance' => max($netMovementAmount, 0),
+        'credit_balance' => $netMovementAmount < 0 ? abs($netMovementAmount) : 0,
+    ]);
+
+    $formattedBalances = $reportService->formatBalances($trialBalance);
+
+    $accountCategoryPluralLabels = array_map(fn ($category) => $category->getPluralLabel(), AccountCategory::getOrderedCategories());
+
+    $retainedEarningsAmount = $reportService->calculateRetainedEarnings($asOfStartDate, $defaultAsOfDate)->getAmount();
+
+    $isCredit = $retainedEarningsAmount >= 0;
+
+    $retainedEarningsDebitAmount = $isCredit ? 0 : abs($retainedEarningsAmount);
+    $retainedEarningsCreditAmount = $isCredit ? $retainedEarningsAmount : 0;
+
+    $formattedRetainedEarnings = $reportService->formatBalances([
+        'debit_balance' => $retainedEarningsDebitAmount,
+        'credit_balance' => $retainedEarningsCreditAmount,
+    ]);
+
+    $retainedEarningsRow = [
+        'RE',
+        'Retained Earnings',
+        $formattedRetainedEarnings->debitBalance,
+        $formattedRetainedEarnings->creditBalance,
+    ];
+
+    Filament::setTenant($testCompany);
+
+    $component = livewire(TrialBalance::class)
+        ->set('deferredFilters.reportType', $defaultReportType)
+        ->call('applyFilters')
+        ->assertFormSet([
+            'deferredFilters.reportType' => $defaultReportType,
+            'deferredFilters.dateRange' => $defaultDateRange,
+            'deferredFilters.asOfDate' => $defaultAsOfDate->toDateTimeString(),
+        ])
+        ->assertSet('filters', [
+            'reportType' => $defaultReportType,
+            'dateRange' => $defaultDateRange,
+            'asOfDate' => $defaultAsOfDate->toDateString(),
+        ])
+        ->call('applyFilters')
+        ->assertSeeTextInOrder($retainedEarningsRow)
+        ->assertSeeTextInOrder([
+            'Total Revenue',
+            '$0.00',
+            '$0.00',
+        ])
+        ->assertSeeTextInOrder([
+            'Total Expenses',
+            '$0.00',
+            '$0.00',
+        ])
+        ->assertSeeTextInOrder($accountCategoryPluralLabels)
+        ->assertSeeTextInOrder([
+            $formattedBalances->debitBalance,
+            $formattedBalances->creditBalance,
+        ]);
+
+    /** @var ExportableReport $report */
+    $report = $component->report;
+
+    $columnLabels = array_map(static fn ($column) => $column->getLabel(), $report->getColumns());
+
+    $component->assertSeeTextInOrder($columnLabels);
+
+    $categories = $report->getCategories();
+
+    foreach ($categories as $category) {
+        $header = $category->header;
+        $data = $category->data;
+        $summary = $category->summary;
+
+        $component->assertSeeTextInOrder($header);
+
+        foreach ($data as $row) {
+            $flatRow = [];
+
+            foreach ($row as $value) {
+                if (is_array($value)) {
+                    $flatRow[] = $value['name'];
+                } else {
+                    $flatRow[] = $value;
+                }
+            }
+
+            $component->assertSeeTextInOrder($flatRow);
+        }
+
+        $component->assertSeeTextInOrder($summary);
+    }
+
+    $overallTotals = $report->getOverallTotals();
+    $component->assertSeeTextInOrder($overallTotals);
+});

tests/Helpers/helpers.php

+<?php
+
+use App\Enums\Setting\EntityType;
+use App\Filament\Company\Pages\CreateCompany;
+use App\Models\Company;
+
+use function Pest\Livewire\livewire;
+
+function createCompany(string $name): Company
+{
+    livewire(CreateCompany::class)
+        ->fillForm([
+            'name' => $name,
+            'profile.email' => 'company@gmail.com',
+            'profile.entity_type' => EntityType::LimitedLiabilityCompany,
+            'profile.country' => 'US',
+            'locale.language' => 'en',
+            'currencies.code' => 'USD',
+        ])
+        ->call('register')
+        ->assertHasNoErrors();
+
+    return auth()->user()->currentCompany;
+}

tests/Pest.php

+<?php
+
+uses(Tests\TestCase::class)
+    ->in('Feature', 'Unit');
+
+/*
+|--------------------------------------------------------------------------
+| Expectations
+|--------------------------------------------------------------------------
+|
+| When you're writing tests, you often need to check that values meet certain conditions. The
+| "expect()" function gives you access to a set of "expectations" methods that you can use
+| to assert different things. Of course, you may extend the Expectation API at any time.
+|
+*/
+
+expect()->extend('toBeOne', function () {
+    return $this->toBe(1);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Functions
+|--------------------------------------------------------------------------
+|
+| While Pest is very powerful out-of-the-box, you may have some testing code specific to your
+| project that you don't want to repeat in every file. Here you can also expose helpers as
+| global functions to help you to reduce the number of lines of code in your test files.
+|
+*/
+
+function something()
+{
+    // ..
+}

tests/TestCase.php

 
 namespace Tests;
 
+use App\Models\Company;
+use App\Models\User;
+use Database\Seeders\TestDatabaseSeeder;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
 
 abstract class TestCase extends BaseTestCase
 {
-    //
+    use RefreshDatabase;
+
+    /**
+     * Indicates whether the default seeder should run before each test.
+     */
+    protected bool $seed = true;
+
+    /**
+     * Run a specific seeder before each test.
+     */
+    protected string $seeder = TestDatabaseSeeder::class;
+
+    protected User $testUser;
+
+    protected ?Company $testCompany;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->testUser = User::first();
+
+        $this->testCompany = $this->testUser->ownedCompanies->first();
+
+        $this->testUser->switchCompany($this->testCompany);
+
+        $this->actingAs($this->testUser)
+            ->withSession(['current_company_id' => $this->testCompany->id]);
+    }
 }

tests/Unit/ExampleTest.php

 <?php
 
-namespace Tests\Unit;
-
-use PHPUnit\Framework\TestCase;
-
-class ExampleTest extends TestCase
-{
-    /**
-     * A basic test example.
-     */
-    public function test_that_true_is_true(): void
-    {
-        $this->assertTrue(true);
-    }
-}
+test('true is true', function () {
+    expect(true)->toBeTrue();
+});