Fix some PHPStan errors

composer.json

@@ -129,7 +129,7 @@
         "ext-pcntl": "*",
         "ext-pdo": "*",
         "ext-redis": "*",
-        "doctrine/dbal": "^3.3.6",
+        "doctrine/dbal": "^3.6.0",
         "doctrine/orm": "^2.8",
         "friendsofphp/php-cs-fixer": "^3.13",
         "infection/infection": "^0.26.16",

src/Bridge/Doctrine/Transport/Configuration/Connection.php

@@ -5,6 +5,7 @@
 namespace SchedulerBundle\Bridge\Doctrine\Transport\Configuration;
 
 use Closure;
+use Doctrine\DBAL\ArrayParameterType;
 use Doctrine\DBAL\Connection as DbalConnection;
 use Doctrine\DBAL\Exception;
 use Doctrine\DBAL\ParameterType;
@@ -45,7 +46,7 @@ public function init(array $options, array $extraOptions = []): void
         $qb = $this->createQueryBuilder(self::TABLE_NAME, 'stc');
         $existingKeysQuery = $qb->select('stc.configuration_key_name')
             ->where($qb->expr()->in('stc.configuration_key_name', ':keys'))
-            ->setParameter('keys', array_keys($options), DbalConnection::PARAM_STR_ARRAY)
+            ->setParameter('keys', array_keys($options), ArrayParameterType::STRING)
         ;
 
         $existingConfigurationKeys = $this->executeQuery(

tests/Bridge/Redis/Transport/RedisTransportFactoryTest.php

@@ -49,7 +49,7 @@ public function testTransportCanBeBuilt(): void
         self::assertSame($dsn->getPort(), $transport->getConfiguration()->get('port'));
         self::assertSame($dsn->getScheme(), $transport->getConfiguration()->get('scheme'));
         self::assertSame($dsn->getOption('timeout', 30), $transport->getConfiguration()->get('timeout'));
-        self::assertSame($dsn->getOption('auth'), $this->transport->getConfiguration()->get('auth'));
+        self::assertSame($dsn->getOption('auth'), $transport->getConfiguration()->get('auth'));
         self::assertArrayHasKey('execution_mode', $transport->getConfiguration()->toArray());
         self::assertSame('first_in_first_out', $transport->getConfiguration()->get('execution_mode'));
         self::assertArrayHasKey('list', $transport->getConfiguration()->toArray());

tests/EventListener/StopWorkerOnFailureLimitSubscriberTest.php

@@ -26,15 +26,15 @@ public function testSubscriberListenValidEvents(): void
     public function testSubscriberCannotUseNegativeLimit(): void
     {
         self::expectException(InvalidArgumentException::class);
-        self::expectErrorMessage('The failure limit must be greater than 0, given -1');
+        self::expectExceptionMessage('The failure limit must be greater than 0, given -1');
         self::expectExceptionCode(0);
         new StopWorkerOnFailureLimitSubscriber(-1);
     }
 
     public function testSubscriberCannotUseZeroLimit(): void
     {
         self::expectException(InvalidArgumentException::class);
-        self::expectErrorMessage('The failure limit must be greater than 0, given 0');
+        self::expectExceptionMessage('The failure limit must be greater than 0, given 0');
         self::expectExceptionCode(0);
         new StopWorkerOnFailureLimitSubscriber(0);
     }

tests/Middleware/TaskLockBagMiddlewareTest.php

@@ -47,7 +47,7 @@ public function testMiddlewareCannotReleaseTaskAfterExecutionWithoutAccessLockBa
         $middleware = new TaskLockBagMiddleware($lockFactory, $logger);
 
         self::expectException(RuntimeException::class);
-        self::expectErrorMessage(sprintf('The task "foo" must be linked to an access lock bag, consider using %s::execute() or %s::schedule()', WorkerInterface::class, SchedulerInterface::class));
+        self::expectExceptionMessage(sprintf('The task "foo" must be linked to an access lock bag, consider using %s::execute() or %s::schedule()', WorkerInterface::class, SchedulerInterface::class));
         self::expectExceptionCode(0);
         $middleware->postExecute(new NullTask('foo'), $worker);
     }

