coverage 100%

Author: rez1dent3

src/Traits/CanConfirm.php

@@ -45,19 +45,33 @@ trait CanConfirm
      */
     public function confirm(Transaction $transaction): bool
     {
-        // Check if the wallet has enough money
+        // Execute the confirmation process within an atomic block to ensure data consistency.
         return app(AtomicServiceInterface::class)->block($this, function () use ($transaction): bool {
+            // Check if the transaction is already confirmed.
+            // If it is, throw an exception.
+            if ($transaction->confirmed) {
+                // Why is there a check here without calling refresh? 
+                // It's because this check can be performed in force confirm again.
+                throw new ConfirmedInvalid(
+                    // Get the error message from the translator service.
+                    app(TranslatorServiceInterface::class)->get('wallet::errors.confirmed_invalid'),
+                    // Set the error code to CONFIRMED_INVALID.
+                    ExceptionInterface::CONFIRMED_INVALID
+                );
+            }
+
+            // Check if the transaction type is withdrawal.
             if ($transaction->type === Transaction::TYPE_WITHDRAW) {
-                // Check if the wallet has enough money
+                // Check if the wallet has enough money to cover the withdrawal amount.
                 app(ConsistencyServiceInterface::class)->checkPotential(
-                // Get the wallet
+                    // Get the wallet.
                     app(CastServiceInterface::class)->getWallet($this),
-                    // Negative amount
+                    // Negate the withdrawal amount to check for sufficient funds.
                     app(MathServiceInterface::class)->negative($transaction->amount)
                 );
             }
 
-            // Force confirm the transaction
+            // Force confirm the transaction.
             return $this->forceConfirm($transaction);
         });
     }
@@ -118,7 +132,7 @@ public function resetConfirm(Transaction $transaction): bool
         // Reset the confirmation of the transaction in a single database transaction
         return app(AtomicServiceInterface::class)->block($this, function () use ($transaction) {
             // Check if the transaction is already confirmed
-            if (! $transaction->confirmed) {
+            if (! $transaction->refresh()->confirmed) {
                 throw new UnconfirmedInvalid(
                 // If the transaction is not confirmed, throw an `UnconfirmedInvalid` exception
                     app(TranslatorServiceInterface::class)->get('wallet::errors.unconfirmed_invalid'),
@@ -195,7 +209,7 @@ public function forceConfirm(Transaction $transaction): bool
         // Attempt to confirm the transaction in a single database transaction
         return app(AtomicServiceInterface::class)->block($this, function () use ($transaction) {
             // Check if the transaction is already confirmed
-            if ($transaction->confirmed) {
+            if ($transaction->refresh()->confirmed) {
                 throw new ConfirmedInvalid(
                     app(TranslatorServiceInterface::class)->get('wallet::errors.confirmed_invalid'),
                     ExceptionInterface::CONFIRMED_INVALID

tests/Units/Domain/ConfirmTest.php

@@ -67,6 +67,25 @@ public function testSafe(): void
         self::assertFalse($transaction->confirmed);
     }
 
+    public function testSafeConfirmedInvalid(): void
+    {
+        /** @var Buyer $buyer */
+        $buyer = BuyerFactory::new()->create();
+        $wallet = $buyer->wallet;
+
+        self::assertSame(0, $wallet->balanceInt);
+
+        $transaction = $wallet->forceWithdraw(1000, ['desc' => 'confirmed']);
+
+        self::assertSame(-1000, $wallet->balanceInt);
+        self::assertTrue($transaction->confirmed);
+        self::assertTrue($transaction->getKey() > 0);
+
+        self::assertTrue($wallet->safeConfirm($transaction));
+        self::assertSame(-1000, $wallet->balanceInt);
+        self::assertTrue($transaction->confirmed);
+    }
+
     public function testSafeResetConfirm(): void
     {
         /** @var Buyer $buyer */
@@ -127,6 +146,25 @@ public function testForce(): void
         self::assertTrue($transaction->confirmed);
     }
 
+    public function testForceConfirmedInvalid(): void
+    {
+        $this->expectException(ConfirmedInvalid::class);
+        $this->expectExceptionCode(ExceptionInterface::CONFIRMED_INVALID);
+        $this->expectExceptionMessageStrict(trans('wallet::errors.confirmed_invalid'));
+
+        /** @var Buyer $buyer */
+        $buyer = BuyerFactory::new()->create();
+        $wallet = $buyer->wallet;
+
+        self::assertSame(0, $wallet->balanceInt);
+
+        $transaction = $wallet->forceWithdraw(1000);
+        self::assertSame(-1000, $wallet->balanceInt);
+        self::assertTrue($transaction->confirmed);
+
+        $wallet->forceConfirm($transaction);
+    }
+
     public function testUnconfirmed(): void
     {
         /** @var Buyer $buyer */
@@ -198,6 +236,31 @@ public function testSafeUnconfirmed(): void
         self::assertTrue($wallet->safeResetConfirm($transaction));
     }
 
+    public function testSafeUnconfirmedWalletOwnerInvalid(): void
+    {
+        /** 
+         * @var Buyer $buyer1 
+         * @var Buyer $buyer2 
+         **/
+        [$buyer1, $buyer2] = BuyerFactory::times(2)->create();
+        $wallet1 = $buyer1->wallet;
+        $wallet2 = $buyer2->wallet;
+
+        self::assertTrue($wallet1->saveOrFail());
+        self::assertTrue($wallet2->saveOrFail());
+
+        self::assertSame(0, $wallet1->balanceInt);
+        self::assertSame(0, $wallet2->balanceInt);
+
+        $transaction1 = $wallet1->deposit(1000, null, true);
+        self::assertSame(1000, $wallet1->balanceInt);
+        self::assertTrue($transaction1->confirmed);
+
+        self::assertFalse($wallet2->safeResetConfirm($transaction1));
+        self::assertSame(1000, $wallet1->balanceInt);
+        self::assertTrue($transaction1->confirmed);
+    }
+
     public function testWalletOwnerInvalid(): void
     {
         $this->expectException(WalletOwnerInvalid::class);
@@ -223,6 +286,31 @@ public function testWalletOwnerInvalid(): void
         $secondWallet->confirm($transaction);
     }
 
+    public function testForceWalletOwnerInvalid(): void
+    {
+        $this->expectException(WalletOwnerInvalid::class);
+        $this->expectExceptionCode(ExceptionInterface::WALLET_OWNER_INVALID);
+        $this->expectExceptionMessageStrict(trans('wallet::errors.owner_invalid'));
+
+        /**
+         * @var Buyer $first
+         * @var Buyer $second
+         */
+        [$first, $second] = BuyerFactory::times(2)->create();
+        $firstWallet = $first->wallet;
+        $secondWallet = $second->wallet;
+
+        self::assertSame(0, $firstWallet->balanceInt);
+
+        $transaction = $firstWallet->deposit(1000, [
+            'desc' => 'unconfirmed',
+        ], false);
+        self::assertSame(0, $firstWallet->balanceInt);
+        self::assertFalse($transaction->confirmed);
+
+        $secondWallet->forceConfirm($transaction);
+    }
+
     public function testUserConfirm(): void
     {
         /** @var UserConfirm $userConfirm */