Use $this over self:: in tests

OskarStark · OskarStark · commit c8346ec94ca5 · 2025-08-05T16:48:52.000+02:00
diff --git a/tests/Bridge/OpenAi/DallE/Base64ImageTest.php b/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/tests/Bridge/OpenAi/DallE/UrlImageTest.php b/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/tests/Bridge/OpenAi/Gpt/ResultConverterTest.php b/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/tests/Contract/JsonSchema/Attribute/ToolParameterTest.php b/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/tests/Message/Content/AudioTest.php b/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/tests/Message/Content/BinaryTest.php b/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/tests/Message/Content/ImageTest.php b/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/tests/Result/BaseResultTest.php b/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/tests/Result/ChoiceResultTest.php b/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/tests/Result/RawResultAwareTraitTest.php b/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/tests/Result/TollCallResultTest.php b/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/tests/Vector/NullVectorTest.php b/tests/Vector/NullVectorTest.php
@@ -27,14 +27,14 @@ public function testImplementsInterface()
 
     public function testGetDataThrowsOnAccess()
     {
-        self::expectException(RuntimeException::class);
+        $this->expectException(RuntimeException::class);
 
         (new NullVector())->getData();
     }
 
     public function testGetDimensionsThrowsOnAccess()
     {
-        self::expectException(RuntimeException::class);
+        $this->expectException(RuntimeException::class);
 
         (new NullVector())->getDimensions();
     }

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`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public function testValidEnum()`
`28`	`28`
`29`	`29`	`public function testInvalidEnumContainsNonString()`
`30`	`30`	`{`
`31`		`- self::expectException(InvalidArgumentException::class);`
	`31`	`+ $this->expectException(InvalidArgumentException::class);`
`32`	`32`	`$enum = ['value1', 2];`
`33`	`33`	`new With(enum: $enum);`
`34`	`34`	`}`
`@@ -42,7 +42,7 @@ public function testValidConstString()`
`42`	`42`
`43`	`43`	`public function testInvalidConstEmptyString()`
`44`	`44`	`{`
`45`		`- self::expectException(InvalidArgumentException::class);`
	`45`	`+ $this->expectException(InvalidArgumentException::class);`
`46`	`46`	`$const = ' ';`
`47`	`47`	`new With(const: $const);`
`48`	`48`	`}`
`@@ -56,7 +56,7 @@ public function testValidPattern()`
`56`	`56`
`57`	`57`	`public function testInvalidPatternEmptyString()`
`58`	`58`	`{`
`59`		`- self::expectException(InvalidArgumentException::class);`
	`59`	`+ $this->expectException(InvalidArgumentException::class);`
`60`	`60`	`$pattern = ' ';`
`61`	`61`	`new With(pattern: $pattern);`
`62`	`62`	`}`
`@@ -70,7 +70,7 @@ public function testValidMinLength()`
`70`	`70`
`71`	`71`	`public function testInvalidMinLengthNegative()`
`72`	`72`	`{`
`73`		`- self::expectException(InvalidArgumentException::class);`
	`73`	`+ $this->expectException(InvalidArgumentException::class);`
`74`	`74`	`new With(minLength: -1);`
`75`	`75`	`}`
`76`	`76`
`@@ -85,7 +85,7 @@ public function testValidMinLengthAndMaxLength()`
`85`	`85`
`86`	`86`	`public function testInvalidMaxLengthLessThanMinLength()`
`87`	`87`	`{`
`88`		`- self::expectException(InvalidArgumentException::class);`
	`88`	`+ $this->expectException(InvalidArgumentException::class);`
`89`	`89`	`new With(minLength: 10, maxLength: 5);`
`90`	`90`	`}`
`91`	`91`
`@@ -98,7 +98,7 @@ public function testValidMinimum()`
`98`	`98`
`99`	`99`	`public function testInvalidMinimumNegative()`
`100`	`100`	`{`
`101`		`- self::expectException(InvalidArgumentException::class);`
	`101`	`+ $this->expectException(InvalidArgumentException::class);`
`102`	`102`	`new With(minimum: -1);`
`103`	`103`	`}`
`104`	`104`
`@@ -111,7 +111,7 @@ public function testValidMultipleOf()`
`111`	`111`
`112`	`112`	`public function testInvalidMultipleOfNegative()`
`113`	`113`	`{`
`114`		`- self::expectException(InvalidArgumentException::class);`
	`114`	`+ $this->expectException(InvalidArgumentException::class);`
`115`	`115`	`new With(multipleOf: -5);`
`116`	`116`	`}`
`117`	`117`
`@@ -126,7 +126,7 @@ public function testValidExclusiveMinimumAndMaximum()`
`126`	`126`
`127`	`127`	`public function testInvalidExclusiveMaximumLessThanExclusiveMinimum()`
`128`	`128`	`{`
`129`		`- self::expectException(InvalidArgumentException::class);`
	`129`	`+ $this->expectException(InvalidArgumentException::class);`
`130`	`130`	`new With(exclusiveMinimum: 10, exclusiveMaximum: 5);`
`131`	`131`	`}`
`132`	`132`
`@@ -141,7 +141,7 @@ public function testValidMinItemsAndMaxItems()`
`141`	`141`
`142`	`142`	`public function testInvalidMaxItemsLessThanMinItems()`
`143`	`143`	`{`
`144`		`- self::expectException(InvalidArgumentException::class);`
	`144`	`+ $this->expectException(InvalidArgumentException::class);`
