Clarified assertions where necessary

This patch clarifies assertions when multiple assertions exist in the
same test method, and when the intent may not be immediately clear. This
is not as comprehensive as @Maks3w suggested in his feedback, but should
be sufficient.

Author: weierophinney

test/AbstractPluginManagerTest.php

@@ -156,7 +156,12 @@ function ($container, $name, $callback) {
         ]);
 
         $instance = $pluginManager->get(stdClass::class);
-        $this->assertEquals($config['option'], $instance->option);
+        $this->assertTrue(isset($instance->option), 'Delegator-injected option was not found');
+        $this->assertEquals(
+            $config['option'],
+            $instance->option,
+            'Delegator-injected option does not match configuration'
+        );
         $this->assertEquals('bar', $instance->foo);
     }
 }

test/CommonServiceLocatorBehaviorsTrait.php

@@ -257,11 +257,7 @@ public function testCanCreateNewLocatorWithMergedConfig()
         $this->assertTrue($newServiceManager->has(stdClass::class));
 
         // Make sure the context has been updated for the new container
-
-        $reflectionProperty = new \ReflectionProperty($newServiceManager, 'creationContext');
-        $reflectionProperty->setAccessible(true);
-
-        $this->assertSame($newServiceManager, $reflectionProperty->getValue($newServiceManager));
+        $this->assertAttributeSame($newServiceManager, 'creationContext', $newServiceManager);
     }
 
     public function testOverrideConfigWhenMerged()
@@ -346,24 +342,24 @@ public function testHasDoesNotCheckAbstractFactoriesByDefault()
     public function abstractFactories()
     {
         return [
-            'simple'  => [new SimpleAbstractFactory(), 'assertTrue'],
-            'failing' => [new FailingAbstractFactory(), 'assertFalse'],
+            'simple'  => [new SimpleAbstractFactory(), true],
+            'failing' => [new FailingAbstractFactory(), false],
         ];
     }
 
     /**
      * @group has
      * @dataProvider abstractFactories
      */
