ZenstruckScheduleExtensionTest - Code Metrics - Inspection of "Add feature to configure tasks in bundle config" - zenstruck/schedule-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Kevin

created 2020-01-14 16:29 UTC

ZenstruckScheduleExtensionTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	360
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	18
eloc	177
c	1
b	0
f	0
dl	0
loc	360
rs	10

18 Methods

Rating	Name	Size	Complexity
A	can_add_schedule_environment_as_array()	7	1
A	getContainerExtensions()	3	1
A	can_configure_ping_handler_http_client()	6	1
A	can_enable_email_on_failure_schedule_extension()	16	1
A	minimum_task_configuration()	26	1
A	can_add_schedule_environment_as_string()	9	1
A	can_configure_default_timezone()	7	1
A	can_configure_without_overlapping_handler_lock_factory()	6	1
A	can_enable_ping_schedule_extensions()	15	1
A	pingScheduleExtensionProvider()	7	1
A	can_configure_single_server_lock_factory()	6	1
A	task_frequency_must_be_valid()	10	1
B	full_task_configuration()	72	1
A	empty_config_loads_default_services()	42	1
A	timezone_must_be_valid()	6	1
A	can_enable_single_server_schedule_extension()	8	1
A	can_configure_email_handler()	14	1
A	minimum_email_handler_configuration()	11	1

<?php

namespace Zenstruck\ScheduleBundle\Tests\DependencyInjection;

use Matthias\SymfonyDependencyInjectionTest\PhpUnit\AbstractExtensionTestCase;
use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
use Zenstruck\ScheduleBundle\Command\ScheduleListCommand;
use Zenstruck\ScheduleBundle\Command\ScheduleRunCommand;
use Zenstruck\ScheduleBundle\DependencyInjection\ZenstruckScheduleExtension;
use Zenstruck\ScheduleBundle\EventListener\ConfigureScheduleSubscriber;
use Zenstruck\ScheduleBundle\EventListener\ConfigureTasksSubscriber;
use Zenstruck\ScheduleBundle\EventListener\LogScheduleSubscriber;
use Zenstruck\ScheduleBundle\EventListener\ScheduleBuilderSubscriber;
use Zenstruck\ScheduleBundle\EventListener\SelfSchedulingSubscriber;
use Zenstruck\ScheduleBundle\EventListener\TimezoneSubscriber;
use Zenstruck\ScheduleBundle\Schedule\Extension\EmailExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\EnvironmentExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\ExtensionHandlerRegistry;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\EmailHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\EnvironmentHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\PingHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\SelfHandlingHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\SingleServerHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\WithoutOverlappingHandler;
use Zenstruck\ScheduleBundle\Schedule\Extension\PingExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\SingleServerExtension;
use Zenstruck\ScheduleBundle\Schedule\Extension\WithoutOverlappingExtension;
use Zenstruck\ScheduleBundle\Schedule\ScheduleRunner;
use Zenstruck\ScheduleBundle\Schedule\Task\Runner\CommandTaskRunner;
use Zenstruck\ScheduleBundle\Schedule\Task\Runner\SelfRunningTaskRunner;

/**
 * @author Kevin Bond <[email protected]>
 */
