Issues testing a static model method which calls delete()

Hello,

I am trying to test a static method in a model class to see that it handles exceptions properly. The method reads as follows:

    public static function remove(string $key): bool
    {
        try {
            self::where('key', '=', $key)->delete();

            return true;
        } catch (\Exception $e) {
            Log::error($e->getMessage()."\n".$e->getTraceAsString());

            return false;
        }
    }

The current implementation of the unit test reads as follows:

/**
 * @runTestsInSeparateProcesses
 * @preserveGlobalState disabled
 */
class MedusaConfigTest extends TestCase
{
   public function testRemoveDatabaseErrorLogsMessageAndReturnsFalse()
    {
        // Arrange
        $mock = Mockery::mock('overload:' . MedusaConfig::class);

        // Expect
        $mock->shouldReceive('remove')
            ->once()
            ->with('some.key')
            ->andReturnSelf();

        $mock->shouldReceive('delete')
            ->once()
            ->andThrow(new \Exception('Database error'));

//        Log::shouldReceive('error')
//            ->once()
//            ->withArgs(function ($message) {
//                return str_starts_with($message, 'Database error');
//            });

        // Act
        $value = MedusaConfig::remove('some.key');

        // Assert
        $this->assertFalse($value, 'Value should be false on error');
    }
}

Sadly, the test is failing on the assertFalse and I am getting a dump of what appears to be a mock of my model class, showing that the exception does not appear to be thrown. Any ideas on how to get this test working for both the return value and logging?

I am using L11 with PHPUnit 11.

LaryAI

8 months ago

Level 58

Certainly! The issue here is that you are mocking the remove method itself, which means your test never actually runs the real logic inside MedusaConfig::remove(). Instead, it just returns a mock object, so the exception is never thrown and caught.

Key Points:

Don't mock the method under test (remove). Instead, mock the underlying Eloquent query chain that remove uses.
You want to mock the where and delete calls so that delete throws an exception, simulating a database error.
Also, you want to assert that the Log::error method is called as expected.

Here's how you can do it:

use Illuminate\Support\Facades\Log;
use Mockery;
use Tests\TestCase;

class MedusaConfigTest extends TestCase
{
    public function testRemoveDatabaseErrorLogsMessageAndReturnsFalse()
    {
        // Arrange: Mock the query builder that Eloquent returns from where()
        $queryMock = Mockery::mock();
        $queryMock->shouldReceive('delete')
            ->once()
            ->andThrow(new \Exception('Database error'));

        // Mock the static where() method on MedusaConfig to return our query mock
        $modelMock = Mockery::mock('alias:App\\Models\\MedusaConfig');
        $modelMock->shouldReceive('where')
            ->with('key', '=', 'some.key')
            ->once()
            ->andReturn($queryMock);

        // Mock the Log facade
        Log::shouldReceive('error')
            ->once()
            ->withArgs(function ($message) {
                return str_starts_with($message, 'Database error');
            });

        // Act
        $value = \App\Models\MedusaConfig::remove('some.key');

        // Assert
        $this->assertFalse($value, 'Value should be false on error');
    }
}

Explanation

Mocking where: We mock the static where method to return a mock object whose delete method will throw an exception.
Not mocking remove: This ensures the real logic in remove runs, including the try/catch.
Mocking Log::error: We assert that logging happens as expected.
Assertion: We check that the return value is false when an exception is thrown.

Notes

Adjust the namespace (App\\Models\\MedusaConfig) as needed for your app.
If you use Laravel's built-in testing helpers, you may need to add use Illuminate\Support\Facades\Log; and ensure the Facade is set up for testing.

This approach allows you to test both the exception handling and the logging behavior of your static method.

cinnion

8 months ago

Level 2

The above code gives me an error that the remove method does not exist on the mock object. And when I try to replace the setup of the where mocking with

        $modelMock = $this->partialMock(MedusaConfig::class, function ($mock) use ($queryMock) {
            $mock->shouldReceive('where')
                ->with('key', '=', 'some.key')
                ->once()
                ->andReturn($queryMock);
        });

it does not appear to throw the exception.

Please or to participate in this conversation.