minor #261 Use $this over self:: in tests (OskarStark)

OskarStark · OskarStark · commit ed4b97e469b9 · 2025-08-05T19:25:54.000+02:00
This PR was merged into the main branch. Discussion ---------- Use `$this` over `self::` in tests | Q | A | ------------- | --- | Bug fix? | no | New feature? | no | Docs? | no | Issues | -- | License | MIT Commits ------- 9235cf9 Use `$this` over `self::` in tests
diff --git a/src/agent/tests/InputProcessor/ModelOverrideInputProcessorTest.php b/src/agent/tests/InputProcessor/ModelOverrideInputProcessorTest.php
@@ -57,8 +57,8 @@ public function testProcessInputWithoutModelOption()
 
     public function testProcessInputWithInvalidModelOption()
     {
-        self::expectException(InvalidArgumentException::class);
-        self::expectExceptionMessage('Option "model" must be an instance of "Symfony\AI\Platform\Model".');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Option "model" must be an instance of "Symfony\AI\Platform\Model".');
 
         $gpt = new Gpt();
         $model = new MessageBag();
diff --git a/src/agent/tests/StructuredOutput/AgentProcessorTest.php b/src/agent/tests/StructuredOutput/AgentProcessorTest.php
@@ -65,7 +65,7 @@ public function testProcessInputWithoutOutputStructure()
 
     public function testProcessInputThrowsExceptionWhenLlmDoesNotSupportStructuredOutput()
     {
-        self::expectException(MissingModelSupportException::class);
+        $this->expectException(MissingModelSupportException::class);
 
         $processor = new AgentProcessor(new ConfigurableResponseFormatFactory());
 
diff --git a/src/agent/tests/Toolbox/AgentProcessorTest.php b/src/agent/tests/Toolbox/AgentProcessorTest.php
@@ -90,7 +90,7 @@ public function testProcessInputWithRegisteredToolsButToolOverride()
 
     public function testProcessInputWithUnsupportedToolCallingWillThrowException()
     {
-        self::expectException(MissingModelSupportException::class);
+        $this->expectException(MissingModelSupportException::class);
 
         $model = new Model('gpt-3');
         $processor = new AgentProcessor($this->createStub(ToolboxInterface::class));
diff --git a/src/agent/tests/Toolbox/MetadataFactory/ChainFactoryTest.php b/src/agent/tests/Toolbox/MetadataFactory/ChainFactoryTest.php
@@ -47,16 +47,16 @@ protected function setUp(): void
 
     public function testTestGetMetadataNotExistingClass()
     {
-        self::expectException(ToolException::class);
-        self::expectExceptionMessage('The reference "NoClass" is not a valid tool.');
+        $this->expectException(ToolException::class);
+        $this->expectExceptionMessage('The reference "NoClass" is not a valid tool.');
 
         iterator_to_array($this->factory->getTool('NoClass'));
     }
 
     public function testTestGetMetadataNotConfiguredClass()
     {
-        self::expectException(ToolConfigurationException::class);
-        self::expectExceptionMessage(\sprintf('Method "foo" not found in tool "%s".', ToolMisconfigured::class));
+        $this->expectException(ToolConfigurationException::class);
+        $this->expectExceptionMessage(\sprintf('Method "foo" not found in tool "%s".', ToolMisconfigured::class));
 
         iterator_to_array($this->factory->getTool(ToolMisconfigured::class));
     }
diff --git a/src/agent/tests/Toolbox/MetadataFactory/MemoryFactoryTest.php b/src/agent/tests/Toolbox/MetadataFactory/MemoryFactoryTest.php
@@ -35,8 +35,8 @@ final class MemoryFactoryTest extends TestCase
 {
     public function testGetMetadataWithoutTools()
     {
-        self::expectException(ToolException::class);
-        self::expectExceptionMessage('The reference "SomeClass" is not a valid tool.');
+        $this->expectException(ToolException::class);
+        $this->expectExceptionMessage('The reference "SomeClass" is not a valid tool.');
 
         $factory = new MemoryToolFactory();
         iterator_to_array($factory->getTool('SomeClass')); // @phpstan-ignore-line Yes, this class does not exist
diff --git a/src/agent/tests/Toolbox/MetadataFactory/ReflectionFactoryTest.php b/src/agent/tests/Toolbox/MetadataFactory/ReflectionFactoryTest.php
@@ -45,16 +45,16 @@ protected function setUp(): void
 
     public function testInvalidReferenceNonExistingClass()
     {
-        self::expectException(ToolException::class);
-        self::expectExceptionMessage('The reference "invalid" is not a valid tool.');
+        $this->expectException(ToolException::class);
+        $this->expectExceptionMessage('The reference "invalid" is not a valid tool.');
 
         iterator_to_array($this->factory->getTool('invalid')); // @phpstan-ignore-line Yes, this class does not exist
     }
 
     public function testWithoutAttribute()
     {
-        self::expectException(ToolException::class);
-        self::expectExceptionMessage(\sprintf('The class "%s" is not a tool, please add %s attribute.', ToolWrong::class, AsTool::class));
+        $this->expectException(ToolException::class);
+        $this->expectExceptionMessage(\sprintf('The class "%s" is not a tool, please add %s attribute.', ToolWrong::class, AsTool::class));
 
         iterator_to_array($this->factory->getTool(ToolWrong::class));
     }
diff --git a/src/agent/tests/Toolbox/ToolboxTest.php b/src/agent/tests/Toolbox/ToolboxTest.php
@@ -153,16 +153,16 @@ public function testGetTools()
 
     public function testExecuteWithUnknownTool()
     {
-        self::expectException(ToolNotFoundException::class);
-        self::expectExceptionMessage('Tool not found for call: foo_bar_baz');
+        $this->expectException(ToolNotFoundException::class);
+        $this->expectExceptionMessage('Tool not found for call: foo_bar_baz');
 
         $this->toolbox->execute(new ToolCall('call_1234', 'foo_bar_baz'));
     }
 
     public function testExecuteWithMisconfiguredTool()
     {
-        self::expectException(ToolConfigurationException::class);
-        self::expectExceptionMessage('Method "foo" not found in tool "Symfony\AI\Fixtures\Tool\ToolMisconfigured".');
+        $this->expectException(ToolConfigurationException::class);
+        $this->expectExceptionMessage('Method "foo" not found in tool "Symfony\AI\Fixtures\Tool\ToolMisconfigured".');
 
         $toolbox = new Toolbox([new ToolMisconfigured()], new ReflectionToolFactory());
 
@@ -171,8 +171,8 @@ public function testExecuteWithMisconfiguredTool()
 
     public function testExecuteWithException()
     {
-        self::expectException(ToolExecutionException::class);
-        self::expectExceptionMessage('Execution of tool "tool_exception" failed with error: Tool error.');
+        $this->expectException(ToolExecutionException::class);
+        $this->expectExceptionMessage('Execution of tool "tool_exception" failed with error: Tool error.');
 
         $this->toolbox->execute(new ToolCall('call_1234', 'tool_exception'));
     }
diff --git a/src/ai-bundle/tests/Security/IsGrantedToolAttributeListenerTest.php b/src/ai-bundle/tests/Security/IsGrantedToolAttributeListenerTest.php
@@ -56,8 +56,8 @@ public function testItWillThrowWhenNotGranted(object $tool, Tool $metadata)
     {
         $this->authChecker->expects($this->once())->method('isGranted')->willReturn(false);
 
-        self::expectException(AccessDeniedException::class);
-        self::expectExceptionMessage(\sprintf('No access to %s tool.', $metadata->name));
+        $this->expectException(AccessDeniedException::class);
+        $this->expectExceptionMessage(\sprintf('No access to %s tool.', $metadata->name));
         $this->dispatcher->dispatch(new ToolCallArgumentsResolved($tool, $metadata, []));
     }
 
diff --git a/src/platform/tests/Bridge/OpenAi/DallE/Base64ImageTest.php b/src/platform/tests/Bridge/OpenAi/DallE/Base64ImageTest.php
@@ -30,8 +30,8 @@ public function testItCreatesBase64Image()
 
     public function testItThrowsExceptionWhenBase64ImageIsEmpty()
     {
-        self::expectException(\InvalidArgumentException::class);
-        self::expectExceptionMessage('The base64 encoded image generated must be given.');
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('The base64 encoded image generated must be given.');
 
         new Base64Image('');
     }
diff --git a/src/platform/tests/Bridge/OpenAi/DallE/UrlImageTest.php b/src/platform/tests/Bridge/OpenAi/DallE/UrlImageTest.php
@@ -29,8 +29,8 @@ public function testItCreatesUrlImage()
 
     public function testItThrowsExceptionWhenUrlIsEmpty()
     {
-        self::expectException(\InvalidArgumentException::class);
-        self::expectExceptionMessage('The image url must be given.');
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('The image url must be given.');
 
         new UrlImage('');
     }
diff --git a/src/platform/tests/Bridge/OpenAi/Gpt/ResultConverterTest.php b/src/platform/tests/Bridge/OpenAi/Gpt/ResultConverterTest.php
@@ -149,8 +149,8 @@ public function getResponse(): ResponseInterface
                 ];
             });
 
-        self::expectException(ContentFilterException::class);
-        self::expectExceptionMessage('Content was filtered');
+        $this->expectException(ContentFilterException::class);
+        $this->expectExceptionMessage('Content was filtered');
 
         $converter->convert(new RawHttpResult($httpResponse));
     }
@@ -161,8 +161,8 @@ public function testThrowsExceptionWhenNoChoices()
         $httpResponse = self::createMock(ResponseInterface::class);
         $httpResponse->method('toArray')->willReturn([]);
 
-        self::expectException(RuntimeException::class);
-        self::expectExceptionMessage('Response does not contain choices');
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Response does not contain choices');
 
         $converter->convert(new RawHttpResult($httpResponse));
     }
@@ -183,8 +183,8 @@ public function testThrowsExceptionForUnsupportedFinishReason()
             ],
         ]);
 