final class ZenstruckScheduleExtensionTest extends AbstractExtensionTestCase
{
    /**
     * @test
     */
    public function empty_config_loads_default_services()
    {
        $this->load([]);

        $this->assertContainerBuilderHasService(ScheduleListCommand::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleListCommand::class, 'console.command');

        $this->assertContainerBuilderHasService(ScheduleRunCommand::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleRunCommand::class, 'console.command');

        $this->assertContainerBuilderHasService(ScheduleRunner::class);

        $this->assertContainerBuilderHasService(ScheduleBuilderSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleBuilderSubscriber::class, 'kernel.event_subscriber');

        $this->assertContainerBuilderHasService(ConfigureScheduleSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(ConfigureScheduleSubscriber::class, 'kernel.event_subscriber');

        $this->assertContainerBuilderHasService(SelfSchedulingSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(SelfSchedulingSubscriber::class, 'kernel.event_subscriber');

        $this->assertContainerBuilderHasService(CommandTaskRunner::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(CommandTaskRunner::class, 'schedule.task_runner');

        $this->assertContainerBuilderHasService(SelfRunningTaskRunner::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(SelfRunningTaskRunner::class, 'schedule.task_runner');

        $this->assertContainerBuilderHasService(LogScheduleSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(LogScheduleSubscriber::class, 'kernel.event_subscriber');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(LogScheduleSubscriber::class, 'monolog.logger', ['channel' => 'schedule']);

        $this->assertContainerBuilderHasService(ExtensionHandlerRegistry::class);

        $this->assertContainerBuilderHasService(SelfHandlingHandler::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(SelfHandlingHandler::class, 'schedule.extension_handler', ['priority' => -100]);

        $this->assertContainerBuilderHasService(EnvironmentHandler::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(EnvironmentHandler::class, 'schedule.extension_handler');

        $this->assertContainerBuilderHasService(ConfigureTasksSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleBuilderSubscriber::class, 'kernel.event_subscriber');
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(ConfigureTasksSubscriber::class, 0, []);
    }

    /**
     * @test
     */
    public function can_configure_default_timezone()
    {
        $this->load(['timezone' => 'UTC']);

        $this->assertContainerBuilderHasService(TimezoneSubscriber::class);
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(TimezoneSubscriber::class, 0, 'UTC');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(TimezoneSubscriber::class, 'kernel.event_subscriber');
    }

    /**
     * @test
     */
    public function timezone_must_be_valid()
    {
        $this->expectException(InvalidConfigurationException::class);
        $this->expectExceptionMessage('Invalid configuration for path "zenstruck_schedule.timezone": Timezone "invalid" is not available');

        $this->load(['timezone' => 'invalid']);
    }

    /**
     * @test
     */
    public function can_configure_single_server_lock_factory()
    {
        $this->load(['single_server_handler' => 'my_factory']);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument(SingleServerHandler::class, 0, 'my_factory');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(SingleServerHandler::class, 'schedule.extension_handler');
    }

    /**
     * @test
     */
    public function can_configure_without_overlapping_handler_lock_factory()
    {
        $this->load(['without_overlapping_handler' => 'my_factory']);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument(WithoutOverlappingHandler::class, 0, 'my_factory');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(WithoutOverlappingHandler::class, 'schedule.extension_handler');
    }

    /**
     * @test
     */
    public function can_configure_ping_handler_http_client()
    {
        $this->load(['ping_handler' => 'my_client']);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument(PingHandler::class, 0, 'my_client');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(PingHandler::class, 'schedule.extension_handler');
    }

    /**
     * @test
     */
    public function can_configure_email_handler()
    {
        $this->load(['email_handler' => [
            'service' => 'my_mailer',
            'default_from' => '[email protected]',
            'default_to' => '[email protected]',
            'subject_prefix' => '[Acme Inc]',
        ]]);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 0, 'my_mailer');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(EmailHandler::class, 'schedule.extension_handler');
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 1, '[email protected]');
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 2, '[email protected]');
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 3, '[Acme Inc]');
    }

    /**
     * @test
     */
    public function minimum_email_handler_configuration()
    {
        $this->load(['email_handler' => [
            'service' => 'my_mailer',
        ]]);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 0, 'my_mailer');
        $this->assertContainerBuilderHasServiceDefinitionWithTag(EmailHandler::class, 'schedule.extension_handler');
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 1, null);
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 2, null);
        $this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 3, null);
    }

    /**
     * @test
     */
    public function can_add_schedule_environment_as_string()
    {
        $this->load(['schedule_extensions' => [
            'environments' => 'prod',
        ]]);

        $this->assertContainerBuilderHasService('zenstruck_schedule.extension.environments', EnvironmentExtension::class);
        $this->assertContainerBuilderHasServiceDefinitionWithArgument('zenstruck_schedule.extension.environments', 0, ['prod']);
        $this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.environments', 'schedule.configured_extension');
    }

    /**
     * @test
     */
    public function can_add_schedule_environment_as_array()
    {
        $this->load(['schedule_extensions' => [
            'environments' => ['prod', 'stage'],
        ]]);

        $this->assertContainerBuilderHasServiceDefinitionWithArgument('zenstruck_schedule.extension.environments', 0, ['prod', 'stage']);
    }

    /**
     * @test
     */
    public function can_enable_single_server_schedule_extension()
    {
        $this->load(['schedule_extensions' => [
            'on_single_server' => null,
        ]]);

        $this->assertContainerBuilderHasService('zenstruck_schedule.extension.on_single_server', SingleServerExtension::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.on_single_server', 'schedule.configured_extension');
    }

    /**
     * @test
     */
    public function can_enable_email_on_failure_schedule_extension()
    {
        $this->load(['schedule_extensions' => [
            'email_on_failure' => [
                'to' => '[email protected]',
                'subject' => 'my subject',
            ],
        ]]);

        $this->assertContainerBuilderHasService('zenstruck_schedule.extension.email_on_failure', EmailExtension::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.email_on_failure', 'schedule.configured_extension');

        $definition = $this->container->getDefinition('zenstruck_schedule.extension.email_on_failure');

        $this->assertSame([EmailExtension::class, 'scheduleFailure'], $definition->getFactory());
        $this->assertSame(['[email protected]', 'my subject'], $definition->getArguments());
    }

    /**
     * @test
     * @dataProvider pingScheduleExtensionProvider
     */
    public function can_enable_ping_schedule_extensions($key, $method)
    {
        $this->load(['schedule_extensions' => [
            $key => [
                'url' => 'example.com',
            ],
        ]]);

        $this->assertContainerBuilderHasService('zenstruck_schedule.extension.'.$key, PingExtension::class);
        $this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.'.$key, 'schedule.configured_extension');

        $definition = $this->container->getDefinition('zenstruck_schedule.extension.'.$key);

        $this->assertSame([PingExtension::class, $method], $definition->getFactory());
        $this->assertSame(['example.com', 'GET', []], $definition->getArguments());
    }

    public static function pingScheduleExtensionProvider()
    {
        return [
            ['ping_before', 'scheduleBefore'],
            ['ping_after', 'scheduleAfter'],
            ['ping_on_success', 'scheduleSuccess'],
            ['ping_on_failure', 'scheduleFailure'],
        ];
    }

    /**
     * @test
     */
    public function minimum_task_configuration()
    {
        $this->load([
            'tasks' => [
                [
                    'command' => 'my:command',
                    'frequency' => '0 * * * *',
                ],
            ],
        ]);

        $config = $this->container->getDefinition(ConfigureTasksSubscriber::class)->getArgument(0)[0];

        $this->assertSame('my:command', $config['command']);
        $this->assertSame('0 * * * *', $config['frequency']);
        $this->assertSame('command', $config['type']);
        $this->assertNull($config['description']);
        $this->assertFalse($config['without_overlapping']['enabled']);
        $this->assertFalse($config['between']['enabled']);
        $this->assertFalse($config['unless_between']['enabled']);
        $this->assertFalse($config['ping_before']['enabled']);
        $this->assertFalse($config['ping_after']['enabled']);
        $this->assertFalse($config['ping_on_success']['enabled']);
        $this->assertFalse($config['ping_on_failure']['enabled']);
        $this->assertFalse($config['email_after']['enabled']);
        $this->assertFalse($config['email_on_failure']['enabled']);
    }

    /**
     * @test
     */
    public function task_frequency_must_be_valid()
    {
        $this->expectException(InvalidConfigurationException::class);
        $this->expectExceptionMessage('Invalid configuration for path "zenstruck_schedule.tasks.0.frequency": "invalid" is an invalid cron expression.');

        $this->load([
            'tasks' => [
                [
                    'command' => 'my:command',
                    'frequency' => 'invalid',
                ],
            ],
        ]);
    }

    /**
     * @test
     */
    public function full_task_configuration()
    {
        $this->load([
            'tasks' => [
                [
                    'command' => 'my:command --option',
                    'type' => 'process',
                    'frequency' => '0 0 * * *',
                    'description' => 'my description',
                    'without_overlapping' => null,
                    'between' => [
                        'start' => 9,
                        'end' => 17,
                    ],
                    'unless_between' => [
                        'start' => 12,
                        'end' => '13:30',
                    ],
                    'ping_before' => [
                        'url' => 'https://example.com/before',
                    ],
                    'ping_after' => [
                        'url' => 'https://example.com/after',
                    ],
                    'ping_on_success' => [
                        'url' => 'https://example.com/success',
                    ],
                    'ping_on_failure' => [
                        'url' => 'https://example.com/failure',
                        'method' => 'POST',
                    ],
                    'email_after' => null,
                    'email_on_failure' => [
                        'to' => '[email protected]',
                        'subject' => 'my subject',
                    ],
                ],
            ],
        ]);

        $config = $this->container->getDefinition(ConfigureTasksSubscriber::class)->getArgument(0)[0];

        $this->assertSame('my:command --option', $config['command']);
        $this->assertSame('0 0 * * *', $config['frequency']);
        $this->assertSame('process', $config['type']);
        $this->assertSame('my description', $config['description']);
        $this->assertTrue($config['without_overlapping']['enabled']);
        $this->assertSame(WithoutOverlappingExtension::DEFAULT_TTL, $config['without_overlapping']['ttl']);
        $this->assertTrue($config['between']['enabled']);
        $this->assertSame(9, $config['between']['start']);
        $this->assertSame(17, $config['between']['end']);
        $this->assertTrue($config['unless_between']['enabled']);
        $this->assertSame(12, $config['unless_between']['start']);
        $this->assertSame('13:30', $config['unless_between']['end']);
        $this->assertTrue($config['ping_before']['enabled']);
        $this->assertSame('https://example.com/before', $config['ping_before']['url']);
        $this->assertSame('GET', $config['ping_before']['method']);
        $this->assertTrue($config['ping_after']['enabled']);
        $this->assertSame('https://example.com/after', $config['ping_after']['url']);
        $this->assertSame('GET', $config['ping_after']['method']);
        $this->assertTrue($config['ping_on_success']['enabled']);
        $this->assertSame('https://example.com/success', $config['ping_on_success']['url']);
        $this->assertSame('GET', $config['ping_on_success']['method']);
        $this->assertTrue($config['ping_on_failure']['enabled']);
        $this->assertSame('https://example.com/failure', $config['ping_on_failure']['url']);
        $this->assertSame('POST', $config['ping_on_failure']['method']);
        $this->assertTrue($config['email_after']['enabled']);
        $this->assertNull($config['email_after']['to']);
        $this->assertNull($config['email_after']['subject']);
        $this->assertTrue($config['email_on_failure']['enabled']);
        $this->assertSame('[email protected]', $config['email_on_failure']['to']);
        $this->assertSame('my subject', $config['email_on_failure']['subject']);
    }

    protected function getContainerExtensions(): array
    {
        return [new ZenstruckScheduleExtension()];
    }
}


1			<?php
2
3			namespace Zenstruck\ScheduleBundle\Tests\DependencyInjection;
4
5			use Matthias\SymfonyDependencyInjectionTest\PhpUnit\AbstractExtensionTestCase;
6			use Symfony\Component\Config\Definition\Exception\InvalidConfigurationException;
7			use Zenstruck\ScheduleBundle\Command\ScheduleListCommand;
8			use Zenstruck\ScheduleBundle\Command\ScheduleRunCommand;
9			use Zenstruck\ScheduleBundle\DependencyInjection\ZenstruckScheduleExtension;
10			use Zenstruck\ScheduleBundle\EventListener\ConfigureScheduleSubscriber;
11			use Zenstruck\ScheduleBundle\EventListener\ConfigureTasksSubscriber;
12			use Zenstruck\ScheduleBundle\EventListener\LogScheduleSubscriber;
13			use Zenstruck\ScheduleBundle\EventListener\ScheduleBuilderSubscriber;
14			use Zenstruck\ScheduleBundle\EventListener\SelfSchedulingSubscriber;
15			use Zenstruck\ScheduleBundle\EventListener\TimezoneSubscriber;
16			use Zenstruck\ScheduleBundle\Schedule\Extension\EmailExtension;
17			use Zenstruck\ScheduleBundle\Schedule\Extension\EnvironmentExtension;
18			use Zenstruck\ScheduleBundle\Schedule\Extension\ExtensionHandlerRegistry;
19			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\EmailHandler;
20			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\EnvironmentHandler;
21			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\PingHandler;
22			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\SelfHandlingHandler;
23			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\SingleServerHandler;
24			use Zenstruck\ScheduleBundle\Schedule\Extension\Handler\WithoutOverlappingHandler;
25			use Zenstruck\ScheduleBundle\Schedule\Extension\PingExtension;
26			use Zenstruck\ScheduleBundle\Schedule\Extension\SingleServerExtension;
27			use Zenstruck\ScheduleBundle\Schedule\Extension\WithoutOverlappingExtension;
28			use Zenstruck\ScheduleBundle\Schedule\ScheduleRunner;
29			use Zenstruck\ScheduleBundle\Schedule\Task\Runner\CommandTaskRunner;
30			use Zenstruck\ScheduleBundle\Schedule\Task\Runner\SelfRunningTaskRunner;
31
32			/**
33			* @author Kevin Bond <[email protected]>
34			*/
35			final class ZenstruckScheduleExtensionTest extends AbstractExtensionTestCase
36			{
37			/**
38			* @test
39			*/
40			public function empty_config_loads_default_services()
41			{
42			$this->load([]);
43
44			$this->assertContainerBuilderHasService(ScheduleListCommand::class);
45			$this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleListCommand::class, 'console.command');
46
47			$this->assertContainerBuilderHasService(ScheduleRunCommand::class);
48			$this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleRunCommand::class, 'console.command');
49
50			$this->assertContainerBuilderHasService(ScheduleRunner::class);
51
52			$this->assertContainerBuilderHasService(ScheduleBuilderSubscriber::class);
53			$this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleBuilderSubscriber::class, 'kernel.event_subscriber');
54
55			$this->assertContainerBuilderHasService(ConfigureScheduleSubscriber::class);
56			$this->assertContainerBuilderHasServiceDefinitionWithTag(ConfigureScheduleSubscriber::class, 'kernel.event_subscriber');
57
58			$this->assertContainerBuilderHasService(SelfSchedulingSubscriber::class);
59			$this->assertContainerBuilderHasServiceDefinitionWithTag(SelfSchedulingSubscriber::class, 'kernel.event_subscriber');
60
61			$this->assertContainerBuilderHasService(CommandTaskRunner::class);
62			$this->assertContainerBuilderHasServiceDefinitionWithTag(CommandTaskRunner::class, 'schedule.task_runner');
63
64			$this->assertContainerBuilderHasService(SelfRunningTaskRunner::class);
65			$this->assertContainerBuilderHasServiceDefinitionWithTag(SelfRunningTaskRunner::class, 'schedule.task_runner');
66
67			$this->assertContainerBuilderHasService(LogScheduleSubscriber::class);
68			$this->assertContainerBuilderHasServiceDefinitionWithTag(LogScheduleSubscriber::class, 'kernel.event_subscriber');
69			$this->assertContainerBuilderHasServiceDefinitionWithTag(LogScheduleSubscriber::class, 'monolog.logger', ['channel' => 'schedule']);
70
71			$this->assertContainerBuilderHasService(ExtensionHandlerRegistry::class);
72
73			$this->assertContainerBuilderHasService(SelfHandlingHandler::class);
74			$this->assertContainerBuilderHasServiceDefinitionWithTag(SelfHandlingHandler::class, 'schedule.extension_handler', ['priority' => -100]);
75
76			$this->assertContainerBuilderHasService(EnvironmentHandler::class);
77			$this->assertContainerBuilderHasServiceDefinitionWithTag(EnvironmentHandler::class, 'schedule.extension_handler');
78
79			$this->assertContainerBuilderHasService(ConfigureTasksSubscriber::class);
80			$this->assertContainerBuilderHasServiceDefinitionWithTag(ScheduleBuilderSubscriber::class, 'kernel.event_subscriber');
81			$this->assertContainerBuilderHasServiceDefinitionWithArgument(ConfigureTasksSubscriber::class, 0, []);
82			}
83
84			/**
85			* @test
86			*/
87			public function can_configure_default_timezone()
88			{
89			$this->load(['timezone' => 'UTC']);
90
91			$this->assertContainerBuilderHasService(TimezoneSubscriber::class);
92			$this->assertContainerBuilderHasServiceDefinitionWithArgument(TimezoneSubscriber::class, 0, 'UTC');
93			$this->assertContainerBuilderHasServiceDefinitionWithTag(TimezoneSubscriber::class, 'kernel.event_subscriber');
94			}
95
96			/**
97			* @test
98			*/
99			public function timezone_must_be_valid()
100			{
101			$this->expectException(InvalidConfigurationException::class);
102			$this->expectExceptionMessage('Invalid configuration for path "zenstruck_schedule.timezone": Timezone "invalid" is not available');
103
104			$this->load(['timezone' => 'invalid']);
105			}
106
107			/**
108			* @test
109			*/
110			public function can_configure_single_server_lock_factory()
111			{
112			$this->load(['single_server_handler' => 'my_factory']);
113
114			$this->assertContainerBuilderHasServiceDefinitionWithArgument(SingleServerHandler::class, 0, 'my_factory');
115			$this->assertContainerBuilderHasServiceDefinitionWithTag(SingleServerHandler::class, 'schedule.extension_handler');
116			}
117
118			/**
119			* @test
120			*/
121			public function can_configure_without_overlapping_handler_lock_factory()
122			{
123			$this->load(['without_overlapping_handler' => 'my_factory']);
124
125			$this->assertContainerBuilderHasServiceDefinitionWithArgument(WithoutOverlappingHandler::class, 0, 'my_factory');
126			$this->assertContainerBuilderHasServiceDefinitionWithTag(WithoutOverlappingHandler::class, 'schedule.extension_handler');
127			}
128
129			/**
130			* @test
131			*/
132			public function can_configure_ping_handler_http_client()
133			{
134			$this->load(['ping_handler' => 'my_client']);
135
136			$this->assertContainerBuilderHasServiceDefinitionWithArgument(PingHandler::class, 0, 'my_client');
137			$this->assertContainerBuilderHasServiceDefinitionWithTag(PingHandler::class, 'schedule.extension_handler');
138			}
139
140			/**
141			* @test
142			*/
143			public function can_configure_email_handler()
144			{
145			$this->load(['email_handler' => [
146			'service' => 'my_mailer',
147			'default_from' => '[email protected]',
148			'default_to' => '[email protected]',
149			'subject_prefix' => '[Acme Inc]',
150			]]);
151
152			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 0, 'my_mailer');
153			$this->assertContainerBuilderHasServiceDefinitionWithTag(EmailHandler::class, 'schedule.extension_handler');
154			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 1, '[email protected]');
155			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 2, '[email protected]');
156			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 3, '[Acme Inc]');
157			}
158
159			/**
160			* @test
161			*/
162			public function minimum_email_handler_configuration()
163			{
164			$this->load(['email_handler' => [
165			'service' => 'my_mailer',
166			]]);
167
168			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 0, 'my_mailer');
169			$this->assertContainerBuilderHasServiceDefinitionWithTag(EmailHandler::class, 'schedule.extension_handler');
170			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 1, null);
171			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 2, null);
172			$this->assertContainerBuilderHasServiceDefinitionWithArgument(EmailHandler::class, 3, null);
173			}
174
175			/**
176			* @test
177			*/
178			public function can_add_schedule_environment_as_string()
179			{
180			$this->load(['schedule_extensions' => [
181			'environments' => 'prod',
182			]]);
183
184			$this->assertContainerBuilderHasService('zenstruck_schedule.extension.environments', EnvironmentExtension::class);
185			$this->assertContainerBuilderHasServiceDefinitionWithArgument('zenstruck_schedule.extension.environments', 0, ['prod']);
186			$this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.environments', 'schedule.configured_extension');
187			}
188
189			/**
190			* @test
191			*/
192			public function can_add_schedule_environment_as_array()
193			{
194			$this->load(['schedule_extensions' => [
195			'environments' => ['prod', 'stage'],
196			]]);
197
198			$this->assertContainerBuilderHasServiceDefinitionWithArgument('zenstruck_schedule.extension.environments', 0, ['prod', 'stage']);
199			}
200
201			/**
202			* @test
203			*/
204			public function can_enable_single_server_schedule_extension()
205			{
206			$this->load(['schedule_extensions' => [
207			'on_single_server' => null,
208			]]);
209
210			$this->assertContainerBuilderHasService('zenstruck_schedule.extension.on_single_server', SingleServerExtension::class);
211			$this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.on_single_server', 'schedule.configured_extension');
212			}
213
214			/**
215			* @test
216			*/
217			public function can_enable_email_on_failure_schedule_extension()
218			{
219			$this->load(['schedule_extensions' => [
220			'email_on_failure' => [
221			'to' => '[email protected]',
222			'subject' => 'my subject',
223			],
224			]]);
225
226			$this->assertContainerBuilderHasService('zenstruck_schedule.extension.email_on_failure', EmailExtension::class);
227			$this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.email_on_failure', 'schedule.configured_extension');
228
229			$definition = $this->container->getDefinition('zenstruck_schedule.extension.email_on_failure');
230
231			$this->assertSame([EmailExtension::class, 'scheduleFailure'], $definition->getFactory());
232			$this->assertSame(['[email protected]', 'my subject'], $definition->getArguments());
233			}
234
235			/**
236			* @test
237			* @dataProvider pingScheduleExtensionProvider
238			*/
239			public function can_enable_ping_schedule_extensions($key, $method)
240			{
241			$this->load(['schedule_extensions' => [
242			$key => [
243			'url' => 'example.com',
244			],
245			]]);
246
247			$this->assertContainerBuilderHasService('zenstruck_schedule.extension.'.$key, PingExtension::class);
248			$this->assertContainerBuilderHasServiceDefinitionWithTag('zenstruck_schedule.extension.'.$key, 'schedule.configured_extension');
249
250			$definition = $this->container->getDefinition('zenstruck_schedule.extension.'.$key);
251
252			$this->assertSame([PingExtension::class, $method], $definition->getFactory());
253			$this->assertSame(['example.com', 'GET', []], $definition->getArguments());
254			}
255
256			public static function pingScheduleExtensionProvider()
257			{
258			return [
259			['ping_before', 'scheduleBefore'],
260			['ping_after', 'scheduleAfter'],
261			['ping_on_success', 'scheduleSuccess'],
262			['ping_on_failure', 'scheduleFailure'],
263			];
264			}
265
266			/**
267			* @test
268			*/
269			public function minimum_task_configuration()
270			{
271			$this->load([
272			'tasks' => [
273			[
274			'command' => 'my:command',
275			'frequency' => '0 * * * *',
276			],
277			],
278			]);
279
280			$config = $this->container->getDefinition(ConfigureTasksSubscriber::class)->getArgument(0)[0];
281
282			$this->assertSame('my:command', $config['command']);
283			$this->assertSame('0 * * * *', $config['frequency']);
284			$this->assertSame('command', $config['type']);
285			$this->assertNull($config['description']);
286			$this->assertFalse($config['without_overlapping']['enabled']);
287			$this->assertFalse($config['between']['enabled']);
288			$this->assertFalse($config['unless_between']['enabled']);
289			$this->assertFalse($config['ping_before']['enabled']);
290			$this->assertFalse($config['ping_after']['enabled']);
291			$this->assertFalse($config['ping_on_success']['enabled']);
292			$this->assertFalse($config['ping_on_failure']['enabled']);
293			$this->assertFalse($config['email_after']['enabled']);
294			$this->assertFalse($config['email_on_failure']['enabled']);
295			}
296
297			/**
298			* @test
299			*/
300			public function task_frequency_must_be_valid()
301			{
302			$this->expectException(InvalidConfigurationException::class);
303			$this->expectExceptionMessage('Invalid configuration for path "zenstruck_schedule.tasks.0.frequency": "invalid" is an invalid cron expression.');
304
305			$this->load([
306			'tasks' => [
307			[
308			'command' => 'my:command',
309			'frequency' => 'invalid',
310			],
311			],
312			]);
313			}
314
315			/**
316			* @test
317			*/
318			public function full_task_configuration()
319			{
320			$this->load([
321			'tasks' => [
322			[
323			'command' => 'my:command --option',
324			'type' => 'process',
325			'frequency' => '0 0 * * *',
326			'description' => 'my description',
327			'without_overlapping' => null,
328			'between' => [
329			'start' => 9,
330			'end' => 17,
331			],
332			'unless_between' => [
333			'start' => 12,
334			'end' => '13:30',
335			],
336			'ping_before' => [
337			'url' => 'https://example.com/before',
338			],
339			'ping_after' => [
340			'url' => 'https://example.com/after',
341			],
342			'ping_on_success' => [
343			'url' => 'https://example.com/success',
344			],
345			'ping_on_failure' => [
346			'url' => 'https://example.com/failure',
347			'method' => 'POST',
348			],
349			'email_after' => null,
350			'email_on_failure' => [
351			'to' => '[email protected]',
352			'subject' => 'my subject',
353			],
354			],
355			],
356			]);
357
358			$config = $this->container->getDefinition(ConfigureTasksSubscriber::class)->getArgument(0)[0];
359
360			$this->assertSame('my:command --option', $config['command']);
361			$this->assertSame('0 0 * * *', $config['frequency']);
362			$this->assertSame('process', $config['type']);
363			$this->assertSame('my description', $config['description']);
364			$this->assertTrue($config['without_overlapping']['enabled']);
365			$this->assertSame(WithoutOverlappingExtension::DEFAULT_TTL, $config['without_overlapping']['ttl']);
366			$this->assertTrue($config['between']['enabled']);
367			$this->assertSame(9, $config['between']['start']);
368			$this->assertSame(17, $config['between']['end']);
369			$this->assertTrue($config['unless_between']['enabled']);
370			$this->assertSame(12, $config['unless_between']['start']);
371			$this->assertSame('13:30', $config['unless_between']['end']);
372			$this->assertTrue($config['ping_before']['enabled']);
373			$this->assertSame('https://example.com/before', $config['ping_before']['url']);
374			$this->assertSame('GET', $config['ping_before']['method']);
375			$this->assertTrue($config['ping_after']['enabled']);
376			$this->assertSame('https://example.com/after', $config['ping_after']['url']);
377			$this->assertSame('GET', $config['ping_after']['method']);
378			$this->assertTrue($config['ping_on_success']['enabled']);
379			$this->assertSame('https://example.com/success', $config['ping_on_success']['url']);
380			$this->assertSame('GET', $config['ping_on_success']['method']);
381			$this->assertTrue($config['ping_on_failure']['enabled']);
382			$this->assertSame('https://example.com/failure', $config['ping_on_failure']['url']);
383			$this->assertSame('POST', $config['ping_on_failure']['method']);
384			$this->assertTrue($config['email_after']['enabled']);
385			$this->assertNull($config['email_after']['to']);
386			$this->assertNull($config['email_after']['subject']);
387			$this->assertTrue($config['email_on_failure']['enabled']);
388			$this->assertSame('[email protected]', $config['email_on_failure']['to']);
389			$this->assertSame('my subject', $config['email_on_failure']['subject']);
390			}
391
392			protected function getContainerExtensions(): array
393			{
394			return [new ZenstruckScheduleExtension()];
395			}
396			}
397

zenstruck / schedule-bundle

Pull Request — master (#2)

ZenstruckScheduleExtensionTest A

Complexity

Size/Duplication

Importance

18 Methods

Duplication Side-by-Side

Filter issues like