function CronTest::setUp

Overrides UnitTestCase::setUp

File

core/tests/Drupal/Tests/Core/CronTest.php, line 66

Class

CronTest

Tests the Cron class.

Namespace

Code

protected function setUp() : void {
    parent::setUp();
    // Construct a state object used for testing logger assertions.
    $time = $this->prophesize(TimeInterface::class)
        ->reveal();
    $this->state = new State(new KeyValueMemoryFactory(), new MemoryBackend($time), new NullLockBackend());
    // Create a mock logger to set a flag in the resulting state.
    $logger = $this->prophesize('Drupal\\Core\\Logger\\LoggerChannelInterface');
    // Safely ignore the cron success message.
    $logger->info('Cron run completed.')
        ->shouldBeCalled();
    // Set a flag to track when a message is logged by adding a callback
    // function for each logging method.
    foreach (get_class_methods(LoggerInterface::class) as $logger_method) {
        $logger->{$logger_method}(Argument::cetera())
            ->will(function () {
            \Drupal::state()->set('cron_test.message_logged', TRUE);
        });
    }
    // Create a logger factory to produce the resulting logger.
    $logger_factory = $this->prophesize('Drupal\\Core\\Logger\\LoggerChannelFactoryInterface');
    $logger_factory->get(Argument::exact('cron'))
        ->willReturn($logger->reveal());
    // Create a mock time service.
    $time = $this->prophesize('Drupal\\Component\\Datetime\\TimeInterface');
    // Create a mock config factory and config object.
    $config_factory = $this->prophesize(ConfigFactoryInterface::class);
    $config = $this->prophesize(ImmutableConfig::class);
    $config->get('logging')
        ->willReturn(FALSE);
    $config_factory->get('system.cron')
        ->willReturn($config->reveal());
    // Build the container using the resulting mock objects.
    \Drupal::setContainer(new ContainerBuilder());
    \Drupal::getContainer()->set('logger.factory', $logger_factory->reveal());
    \Drupal::getContainer()->set('datetime.time', $time->reveal());
    \Drupal::getContainer()->set('state', $this->state);
    \Drupal::getContainer()->set('config.factory', $config_factory->reveal());
    // Create mock objects for constructing the Cron class.
    $module_handler = $this->prophesize('Drupal\\Core\\Extension\\ModuleHandlerInterface');
    $queue_factory = $this->prophesize('Drupal\\Core\\Queue\\QueueFactory');
    $queue_worker_manager = $this->prophesize('Drupal\\Core\\Queue\\QueueWorkerManagerInterface');
    $state = $this->prophesize('Drupal\\Core\\State\\StateInterface');
    $account_switcher = $this->prophesize('Drupal\\Core\\Session\\AccountSwitcherInterface');
    $queueConfig = [
        'suspendMaximumWait' => 30.0,
    ];
    // Create a lock that will always fail when attempting to acquire; we're
    // only interested in testing ::processQueues(), not the other stuff.
    $lock_backend = $this->prophesize('Drupal\\Core\\Lock\\LockBackendInterface');
    $lock_backend->acquire('cron', Argument::cetera())
        ->willReturn(TRUE);
    $lock_backend->release('cron')
        ->shouldBeCalled();
    // Create a queue worker definition for testing purposes.
    $queue_worker = $this->randomMachineName();
    $queue_worker_definition = [
        'id' => $queue_worker,
        'cron' => [
            'time' => &$this->claimTime,
        ],
    ];
    // Create a queue instance for this queue worker.
    $this->queue = new Memory($queue_worker);
    $queue_factory->get($queue_worker)
        ->willReturn($this->queue);
    // Create a mock queue worker plugin instance based on above definition.
    $queue_worker_plugin = $this->prophesize('Drupal\\Core\\Queue\\QueueWorkerInterface');
    $queue_worker_plugin->getPluginId()
        ->willReturn($queue_worker);
    $queue_worker_plugin->getPluginDefinition()
        ->willReturn($queue_worker_definition);
    $queue_worker_plugin->processItem('Complete')
        ->willReturn();
    $queue_worker_plugin->processItem('Exception')
        ->willThrow(\Exception::class);
    $queue_worker_plugin->processItem('DelayedRequeueException')
        ->willThrow(DelayedRequeueException::class);
    $queue_worker_plugin->processItem('SuspendQueueException')
        ->willThrow(SuspendQueueException::class);
    // 'RequeueException' would normally result in an infinite loop.
    //
    // This is avoided by throwing RequeueException for the first few calls to
    // ::processItem() and then returning void. ::testRequeueException()
    // establishes sanity assertions for this case.
    $queue_worker_plugin->processItem('RequeueException')
        ->will(function ($args, $mock, $method) {
        // Fetch the number of calls to this prophesied method. This value will
        // start at zero during the first call.
        $method_calls = count($mock->findProphecyMethodCalls($method->getMethodName(), new ArgumentsWildcard($args)));
        // Throw the expected exception on the first few calls.
        if ($method_calls < self::REQUEUE_COUNT) {
            \Drupal::state()->set('cron_test.requeue_count', $method_calls + 1);
            throw new RequeueException();
        }
    });
    // Set the mock queue worker manager to return the definition/plugin.
    $queue_worker_manager->getDefinitions()
        ->willReturn([
        $queue_worker => $queue_worker_definition,
    ]);
    $queue_worker_manager->createInstance($queue_worker)
        ->willReturn($queue_worker_plugin->reveal());
    // Construct the Cron class to test.
    $this->cron = new Cron($module_handler->reveal(), $lock_backend->reveal(), $queue_factory->reveal(), $state->reveal(), $account_switcher->reveal(), $logger->reveal(), $queue_worker_manager->reveal(), $time->reveal(), $queueConfig);
}