-        self::expectException(RuntimeException::class);
-        self::expectExceptionMessage('Unsupported finish reason "unsupported_reason"');
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Unsupported finish reason "unsupported_reason"');
 
         $converter->convert(new RawHttpResult($httpResponse));
     }
diff --git a/src/platform/tests/Contract/JsonSchema/Attribute/ToolParameterTest.php b/src/platform/tests/Contract/JsonSchema/Attribute/ToolParameterTest.php
@@ -28,7 +28,7 @@ public function testValidEnum()
 
     public function testInvalidEnumContainsNonString()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         $enum = ['value1', 2];
         new With(enum: $enum);
     }
@@ -42,7 +42,7 @@ public function testValidConstString()
 
     public function testInvalidConstEmptyString()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         $const = '   ';
         new With(const: $const);
     }
@@ -56,7 +56,7 @@ public function testValidPattern()
 
     public function testInvalidPatternEmptyString()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         $pattern = '   ';
         new With(pattern: $pattern);
     }
@@ -70,7 +70,7 @@ public function testValidMinLength()
 
     public function testInvalidMinLengthNegative()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minLength: -1);
     }
 
@@ -85,7 +85,7 @@ public function testValidMinLengthAndMaxLength()
 
     public function testInvalidMaxLengthLessThanMinLength()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minLength: 10, maxLength: 5);
     }
 
