Fakes, mocks and time travel

Pathshala’s fees:remind command runs at 09:00 IST and texts one SMS to the guardian of each pending fee instalment due within three days. Its test cannot wait for 09:00, must never text a real phone, and has to give the same answer at 15:40 on a laptop and at 02:00 in a nightly build.

Three tools make that possible. Laravel’s fakes record what the code would have sent, mocks fail the test when the code calls them wrongly, and time travel sets the clock that now() reads. The code is the Pathshala fees app of HTTP tests and database tests, and every run below was recorded on the course’s Laravel 13.34.0 project with Mockery 1.6.15.

Fakes, mocks and time travel each replace one outside thing

Follow one reminder out of the app. The command reads the clock to learn what today is, and the notification goes to an SMS channel, which hands its text to a provider. The payment code beside it asks ExamplePay’s API about money and queues jobs for receipts. In a test, each of these is taken over by a test doubletest double: Any object or setting a test puts in place of a real collaborator for one test, so the code can run without it: a fake, a mock, a spy or a fixed clock.:

Fakes are Laravel’s own doubles for its services: a facade fakefacade fake: A test double installed with a facade's fake() method, such as Mail::fake() or Storage::fake(), which replaces the real service for one test and records what the code did. More in “Service providers, facades and contracts” such as Notification::fake() swaps the service for a recorder, and the test asks afterwards what was sent and to whom. Mocks are doubles of your own classes, built with Mockery, which every Laravel project includes. A mockmock: A test double that is told before the code runs which calls to expect, with which arguments and how often. A call that breaks those expectations fails the test. is told the expected calls before the code runs, and a call with other arguments, or one too many, fails the test. Time traveltime travel: In a Laravel test, setting the moment that now() and Carbon return, with travelTo() for a fixed moment or travel() to move it, so a date rule can be tested at any hour. sets the moment that now() returns, so a rule about 09:00 IST can be tested at any hour.

The later sections use each of these:

• Bus::fake() records jobs, chains and batches without running them.
• Http::fake() answers outbound requests, and Http::preventStrayRequests() fails any request no fake covers.
• Event::fake() given one event class records only that event.
• Storage::fake('local') swaps a disk for an empty temporary folder.
• $this->spy() records every call, for the test to check afterwards.
• $this->partialMock() replaces chosen methods of a real class and keeps the rest.

One reminder test, with a fake and a moved clock

The first test of FeeReminderTest.php checks the main path: at 09:00 IST on the 12th, an instalment due on the 15th gets one reminder. Read it beside the command:

<?php

namespace Tests\Feature;

use App\Models\Instalment;
use App\Models\Student;
use App\Notifications\FeeDueReminder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Notification;
use Tests\TestCase;

class FeeReminderTest extends TestCase
{
    use RefreshDatabase;

    public function test_a_guardian_is_reminded_three_days_before_the_due_day(): void
    {
        Notification::fake();
        $this->travelTo(Carbon::parse('2026-01-12 09:00', 'Asia/Kolkata'));

        $student = Student::factory()->withGuardian()->create(['name' => 'Riya Sharma']);
        $instalment = Instalment::factory()->for($student)->create(['due_on' => '2026-01-15']);

        $this->artisan('fees:remind')
            ->expectsOutput('Reminders sent: 1, failed: 0')
            ->assertSuccessful();

        Notification::assertSentTo(
            $student->guardian,
            FeeDueReminder::class,
            fn (FeeDueReminder $reminder) => $reminder->instalment->is($instalment),
        );
        Notification::assertCount(1);
        $this->assertSame('2026-01-12 03:30:00', $instalment->fresh()->reminded_at->toDateTimeString());
    }

    public function test_nobody_is_reminded_four_days_before_the_due_day(): void
    {
        Notification::fake();
        $this->travelTo(Carbon::parse('2026-01-11 09:00', 'Asia/Kolkata'));

        $student = Student::factory()->withGuardian()->create();
        Instalment::factory()->for($student)->create(['due_on' => '2026-01-15']);

        $this->artisan('fees:remind')
            ->expectsOutput('Reminders sent: 0, failed: 0')
            ->assertSuccessful();

        Notification::assertNothingSent();
    }
}

<?php

namespace App\Console\Commands;

use App\Exceptions\SmsFailed;
use App\Models\Instalment;
use App\Notifications\FeeDueReminder;
use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Command;
use Illuminate\Support\Carbon;

