Provide backwards compatibility for AggregateHydrator events

Per #55 (and originally reported as zendframework/zend-hydrator#19),
this patch does the following:

- Adds tests against the hydrate and extract methods to ensure that the
  event triggered is the zend-stdlib variant (as well as kept the tests
  for the zend-hydrator variants).
- Updated test expectations to check for `triggerEvent()` (and not
  `trigger()`), as the 1.1 version of zend-hydrator is now
  forwards-compatible with zend-eventmanager v3. This also required
  raising the minimum version of zend-hydrator to 1.1 so that tests do
  not need to be varied.
- Fixes the test assumptions in `testAdd()`, as attachment of the
  aggregate listener now calls the `attach()` method of the listener
  class, changing how the mock EM instance is called.

Author: weierophinney

composer.json

@@ -14,7 +14,7 @@
     },
     "require": {
         "php": "^5.5 || ^7.0",
-        "zendframework/zend-hydrator": "~1.0"
+        "zendframework/zend-hydrator": "~1.1"
     },
     "require-dev": {
         "zendframework/zend-config": "~2.5",

src/Hydrator/Aggregate/AggregateHydrator.php

@@ -19,4 +19,27 @@
  */
 class AggregateHydrator extends BaseAggregateHydrator implements HydratorInterface
 {
+    /**
+     * {@inheritDoc}
+     */
+    public function extract($object)
+    {
+        $event = new ExtractEvent($this, $object);
+
+        $this->getEventManager()->triggerEvent($event);
+
+        return $event->getExtractedData();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hydrate(array $data, $object)
+    {
+        $event = new HydrateEvent($this, $object, $data);
+
+        $this->getEventManager()->triggerEvent($event);
+
+        return $event->getHydratedObject();
+    }
 }

test/Hydrator/Aggregate/AggregateHydratorTest.php

@@ -10,7 +10,13 @@
 namespace ZendTest\Stdlib\Hydrator\Aggregate;
 
 use PHPUnit_Framework_TestCase;
+use Prophecy\Argument;
+use Zend\EventManager\EventManager;
+use Zend\Hydrator\Aggregate\HydratorListener;
+use Zend\Hydrator\HydratorInterface;
 use Zend\Stdlib\Hydrator\Aggregate\AggregateHydrator;
+use Zend\Stdlib\Hydrator\Aggregate\ExtractEvent;
+use Zend\Stdlib\Hydrator\Aggregate\HydrateEvent;
 use stdClass;
 
 /**
@@ -24,7 +30,7 @@ class AggregateHydratorTest extends PHPUnit_Framework_TestCase
     protected $hydrator;
 
     /**
-     * @var \Zend\EventManager\EventManagerInterface|\PHPUnit_Framework_MockObject_MockObject
+     * @var \Zend\EventManager\EventManager|\PHPUnit_Framework_MockObject_MockObject
      */
     protected $eventManager;
 
@@ -33,7 +39,7 @@ class AggregateHydratorTest extends PHPUnit_Framework_TestCase
      */
     public function setUp()
     {
-        $this->eventManager = $this->getMock('Zend\EventManager\EventManagerInterface');
+        $this->eventManager = $this->getMock(EventManager::class);
         $this->hydrator     = new AggregateHydrator();
 
         $this->hydrator->setEventManager($this->eventManager);
@@ -44,45 +50,112 @@ public function setUp()
      */
     public function testAdd()
     {
-        $attached = $this->getMock('Zend\Hydrator\HydratorInterface');
+        $hydrator = $this->prophesize(HydratorInterface::class)->reveal();
+
+        $events = $this->prophesize(EventManager::class);
+
+        $events->setIdentifiers(Argument::type('array'))->shouldBeCalled();
+
+        $events->attach(
+            HydrateEvent::EVENT_HYDRATE,
+            Argument::that(function ($argument) {
+                if (! is_callable($argument)) {
+                    return false;
+                }
+                if (! is_array($argument)) {
+                    return false;
+                }
+                return (
+                    $argument[0] instanceof HydratorListener
+                    && $argument[1] === 'onHydrate'
+                );
+            }),
+            123
+        )->shouldBeCalled();
+
+        $events->attach(
+            ExtractEvent::EVENT_EXTRACT,
+            Argument::that(function ($argument) {
+                if (! is_callable($argument)) {
+                    return false;
+                }
+                if (! is_array($argument)) {
+                    return false;
+                }
+                return (
+                    $argument[0] instanceof HydratorListener
+                    && $argument[1] === 'onExtract'
+                );
+            }),
+            123
+        )->shouldBeCalled();
+
+        $this->hydrator->setEventManager($events->reveal());
+        $this->hydrator->add($hydrator, 123);
+    }
+
+    /**
+     * @covers \Zend\Stdlib\Hydrator\Aggregate\AggregateHydrator::hydrate
+     */
+    public function testHydrate()
+    {
+        $object = new stdClass();
 
         $this
             ->eventManager
             ->expects($this->once())
-            ->method('attachAggregate')
-            ->with($this->isInstanceOf('Zend\Hydrator\Aggregate\HydratorListener'), 123);
+            ->method('triggerEvent')
+            ->with($this->isInstanceOf('Zend\Hydrator\Aggregate\HydrateEvent'));
 
-        $this->hydrator->add($attached, 123);
+        $this->assertSame($object, $this->hydrator->hydrate(['foo' => 'bar'], $object));
     }
 
     /**
+     * @covers \Zend\Stdlib\Hydrator\Aggregate\AggregateHydrator::extract
+     */
+    public function testExtract()
+    {
+        $object = new stdClass();
+
+        $this
+            ->eventManager
+            ->expects($this->once())
+            ->method('triggerEvent')
+            ->with($this->isInstanceOf('Zend\Hydrator\Aggregate\ExtractEvent'));
+
+        $this->assertSame([], $this->hydrator->extract($object));
+    }
+
+    /**
+     * @group 55
      * @covers \Zend\Stdlib\Hydrator\Aggregate\AggregateHydrator::hydrate
      */
-    public function testHydrate()
+    public function testHydrateUsesStdlibHydrateEvent()
     {
         $object = new stdClass();
 
         $this
             ->eventManager
             ->expects($this->once())
-            ->method('trigger')
-            ->with($this->isInstanceOf('Zend\Hydrator\Aggregate\HydrateEvent'));
+            ->method('triggerEvent')
+            ->with($this->isInstanceOf('Zend\Stdlib\Hydrator\Aggregate\HydrateEvent'));
 
         $this->assertSame($object, $this->hydrator->hydrate(['foo' => 'bar'], $object));
     }
 
     /**
+     * @group 55
      * @covers \Zend\Stdlib\Hydrator\Aggregate\AggregateHydrator::extract
      */
-    public function testExtract()
+    public function testExtractUsesStdlibExtractEvent()
     {
         $object = new stdClass();
 
         $this
             ->eventManager
             ->expects($this->once())
-            ->method('trigger')
-            ->with($this->isInstanceOf('Zend\Hydrator\Aggregate\ExtractEvent'));
+            ->method('triggerEvent')
+            ->with($this->isInstanceOf('Zend\Stdlib\Hydrator\Aggregate\ExtractEvent'));
 
         $this->assertSame([], $this->hydrator->extract($object));
     }