/**
* @param EventDispatcher $eventDispatcher
*/
public function attach(EventDispatcher $eventDispatcher)
{
$studentClient = CouchDBClient::create(['dbname' => static::$studentDb]);
$solutionClient = CouchDBClient::create(['dbname' => static::$solutionDb]);
$studentClient->createDatabase($studentClient->getDatabase());
$solutionClient->createDatabase($solutionClient->getDatabase());
$eventDispatcher->listen('verify.start', function (Event $e) use($studentClient, $solutionClient) {
$e->getParameter('exercise')->seed($studentClient);
$this->replicateDbFromStudentToSolution($studentClient, $solutionClient);
});
$eventDispatcher->listen('run.start', function (Event $e) use($studentClient) {
$e->getParameter('exercise')->seed($studentClient);
});
$eventDispatcher->listen('cli.verify.reference-execute.pre', function (CliExecuteEvent $e) {
$e->prependArg('phpschool');
});
$eventDispatcher->listen(['cli.verify.student-execute.pre', 'cli.run.student-execute.pre'], function (CliExecuteEvent $e) {
$e->prependArg('phpschool-student');
});
$eventDispatcher->insertVerifier('verify.finish', function (Event $e) use($studentClient) {
$verifyResult = $e->getParameter('exercise')->verify($studentClient);
if (false === $verifyResult) {
return Failure::fromNameAndReason($this->getName(), 'Database verification failed');
}
return Success::fromCheck($this);
});
$eventDispatcher->listen(['cli.verify.reference-execute.fail', 'verify.finish', 'run.finish'], function (Event $e) use($studentClient, $solutionClient) {
$studentClient->deleteDatabase(static::$studentDb);
$solutionClient->deleteDatabase(static::$solutionDb);
});
}
public function testListenWithMultipleEvents()
{
$e1 = new Event('some-event', ['arg1' => 1, 'arg2' => 2]);
$e2 = new Event('some-event', ['arg1' => 1, 'arg2' => 2]);
$mockCallback1 = $this->getMock('stdClass', ['callback']);
$mockCallback1->expects($this->exactly(2))->method('callback')->withConsecutive([$e1], [$e2])->will($this->returnValue(true));
$this->eventDispatcher->listen(['some-event', 'second-event'], [$mockCallback1, 'callback']);
$this->eventDispatcher->dispatch($e1);
$this->eventDispatcher->dispatch($e2);
}
/**
* @param string $eventName
* @param array $listeners
* @param ContainerInterface $container
* @param EventDispatcher $dispatcher
* @throws \PhpSchool\PhpWorkshop\Exception\InvalidArgumentException
*/
private function attachListeners($eventName, array $listeners, ContainerInterface $container, EventDispatcher $dispatcher)
{
array_walk($listeners, function ($listener) use($eventName, $dispatcher, $container) {
if (is_callable($listener)) {
return $dispatcher->listen($eventName, $listener);
}
if (!is_string($listener)) {
throw new InvalidArgumentException(sprintf('Listener must be a callable or a container entry for a callable service.'));
}
if (!$container->has($listener)) {
throw new InvalidArgumentException(sprintf('Container has no entry named: "%s"', $listener));
}
$listener = $container->get($listener);
if (!is_callable($listener)) {
throw InvalidArgumentException::typeMisMatch('callable', $listener);
}
return $dispatcher->listen($eventName, $listener);
});
}
/**
* @param string $eventName
* @param array $listeners
* @param ContainerInterface $container
* @param EventDispatcher $dispatcher
* @throws \PhpSchool\PhpWorkshop\Exception\InvalidArgumentException
*/
private function attachListeners($eventName, array $listeners, ContainerInterface $container, EventDispatcher $dispatcher)
{
array_walk($listeners, function ($listener) use($eventName, $dispatcher, $container) {
if ($listener instanceof ContainerListenerHelper) {
if (!$container->has($listener->getService())) {
throw new InvalidArgumentException(sprintf('Container has no entry named: "%s"', $listener->getService()));
}
return $dispatcher->listen($eventName, function (...$args) use($container, $listener) {
$service = $container->get($listener->getService());
if (!method_exists($service, $listener->getMethod())) {
throw new InvalidArgumentException(sprintf('Method "%s" does not exist on "%s"', $listener->getMethod(), get_class($service)));
}
$service->{$listener->getMethod()}(...$args);
});
}
if (!is_callable($listener)) {
throw new InvalidArgumentException(sprintf('Listener must be a callable or a container entry for a callable service.'));
}
return $dispatcher->listen($eventName, $listener);
});
}
/**
* @param EventDispatcher $eventDispatcher
*/
public function attach(EventDispatcher $eventDispatcher)
{
if (file_exists($this->databaseDirectory)) {
throw new \RuntimeException(sprintf('Database directory: "%s" already exists', $this->databaseDirectory));
}
mkdir($this->databaseDirectory, 0777, true);
$solutionDsn = sprintf('sqlite:%s', $this->solutionDatabasePath);
$userDsn = sprintf('sqlite:%s', $this->userDatabasePath);
$db = new PDO($userDsn);
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
$eventDispatcher->listen('verify.start', function (Event $e) use($db) {
$e->getParameter('exercise')->seed($db);
//make a copy - so solution can modify without effecting database user has access to
copy($this->userDatabasePath, $this->solutionDatabasePath);
});
$eventDispatcher->listen('run.start', function (Event $e) use($db) {
$e->getParameter('exercise')->seed($db);
});
$eventDispatcher->listen('cli.verify.solution-execute.pre', function (CliExecuteEvent $e) use($solutionDsn) {
$e->prependArg($solutionDsn);
});
$eventDispatcher->listen(['cli.verify.user-execute.pre', 'cli.run.user-execute.pre'], function (CliExecuteEvent $e) use($userDsn) {
$e->prependArg($userDsn);
});
$eventDispatcher->insertVerifier('verify.finish', function (Event $e) use($db) {
$verifyResult = $e->getParameter('exercise')->verify($db);
if (false === $verifyResult) {
return Failure::fromNameAndReason($this->getName(), 'Database verification failed');
}
return new Success('Database Verification Check');
});
$eventDispatcher->listen(['cli.verify.solution-execute.fail', 'verify.finish', 'run.finish'], function (Event $e) use($db) {
unset($db);
@unlink($this->userDatabasePath);
@unlink($this->solutionDatabasePath);
rmdir($this->databaseDirectory);
});
}
public function testListenersAndVerifiersAreCalledInOrderOfAttachment()
{
$e1 = new Event('first-event', ['arg1' => 1, 'arg2' => 2]);
$counter = 0;
$this->eventDispatcher->insertVerifier('first-event', function (Event $e) use(&$counter) {
$this->assertEquals(0, $counter);
$counter++;
});
$this->eventDispatcher->listen('first-event', function (Event $e) use(&$counter) {
$this->assertEquals(1, $counter);
$counter++;
});
$this->eventDispatcher->dispatch($e1);
}
/**
* @param ContainerInterface $container
* @return EventDispatcher
*/
public function __invoke(ContainerInterface $container)
{
$dispatcher = new EventDispatcher($container->get(ResultAggregator::class));
$prepareSolutionListener = $container->get(PrepareSolutionListener::class);
$dispatcher->listen('verify.start', $prepareSolutionListener);
$dispatcher->listen('run.start', $prepareSolutionListener);
$codePatcherListener = $container->get(CodePatchListener::class);
$dispatcher->listen('verify.pre.execute', [$codePatcherListener, 'patch']);
$dispatcher->listen('verify.post.execute', [$codePatcherListener, 'revert']);
$dispatcher->listen('run.start', [$codePatcherListener, 'patch']);
$dispatcher->listen('run.finish', [$codePatcherListener, 'revert']);
$dispatcher->listen('verify.post.check', $container->get(SelfCheckListener::class));
return $dispatcher;
}