-    public function testHasCanCheckAbstractFactoriesWhenRequested($abstractFactory, $assertion)
+    public function testHasCanCheckAbstractFactoriesWhenRequested($abstractFactory, $expected)
     {
         $serviceManager = $this->createContainer([
             'abstract_factories' => [
                 $abstractFactory,
             ],
         ]);
 
-        $this->{$assertion}($serviceManager->has(DateTime::class, true));
+        $this->assertSame($expected, $serviceManager->has(DateTime::class, true));
     }
 
     /**
@@ -409,20 +405,40 @@ function ($container, $instance) {
         ]);
 
         $dateTime = $serviceManager->get(DateTime::class);
-        $this->assertInstanceOf(DateTime::class, $dateTime);
+        $this->assertInstanceOf(DateTime::class, $dateTime, 'DateTime service did not resolve as expected');
         $notShared = $serviceManager->get(DateTime::class);
-        $this->assertInstanceOf(DateTime::class, $notShared);
-        $this->assertNotSame($dateTime, $notShared);
+        $this->assertInstanceOf(DateTime::class, $notShared, 'DateTime service did not re-resolve as expected');
+        $this->assertNotSame(
+            $dateTime,
+            $notShared,
+            'Expected unshared instances for DateTime service but received shared instances'
+        );
 
         $config = $serviceManager->get('config');
-        $this->assertInternalType('array', $config);
-        $this->assertSame($config, $serviceManager->get('config'));
+        $this->assertInternalType('array', $config, 'Config service did not resolve as expected');
+        $this->assertSame(
+            $config,
+            $serviceManager->get('config'),
+            'Config service resolved as unshared instead of shared'
+        );
 
         $stdClass = $serviceManager->get(stdClass::class);
-        $this->assertInstanceOf(stdClass::class, $stdClass);
-        $this->assertSame($stdClass, $serviceManager->get(stdClass::class));
-        $this->assertEquals('bar', $stdClass->foo);
-        $this->assertEquals('baz', $stdClass->bar);
+        $this->assertInstanceOf(stdClass::class, $stdClass, 'stdClass service did not resolve as expected');
+        $this->assertSame(
+            $stdClass,
+            $serviceManager->get(stdClass::class),
+            'stdClass service should be shared, but resolved as unshared'
+        );
+        $this->assertTrue(
+            isset($stdClass->foo),
+            'Expected delegator to inject "foo" property in stdClass service, but it was not'
+        );
+        $this->assertEquals('bar', $stdClass->foo, 'stdClass "foo" property was not injected correctly');
+        $this->assertTrue(
+            isset($stdClass->bar),
+            'Expected initializer to inject "bar" property in stdClass service, but it was not'
+        );
+        $this->assertEquals('baz', $stdClass->bar, 'stdClass "bar" property was not injected correctly');
     }
 
     /**
@@ -482,7 +498,8 @@ public function testCanSpecifyInitializerUsingStringViaConfiguration()
 
         $instance = $serviceManager->get(stdClass::class);
         $this->assertInstanceOf(stdClass::class, $instance);
-        $this->assertEquals('bar', $instance->foo);
+        $this->assertTrue(isset($instance->foo), '"foo" property was not injected by initializer');
+        $this->assertEquals('bar', $instance->foo, '"foo" property was not properly injected');
     }
 
     /**

test/LazyServiceIntegrationTest.php

@@ -72,23 +72,25 @@ public function listProxyFiles()
         return new RegexIterator($rii, '/^.+\.php$/i', RecursiveRegexIterator::GET_MATCH);
     }
 
-    public function assertProxyDirEmpty()
+    public function assertProxyDirEmpty($message = '')
     {
+        $message = $message ?: 'Expected empty proxy directory; found files';
         $count = 0;
         foreach ($this->listProxyFiles() as $file) {
-            $this->assertFail('Expected empty proxy directory; found files');
+            $this->assertFail($message);
         }
         $this->assertEquals(0, $count);
     }
 
-    public function assertProxyFileWritten()
+    public function assertProxyFileWritten($message = '')
     {
+        $message = $message ?: 'Expected ProxyManager to write at least one class file; none found';
         $count = 0;
         foreach ($this->listProxyFiles() as $file) {
             $count += 1;
             break;
         }
-        $this->assertNotEquals(0, $count);
+        $this->assertNotEquals(0, $count, $message);
     }
 
     /**
@@ -121,12 +123,27 @@ public function testCanUseLazyServiceFactoryFactoryToCreateLazyServiceFactoryToA
         $this->assertProxyFileWritten();
 
         // Test we got a usable proxy
-        $this->assertInstanceOf(InvokableObject::class, $instance);
-        $this->assertContains('TestAssetProxy', get_class($instance));
+        $this->assertInstanceOf(
+            InvokableObject::class,
+            $instance,
+            'Service returned does not extend ' . InvokableObject::class
+        );
+        $this->assertContains(
+            'TestAssetProxy',
+            get_class($instance),
+            'Service returned does not contain expected namespace'
+        );
 
         // Test proxying works as expected
         $options = $instance->getOptions();
-        $this->assertInternalType('array', $options);
-        $this->assertEquals(['foo' => 'bar'], $options);
+        $this->assertInternalType(
+            'array',
+            $options,
+            sprintf(
+                'Expected an array of options; %s received',
+                (is_object($options) ? get_class($options) : gettype($options))
+            )
+        );
+        $this->assertEquals(['foo' => 'bar'], $options, 'Options returned do not match configuration');
     }
 }

test/ServiceManagerTest.php

@@ -47,6 +47,7 @@ public function testConfigurationCanBeMerged()
         ]);
 
         $this->assertTrue($serviceManager->has(DateTime::class));
+        // stdClass service is inlined in SimpleServiceManager
         $this->assertTrue($serviceManager->has(stdClass::class));
     }
 
@@ -94,7 +95,12 @@ function ($container, $name, $callback) {
         ]);
 
         $instance = $serviceManager->get(stdClass::class);
-        $this->assertEquals($config['option'], $instance->option);
+        $this->assertTrue(isset($instance->option), 'Delegator-injected option was not found');
+        $this->assertEquals(
+            $config['option'],
+            $instance->option,
+            'Delegator-injected option does not match configuration'
+        );
         $this->assertEquals('bar', $instance->foo);
     }
 }