@@ -98,7 +98,7 @@ public function testValidMinimum()
 
     public function testInvalidMinimumNegative()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minimum: -1);
     }
 
@@ -111,7 +111,7 @@ public function testValidMultipleOf()
 
     public function testInvalidMultipleOfNegative()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(multipleOf: -5);
     }
 
@@ -126,7 +126,7 @@ public function testValidExclusiveMinimumAndMaximum()
 
     public function testInvalidExclusiveMaximumLessThanExclusiveMinimum()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(exclusiveMinimum: 10, exclusiveMaximum: 5);
     }
 
@@ -141,7 +141,7 @@ public function testValidMinItemsAndMaxItems()
 
     public function testInvalidMaxItemsLessThanMinItems()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minItems: 5, maxItems: 1);
     }
 
@@ -153,7 +153,7 @@ public function testValidUniqueItemsTrue()
 
     public function testInvalidUniqueItemsFalse()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(uniqueItems: false);
     }
 
@@ -168,7 +168,7 @@ public function testValidMinContainsAndMaxContains()
 
     public function testInvalidMaxContainsLessThanMinContains()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minContains: 3, maxContains: 1);
     }
 
@@ -189,7 +189,7 @@ public function testValidMinPropertiesAndMaxProperties()
 
     public function testInvalidMaxPropertiesLessThanMinProperties()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minProperties: 5, maxProperties: 1);
     }
 
