If you want to unit test the scheduling of events you can use this example. It is based on the default inspire command:

public function testIsAvailableInTheScheduler()
{
    /** @var \Illuminate\Console\Scheduling\Schedule $schedule */
    $schedule = app()->make(\Illuminate\Console\Scheduling\Schedule::class);

    $events = collect($schedule->events())->filter(function (\Illuminate\Console\Scheduling\Event $event) {
        return stripos($event->command, 'YourCommandHere');
    });

    if ($events->count() == 0) {
        $this->fail('No events found');
    }

    $events->each(function (\Illuminate\Console\Scheduling\Event $event) {
        // This example is for hourly commands.
        $this->assertEquals('0 * * * * *', $event->expression);
    });
}

I've had luck in Laravel 8 with the following test:

public function testRunsAt930()
{
    Event::fake();
    $this->travelTo(now()->startOfWeek()->setHour(9)->setMinute(30));
    $this->artisan('schedule:run');
    
    Event::assertDispatched(ScheduledTaskFinished::class, function ($event) {
        return strpos($event->task->command, 'your-command-name') !== false;
    });
}

The scheduler fires off the Illuminate\Console\Events\ScheduledTaskFinished event when it successfully runs a schedule, so you can find out if your schedule would run at a particular time by mocking your time then actually running the schedule and then you just listen for that event.

If you're not using L8 you can probably use something like Carbonite for the time mocking, though I think the rest should work, though you might need to use Artisan facade in earlier versions.

To find out if a schedule ran just use Event::assertDispatched() as in the above example. Though if you want to find out if it did not run you can just use Event::assertNotDispatched() for the ScheduledTaskFinished::class or listen for the ScheduledTaskFailed::class instead.

I know this has already been answered but I found this method may be a bit cleaner if you're using L8, and maybe even for earlier versions.

Building on Michiel's answer, I've used the methods contained in Illuminate\Console\Scheduling\Event to test if the event is due to run for a given date.

I've mocked the current date using Carbon::setTestNow() so that any date based logic in the when() and skip() filters will behave as expected.

use Tests\TestCase;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Console\Scheduling\Event;

use Cron\CronExpression;
use Carbon\Carbon;


class ScheduleTest extends TestCase {


    public function testCompanyFeedbackSchedule()
    {
        $event = $this->getCommandEvent('your-command-signature');

        $test_date = Carbon::now()->startOfDay()->addHours(8);

        for ($i=0; $i < 365; $i++) { 
            $test_date->addDay();
            Carbon::setTestNow($test_date);

            // Run the when() & skip() filters
            $filters_pass = $event->filtersPass($this->app);
            // Test that the Cron expression passes
            $date_passes = $this->isEventDue($event);
            $will_run = $filters_pass && $date_passes;

            // Should only run on first friday of month
            if ($test_date->format('l') === 'Friday' && $test_date->weekOfMonth === 1) {
                $this->assertTrue($will_run, 'Task should run on '. $test_date->toDateTimeString());
            } else {
                $this->assertFalse($will_run, 'Task should not run on '. $test_date->toDateTimeString());
            }
        }
    }


    /**
     * Get the event matching the given command signature from the scheduler
     * 
     * @param  string  $command_signature
     * 
     * @return Illuminate\Console\Scheduling\Event
     */
    private function getCommandEvent($command_signature)
    {
        $schedule = app()->make(Schedule::class);

        $event = collect($schedule->events())->first(function (Event $event) use ($command_signature) {
            return stripos($event->command, $command_signature);
        });

        if (!$event) {
            $this->fail('Event for '. $command_signature .' not found');
        }

        return $event;
    }


    /**
     * Determine if the Cron expression passes.
     * 
     * Copied from the protected method Illuminate\Console\Scheduling\Event@isEventDue
     * 
     * @return bool
     */
    private function isEventDue(Event $event)
    {
        $date = Carbon::now();

        if ($event->timezone) {
            $date->setTimezone($event->timezone);
        }

        return CronExpression::factory($event->expression)->isDue($date->toDateTimeString());
    }
}

Building on Michiel's anwer as well, at least in L8 there is a difference.

Instead of $event->command:

$events = collect($schedule->events())->filter(function (Event $event) {
  return stripos($event->command, 'YourCommandHere');
});

An $event->description is required:

$events = collect($schedule->events())->filter(function (Event $event) {
  return stripos($event->description, 'YourCommandHere');
});

I have found this while looking into Tinker:

>>> app()->make(\Illuminate\Console\Scheduling\Schedule::class)->events();
=> [
     Illuminate\Console\Scheduling\CallbackEvent {#3496
       +command: null,
       +expression: "* * * * *",
       +timezone: "UTC",
       +user: null,
       +environments: [],
       +evenInMaintenanceMode: false,
       +withoutOverlapping: false,
       +onOneServer: false,
       +expiresAt: 1440,
       +runInBackground: false,
       +output: "/dev/null",
       +shouldAppendOutput: false,
       +description: "App\Jobs\GenerateSuggestion",
       +mutex: Illuminate\Console\Scheduling\CacheEventMutex {#3498
         +cache: Illuminate\Cache\CacheManager {#282},
         +store: null,
       },
       +exitCode: null,
     },
   ]

You can check if job added to scheduler (L9) :

$addedToScheduler = collect(App::make(Schedule::class)->events())
   ->pluck('description')
   ->contains(PaymentRenewJob::class);

$this->assertTrue($addedToScheduler, 'PaymentRenewJob is not added to scheduler');

Rest of your code can tested on console testing. see more on laravel docs eg:

$this->artisan('inspire')->assertSuccessful();

This solution is inspired by Hasan's answer.

<?php
    
    namespace App\Console\Callable;
    
    class ExampleCallable
    {
        public function __invoke(): void
        {
            // @todo Do something
        }
    }

The main difference is that scheduled item is just a callable class and has an empty description value. Collection is filtered using reflection to access the protected callback parameter to filter out unsuitable events and then check if there are any events with suitable execution schedule. Detection approach is taken from the core schedule list command.

<?php

namespace Tests\Unit\Console;

use App\Console\Callable\ExampleCallable;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Support\Facades\App;
use ReflectionClass;
use Tests\TestCase;

class KernelTest extends TestCase
{
    public function testSchedule(): void
    {
        // Collect all scheduled events and filter out suitable callbacks
        $events = collect(App::make(Schedule::class)->events())
            ->filter(function ($event) {
                $callback = (new ReflectionClass($event))
                    ->getProperty('callback')
                    ->getValue($event);

                return $callback instanceof ExampleCallable;
            });

        $this->assertFalse($events->isEmpty());
        $this->assertNotEquals(0,
            $events
                ->where('expression', '* * * * *')
                ->count()
        );
    }
}