`145`	`145`	`new With(minItems: 5, maxItems: 1);`
`146`	`146`	`}`
`147`	`147`
`@@ -153,7 +153,7 @@ public function testValidUniqueItemsTrue()`
`153`	`153`
`154`	`154`	`public function testInvalidUniqueItemsFalse()`
`155`	`155`	`{`
`156`		`- self::expectException(InvalidArgumentException::class);`
	`156`	`+ $this->expectException(InvalidArgumentException::class);`
`157`	`157`	`new With(uniqueItems: false);`
`158`	`158`	`}`
`159`	`159`
`@@ -168,7 +168,7 @@ public function testValidMinContainsAndMaxContains()`
`168`	`168`
`169`	`169`	`public function testInvalidMaxContainsLessThanMinContains()`
`170`	`170`	`{`
`171`		`- self::expectException(InvalidArgumentException::class);`
	`171`	`+ $this->expectException(InvalidArgumentException::class);`
`172`	`172`	`new With(minContains: 3, maxContains: 1);`
`173`	`173`	`}`
`174`	`174`
`@@ -189,7 +189,7 @@ public function testValidMinPropertiesAndMaxProperties()`
`189`	`189`
`190`	`190`	`public function testInvalidMaxPropertiesLessThanMinProperties()`
`191`	`191`	`{`
`192`		`- self::expectException(InvalidArgumentException::class);`
	`192`	`+ $this->expectException(InvalidArgumentException::class);`
`193`	`193`	`new With(minProperties: 5, maxProperties: 1);`
`194`	`194`	`}`
`195`	`195`
`@@ -228,7 +228,7 @@ enum: ['value1', 'value2'],`
`228`	`228`
`229`	`229`	`public function testInvalidCombination()`
`230`	`230`	`{`
`231`		`- self::expectException(InvalidArgumentException::class);`
	`231`	`+ $this->expectException(InvalidArgumentException::class);`
`232`	`232`	`new With(minLength: -1, maxLength: -2);`
`233`	`233`	`}`
`234`	`234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,8 @@ public function testFromDataUrlWithValidUrl()`
`39`	`39`
`40`	`40`	`public function testFromDataUrlWithInvalidUrl()`
`41`	`41`	`{`
`42`		`- self::expectException(\InvalidArgumentException::class);`
`43`		`- self::expectExceptionMessage('Invalid audio data URL format.');`
	`42`	`+ $this->expectException(\InvalidArgumentException::class);`
	`43`	`+ $this->expectExceptionMessage('Invalid audio data URL format.');`
`44`	`44`
`45`	`45`	`Audio::fromDataUrl('invalid-url');`
`46`	`46`	`}`
`@@ -55,8 +55,8 @@ public function testFromFileWithValidPath()`
`55`	`55`
`56`	`56`	`public function testFromFileWithInvalidPath()`
`57`	`57`	`{`
`58`		`- self::expectException(\InvalidArgumentException::class);`
`59`		`- self::expectExceptionMessage('The file "foo.mp3" does not exist or is not readable.');`
	`58`	`+ $this->expectException(\InvalidArgumentException::class);`
	`59`	`+ $this->expectExceptionMessage('The file "foo.mp3" does not exist or is not readable.');`
`60`	`60`
`61`	`61`	`Audio::fromFile('foo.mp3');`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ public function testCreateFromDataUrl()`
`35`	`35`
`36`	`36`	`public function testThrowsExceptionForInvalidDataUrl()`
`37`	`37`	`{`
`38`		`- self::expectException(InvalidArgumentException::class);`
`39`		`- self::expectExceptionMessage('Invalid audio data URL format.');`
	`38`	`+ $this->expectException(InvalidArgumentException::class);`
	`39`	`+ $this->expectExceptionMessage('Invalid audio data URL format.');`
`40`	`40`
`41`	`41`	`File::fromDataUrl('invalid-data-url');`
`42`	`42`	`}`
`@@ -77,7 +77,7 @@ public static function provideExistingFiles(): iterable`
`77`	`77`
`78`	`78`	`public function testThrowsExceptionForNonExistentFile()`
`79`	`79`	`{`
`80`		`- self::expectException(\InvalidArgumentException::class);`
	`80`	`+ $this->expectException(\InvalidArgumentException::class);`
`81`	`81`
`82`	`82`	`File::fromFile('/non/existent/file.jpg');`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public function testWithValidFile()`
`34`	`34`
`35`	`35`	`public function testFromBinaryWithInvalidFile()`
`36`	`36`	`{`
`37`		`- self::expectExceptionMessage('The file "foo.jpg" does not exist or is not readable.');`
	`37`	`+ $this->expectExceptionMessage('The file "foo.jpg" does not exist or is not readable.');`
`38`	`38`
`39`	`39`	`Image::fromFile('foo.jpg');`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public function testItCanBeEnrichedWithARawResponse()`
`55`	`55`
`56`	`56`	`public function testItThrowsAnExceptionWhenSettingARawResponseTwice()`
`57`	`57`	`{`
`58`		`- self::expectException(RawResultAlreadySetException::class);`
	`58`	`+ $this->expectException(RawResultAlreadySetException::class);`
`59`	`59`
`60`	`60`	`$result = $this->createResult();`
`61`	`61`	`$rawResult = $this->createRawResult();`
Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public function testItCanBeEnrichedWithARawResponse()`
`36`	`36`
`37`	`37`	`public function testItThrowsAnExceptionWhenSettingARawResponseTwice()`
`38`	`38`	`{`
`39`		`- self::expectException(RawResultAlreadySetException::class);`
	`39`	`+ $this->expectException(RawResultAlreadySetException::class);`
`40`	`40`
`41`	`41`	`$result = $this->createTestClass();`
`42`	`42`	`$rawResponse = self::createMock(SymfonyHttpResponse::class);`