wip testing

app/Collections/Accounting/JournalEntryCollection.php

 
 namespace App\Collections\Accounting;
 
+use App\Enums\Accounting\JournalEntryType;
 use App\Models\Accounting\JournalEntry;
 use App\Utilities\Currency\CurrencyAccessor;
-use App\Utilities\Currency\CurrencyConverter;
 use App\ValueObjects\Money;
 use Illuminate\Database\Eloquent\Collection;
 
 {
     public function sumDebits(): Money
     {
-        $total = $this->reduce(static function ($carry, JournalEntry $item) {
-            if ($item->type->isDebit()) {
-                $amountAsInteger = CurrencyConverter::prepareForAccessor($item->amount, CurrencyAccessor::getDefaultCurrency());
-
-                return bcadd($carry, $amountAsInteger, 0);
-            }
-
-            return $carry;
-        }, 0);
+        $total = $this->where('type', JournalEntryType::Debit)
+            ->sum(static function (JournalEntry $item) {
+                return $item->rawValue('amount');
+            });
 
         return new Money($total, CurrencyAccessor::getDefaultCurrency());
     }
 
     public function sumCredits(): Money
     {
-        $total = $this->reduce(static function ($carry, JournalEntry $item) {
-            if ($item->type->isCredit()) {
-                $amountAsInteger = CurrencyConverter::prepareForAccessor($item->amount, CurrencyAccessor::getDefaultCurrency());
-
-                return bcadd($carry, $amountAsInteger, 0);
-            }
-
-            return $carry;
-        }, 0);
+        $total = $this->where('type', JournalEntryType::Credit)
+            ->sum(static function (JournalEntry $item) {
+                return $item->rawValue('amount');
+            });
 
         return new Money($total, CurrencyAccessor::getDefaultCurrency());
     }

app/Providers/MacroServiceProvider.php

 
         Money::macro('swapAmountFor', function ($newCurrency) {
             $oldCurrency = $this->currency->getCurrency();
-            $balanceInMajorUnits = $this->getAmount();
+            $balanceInSubunits = $this->getAmount();
+
+            $oldCurrencySubunit = currency($oldCurrency)->getSubunit();
+            $newCurrencySubunit = currency($newCurrency)->getSubunit();
+
+            $balanceInMajorUnits = $balanceInSubunits / $oldCurrencySubunit;
 
             $oldRate = currency($oldCurrency)->getRate();
             $newRate = currency($newCurrency)->getRate();
 
             $ratio = $newRate / $oldRate;
+            $convertedBalanceInMajorUnits = $balanceInMajorUnits * $ratio;
+
+            $roundedConvertedBalanceInMajorUnits = round($convertedBalanceInMajorUnits, currency($newCurrency)->getPrecision());
 
-            $convertedBalance = bcmul($balanceInMajorUnits, $ratio, 2);
+            $convertedBalanceInSubunits = $roundedConvertedBalanceInMajorUnits * $newCurrencySubunit;
 
-            return (int) round($convertedBalance);
+            return (int) round($convertedBalanceInSubunits);
         });
 
         Money::macro('formatWithCode', function (bool $codeBefore = false) {

app/Services/TransactionService.php

     {
         $defaultCurrency = CurrencyAccessor::getDefaultCurrency();
         $bankAccountCurrency = $transaction->bankAccount->account->currency_code;
-        $chartAccountCurrency = $transaction->account->currency_code;
 
         if ($bankAccountCurrency !== $defaultCurrency) {
             return $this->convertToDefaultCurrency($transaction->amount, $bankAccountCurrency, $defaultCurrency);
-        } elseif ($chartAccountCurrency !== $defaultCurrency) {
-            return $this->convertToDefaultCurrency($transaction->amount, $chartAccountCurrency, $defaultCurrency);
         }
 
         return $transaction->amount;

composer.lock

         },
         {
             "name": "pestphp/pest",
-            "version": "v3.2.5",
+            "version": "v3.3.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/pestphp/pest.git",
-                "reference": "1e0bb88b734b3b5999a38fa479683c5dc3ee6f2f"
+                "reference": "0a7bff0d246b10040e12e4152215e12a599e742a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/pestphp/pest/zipball/1e0bb88b734b3b5999a38fa479683c5dc3ee6f2f",
-                "reference": "1e0bb88b734b3b5999a38fa479683c5dc3ee6f2f",
+                "url": "https://api.github.com/repos/pestphp/pest/zipball/0a7bff0d246b10040e12e4152215e12a599e742a",
+                "reference": "0a7bff0d246b10040e12e4152215e12a599e742a",
                 "shasum": ""
             },
             "require": {
-                "brianium/paratest": "^7.5.5",
+                "brianium/paratest": "^7.5.6",
                 "nunomaduro/collision": "^8.4.0",
                 "nunomaduro/termwind": "^2.1.0",
                 "pestphp/pest-plugin": "^3.0.0",
                 "pestphp/pest-plugin-arch": "^3.0.0",
                 "pestphp/pest-plugin-mutate": "^3.0.5",
                 "php": "^8.2.0",
-                "phpunit/phpunit": "^11.3.6"
+                "phpunit/phpunit": "^11.4.0"
             },
             "conflict": {
-                "phpunit/phpunit": ">11.3.6",
+                "phpunit/phpunit": ">11.4.0",
                 "sebastian/exporter": "<6.0.0",
                 "webmozart/assert": "<1.11.0"
             },
             "require-dev": {
                 "pestphp/pest-dev-tools": "^3.0.0",
-                "pestphp/pest-plugin-type-coverage": "^3.0.1",
+                "pestphp/pest-plugin-type-coverage": "^3.1.0",
                 "symfony/process": "^7.1.5"
             },
             "bin": [
             ],
             "support": {
                 "issues": "https://github.com/pestphp/pest/issues",
-                "source": "https://github.com/pestphp/pest/tree/v3.2.5"
+                "source": "https://github.com/pestphp/pest/tree/v3.3.0"
             },
             "funding": [
                 {
                     "type": "github"
                 }
             ],
-            "time": "2024-10-01T10:55:18+00:00"
+            "time": "2024-10-06T18:25:27+00:00"
         },
         {
             "name": "pestphp/pest-plugin",
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.12.5",
+            "version": "1.12.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/phpstan/phpstan.git",
-                "reference": "7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17"
+                "reference": "dc4d2f145a88ea7141ae698effd64d9df46527ae"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17",
-                "reference": "7e6c6cb7cecb0a6254009a1a8a7d54ec99812b17",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/dc4d2f145a88ea7141ae698effd64d9df46527ae",
+                "reference": "dc4d2f145a88ea7141ae698effd64d9df46527ae",
                 "shasum": ""
             },
             "require": {
                     "type": "github"
                 }
             ],
-            "time": "2024-09-26T12:45:22+00:00"
+            "time": "2024-10-06T15:03:59+00:00"
         },
         {
             "name": "phpunit/php-code-coverage",
         },
         {
             "name": "phpunit/phpunit",
-            "version": "11.3.6",
+            "version": "11.4.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "d62c45a19c665bb872c2a47023a0baf41a98bb2b"
+                "reference": "89fe0c530133c08f7fff89d3d727154e4e504925"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/d62c45a19c665bb872c2a47023a0baf41a98bb2b",
-                "reference": "d62c45a19c665bb872c2a47023a0baf41a98bb2b",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/89fe0c530133c08f7fff89d3d727154e4e504925",
+                "reference": "89fe0c530133c08f7fff89d3d727154e4e504925",
                 "shasum": ""
             },
             "require": {
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "11.3-dev"
+                    "dev-main": "11.4-dev"
                 }
             },
             "autoload": {
             "support": {
                 "issues": "https://github.com/sebastianbergmann/phpunit/issues",
                 "security": "https://github.com/sebastianbergmann/phpunit/security/policy",
-                "source": "https://github.com/sebastianbergmann/phpunit/tree/11.3.6"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/11.4.0"
             },
             "funding": [
                 {
                     "type": "tidelift"
                 }
             ],
-            "time": "2024-09-19T10:54:28+00:00"
+            "time": "2024-10-05T08:39:03+00:00"
         },
         {
             "name": "rector/rector",

database/factories/Accounting/AccountFactory.php

 namespace Database\Factories\Accounting;
 
 use App\Models\Accounting\Account;
+use App\Models\Accounting\AccountSubtype;
+use App\Models\Banking\BankAccount;
+use App\Models\Setting\Currency;
+use App\Utilities\Currency\CurrencyAccessor;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
 /**
     public function definition(): array
     {
         return [
-            //
+            'company_id' => 1,
+            'subtype_id' => 1,
+            'name' => $this->faker->unique()->word,
+            'currency_code' => CurrencyAccessor::getDefaultCurrency() ?? 'USD',
+            'description' => $this->faker->sentence,
+            'archived' => false,
+            'default' => false,
         ];
     }
+
+    public function withBankAccount(string $name): static
+    {
+        return $this->state(function (array $attributes) use ($name) {
+            $bankAccount = BankAccount::factory()->create();
+            $accountSubtype = AccountSubtype::where('name', 'Cash and Cash Equivalents')->first();
+
+            return [
+                'bank_account_id' => $bankAccount->id,
+                'subtype_id' => $accountSubtype->id,
+                'name' => $name,
+            ];
+        });
+    }
+
+    public function withForeignBankAccount(string $name, string $currencyCode, float $rate): static
+    {
+        return $this->state(function (array $attributes) use ($currencyCode, $rate, $name) {
+            $currency = Currency::factory()->forCurrency($currencyCode, $rate)->create();
+            $bankAccount = BankAccount::factory()->create();
+            $accountSubtype = AccountSubtype::where('name', 'Cash and Cash Equivalents')->first();
+
+            return [
+                'bank_account_id' => $bankAccount->id,
+                'subtype_id' => $accountSubtype->id,
+                'name' => $name,
+                'currency_code' => $currency->code,
+            ];
+        });
+    }
 }

database/factories/Accounting/TransactionFactory.php

         });
     }
 
+    public function forBankAccount(?BankAccount $bankAccount = null): static
+    {
+        return $this->state(function (array $attributes) use ($bankAccount) {
+            $bankAccount = $bankAccount ?? BankAccount::factory()->create();
+
+            return [
+                'bank_account_id' => $bankAccount->id,
+            ];
+        });
+    }
+
+    public function forDestinationBankAccount(?Account $account = null): static
+    {
+        return $this->state(function (array $attributes) use ($account) {
+            $destinationBankAccount = $account ?? Account::factory()->withBankAccount('Destination Bank Account')->create();
+
+            return [
+                'account_id' => $destinationBankAccount->id,
+            ];
+        });
+    }
+
     public function forUncategorizedRevenue(): static
     {
         return $this->state(function (array $attributes) {
             ];
         });
     }
+
+    public function asJournal(int $amount): static
+    {
+        return $this->state(function () use ($amount) {
+            return [
+                'type' => TransactionType::Journal,
+                'amount' => $amount,
+            ];
+        });
+    }
+
+    public function asTransfer(int $amount): static
+    {
+        return $this->state(function () use ($amount) {
+            return [
+                'type' => TransactionType::Transfer,
+                'amount' => $amount,
+            ];
+        });
+    }
 }

database/factories/Banking/BankAccountFactory.php

 
 namespace Database\Factories\Banking;
 
+use App\Enums\Banking\BankAccountType;
 use App\Models\Banking\BankAccount;
 use Illuminate\Database\Eloquent\Factories\Factory;
 
  */
 class BankAccountFactory extends Factory
 {
+    /**
+     * The name of the factory's corresponding model.
+     */
+    protected $model = BankAccount::class;
+
     /**
      * Define the model's default state.
      *
     public function definition(): array
     {
         return [
-            //
+            'company_id' => 1,
+            'type' => BankAccountType::Depository,
+            'number' => $this->faker->unique()->numerify(str_repeat('#', 12)),
+            'enabled' => false,
         ];
     }
 }

database/factories/Setting/CurrencyFactory.php

     /**
      * Define a state for a specific currency.
      */
-    public function forCurrency(string $code): Factory
+    public function forCurrency(string $code, ?float $rate = null): static
     {
         $currency = currency($code);
 
         return $this->state([
             'name' => $currency->getName(),
             'code' => $currency->getCurrency(),
-            'rate' => $currency->getRate(),
+            'rate' => $rate ?? $currency->getRate(),
             'precision' => $currency->getPrecision(),
             'symbol' => $currency->getSymbol(),
             'symbol_first' => $currency->isSymbolFirst(),

tests/Feature/Accounting/TransactionTest.php

+<?php
+
+use App\Models\Accounting\Account;
+use App\Models\Accounting\Transaction;
+use App\Utilities\Currency\ConfigureCurrencies;
+
+it('creates correct journal entries for a deposit transaction', function () {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forUncategorizedRevenue()
+        ->asDeposit(1000)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Cash on Hand')
+        ->and($creditAccount->name)->toBe('Uncategorized Income');
+});
+
+it('creates correct journal entries for a withdrawal transaction', function () {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forUncategorizedExpense()
+        ->asWithdrawal(500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Uncategorized Expense')
+        ->and($creditAccount->name)->toBe('Cash on Hand');
+});
+
+it('creates correct journal entries for a transfer transaction', function () {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forDestinationBankAccount()
+        ->asTransfer(1500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    // Acts as a withdrawal transaction for the source account
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Destination Bank Account')
+        ->and($creditAccount->name)->toBe('Cash on Hand');
+});
+
+it('does not create journal entries for a journal transaction', function () {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forUncategorizedRevenue()
+        ->asJournal(1000)
+        ->create();
+
+    // Journal entries for a journal transaction are created manually
+    expect($transaction->journalEntries->count())->toBe(0);
+});
+
+it('stores and sums correct debit and credit amounts for different transaction types', function ($method, $setupMethod, $amount) {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->{$setupMethod}()
+        ->{$method}($amount)
+        ->create();
+
+    expect($transaction->journalEntries->sumDebits()->getValue())->toEqual($amount)
+        ->and($transaction->journalEntries->sumCredits()->getValue())->toEqual($amount);
+})->with([
+    ['asDeposit', 'forUncategorizedRevenue', 2000],
+    ['asWithdrawal', 'forUncategorizedExpense', 500],
+    ['asTransfer', 'forDestinationBankAccount', 1500],
+]);
+
+it('deletes associated journal entries when transaction is deleted', function () {
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forUncategorizedRevenue()
+        ->asDeposit(1000)
+        ->create();
+
+    expect($transaction->journalEntries()->count())->toBe(2);
+
+    $transaction->delete();
+
+    $this->assertModelMissing($transaction);
+
+    $this->assertDatabaseCount('journal_entries', 0);
+});
+
+it('handles multi-currency transfers without conversion when the source bank account is in the default currency', function () {
+    $foreignBankAccount = Account::factory()
+        ->withForeignBankAccount('Foreign Bank Account', 'EUR', 0.92)
+        ->create();
+
+    $transaction = Transaction::factory()
+        ->forDefaultBankAccount()
+        ->forDestinationBankAccount($foreignBankAccount)
+        ->asTransfer(1500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Foreign Bank Account')
+        ->and($creditAccount->name)->toBe('Cash on Hand')
+        ->and($transaction->journalEntries->sumDebits()->getValue())->toEqual(1500)
+        ->and($transaction->journalEntries->sumCredits()->getValue())->toEqual(1500)
+        ->and($transaction->amount)->toEqual('1,500.00');
+});
+
+it('handles multi-currency transfers correctly', function () {
+    $foreignBankAccount = Account::factory()
+        ->withForeignBankAccount('CAD Bank Account', 'CAD', 1.36)
+        ->create();
+
+    ConfigureCurrencies::syncCurrencies();
+
+    // Create a transfer of 1500 CAD from the foreign bank account to USD bank account
+    $transaction = Transaction::factory()
+        ->forBankAccount($foreignBankAccount->bankAccount)
+        ->forDestinationBankAccount()
+        ->asTransfer(1500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Destination Bank Account') // Debit: Destination (USD) account
+        ->and($creditAccount->name)->toBe('CAD Bank Account'); // Credit: Foreign (CAD) account
+
+    // The 1500 CAD is worth 1102.94 USD (1500 CAD / 1.36)
+    $expectedUSDValue = round(1500 / 1.36, 2);
+
+    // Verify that the debit is 1102.94 USD and the credit is 1500 CAD converted to 1102.94 USD
+    // Transaction amount stays in source bank account currency (cast is applied)
+    expect($transaction->journalEntries->sumDebits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->journalEntries->sumCredits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->amount)->toEqual('1,500.00');
+});
+
+it('handles multi-currency deposits correctly', function () {
+    $foreignBankAccount = Account::factory()
+        ->withForeignBankAccount('BHD Bank Account', 'BHD', 0.38)
+        ->create();
+
+    ConfigureCurrencies::syncCurrencies();
+
+    // Create a deposit of 1500 BHD to the foreign bank account
+    $transaction = Transaction::factory()
+        ->forBankAccount($foreignBankAccount->bankAccount)
+        ->forUncategorizedRevenue()
+        ->asDeposit(1500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('BHD Bank Account') // Debit: Foreign (BHD) account
+        ->and($creditAccount->name)->toBe('Uncategorized Income'); // Credit: Uncategorized Income (USD) account
+
+    // Convert to USD using the rate 0.38 BHD per USD
+    $expectedUSDValue = round(1500 / 0.38, 2);
+
+    // Verify that the debit is 39473.68 USD and the credit is 1500 BHD converted to 39473.68 USD
+    expect($transaction->journalEntries->sumDebits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->journalEntries->sumCredits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->amount)->toEqual('1,500.000'); // Original amount in BHD (3 decimal precision)
+});
+
+it('handles multi-currency withdrawals correctly', function () {
+    $foreignBankAccount = Account::factory()
+        ->withForeignBankAccount('Foreign Bank Account', 'GBP', 0.76) // GBP account
+        ->create();
+
+    ConfigureCurrencies::syncCurrencies();
+
+    $transaction = Transaction::factory()
+        ->forBankAccount($foreignBankAccount->bankAccount)
+        ->forUncategorizedExpense()
+        ->asWithdrawal(1500)
+        ->create();
+
+    [$debitAccount, $creditAccount] = getTransactionDebitAndCreditAccounts($transaction);
+
+    expect($transaction->journalEntries->count())->toBe(2)
+        ->and($debitAccount->name)->toBe('Uncategorized Expense')
+        ->and($creditAccount->name)->toBe('Foreign Bank Account');
+
+    $expectedUSDValue = round(1500 / 0.76, 2);
+
+    expect($transaction->journalEntries->sumDebits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->journalEntries->sumCredits()->getValue())->toEqual($expectedUSDValue)
+        ->and($transaction->amount)->toEqual('1,500.00');
+});

tests/Feature/ExampleTest.php

-<?php
-
-it('returns a successful response', function () {
-    $response = $this->get('/');
-
-    $response->assertStatus(200);
-});

tests/Helpers/helpers.php

 <?php
 
+use App\Enums\Accounting\JournalEntryType;
 use App\Enums\Setting\EntityType;
 use App\Filament\Company\Pages\CreateCompany;
+use App\Models\Accounting\Account;
+use App\Models\Accounting\Transaction;
 use App\Models\Company;
 
 use function Pest\Livewire\livewire;
 
     return auth()->user()->currentCompany;
 }
+
+/**
+ * Get the debit and credit accounts for a transaction.
+ *
+ * @return array<Account>
+ */
+function getTransactionDebitAndCreditAccounts(Transaction $transaction): array
+{
+    $debitAccount = $transaction->journalEntries->where('type', JournalEntryType::Debit)->firstOrFail()->account;
+    $creditAccount = $transaction->journalEntries->where('type', JournalEntryType::Credit)->firstOrFail()->account;
+
+    return [$debitAccount, $creditAccount];
+}