@@ -228,7 +228,7 @@ enum: ['value1', 'value2'],
 
     public function testInvalidCombination()
     {
-        self::expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidArgumentException::class);
         new With(minLength: -1, maxLength: -2);
     }
 }
diff --git a/src/platform/tests/Message/Content/AudioTest.php b/src/platform/tests/Message/Content/AudioTest.php
@@ -39,8 +39,8 @@ public function testFromDataUrlWithValidUrl()
 
     public function testFromDataUrlWithInvalidUrl()
     {
-        self::expectException(\InvalidArgumentException::class);
-        self::expectExceptionMessage('Invalid audio data URL format.');
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid audio data URL format.');
 
         Audio::fromDataUrl('invalid-url');
     }
@@ -55,8 +55,8 @@ public function testFromFileWithValidPath()
 
     public function testFromFileWithInvalidPath()
     {
-        self::expectException(\InvalidArgumentException::class);
-        self::expectExceptionMessage('The file "foo.mp3" does not exist or is not readable.');
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('The file "foo.mp3" does not exist or is not readable.');
 
         Audio::fromFile('foo.mp3');
     }
diff --git a/src/platform/tests/Message/Content/BinaryTest.php b/src/platform/tests/Message/Content/BinaryTest.php
@@ -35,8 +35,8 @@ public function testCreateFromDataUrl()
 
     public function testThrowsExceptionForInvalidDataUrl()
     {
-        self::expectException(InvalidArgumentException::class);
-        self::expectExceptionMessage('Invalid audio data URL format.');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Invalid audio data URL format.');
 
         File::fromDataUrl('invalid-data-url');
     }
@@ -77,7 +77,7 @@ public static function provideExistingFiles(): iterable
 
     public function testThrowsExceptionForNonExistentFile()
     {
-        self::expectException(\InvalidArgumentException::class);
+        $this->expectException(\InvalidArgumentException::class);
 
         File::fromFile('/non/existent/file.jpg');
     }
diff --git a/src/platform/tests/Message/Content/ImageTest.php b/src/platform/tests/Message/Content/ImageTest.php
@@ -34,7 +34,7 @@ public function testWithValidFile()
 
     public function testFromBinaryWithInvalidFile()
     {
-        self::expectExceptionMessage('The file "foo.jpg" does not exist or is not readable.');
+        $this->expectExceptionMessage('The file "foo.jpg" does not exist or is not readable.');
 
         Image::fromFile('foo.jpg');
     }
