public function testRegisterAndBoot()
{
$container = new Container();
$mockery = Mockery::mock(ServiceProviderTestInjector::class);
$mockery->shouldReceive('register')->once();
$mockery->shouldReceive('boot')->once();
$container->instance('mockery', $mockery);
$container->register(new ServiceProviderTestBootProvider());
$container->boot();
}
public function testInstanceFactory()
{
$container = new Container();
$object1 = new stdClass();
$container->instance('obj1', $object1);
// all same
static::assertSame($object1, $container['obj1']);
static::assertSame($object1, $container['obj1']);
static::assertSame($object1, $container['obj1']);
$object2 = new stdClass();
$container->instance('obj2', $object2)->factory();
// all not same
$object2_1 = $container['obj2'];
static::assertNotSame($object2, $object2_1);
static::assertEquals($object2, $object2_1);
$object2_2 = $container['obj2'];
static::assertNotSame($object2, $object2_2);
static::assertEquals($object2, $object2_2);
static::assertNotSame($object2_1, $object2_2);
static::assertEquals($object2_1, $object2_2);
}
public function testAliasExtendPropagation()
{
$container = new Container();
// extend first,,
$container->extend('xml.other.alias', function ($item) {
$item->contents = 'alias contents';
return $item;
});
$container->instance('xml', $renderer = new ExtendTestXmlRenderer());
$container->alias('xml.alias', 'xml');
$container->alias('xml.other.alias', 'xml.alias');
static::assertEquals('alias contents', $container['xml']->contents);
// and equal :-)
static::assertSame($renderer, $container['xml.other.alias']);
}
public function testTriggerByClass()
{
$container = new Container();
$container->instance(DispatcherTestListener::class, $listener = new DispatcherTestListener());
$dispatcher = new Dispatcher($container);
$dispatcher->on(DispatcherTestEvent::class, DispatcherTestListener::class);
// check init event & listener
$event = new DispatcherTestEvent();
$this->assertEquals(0, $event->getCallCount());
$this->assertEquals(0, $listener->getLastCallCount());
$dispatcher->trigger($event);
$this->assertEquals(1, $event->getCallCount());
$this->assertEquals(1, $listener->getLastCallCount());
$dispatcher->trigger($event);
$dispatcher->trigger($event);
$dispatcher->trigger($event);
$this->assertEquals(4, $event->getCallCount());
$this->assertEquals(4, $listener->getLastCallCount());
}
/**
* @param $isThrow
* @param $response
* @param \Closure $responseChecker
* @param bool|false $isDebug
* @param mixed $errorHandler
* @return \Wandu\DI\ContainerInterface
*/
protected function generateContainer($isThrow, $response, Closure $responseChecker, $isDebug = false, $errorHandler = null)
{
$request = new ServerRequest();
$dispatcher = Mockery::mock(Dispatcher::class);
$dispatcher->shouldReceive('withRouter')->andReturnSelf();
if ($isThrow) {
$dispatcher->shouldReceive('dispatch')->with($request)->andThrow($response);
} else {
$dispatcher->shouldReceive('dispatch')->with($request)->andReturn($response);
}
$requestFactory = Mockery::mock(ServerRequestFactory::class);
$requestFactory->shouldReceive('fromGlobals')->andReturn($request);
$responseSender = Mockery::mock(ResponseSender::class);
$responseSender->shouldReceive('sendToGlobal')->with(Mockery::on($responseChecker));
$container = new Container();
$container->instance(ServerRequestFactory::class, $requestFactory);
$container->instance('router', $dispatcher);
$container->instance(ResponseSender::class, $responseSender);
$container->instance('config', new DotConfig(['debug' => $isDebug, 'error' => ['handler' => $errorHandler]]));
return $container;
}
public function testWith()
{
$container = new Container();
$instance1 = new ArrayObject();
$instance2 = new ArrayObject();
$instance3 = new ArrayObject();
$instance4 = new ArrayObject();
$container->instance('instance1', $instance1);
$container->instance('instance2', $instance2);
$container->instance('instance3', $instance3);
$container->instance('instance4', $instance4);
static::assertNotSame($instance1, $instance2);
// same is real same?
static::assertSame($instance1, $container->get('instance1'));
static::assertSame($instance2, $container->get('instance2'));
static::assertSame($instance3, $container->get('instance3'));
static::assertSame($instance4, $container->get('instance4'));
static::assertSame($container, $container->get(Container::class));
static::assertSame($container, $container->get(ContainerInterface::class));
static::assertSame($container, $container->get(InteropContainer::class));
static::assertSame($container, $container->get('container'));
$addedInstance1 = new ArrayObject();
$addedInstance2 = new ArrayObject();
$otherContainer = $container->with(['added_instance1' => $addedInstance1, 'added_instance2' => $addedInstance2]);
static::assertNotEquals($otherContainer, $container);
static::assertFalse($container->has('added_instance1'));
static::assertFalse($container->has('added_instance2'));
static::assertTrue($otherContainer->has('added_instance1'));
static::assertTrue($otherContainer->has('added_instance2'));
static::assertSame($instance1, $otherContainer->get('instance1'));
static::assertSame($instance2, $otherContainer->get('instance2'));
static::assertSame($instance3, $otherContainer->get('instance3'));
static::assertSame($instance4, $otherContainer->get('instance4'));
static::assertSame($addedInstance1, $otherContainer->get('added_instance1'));
static::assertSame($addedInstance2, $otherContainer->get('added_instance2'));
static::assertSame($otherContainer, $otherContainer->get(Container::class));
static::assertSame($otherContainer, $otherContainer->get(ContainerInterface::class));
static::assertSame($otherContainer, $otherContainer->get(InteropContainer::class));
static::assertSame($otherContainer, $otherContainer->get('container'));
}
