let's not call "tests" things that aren't really tests

maksimovic · maksimovic · commit d7af4aae8474 · 2026-04-28T10:20:40.000+02:00
diff --git a/phpunit.xml.dist b/phpunit.xml.dist
@@ -16,7 +16,6 @@
     <testsuites>
         <testsuite name="Slim Test Suite">
             <directory>./tests/</directory>
-            <exclude>./tests/Mocks</exclude>
         </testsuite>
     </testsuites>
 
diff --git a/tests/CallableResolverTest.php b/tests/CallableResolverTest.php
@@ -10,8 +10,8 @@
 use PHPUnit\Framework\TestCase;
 use Slim\CallableResolver;
 use Slim\Container;
-use Slim\Tests\Mocks\CallableTest;
-use Slim\Tests\Mocks\InvokableTest;
+use Slim\Tests\Mocks\CallableMock;
+use Slim\Tests\Mocks\InvokableMock;
 
 class CallableResolverTest extends TestCase
 {
@@ -22,8 +22,8 @@ class CallableResolverTest extends TestCase
 
     public function setUp(): void
     {
-        CallableTest::$CalledCount = 0;
-        InvokableTest::$CalledCount = 0;
+        CallableMock::$CalledCount = 0;
+        InvokableMock::$CalledCount = 0;
         $this->container = new Container();
     }
 
@@ -49,59 +49,59 @@ public function testFunctionName()
 
     public function testObjMethodArray()
     {
-        $obj = new CallableTest();
+        $obj = new CallableMock();
         $resolver = new CallableResolver($this->container);
         $callable = $resolver->resolve([$obj, 'toCall']);
         $callable();
-        $this->assertEquals(1, CallableTest::$CalledCount);
+        $this->assertEquals(1, CallableMock::$CalledCount);
     }
 
     public function testSlimCallable()
     {
         $resolver = new CallableResolver($this->container);
-        $callable = $resolver->resolve('Slim\Tests\Mocks\CallableTest:toCall');
+        $callable = $resolver->resolve('Slim\Tests\Mocks\CallableMock:toCall');
         $callable();
-        $this->assertEquals(1, CallableTest::$CalledCount);
+        $this->assertEquals(1, CallableMock::$CalledCount);
     }
 
     public function testSlimCallableContainer()
     {
         $resolver = new CallableResolver($this->container);
-        $resolver->resolve('Slim\Tests\Mocks\CallableTest:toCall');
-        $this->assertEquals($this->container, CallableTest::$CalledContainer);
+        $resolver->resolve('Slim\Tests\Mocks\CallableMock:toCall');
+        $this->assertEquals($this->container, CallableMock::$CalledContainer);
     }
 
     public function testContainer()
     {
-        $this->container['callable_service'] = new CallableTest();
+        $this->container['callable_service'] = new CallableMock();
         $resolver = new CallableResolver($this->container);
         $callable = $resolver->resolve('callable_service:toCall');
         $callable();
-        $this->assertEquals(1, CallableTest::$CalledCount);
+        $this->assertEquals(1, CallableMock::$CalledCount);
     }
 
     public function testResolutionToAnInvokableClassInContainer()
     {
         $this->container['an_invokable'] = function ($c) {
-            return new InvokableTest();
+            return new InvokableMock();
         };
         $resolver = new CallableResolver($this->container);
         $callable = $resolver->resolve('an_invokable');
         $callable();
-        $this->assertEquals(1, InvokableTest::$CalledCount);
+        $this->assertEquals(1, InvokableMock::$CalledCount);
     }
 
     public function testResolutionToAnInvokableClass()
     {
         $resolver = new CallableResolver($this->container);
-        $callable = $resolver->resolve('Slim\Tests\Mocks\InvokableTest');
+        $callable = $resolver->resolve('Slim\Tests\Mocks\InvokableMock');
         $callable();
-        $this->assertEquals(1, InvokableTest::$CalledCount);
+        $this->assertEquals(1, InvokableMock::$CalledCount);
     }
 
     public function testMethodNotFoundThrowException()
     {
-        $this->container['callable_service'] = new CallableTest();
+        $this->container['callable_service'] = new CallableMock();
         $resolver = new CallableResolver($this->container);
         $this->expectException('\RuntimeException');
         $resolver->resolve('callable_service:noFound');
diff --git a/tests/DeferredCallableTest.php b/tests/DeferredCallableTest.php
@@ -10,19 +10,19 @@
 use PHPUnit\Framework\TestCase;
 use Slim\Container;
 use Slim\DeferredCallable;
-use Slim\Tests\Mocks\CallableTest;
+use Slim\Tests\Mocks\CallableMock;
 
 class DeferredCallableTest extends TestCase
 {
     public function testItResolvesCallable()
     {
         $container = new Container();
-        $container['CallableTest'] = new CallableTest;
+        $container['CallableTest'] = new CallableMock;
 
         $deferred = new DeferredCallable('CallableTest:toCall', $container);
         $deferred();
 
-        $this->assertEquals(1, CallableTest::$CalledCount);
+        $this->assertEquals(1, CallableMock::$CalledCount);
     }
 
     public function testItBindsClosuresToContainer()
diff --git a/tests/Mocks/CallableMock.php b/tests/Mocks/CallableMock.php
@@ -7,7 +7,7 @@
 
 namespace Slim\Tests\Mocks;
 
-class CallableTest
+class CallableMock
 {
     public static $CalledCount = 0;
 
diff --git a/tests/Mocks/InvocationStrategyMock.php b/tests/Mocks/InvocationStrategyMock.php
@@ -11,7 +11,7 @@
 use Psr\Http\Message\ServerRequestInterface;
 use Slim\Interfaces\InvocationStrategyInterface;
 
-class InvocationStrategyTest implements InvocationStrategyInterface
+class InvocationStrategyMock implements InvocationStrategyInterface
 {
     public static $LastCalledFor = null;
 
diff --git a/tests/Mocks/InvokableMock.php b/tests/Mocks/InvokableMock.php
@@ -7,7 +7,7 @@
 
 namespace Slim\Tests\Mocks;
 
-class InvokableTest
+class InvokableMock
 {
     public static $CalledCount = 0;
 
diff --git a/tests/RouteTest.php b/tests/RouteTest.php
@@ -18,8 +18,8 @@
 use Slim\Http\Response;
 use Slim\Http\Uri;
 use Slim\Route;
-use Slim\Tests\Mocks\CallableTest;
-use Slim\Tests\Mocks\InvocationStrategyTest;
+use Slim\Tests\Mocks\CallableMock;
+use Slim\Tests\Mocks\InvocationStrategyMock;
 use Slim\Tests\Mocks\MiddlewareStub;
 
 class RouteTest extends TestCase
@@ -237,7 +237,7 @@ public function testControllerInContainer()
     {
 
         $container = new Container();
-        $container['CallableTest'] = new CallableTest;
+        $container['CallableTest'] = new CallableMock;
 
         $deferred = new DeferredCallable('CallableTest:toCall', $container);
 
@@ -248,12 +248,12 @@ public function testControllerInContainer()
         $body = new Body(fopen('php://temp', 'r+'));
         $request = new Request('GET', $uri, new Headers(), [], Environment::mock()->all(), $body);
 
-        CallableTest::$CalledCount = 0;
+        CallableMock::$CalledCount = 0;
 
         $result = $route->callMiddlewareStack($request, new Response);
 
         $this->assertInstanceOf('Slim\Http\Response', $result);
-        $this->assertEquals(1, CallableTest::$CalledCount);
+        $this->assertEquals(1, CallableMock::$CalledCount);
     }
 
     public function testInvokeWhenReturningAResponse()
@@ -348,9 +348,9 @@ public function testInvokeWhenDisablingOutputBuffer()
     public function testInvokeDeferredCallable()
     {
         $container = new Container();
-        $container['CallableTest'] = new CallableTest;
+        $container['CallableTest'] = new CallableMock;
         $container['foundHandler'] = function () {
-            return new InvocationStrategyTest();
+            return new InvocationStrategyMock();
         };
 
         $route = new Route(['GET'], '/', 'CallableTest:toCall');
@@ -363,7 +363,7 @@ public function testInvokeDeferredCallable()
         $result = $route->callMiddlewareStack($request, new Response);
 
         $this->assertInstanceOf('Slim\Http\Response', $result);
-        $this->assertEquals([$container['CallableTest'], 'toCall'], InvocationStrategyTest::$LastCalledFor);
+        $this->assertEquals([$container['CallableTest'], 'toCall'], InvocationStrategyMock::$LastCalledFor);
     }
 
     public function testPatternCanBeChanged()
@@ -376,9 +376,9 @@ public function testPatternCanBeChanged()
     public function testChangingCallable()
     {
         $container = new Container();
-        $container['CallableTest2'] = new CallableTest;
+        $container['CallableTest2'] = new CallableMock;
         $container['foundHandler'] = function () {
-            return new InvocationStrategyTest();
+            return new InvocationStrategyMock();
         };
 
         $route = new Route(['GET'], '/', 'CallableTest:toCall'); //Note that this doesn't actually exist
@@ -393,6 +393,6 @@ public function testChangingCallable()
         $result = $route->callMiddlewareStack($request, new Response);
 
         $this->assertInstanceOf('Slim\Http\Response', $result);
-        $this->assertEquals([$container['CallableTest2'], 'toCall'], InvocationStrategyTest::$LastCalledFor);
+        $this->assertEquals([$container['CallableTest2'], 'toCall'], InvocationStrategyMock::$LastCalledFor);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@`
`10`	`10`	`use PHPUnit\Framework\TestCase;`
`11`	`11`	`use Slim\CallableResolver;`
`12`	`12`	`use Slim\Container;`
`13`		`-use Slim\Tests\Mocks\CallableTest;`
`14`		`-use Slim\Tests\Mocks\InvokableTest;`
	`13`	`+use Slim\Tests\Mocks\CallableMock;`
	`14`	`+use Slim\Tests\Mocks\InvokableMock;`
`15`	`15`
`16`	`16`	`class CallableResolverTest extends TestCase`
`17`	`17`	`{`
`@@ -22,8 +22,8 @@ class CallableResolverTest extends TestCase`
`22`	`22`
`23`	`23`	`public function setUp(): void`
`24`	`24`	`{`
`25`		`- CallableTest::$CalledCount = 0;`
`26`		`- InvokableTest::$CalledCount = 0;`
	`25`	`+ CallableMock::$CalledCount = 0;`
	`26`	`+ InvokableMock::$CalledCount = 0;`
`27`	`27`	`$this->container = new Container();`
`28`	`28`	`}`
`29`	`29`
`@@ -49,59 +49,59 @@ public function testFunctionName()`
`49`	`49`
`50`	`50`	`public function testObjMethodArray()`
`51`	`51`	`{`
`52`		`- $obj = new CallableTest();`
	`52`	`+ $obj = new CallableMock();`
`53`	`53`	`$resolver = new CallableResolver($this->container);`
`54`	`54`	`$callable = $resolver->resolve([$obj, 'toCall']);`
`55`	`55`	`$callable();`
`56`		`- $this->assertEquals(1, CallableTest::$CalledCount);`
	`56`	`+ $this->assertEquals(1, CallableMock::$CalledCount);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`public function testSlimCallable()`
`60`	`60`	`{`
`61`	`61`	`$resolver = new CallableResolver($this->container);`
`62`		`- $callable = $resolver->resolve('Slim\Tests\Mocks\CallableTest:toCall');`
	`62`	`+ $callable = $resolver->resolve('Slim\Tests\Mocks\CallableMock:toCall');`
`63`	`63`	`$callable();`
`64`		`- $this->assertEquals(1, CallableTest::$CalledCount);`
	`64`	`+ $this->assertEquals(1, CallableMock::$CalledCount);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`public function testSlimCallableContainer()`
`68`	`68`	`{`
`69`	`69`	`$resolver = new CallableResolver($this->container);`
`70`		`- $resolver->resolve('Slim\Tests\Mocks\CallableTest:toCall');`
`71`		`- $this->assertEquals($this->container, CallableTest::$CalledContainer);`
	`70`	`+ $resolver->resolve('Slim\Tests\Mocks\CallableMock:toCall');`
	`71`	`+ $this->assertEquals($this->container, CallableMock::$CalledContainer);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`public function testContainer()`
`75`	`75`	`{`
`76`		`- $this->container['callable_service'] = new CallableTest();`
	`76`	`+ $this->container['callable_service'] = new CallableMock();`
`77`	`77`	`$resolver = new CallableResolver($this->container);`
`78`	`78`	`$callable = $resolver->resolve('callable_service:toCall');`
`79`	`79`	`$callable();`
`80`		`- $this->assertEquals(1, CallableTest::$CalledCount);`
	`80`	`+ $this->assertEquals(1, CallableMock::$CalledCount);`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`public function testResolutionToAnInvokableClassInContainer()`
`84`	`84`	`{`
`85`	`85`	`$this->container['an_invokable'] = function ($c) {`
`86`		`- return new InvokableTest();`
	`86`	`+ return new InvokableMock();`
`87`	`87`	`};`
`88`	`88`	`$resolver = new CallableResolver($this->container);`
`89`	`89`	`$callable = $resolver->resolve('an_invokable');`
`90`	`90`	`$callable();`
`91`		`- $this->assertEquals(1, InvokableTest::$CalledCount);`
	`91`	`+ $this->assertEquals(1, InvokableMock::$CalledCount);`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`public function testResolutionToAnInvokableClass()`
`95`	`95`	`{`
`96`	`96`	`$resolver = new CallableResolver($this->container);`
`97`		`- $callable = $resolver->resolve('Slim\Tests\Mocks\InvokableTest');`
	`97`	`+ $callable = $resolver->resolve('Slim\Tests\Mocks\InvokableMock');`
`98`	`98`	`$callable();`
`99`		`- $this->assertEquals(1, InvokableTest::$CalledCount);`
	`99`	`+ $this->assertEquals(1, InvokableMock::$CalledCount);`
`100`	`100`	`}`
`101`	`101`
`102`	`102`	`public function testMethodNotFoundThrowException()`
`103`	`103`	`{`
`104`		`- $this->container['callable_service'] = new CallableTest();`
	`104`	`+ $this->container['callable_service'] = new CallableMock();`
`105`	`105`	`$resolver = new CallableResolver($this->container);`
`106`	`106`	`$this->expectException('\RuntimeException');`
`107`	`107`	`$resolver->resolve('callable_service:noFound');`
Original file line number	Diff line number	Diff line change
`@@ -10,19 +10,19 @@`
`10`	`10`	`use PHPUnit\Framework\TestCase;`
`11`	`11`	`use Slim\Container;`
`12`	`12`	`use Slim\DeferredCallable;`
`13`		`-use Slim\Tests\Mocks\CallableTest;`
	`13`	`+use Slim\Tests\Mocks\CallableMock;`
`14`	`14`
`15`	`15`	`class DeferredCallableTest extends TestCase`
`16`	`16`	`{`
`17`	`17`	`public function testItResolvesCallable()`
`18`	`18`	`{`
`19`	`19`	`$container = new Container();`
`20`		`- $container['CallableTest'] = new CallableTest;`
	`20`	`+ $container['CallableTest'] = new CallableMock;`
`21`	`21`
`22`	`22`	`$deferred = new DeferredCallable('CallableTest:toCall', $container);`
`23`	`23`	`$deferred();`
`24`	`24`
`25`		`- $this->assertEquals(1, CallableTest::$CalledCount);`
	`25`	`+ $this->assertEquals(1, CallableMock::$CalledCount);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public function testItBindsClosuresToContainer()`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`
`8`	`8`	`namespace Slim\Tests\Mocks;`
`9`	`9`
`10`		`-class CallableTest`
	`10`	`+class CallableMock`
`11`	`11`	`{`
`12`	`12`	`public static $CalledCount = 0;`
`13`	`13`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`	`use Psr\Http\Message\ServerRequestInterface;`
`12`	`12`	`use Slim\Interfaces\InvocationStrategyInterface;`
`13`	`13`
`14`		`-class InvocationStrategyTest implements InvocationStrategyInterface`
	`14`	`+class InvocationStrategyMock implements InvocationStrategyInterface`
`15`	`15`	`{`
`16`	`16`	`public static $LastCalledFor = null;`
`17`	`17`