tests/SchedulePolicy/DeadlinePolicyTest.php

@@ -39,7 +39,7 @@ public function testTasksCannotBeSortedWithoutArrivalTime(): void
         $deadlinePolicy = new DeadlinePolicy();
 
         self::expectException(RuntimeException::class);
-        self::expectDeprecationMessage('The arrival time must be defined, consider executing the task "foo" first');
+        self::expectExceptionMessage('The arrival time must be defined, consider executing the task "foo" first');
         self::expectExceptionCode(0);
         $deadlinePolicy->sort(new TaskList([
             $secondTask,
@@ -62,7 +62,7 @@ public function testTasksCannotBeSortedWithoutExecutionRelativeDeadline(): void
         $deadlinePolicy = new DeadlinePolicy();
 
         self::expectException(RuntimeException::class);
-        self::expectDeprecationMessage('The execution relative deadline must be defined, consider using SchedulerBundle\Task\TaskInterface::setExecutionRelativeDeadline()');
+        self::expectExceptionMessage('The execution relative deadline must be defined, consider using SchedulerBundle\Task\TaskInterface::setExecutionRelativeDeadline()');
         self::expectExceptionCode(0);
         $deadlinePolicy->sort(new TaskList([$secondTask, $task]));
     }

tests/Worker/FiberWorkerTest.php

@@ -536,8 +536,28 @@ public function testTaskCanBeExecutedWithErroredAfterExecutionCallback(): void
         $logger->expects(self::never())->method('info');
 
         $tracker = $this->createMock(TaskExecutionTrackerInterface::class);
-        $tracker->expects(self::exactly(2))->method('startTracking')->withConsecutive([$task], [$validTask]);
-        $tracker->expects(self::exactly(2))->method('endTracking')->withConsecutive([$task], [$validTask]);
+
+        $startTrackingMatcher = self::exactly(2);
+        $tracker
+            ->expects($startTrackingMatcher)
+            ->method('startTracking')
+            ->willReturnCallback(function (NullTask $param) use ($startTrackingMatcher, $task, $validTask): void {
+                match ($startTrackingMatcher->getInvocationCount()) {
+                    1 => self::assertSame($param, $task),
+                    2 => self::assertSame($param, $validTask),
+                };
+            });
+
+        $endTrackingMatcher = self::exactly(2);
+        $tracker
+            ->expects($endTrackingMatcher)
+            ->method('endTracking')
+            ->willReturnCallback(function ($param) use ($endTrackingMatcher, $task, $validTask) {
+                match ($endTrackingMatcher->getInvocationCount()) {
+                    1 => self::assertSame($param, $task),
+                    2 => self::assertSame($param, $validTask),
+                };
+            });
 
         $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),
@@ -1305,21 +1325,30 @@ public function testPausedTaskIsNotExecutedIfListContainsASingleTask(): void
         $tracker = $this->createMock(TaskExecutionTrackerInterface::class);
 
         $logger = $this->createMock(LoggerInterface::class);
-        $logger->expects(self::exactly(2))->method('info')->withConsecutive([
-            self::equalTo('The following task "bar" is paused|disabled, consider enable it if it should be executed!'),
-            [
-                'name' => 'bar',
-                'expression' => '* * * * *',
-                'state' => TaskInterface::PAUSED,
-            ],
-        ], [
-            self::equalTo('The following task "foo" is paused|disabled, consider enable it if it should be executed!'),
-            [
-                'name' => 'foo',
-                'expression' => '* * * * *',
-                'state' => TaskInterface::PAUSED,
-            ],
-        ]);
+        $matcher = self::exactly(2);
+        $logger
+            ->expects($matcher)
+            ->method('info')
+            ->willReturnCallback(function () use ($matcher): void {
+                match ($matcher->getInvocationCount()) {
+                    1 => [
+                        self::equalTo('The following task "bar" is paused|disabled, consider enable it if it should be executed!'),
+                        [
+                            'name' => 'bar',
+                            'expression' => '* * * * *',
+                            'state' => TaskInterface::PAUSED,
+                        ]
+                    ],
+                    2 => [
+                        self::equalTo('The following task "foo" is paused|disabled, consider enable it if it should be executed!'),
+                        [
+                            'name' => 'foo',
+                            'expression' => '* * * * *',
+                            'state' => TaskInterface::PAUSED,
+                        ],
+                    ],
+                };
+            });
 
         $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),