// Runs every morning at 09:00 IST (routes/console.php). Each pending instalment due within the next three days gets
// one SMS reminder. A send that fails leaves reminded_at empty, so the next morning's run tries again.
#[Signature('fees:remind')]
#[Description('Send one SMS reminder for each pending instalment due within three days')]
class SendFeeReminders extends Command
{
    public function handle(): int
    {
        // The rule follows the guardian's calendar, so "today" is the day in India, not in the app's UTC.
        $today = Carbon::now('Asia/Kolkata')->startOfDay();

        $instalments = Instalment::query()
            ->where('status', 'pending')
            ->whereNull('reminded_at')
            ->whereDate('due_on', '>=', $today->toDateString())
            ->whereDate('due_on', '<=', $today->copy()->addDays(3)->toDateString())
            ->whereHas('student.guardian')
            ->with('student.guardian')
            ->orderBy('id')
            ->get();

        $sent = 0;
        $failed = 0;

        foreach ($instalments as $instalment) {
            try {
                $instalment->student->guardian->notify(new FeeDueReminder($instalment));
            } catch (SmsFailed $e) {
                report($e);
                $failed++;

                continue;
            }

            $instalment->forceFill(['reminded_at' => Carbon::now()])->save();
            $sent++;
        }

        $this->info("Reminders sent: {$sent}, failed: {$failed}");

        return self::SUCCESS;
    }
}

<?php

namespace App\Notifications;

use App\Models\Instalment;
use App\Notifications\Channels\SmsChannel;
use Illuminate\Notifications\Notification;

// The SMS a guardian gets before an instalment is due. Amounts are integer paise: 118000 paise is Rs 1,180.00.
class FeeDueReminder extends Notification
{
    public function __construct(public Instalment $instalment)
    {
    }

    public function via(object $notifiable): array
    {
        return [SmsChannel::class];
    }

    public function toSms(object $notifiable): string
    {
        $rupees = number_format($this->instalment->amount_paise / 100, 2);

        return "Pathshala: the fee instalment of Rs {$rupees} for {$this->instalment->student->name}"
            ." is due on {$this->instalment->due_on->toDateString()}.";
    }
}

Step through it in order:

from session import run

# The fee reminder of the free part (reminders-app/tests/Feature/FeeReminderTest.php): Notification::fake() records
# the SMS notification instead of sending it, and travelTo() sets the clock to 09:00 IST on the 12th (the reminder
# is due) and on the 11th (too early). Nothing leaves the machine and the result does not depend on today's date.
run(
    """
export COLLISION_IGNORE_DURATION=true
php artisan test tests/Feature/FeeReminderTest.php
""",
    app=True,
    overlay=("reminders-app",),
)

$ export COLLISION_IGNORE_DURATION=true
$ php artisan test tests/Feature/FeeReminderTest.php
   PASS  Tests\Feature\FeeReminderTest
  ✓ a guardian is reminded three days before the due day
  ✓ nobody is reminded four days before the due day

  Tests:    2 passed (8 assertions)
  Duration: …s

Both tests passed, with 8 assertions. The fake comes first, because it records only what happens after it is in place. The second test stands at 09:00 IST on the 11th, when the 15th is four days away, and assertNothingSent() proves the window’s edge. The first test read reminded_at back as 03:30 on the 12th: the app keeps UTC, as config/app.php sets, and the run shows India’s clock five and a half hours ahead of it.

Every fake on one payment, and the bug a fake cannot see Pro: opens with a Pro, Premium or Ultimate pass

Mocks, spies and partial mocks on a contract you own, and their failures Pro: opens with a Pro, Premium or Ultimate pass

Time travel through the reminder's week, and a test that failed at night Pro: opens with a Pro, Premium or Ultimate pass

Practise

Build the two reminder tests in your own Pathshala project, then break each one on purpose: put Notification::fake() after the command, move travelTo() to the 11th, and swap travelTo() for freezeTime(). Say what each change will do before you run it. The self-check starts where your answers have been weakest:

Interview questions

A warm-up for freshers and 2–5 years: how does a fake differ from a mock in a Laravel test?

A fake replaces one of Laravel’s services with a recorder. After Notification::fake() or Bus::fake() the code runs as usual, nothing leaves the app, and the test asks afterwards what was recorded. A mock stands in for a class or interface of your own, made with Mockery, and is told before the code runs which calls to expect; a call with other arguments, or too many calls, fails the test. Use a fake when Laravel has one and the question is what was sent, and a mock when the exact call to your own collaborator matters.

The three harder questions below use the same reminder and payment code. Write down your first step for each before you open it:

Key takeaways

• A test double takes the place of something outside the code: fakes for Laravel’s services, mocks for your own contracts, time travel for the clock.
• A facade fake must be in place before the code runs, because it records only what happens after it.
• travelTo() fixes the moment that now() returns, so a rule about 09:00 IST gives one result at any hour.
• The app keeps UTC, so a reminder sent at 09:00 IST is stored as 03:30.