public function testExtendUnknown()
{
$container = new Container();
$container->extend('unknown', function ($item) {
return $item . ' extended..';
});
}
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 testCascadeResolve()
{
$container = new Container();
$count = 0;
$request = new ServerRequest();
$request = $request->withParsedBody(['abc' => 'def']);
$container->with([ServerRequestInterface::class => $request])->call(function (ServerRequestInterface $req, ParsedBody $parsedBody) use(&$count, $request) {
static::assertSame($request, $req);
$count++;
});
static::assertEquals(1, $count);
}
public function testS()
{
$container = new Container();
$closure = function () {
return ['$CLOSURE', func_get_args()];
};
// closure
$result = $container->call($closure, ['param1', 'param2']);
static::assertEquals(['$CLOSURE', ['param1', 'param2']], $result);
// function
$result = $container->call(__NAMESPACE__ . '\\callTestFunction', ['param2', 'param3']);
static::assertEquals(['function', ['param2', 'param3']], $result);
// static method
$result = $container->call(CallTestInvokers::class . '::staticMethod', ['param3', 'param4']);
static::assertEquals(['staticMethod', ['param3', 'param4']], $result);
// array of static
$result = $container->call([CallTestInvokers::class, 'staticMethod'], ['param4', 'param5']);
static::assertEquals(['staticMethod', ['param4', 'param5']], $result);
// array of method
$result = $container->call([new CallTestInvokers(), 'instanceMethod'], ['param5', 'param6']);
static::assertEquals(['instanceMethod', ['param5', 'param6']], $result);
// invoker
$result = $container->call(new CallTestInvokers(), ['param6', 'param7']);
static::assertEquals(['__invoke', ['param6', 'param7']], $result);
// __call
$result = $container->call([new CallTestInvokers(), 'callViaCallMagicMethod'], ['param7', 'param8']);
static::assertEquals(['__call', 'callViaCallMagicMethod', ['param7', 'param8']], $result);
// __staticCall
$result = $container->call([CallTestInvokers::class, 'callViaStaticCallMagicMethod'], ['param8', 'param9']);
static::assertEquals(['__callStatic', 'callViaStaticCallMagicMethod', ['param8', 'param9']], $result);
}
/**
* {@inheritdoc}
*/
public function boot()
{
if (!$this->isBooted) {
$this->kernel->boot($this);
parent::boot();
}
return $this;
}
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());
}
public function testInject()
{
$container = new Container();
$example = new InjectTestExample();
static::assertNull($example->getSomething());
// null
static::assertNull($example->getOtherthing());
// null
// inject object
$container->inject($example, ['something' => $something = new stdClass()]);
static::assertSame($something, $example->getSomething());
// same
// inject scalar
$container->inject($example, ['otherthing' => $otherthing = 303030]);
static::assertSame($something, $example->getSomething());
// same
static::assertSame($otherthing, $example->getOtherthing());
// same
}
public function testAutoWiringEachOther()
{
$container = new Container();
$container->bind(Reader::class, AnnotationReader::class);
// add annotation.
$container->bind(AutoWiringTestEachOther1::class)->wire();
$container->bind(AutoWiringTestEachOther2::class)->wire();
$object = $container->get(AutoWiringTestEachOther1::class);
static::assertInstanceOf(AutoWiringTestEachOther2::class, $object->getDepend());
static::assertInstanceOf(AutoWiringTestEachOther1::class, $object->getDepend()->getDepend());
$container = new Container();
$container->bind(Reader::class, AnnotationReader::class);
// add annotation.
$container->bind(AutoWiringTestEachOther1::class)->wire();
$container->bind(AutoWiringTestEachOther2::class)->wire();
$object = $container->get(AutoWiringTestEachOther2::class);
static::assertInstanceOf(AutoWiringTestEachOther1::class, $object->getDepend());
static::assertInstanceOf(AutoWiringTestEachOther2::class, $object->getDepend()->getDepend());
}
/**
* @param \Festiv\Foundation\KernelInterface $kernel
* @param array $config
*/
public function __construct(KernelInterface $kernel = null, array $config = [])
{
parent::__construct();
if (!isset($kernel)) {
$kernel = new NullKernel();
}
$this->instance(KernelInterface::class, $this->kernel = $kernel);
$this->instance('config', new DotConfig($config));
// Load Kernel Providers
$this->kernel->registered($this);
}
public function testBindFactory()
{
$container = new Container();
$container->bind(ChainMethodTestDependInterface::class, ChainMethodTestDepend::class);
// all same
$object1 = $container[ChainMethodTestDependInterface::class];
static::assertSame($object1, $container[ChainMethodTestDependInterface::class]);
static::assertSame($object1, $container[ChainMethodTestDependInterface::class]);
static::assertSame($object1, $container[ChainMethodTestDependInterface::class]);
// reset
$container = new Container();
$container->bind(ChainMethodTestDependInterface::class, ChainMethodTestDepend::class)->factory(true);
$object2 = $container[ChainMethodTestDependInterface::class];
// all not same
$object2_1 = $container[ChainMethodTestDependInterface::class];
static::assertNotSame($object2, $object2_1);
static::assertEquals($object2, $object2_1);
$object2_2 = $container[ChainMethodTestDependInterface::class];
static::assertNotSame($object2, $object2_2);
static::assertEquals($object2, $object2_2);
static::assertNotSame($object2_1, $object2_2);
static::assertEquals($object2_1, $object2_2);
}
public function testCreateMultiParamsClassWithArguments()
{
$container = new Container();
try {
$container->create(CreateTestHasMultiParam::class);
static::fail();
} catch (CannotResolveException $e) {
static::assertEquals(CreateTestHasMultiParam::class, $e->getClass());
static::assertEquals('param1', $e->getParameter());
}
$container->bind(CreateTestDependencyInterface::class, CreateTestDependency::class);
try {
$container->create(CreateTestHasMultiParam::class);
static::fail();
} catch (CannotResolveException $e) {
static::assertEquals(CreateTestHasMultiParam::class, $e->getClass());
static::assertEquals('param2', $e->getParameter());
}
// only sequential
$object = $container->create(CreateTestHasMultiParam::class, [$param1 = new CreateTestDependency(), $param2 = new stdClass()]);
static::assertSame($param1, $object->param1);
static::assertSame($param2, $object->param2);
static::assertSame('param3', $object->param3);
static::assertSame('param4', $object->param4);
// only assoc
$object = $container->create(CreateTestHasMultiParam::class, ['param2' => $param2 = new stdClass(), 'param4' => $param4 = new stdClass()]);
static::assertInstanceOf(CreateTestDependencyInterface::class, $object->param1);
static::assertSame($param2, $object->param2);
static::assertSame('param3', $object->param3);
static::assertSame($param4, $object->param4);
// complex
$object = $container->create(CreateTestHasMultiParam::class, [$param1 = new CreateTestDependency(), $param2 = new stdClass(), 'param4' => $param4 = new stdClass(), 'param3' => $param3 = new stdClass()]);
static::assertSame($param1, $object->param1);
static::assertSame($param2, $object->param2);
static::assertSame($param3, $object->param3);
static::assertSame($param4, $object->param4);
}
/**
* @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;
}
<?php
namespace PHPSTORM_META;
$STATIC_METHOD_TYPES = [\Interop\Container\ContainerInterface::get('') => ["" == "@"], \Wandu\DI\Container::get('') => ["" == "@"]];
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'));
}