tests/Worker/WorkerTest.php

@@ -508,8 +508,28 @@ public function testTaskCanBeExecutedWithErroredAfterExecutionCallback(): void
         $logger->expects(self::never())->method('info');
 
         $tracker = $this->createMock(TaskExecutionTrackerInterface::class);
-        $tracker->expects(self::exactly(2))->method('startTracking')->withConsecutive([$task], [$validTask]);
-        $tracker->expects(self::exactly(2))->method('endTracking')->withConsecutive([$task], [$validTask]);
+
+        $startTrackingMatcher = self::exactly(2);
+        $tracker
+            ->expects($startTrackingMatcher)
+            ->method('startTracking')
+            ->willReturnCallback(function (NullTask $param) use ($startTrackingMatcher, $task, $validTask): void {
+                match ($startTrackingMatcher->getInvocationCount()) {
+                    1 => self::assertSame($param, $task),
+                    2 => self::assertSame($param, $validTask),
+                };
+            });
+
+        $endTrackingMatcher = self::exactly(2);
+        $tracker
+            ->expects($endTrackingMatcher)
+            ->method('endTracking')
+            ->willReturnCallback(function ($param) use ($endTrackingMatcher, $task, $validTask) {
+                match ($endTrackingMatcher->getInvocationCount()) {
+                    1 => self::assertSame($param, $task),
+                    2 => self::assertSame($param, $validTask),
+                };
+            });
 
         $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),
@@ -1231,21 +1251,30 @@ public function testPausedTaskIsNotExecutedIfListContainsASingleTask(): void
         $tracker = $this->createMock(TaskExecutionTrackerInterface::class);
 
         $logger = $this->createMock(LoggerInterface::class);
-        $logger->expects(self::exactly(2))->method('info')->withConsecutive([
-            self::equalTo('The following task "bar" is paused|disabled, consider enable it if it should be executed!'),
-            [
-                'name' => 'bar',
-                'expression' => '* * * * *',
-                'state' => TaskInterface::PAUSED,
-            ],
-        ], [
-            self::equalTo('The following task "foo" is paused|disabled, consider enable it if it should be executed!'),
-            [
-                'name' => 'foo',
-                'expression' => '* * * * *',
-                'state' => TaskInterface::PAUSED,
-            ],
-        ]);
+        $matcher = self::exactly(2);
+        $logger
+            ->expects($matcher)
+            ->method('info')
+            ->willReturnCallback(function () use ($matcher): void {
+                match ($matcher->getInvocationCount()) {
+                    1 => [
+                        self::equalTo('The following task "bar" is paused|disabled, consider enable it if it should be executed!'),
+                        [
+                            'name' => 'bar',
+                            'expression' => '* * * * *',
+                            'state' => TaskInterface::PAUSED,
+                        ]
+                    ],
+                    2 => [
+                        self::equalTo('The following task "foo" is paused|disabled, consider enable it if it should be executed!'),
+                        [
+                            'name' => 'foo',
+                            'expression' => '* * * * *',
+                            'state' => TaskInterface::PAUSED,
+                        ],
+                    ],
+                };
+            });
 
         $transport = new InMemoryTransport(new InMemoryConfiguration(), new SchedulePolicyOrchestrator([
             new FirstInFirstOutPolicy(),