refactor(dic): fix on scheduler injection (#242)

Guikingone · Apr 27, 2022 · 4fd50b1 · 4fd50b1
1 parent a4df307
commit 4fd50b1
Show file tree

Hide file tree

Showing 12 changed files with 474 additions and 305 deletions.
diff --git a/src/DependencyInjection/SchedulerBundleExtension.php b/src/DependencyInjection/SchedulerBundleExtension.php
@@ -1387,7 +1387,7 @@ private function registerMiddlewareStacks(ContainerBuilder $container, array $co
 
         $container->register(SingleRunTaskMiddleware::class, SingleRunTaskMiddleware::class)
             ->setArguments([
-                new Reference(SchedulerInterface::class, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE),
+                new Reference(TransportInterface::class, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE),
                 new Reference(LoggerInterface::class, ContainerInterface::NULL_ON_INVALID_REFERENCE),
             ])
             ->setPublic(false)
@@ -1400,7 +1400,7 @@ private function registerMiddlewareStacks(ContainerBuilder $container, array $co
 
         $container->register(TaskUpdateMiddleware::class, TaskUpdateMiddleware::class)
             ->setArguments([
-                new Reference(SchedulerInterface::class, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE),
+                new Reference(TransportInterface::class, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE),
             ])
             ->setPublic(false)
             ->addTag(self::SCHEDULER_MIDDLEWARE_TAG)

diff --git a/src/Middleware/SingleRunTaskMiddleware.php b/src/Middleware/SingleRunTaskMiddleware.php
@@ -6,8 +6,8 @@
 
 use Psr\Log\LoggerInterface;
 use Psr\Log\NullLogger;
-use SchedulerBundle\SchedulerInterface;
 use SchedulerBundle\Task\TaskInterface;
+use SchedulerBundle\Transport\TransportInterface;
 use SchedulerBundle\Worker\WorkerInterface;
 use function in_array;
 use function sprintf;
@@ -20,7 +20,7 @@ final class SingleRunTaskMiddleware implements PostExecutionMiddlewareInterface,
     private LoggerInterface $logger;
 
     public function __construct(
-        private SchedulerInterface $scheduler,
+        private TransportInterface $transport,
         ?LoggerInterface $logger = null
     ) {
         $this->logger = $logger ?? new NullLogger();
@@ -42,12 +42,12 @@ public function postExecute(TaskInterface $task, WorkerInterface $worker): void
         }
 
         if ($task->isDeleteAfterExecute()) {
-            $this->scheduler->unschedule($task->getName());
+            $this->transport->delete($task->getName());
 
             return;
         }
 
-        $this->scheduler->pause($task->getName());
+        $this->transport->pause($task->getName());
     }
 
     /**

diff --git a/src/Middleware/TaskUpdateMiddleware.php b/src/Middleware/TaskUpdateMiddleware.php
@@ -4,16 +4,16 @@
 
 namespace SchedulerBundle\Middleware;
 
-use SchedulerBundle\SchedulerInterface;
 use SchedulerBundle\Task\TaskInterface;
+use SchedulerBundle\Transport\TransportInterface;
 use SchedulerBundle\Worker\WorkerInterface;
 
 /**
  * @author Guillaume Loulier <contact@guillaumeloulier.fr>
  */
 final class TaskUpdateMiddleware implements PostExecutionMiddlewareInterface, OrderedMiddlewareInterface, RequiredMiddlewareInterface
 {
-    public function __construct(private SchedulerInterface $scheduler)
+    public function __construct(private TransportInterface $transport)
     {
     }
 
@@ -22,7 +22,7 @@ public function __construct(private SchedulerInterface $scheduler)
      */
     public function postExecute(TaskInterface $task, WorkerInterface $worker): void
     {
-        $this->scheduler->update($task->getName(), $task);
+        $this->transport->update($task->getName(), $task);
     }
 
     /**

diff --git a/tests/Command/DebugMiddlewareCommandTest.php b/tests/Command/DebugMiddlewareCommandTest.php
@@ -13,7 +13,10 @@
 use SchedulerBundle\Middleware\TaskCallbackMiddleware;
 use SchedulerBundle\Middleware\TaskLockBagMiddleware;
 use SchedulerBundle\Middleware\WorkerMiddlewareStack;
-use SchedulerBundle\SchedulerInterface;
+use SchedulerBundle\SchedulePolicy\FirstInFirstOutPolicy;
+use SchedulerBundle\SchedulePolicy\SchedulePolicyOrchestrator;
+use SchedulerBundle\Transport\Configuration\InMemoryConfiguration;
+use SchedulerBundle\Transport\InMemoryTransport;
 use Symfony\Component\Console\Tester\CommandTester;
 use Symfony\Component\Lock\LockFactory;
 use Symfony\Component\Lock\Store\InMemoryStore;
@@ -92,12 +95,12 @@ public function testCommandCanDisplaySchedulingPhaseMiddlewareList(): void
 
     public function testCommandCanDisplayExecutionPhaseMiddlewareList(): void
     {
-        $scheduler = $this->createMock(SchedulerInterface::class);
-
         $command = new DebugMiddlewareCommand(new SchedulerMiddlewareStack(new MiddlewareRegistry([])), new WorkerMiddlewareStack(new MiddlewareRegistry([
             new TaskCallbackMiddleware(),
             new TaskLockBagMiddleware(new LockFactory(new InMemoryStore())),
-            new SingleRunTaskMiddleware($scheduler),
+            new SingleRunTaskMiddleware(new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+                new FirstInFirstOutPolicy(),
+            ]))),
             new PostExecutionMiddleware(),
             new PreExecutionMiddleware(),
         ])));

diff --git a/tests/DependencyInjection/SchedulerBundleExtensionTest.php b/tests/DependencyInjection/SchedulerBundleExtensionTest.php
@@ -1754,7 +1754,7 @@ public function testMiddlewareStackAreConfigured(): void
         self::assertFalse($container->getDefinition(SingleRunTaskMiddleware::class)->isPublic());
         self::assertCount(2, $container->getDefinition(SingleRunTaskMiddleware::class)->getArguments());
         self::assertInstanceOf(Reference::class, $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(0));
-        self::assertSame(SchedulerInterface::class, (string) $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(0));
+        self::assertSame(TransportInterface::class, (string) $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(0));
         self::assertSame(ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(0)->getInvalidBehavior());
         self::assertInstanceOf(Reference::class, $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(1));
         self::assertSame(LoggerInterface::class, (string) $container->getDefinition(SingleRunTaskMiddleware::class)->getArgument(1));
@@ -1769,7 +1769,7 @@ public function testMiddlewareStackAreConfigured(): void
         self::assertFalse($container->getDefinition(TaskUpdateMiddleware::class)->isPublic());
         self::assertCount(1, $container->getDefinition(TaskUpdateMiddleware::class)->getArguments());
         self::assertInstanceOf(Reference::class, $container->getDefinition(TaskUpdateMiddleware::class)->getArgument(0));
-        self::assertSame(SchedulerInterface::class, (string) $container->getDefinition(TaskUpdateMiddleware::class)->getArgument(0));
+        self::assertSame(TransportInterface::class, (string) $container->getDefinition(TaskUpdateMiddleware::class)->getArgument(0));
         self::assertCount(3, $container->getDefinition(TaskUpdateMiddleware::class)->getTags());
         self::assertTrue($container->getDefinition(TaskUpdateMiddleware::class)->hasTag('scheduler.middleware'));
         self::assertTrue($container->getDefinition(TaskUpdateMiddleware::class)->hasTag('scheduler.worker_middleware'));

diff --git a/tests/FiberSchedulerTest.php b/tests/FiberSchedulerTest.php
@@ -1672,9 +1672,11 @@ public function testSchedulerCanPreemptTasks(): void
 
         $eventDispatcher = new EventDispatcher();
 
-        $scheduler = new FiberScheduler(new Scheduler('UTC', new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),
-        ])), new SchedulerMiddlewareStack(), $eventDispatcher));
+        ]));
+
+        $scheduler = new FiberScheduler(new Scheduler('UTC', $transport, new SchedulerMiddlewareStack(), $eventDispatcher));
 
         $scheduler->schedule(new NullTask('foo'));
         $scheduler->schedule(new NullTask('bar'));
@@ -1688,8 +1690,8 @@ public function testSchedulerCanPreemptTasks(): void
         ]), new ExecutionPolicyRegistry([
             new DefaultPolicy(),
         ]), new TaskExecutionTracker(new Stopwatch()), new WorkerMiddlewareStack([
-            new SingleRunTaskMiddleware($scheduler),
-            new TaskUpdateMiddleware($scheduler),
+            new SingleRunTaskMiddleware($transport),
+            new TaskUpdateMiddleware($transport),
             new TaskLockBagMiddleware($lockFactory),
         ]), $eventDispatcher, $lockFactory, $logger);
 

diff --git a/tests/LazySchedulerTest.php b/tests/LazySchedulerTest.php
@@ -709,9 +709,11 @@ public function testSchedulerCanPreemptTasks(): void
 
         $eventDispatcher = new EventDispatcher();
 
-        $scheduler = new LazyScheduler(new Scheduler('UTC', new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),
-        ])), new SchedulerMiddlewareStack(new MiddlewareRegistry([])), $eventDispatcher));
+        ]));
+
+        $scheduler = new LazyScheduler(new Scheduler('UTC', $transport, new SchedulerMiddlewareStack(new MiddlewareRegistry([])), $eventDispatcher));
         self::assertFalse($scheduler->isInitialized());
 
         $scheduler->schedule(new NullTask('foo'));
@@ -726,8 +728,8 @@ public function testSchedulerCanPreemptTasks(): void
         ]), new ExecutionPolicyRegistry([
             new DefaultPolicy(),
         ]), new TaskExecutionTracker(new Stopwatch()), new WorkerMiddlewareStack(new MiddlewareRegistry([
-            new SingleRunTaskMiddleware($scheduler),
-            new TaskUpdateMiddleware($scheduler),
+            new SingleRunTaskMiddleware($transport),
+            new TaskUpdateMiddleware($transport),
             new TaskLockBagMiddleware($lockFactory),
         ])), $eventDispatcher, $lockFactory, $logger);
 

diff --git a/tests/Middleware/SingleRunTaskMiddlewareTest.php b/tests/Middleware/SingleRunTaskMiddlewareTest.php
@@ -8,9 +8,12 @@
 use Psr\Log\LoggerInterface;
 use SchedulerBundle\Middleware\PostExecutionMiddlewareInterface;
 use SchedulerBundle\Middleware\SingleRunTaskMiddleware;
-use SchedulerBundle\SchedulerInterface;
+use SchedulerBundle\SchedulePolicy\FirstInFirstOutPolicy;
+use SchedulerBundle\SchedulePolicy\SchedulePolicyOrchestrator;
 use SchedulerBundle\Task\NullTask;
 use SchedulerBundle\Task\TaskInterface;
+use SchedulerBundle\Transport\Configuration\InMemoryConfiguration;
+use SchedulerBundle\Transport\InMemoryTransport;
 use SchedulerBundle\Worker\WorkerInterface;
 use Throwable;
 
@@ -21,9 +24,9 @@ final class SingleRunTaskMiddlewareTest extends TestCase
 {
     public function testMiddlewareIsConfigured(): void
     {
-        $scheduler = $this->createMock(SchedulerInterface::class);
-
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware(new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ])));
 
         self::assertSame(15, $singleRunTaskMiddleware->getPriority());
     }
@@ -38,11 +41,10 @@ public function testMiddlewareCannotHandleTaskWithIncompleteExecutionState(): vo
         $logger = $this->createMock(LoggerInterface::class);
         $logger->expects(self::once())->method('warning')->with(self::equalTo('The task "foo" is marked as incomplete or to retry, the "is_single" option is not used'));
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::never())->method('unschedule');
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware(new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ])), $logger);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler, $logger);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'execution_state' => TaskInterface::INCOMPLETE,
         ]), $worker);
@@ -58,11 +60,10 @@ public function testMiddlewareCannotHandleTaskWithToRetryExecutionState(): void
         $logger = $this->createMock(LoggerInterface::class);
         $logger->expects(self::once())->method('warning')->with(self::equalTo('The task "foo" is marked as incomplete or to retry, the "is_single" option is not used'));
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::never())->method('unschedule');
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware(new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ])), $logger);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler, $logger);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'execution_state' => TaskInterface::TO_RETRY,
         ]), $worker);
@@ -75,14 +76,17 @@ public function testMiddlewareCannotHandleInvalidTask(): void
     {
         $worker = $this->createMock(WorkerInterface::class);
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::never())->method('unschedule');
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ]));
+        $transport->create(new NullTask('foo'));
+
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($transport);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'single_run' => false,
         ]), $worker);
+        self::assertCount(1, $transport->list());
     }
 
     /**
@@ -92,14 +96,17 @@ public function testMiddlewareCanHandleSingleRunTask(): void
     {
         $worker = $this->createMock(WorkerInterface::class);
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::once())->method('pause')->with(self::equalTo('foo'));
-        $scheduler->expects(self::never())->method('unschedule');
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ]));
+        $transport->create(new NullTask('foo'));
+
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($transport);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'single_run' => true,
         ]), $worker);
+        self::assertSame(TaskInterface::PAUSED, $transport->get('foo')->getState());
     }
 
     /**
@@ -109,15 +116,18 @@ public function testMiddlewareCanHandleSingleRunTrueAndDeleteAfterExecuteTrueTas
     {
         $worker = $this->createMock(WorkerInterface::class);
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::once())->method('unschedule')->with(self::equalTo('foo'));
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ]));
+        $transport->create(new NullTask('foo'));
+
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($transport);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'single_run' => true,
             'delete_after_execute' => true,
         ]), $worker);
+        self::assertCount(0, $transport->list());
     }
 
     /**
@@ -127,15 +137,18 @@ public function testMiddlewareCanHandleSingleRunFalseAndDeleteAfterExecuteFalseT
     {
         $worker = $this->createMock(WorkerInterface::class);
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::never())->method('unschedule');
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ]));
+        $transport->create(new NullTask('foo'));
+
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($transport);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'single_run' => false,
             'delete_after_execute' => false,
         ]), $worker);
+        self::assertCount(1, $transport->list());
     }
 
     /**
@@ -145,14 +158,17 @@ public function testMiddlewareCanHandleSingleRunFalseAndDeleteAfterExecuteTrueTa
     {
         $worker = $this->createMock(WorkerInterface::class);
 
-        $scheduler = $this->createMock(SchedulerInterface::class);
-        $scheduler->expects(self::never())->method('pause');
-        $scheduler->expects(self::never())->method('unschedule');
+        $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
+            new FirstInFirstOutPolicy(),
+        ]));
+        $transport->create(new NullTask('foo'));
+
+        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($transport);
 
-        $singleRunTaskMiddleware = new SingleRunTaskMiddleware($scheduler);
         $singleRunTaskMiddleware->postExecute(new NullTask('foo', [
             'single_run' => false,
             'delete_after_execute' => true,
         ]), $worker);
+        self::assertCount(1, $transport->list());
     }
 }