diff --git a/src/platform/tests/Result/BaseResultTest.php b/src/platform/tests/Result/BaseResultTest.php
@@ -55,7 +55,7 @@ public function testItCanBeEnrichedWithARawResponse()
 
     public function testItThrowsAnExceptionWhenSettingARawResponseTwice()
     {
-        self::expectException(RawResultAlreadySetException::class);
+        $this->expectException(RawResultAlreadySetException::class);
 
         $result = $this->createResult();
         $rawResult = $this->createRawResult();
diff --git a/src/platform/tests/Result/ChoiceResultTest.php b/src/platform/tests/Result/ChoiceResultTest.php
@@ -35,8 +35,8 @@ public function testChoiceResultCreation()
 
     public function testChoiceResultWithNoChoices()
     {
-        self::expectException(InvalidArgumentException::class);
-        self::expectExceptionMessage('A choice result must contain at least two results.');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('A choice result must contain at least two results.');
 
         new ChoiceResult();
     }
diff --git a/src/platform/tests/Result/RawResultAwareTraitTest.php b/src/platform/tests/Result/RawResultAwareTraitTest.php
@@ -36,7 +36,7 @@ public function testItCanBeEnrichedWithARawResponse()
 
     public function testItThrowsAnExceptionWhenSettingARawResponseTwice()
     {
-        self::expectException(RawResultAlreadySetException::class);
+        $this->expectException(RawResultAlreadySetException::class);
 
         $result = $this->createTestClass();
         $rawResponse = self::createMock(SymfonyHttpResponse::class);
diff --git a/src/platform/tests/Result/TollCallResultTest.php b/src/platform/tests/Result/TollCallResultTest.php
@@ -26,8 +26,8 @@ final class TollCallResultTest extends TestCase
 {
     public function testThrowsIfNoToolCall()
     {
-        self::expectException(InvalidArgumentException::class);
-        self::expectExceptionMessage('Response must have at least one tool call.');
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Response must have at least one tool call.');
 
         new ToolCallResult();
     }
diff --git a/src/platform/tests/Vector/NullVectorTest.php b/src/platform/tests/Vector/NullVectorTest.php
diff --git a/src/store/tests/Bridge/Meilisearch/StoreTest.php b/src/store/tests/Bridge/Meilisearch/StoreTest.php
diff --git a/src/store/tests/Bridge/Neo4j/StoreTest.php b/src/store/tests/Bridge/Neo4j/StoreTest.php
diff --git a/src/store/tests/Bridge/Qdrant/StoreTest.php b/src/store/tests/Bridge/Qdrant/StoreTest.php
diff --git a/src/store/tests/Bridge/SurrealDb/StoreTest.php b/src/store/tests/Bridge/SurrealDb/StoreTest.php
diff --git a/src/store/tests/Document/Loader/TextFileLoaderTest.php b/src/store/tests/Document/Loader/TextFileLoaderTest.php
diff --git a/src/store/tests/Document/Transformer/TextSplitTransformerTest.php b/src/store/tests/Document/Transformer/TextSplitTransformerTest.php

Original file line number	Diff line number	Diff line change
`@@ -57,8 +57,8 @@ public function testProcessInputWithoutModelOption()`
`57`	`57`
`58`	`58`	`public function testProcessInputWithInvalidModelOption()`
`59`	`59`	`{`
`60`		`- self::expectException(InvalidArgumentException::class);`
`61`		`- self::expectExceptionMessage('Option "model" must be an instance of "Symfony\AI\Platform\Model".');`
	`60`	`+ $this->expectException(InvalidArgumentException::class);`
	`61`	`+ $this->expectExceptionMessage('Option "model" must be an instance of "Symfony\AI\Platform\Model".');`
`62`	`62`
`63`	`63`	`$gpt = new Gpt();`
`64`	`64`	`$model = new MessageBag();`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public function testProcessInputWithoutOutputStructure()`
`65`	`65`
`66`	`66`	`public function testProcessInputThrowsExceptionWhenLlmDoesNotSupportStructuredOutput()`
`67`	`67`	`{`
`68`		`- self::expectException(MissingModelSupportException::class);`
	`68`	`+ $this->expectException(MissingModelSupportException::class);`
`69`	`69`
`70`	`70`	`$processor = new AgentProcessor(new ConfigurableResponseFormatFactory());`
`71`	`71`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ public function testProcessInputWithRegisteredToolsButToolOverride()`
`90`	`90`
`91`	`91`	`public function testProcessInputWithUnsupportedToolCallingWillThrowException()`
`92`	`92`	`{`
`93`		`- self::expectException(MissingModelSupportException::class);`
	`93`	`+ $this->expectException(MissingModelSupportException::class);`
`94`	`94`
`95`	`95`	`$model = new Model('gpt-3');`
`96`	`96`	`$processor = new AgentProcessor($this->createStub(ToolboxInterface::class));`
Original file line number	Diff line number	Diff line change
`@@ -47,16 +47,16 @@ protected function setUp(): void`
`47`	`47`
`48`	`48`	`public function testTestGetMetadataNotExistingClass()`
`49`	`49`	`{`
`50`		`- self::expectException(ToolException::class);`
`51`		`- self::expectExceptionMessage('The reference "NoClass" is not a valid tool.');`
	`50`	`+ $this->expectException(ToolException::class);`
	`51`	`+ $this->expectExceptionMessage('The reference "NoClass" is not a valid tool.');`
`52`	`52`
`53`	`53`	`iterator_to_array($this->factory->getTool('NoClass'));`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`public function testTestGetMetadataNotConfiguredClass()`
`57`	`57`	`{`
`58`		`- self::expectException(ToolConfigurationException::class);`
`59`		`- self::expectExceptionMessage(\sprintf('Method "foo" not found in tool "%s".', ToolMisconfigured::class));`
	`58`	`+ $this->expectException(ToolConfigurationException::class);`
	`59`	`+ $this->expectExceptionMessage(\sprintf('Method "foo" not found in tool "%s".', ToolMisconfigured::class));`
`60`	`60`
`61`	`61`	`iterator_to_array($this->factory->getTool(ToolMisconfigured::class));`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ final class MemoryFactoryTest extends TestCase`
`35`	`35`	`{`
`36`	`36`	`public function testGetMetadataWithoutTools()`
`37`	`37`	`{`
`38`		`- self::expectException(ToolException::class);`
`39`		`- self::expectExceptionMessage('The reference "SomeClass" is not a valid tool.');`
	`38`	`+ $this->expectException(ToolException::class);`
	`39`	`+ $this->expectExceptionMessage('The reference "SomeClass" is not a valid tool.');`
`40`	`40`
`41`	`41`	`$factory = new MemoryToolFactory();`
`42`	`42`	`iterator_to_array($factory->getTool('SomeClass')); // @phpstan-ignore-line Yes, this class does not exist`
Original file line number	Diff line number	Diff line change
`@@ -45,16 +45,16 @@ protected function setUp(): void`
`45`	`45`
`46`	`46`	`public function testInvalidReferenceNonExistingClass()`
`47`	`47`	`{`
`48`		`- self::expectException(ToolException::class);`
`49`		`- self::expectExceptionMessage('The reference "invalid" is not a valid tool.');`
	`48`	`+ $this->expectException(ToolException::class);`
	`49`	`+ $this->expectExceptionMessage('The reference "invalid" is not a valid tool.');`
`50`	`50`
`51`	`51`	`iterator_to_array($this->factory->getTool('invalid')); // @phpstan-ignore-line Yes, this class does not exist`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`public function testWithoutAttribute()`
`55`	`55`	`{`
`56`		`- self::expectException(ToolException::class);`
`57`		`- self::expectExceptionMessage(\sprintf('The class "%s" is not a tool, please add %s attribute.', ToolWrong::class, AsTool::class));`
	`56`	`+ $this->expectException(ToolException::class);`
	`57`	`+ $this->expectExceptionMessage(\sprintf('The class "%s" is not a tool, please add %s attribute.', ToolWrong::class, AsTool::class));`
`58`	`58`
`59`	`59`	`iterator_to_array($this->factory->getTool(ToolWrong::class));`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -153,16 +153,16 @@ public function testGetTools()`
`153`	`153`
`154`	`154`	`public function testExecuteWithUnknownTool()`
`155`	`155`	`{`
`156`		`- self::expectException(ToolNotFoundException::class);`
`157`		`- self::expectExceptionMessage('Tool not found for call: foo_bar_baz');`
	`156`	`+ $this->expectException(ToolNotFoundException::class);`
	`157`	`+ $this->expectExceptionMessage('Tool not found for call: foo_bar_baz');`
`158`	`158`
`159`	`159`	`$this->toolbox->execute(new ToolCall('call_1234', 'foo_bar_baz'));`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`public function testExecuteWithMisconfiguredTool()`
`163`	`163`	`{`
`164`		`- self::expectException(ToolConfigurationException::class);`
`165`		`- self::expectExceptionMessage('Method "foo" not found in tool "Symfony\AI\Fixtures\Tool\ToolMisconfigured".');`
	`164`	`+ $this->expectException(ToolConfigurationException::class);`
	`165`	`+ $this->expectExceptionMessage('Method "foo" not found in tool "Symfony\AI\Fixtures\Tool\ToolMisconfigured".');`
`166`	`166`
`167`	`167`	`$toolbox = new Toolbox([new ToolMisconfigured()], new ReflectionToolFactory());`
`168`	`168`
`@@ -171,8 +171,8 @@ public function testExecuteWithMisconfiguredTool()`
`171`	`171`
`172`	`172`	`public function testExecuteWithException()`
`173`	`173`	`{`
`174`		`- self::expectException(ToolExecutionException::class);`
`175`		`- self::expectExceptionMessage('Execution of tool "tool_exception" failed with error: Tool error.');`
	`174`	`+ $this->expectException(ToolExecutionException::class);`
	`175`	`+ $this->expectExceptionMessage('Execution of tool "tool_exception" failed with error: Tool error.');`
`176`	`176`
`177`	`177`	`$this->toolbox->execute(new ToolCall('call_1234', 'tool_exception'));`
`178`	`178`	`}`
Original file line number	Diff line number	Diff line change
`@@ -56,8 +56,8 @@ public function testItWillThrowWhenNotGranted(object $tool, Tool $metadata)`
`56`	`56`	`{`
`57`	`57`	`$this->authChecker->expects($this->once())->method('isGranted')->willReturn(false);`
`58`	`58`
`59`		`- self::expectException(AccessDeniedException::class);`
`60`		`- self::expectExceptionMessage(\sprintf('No access to %s tool.', $metadata->name));`
	`59`	`+ $this->expectException(AccessDeniedException::class);`
	`60`	`+ $this->expectExceptionMessage(\sprintf('No access to %s tool.', $metadata->name));`
`61`	`61`	`$this->dispatcher->dispatch(new ToolCallArgumentsResolved($tool, $metadata, []));`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,8 @@ public function testItCreatesBase64Image()`
`30`	`30`
`31`	`31`	`public function testItThrowsExceptionWhenBase64ImageIsEmpty()`
`32`	`32`	`{`
`33`		`- self::expectException(\InvalidArgumentException::class);`
`34`		`- self::expectExceptionMessage('The base64 encoded image generated must be given.');`
	`33`	`+ $this->expectException(\InvalidArgumentException::class);`
	`34`	`+ $this->expectExceptionMessage('The base64 encoded image generated must be given.');`
`35`	`35`
`36`	`36`	`new Base64Image('');`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,8 +29,8 @@ public function testItCreatesUrlImage()`
`29`	`29`
`30`	`30`	`public function testItThrowsExceptionWhenUrlIsEmpty()`
`31`	`31`	`{`
`32`		`- self::expectException(\InvalidArgumentException::class);`
`33`		`- self::expectExceptionMessage('The image url must be given.');`
	`32`	`+ $this->expectException(\InvalidArgumentException::class);`
	`33`	`+ $this->expectExceptionMessage('The image url must be given.');`
`34`	`34`
`35`	`35`	`new UrlImage('');`
`36`	`36`	`}`