[Tests] Move expectException closer to the place of the expectation to avoid false positives

Author: OskarStark

Tests/AliasTest.php

@@ -74,12 +74,14 @@ public function testReturnsCorrectDeprecation()
      */
     public function testCannotDeprecateWithAnInvalidTemplate($message)
     {
-        $this->expectException(InvalidArgumentException::class);
         $def = new Alias('foo');
+
+        $this->expectException(InvalidArgumentException::class);
+
         $def->setDeprecated('package', '1.1', $message);
     }
 
-    public static function invalidDeprecationMessageProvider()
+    public static function invalidDeprecationMessageProvider(): array
     {
         return [
             "With \rs" => ["invalid \r message %alias_id%"],

Tests/ChildDefinitionTest.php

@@ -91,9 +91,10 @@ public function testSetArgument()
 
     public function testReplaceArgumentShouldRequireIntegerIndex()
     {
-        $this->expectException(\InvalidArgumentException::class);
         $def = new ChildDefinition('foo');
 
+        $this->expectException(\InvalidArgumentException::class);
+
         $def->replaceArgument('0', 'foo');
     }
 
@@ -118,12 +119,13 @@ public function testReplaceArgument()
 
     public function testGetArgumentShouldCheckBounds()
     {
-        $this->expectException(\OutOfBoundsException::class);
         $def = new ChildDefinition('foo');
 
         $def->setArguments([0 => 'foo']);
         $def->replaceArgument(0, 'foo');
 
+        $this->expectException(\OutOfBoundsException::class);
+
         $def->getArgument(1);
     }
 

Tests/Compiler/AbstractRecursivePassTest.php

@@ -107,12 +107,12 @@ protected function processValue($value, $isRoot = false): mixed
 
     public function testGetConstructorDefinitionNoClass()
     {
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Invalid service "foo": the class is not set.');
-
         $container = new ContainerBuilder();
         $container->register('foo');
 
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Invalid service "foo": the class is not set.');
+
         (new class() extends AbstractRecursivePass {
             protected function processValue($value, $isRoot = false): mixed
             {

Tests/Compiler/AliasDeprecatedPublicServicesPassTest.php

@@ -47,14 +47,14 @@ public function testProcess()
      */
     public function testProcessWithMissingAttribute(string $attribute, array $attributes)
     {
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(sprintf('The "%s" attribute is mandatory for the "container.private" tag on the "foo" service.', $attribute));
-
         $container = new ContainerBuilder();
         $container
             ->register('foo')
             ->addTag('container.private', $attributes);
 
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(sprintf('The "%s" attribute is mandatory for the "container.private" tag on the "foo" service.', $attribute));
+
         (new AliasDeprecatedPublicServicesPass())->process($container);
     }
 

Tests/Compiler/AutoAliasServicePassTest.php

@@ -21,26 +21,30 @@ class AutoAliasServicePassTest extends TestCase
 {
     public function testProcessWithMissingParameter()
     {
-        $this->expectException(ParameterNotFoundException::class);
         $container = new ContainerBuilder();
 
         $container->register('example')
             ->addTag('auto_alias', ['format' => '%non_existing%.example']);
 
         $pass = new AutoAliasServicePass();
+
+        $this->expectException(ParameterNotFoundException::class);
+
         $pass->process($container);
     }
 
     public function testProcessWithMissingFormat()
     {
-        $this->expectException(InvalidArgumentException::class);
         $container = new ContainerBuilder();
 
         $container->register('example')
             ->addTag('auto_alias', []);
         $container->setParameter('existing', 'mysql');
 
         $pass = new AutoAliasServicePass();
+
+        $this->expectException(InvalidArgumentException::class);
+
         $pass->process($container);
     }
 

Tests/Compiler/AutowirePassTest.php

@@ -609,13 +609,14 @@ public function testScalarArgsCannotBeAutowired()
 
     public function testUnionScalarArgsCannotBeAutowired()
     {
-        $this->expectException(AutowiringFailedException::class);
-        $this->expectExceptionMessage('Cannot autowire service "union_scalars": argument "$timeout" of method "Symfony\Component\DependencyInjection\Tests\Compiler\UnionScalars::__construct()" is type-hinted "float|int", you should configure its value explicitly.');
         $container = new ContainerBuilder();
 
         $container->register('union_scalars', UnionScalars::class)
             ->setAutowired(true);
 
+        $this->expectException(AutowiringFailedException::class);
+        $this->expectExceptionMessage('Cannot autowire service "union_scalars": argument "$timeout" of method "Symfony\Component\DependencyInjection\Tests\Compiler\UnionScalars::__construct()" is type-hinted "float|int", you should configure its value explicitly.');
+
         (new AutowirePass())->process($container);
     }
 

Tests/Compiler/CheckCircularReferencesPassTest.php

@@ -24,28 +24,29 @@ class CheckCircularReferencesPassTest extends TestCase
 {
     public function testProcess()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
         $container->register('a')->addArgument(new Reference('b'));
         $container->register('b')->addArgument(new Reference('a'));
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 
     public function testProcessWithAliases()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
         $container->register('a')->addArgument(new Reference('b'));
         $container->setAlias('b', 'c');
         $container->setAlias('c', 'a');
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 
     public function testProcessWithFactory()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
 
         $container
@@ -56,23 +57,25 @@ public function testProcessWithFactory()
             ->register('b', 'stdClass')
             ->setFactory([new Reference('a'), 'getInstance']);
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 
     public function testProcessDetectsIndirectCircularReference()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
         $container->register('a')->addArgument(new Reference('b'));
         $container->register('b')->addArgument(new Reference('c'));
         $container->register('c')->addArgument(new Reference('a'));
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 
     public function testProcessDetectsIndirectCircularReferenceWithFactory()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
 
         $container->register('a')->addArgument(new Reference('b'));
@@ -83,17 +86,20 @@ public function testProcessDetectsIndirectCircularReferenceWithFactory()
 
         $container->register('c')->addArgument(new Reference('a'));
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 
     public function testDeepCircularReference()
     {
-        $this->expectException(ServiceCircularReferenceException::class);
         $container = new ContainerBuilder();
         $container->register('a')->addArgument(new Reference('b'));
         $container->register('b')->addArgument(new Reference('c'));
         $container->register('c')->addArgument(new Reference('b'));
 
+        $this->expectException(ServiceCircularReferenceException::class);
+
         $this->process($container);
     }
 

Tests/Compiler/CheckDefinitionValidityPassTest.php

@@ -21,19 +21,21 @@ class CheckDefinitionValidityPassTest extends TestCase
 {
     public function testProcessDetectsSyntheticNonPublicDefinitions()
     {
-        $this->expectException(RuntimeException::class);
         $container = new ContainerBuilder();
         $container->register('a')->setSynthetic(true)->setPublic(false);
 
+        $this->expectException(RuntimeException::class);
+
         $this->process($container);
     }
 
     public function testProcessDetectsNonSyntheticNonAbstractDefinitionWithoutClass()
     {
-        $this->expectException(RuntimeException::class);
         $container = new ContainerBuilder();
         $container->register('a')->setSynthetic(false)->setAbstract(false);
 
+        $this->expectException(RuntimeException::class);
+
         $this->process($container);
     }
 
@@ -92,10 +94,12 @@ public function testValidTags()
      */
     public function testInvalidTags(string $name, array $attributes, string $message)
     {
-        $this->expectException(RuntimeException::class);
         $this->expectExceptionMessage($message);
         $container = new ContainerBuilder();
         $container->register('a', 'class')->addTag($name, $attributes);
+
+        $this->expectException(RuntimeException::class);
+
         $this->process($container);
     }
 
@@ -121,21 +125,23 @@ public static function provideInvalidTags(): iterable
 
     public function testDynamicPublicServiceName()
     {
-        $this->expectException(EnvParameterException::class);
         $container = new ContainerBuilder();
         $env = $container->getParameterBag()->get('env(BAR)');
         $container->register("foo.$env", 'class')->setPublic(true);
 
+        $this->expectException(EnvParameterException::class);
+
         $this->process($container);
     }
 
     public function testDynamicPublicAliasName()
     {
-        $this->expectException(EnvParameterException::class);
         $container = new ContainerBuilder();
         $env = $container->getParameterBag()->get('env(BAR)');
         $container->setAlias("foo.$env", 'class')->setPublic(true);
 
+        $this->expectException(EnvParameterException::class);
+
         $this->process($container);
     }
 

Tests/Compiler/CheckExceptionOnInvalidReferenceBehaviorPassTest.php

@@ -41,20 +41,20 @@ public function testProcess()
 
     public function testProcessThrowsExceptionOnInvalidReference()
     {
-        $this->expectException(ServiceNotFoundException::class);
         $container = new ContainerBuilder();
 
         $container
             ->register('a', '\stdClass')
             ->addArgument(new Reference('b'))
         ;
 
+        $this->expectException(ServiceNotFoundException::class);
+
         $this->process($container);
     }
 
     public function testProcessThrowsExceptionOnInvalidReferenceFromInlinedDefinition()
     {
-        $this->expectException(ServiceNotFoundException::class);
         $container = new ContainerBuilder();
 
         $def = new Definition();
@@ -65,6 +65,8 @@ public function testProcessThrowsExceptionOnInvalidReferenceFromInlinedDefinitio
             ->addArgument($def)
         ;
 
+        $this->expectException(ServiceNotFoundException::class);
+
         $this->process($container);
     }
 
@@ -84,34 +86,36 @@ public function testProcessDefinitionWithBindings()
 
     public function testWithErroredServiceLocator()
     {
-        $this->expectException(ServiceNotFoundException::class);
-        $this->expectExceptionMessage('The service "foo" in the container provided to "bar" has a dependency on a non-existent service "baz".');
         $container = new ContainerBuilder();
 
         ServiceLocatorTagPass::register($container, ['foo' => new Reference('baz')], 'bar');
 
         (new AnalyzeServiceReferencesPass())->process($container);
         (new InlineServiceDefinitionsPass())->process($container);
+
+        $this->expectException(ServiceNotFoundException::class);
+        $this->expectExceptionMessage('The service "foo" in the container provided to "bar" has a dependency on a non-existent service "baz".');
+
         $this->process($container);
     }
 
     public function testWithErroredHiddenService()
     {
-        $this->expectException(ServiceNotFoundException::class);
-        $this->expectExceptionMessage('The service "bar" has a dependency on a non-existent service "foo".');
         $container = new ContainerBuilder();
 
         ServiceLocatorTagPass::register($container, ['foo' => new Reference('foo')], 'bar');
 
         (new AnalyzeServiceReferencesPass())->process($container);
         (new InlineServiceDefinitionsPass())->process($container);
+
+        $this->expectException(ServiceNotFoundException::class);
+        $this->expectExceptionMessage('The service "bar" has a dependency on a non-existent service "foo".');
+
         $this->process($container);
     }
 
     public function testProcessThrowsExceptionOnInvalidReferenceWithAlternatives()
     {
-        $this->expectException(ServiceNotFoundException::class);
-        $this->expectExceptionMessage('The service "a" has a dependency on a non-existent service "@ccc". Did you mean this: "ccc"?');
         $container = new ContainerBuilder();
 
         $container
@@ -121,19 +125,22 @@ public function testProcessThrowsExceptionOnInvalidReferenceWithAlternatives()
         $container
             ->register('ccc', '\stdClass');
 
+        $this->expectException(ServiceNotFoundException::class);
+        $this->expectExceptionMessage('The service "a" has a dependency on a non-existent service "@ccc". Did you mean this: "ccc"?');
+
         $this->process($container);
     }
 
     public function testCurrentIdIsExcludedFromAlternatives()
     {
-        $this->expectException(ServiceNotFoundException::class);
-        $this->expectExceptionMessage('The service "app.my_service" has a dependency on a non-existent service "app.my_service2".');
-
         $container = new ContainerBuilder();
         $container
             ->register('app.my_service', \stdClass::class)
             ->addArgument(new Reference('app.my_service2'));
 
+        $this->expectException(ServiceNotFoundException::class);
+        $this->expectExceptionMessage('The service "app.my_service" has a dependency on a non-existent service "app.my_service2".');
+
         $this->process($container);
     }
 

Tests/Compiler/CheckReferenceValidityPassTest.php

@@ -20,12 +20,13 @@ class CheckReferenceValidityPassTest extends TestCase
 {
     public function testProcessDetectsReferenceToAbstractDefinition()
     {
-        $this->expectException(\RuntimeException::class);
         $container = new ContainerBuilder();
 
         $container->register('a')->setAbstract(true);
         $container->register('b')->addArgument(new Reference('a'));
 
+        $this->expectException(\RuntimeException::class);
+
         $this->process($container);
     }