function __construct(Factory $factory, $workingDirectory, array $config)
{
$factory->setSingleton($this);
$this->workingDirectory = $workingDirectory;
$this->config = $config;
$this->factory = $factory;
}
public function __construct($storageDir, Factory $factory)
{
$this->factory = $factory;
$this->authors = new PersistentAuthorRepository($storageDir);
$this->posts = new PersistentPostRepository($storageDir);
$this->postService = $factory->setSingleton(new Posts($this->authors, $this->posts));
$this->authorService = $factory->setSingleton(new Authors($this->authors));
}
protected function before()
{
$this->factory = new Factory();
$this->factory->setSingleton($this->action->registry);
$this->access = $this->factory->setSingleton(new AccessControl());
$this->app = $this->factory->getInstance(WebApplication::class);
$this->app->prepare();
}
private function whenIExecuteTheCommand()
{
$this->listener = new ArrayListener();
$factory = new Factory();
$factory->setSingleton($this->listener);
$command = new ScrutCommand(new ConfigurationReader($this->files->fullPath(), $factory));
$command->execute(['-c' . json_encode(['listen' => [ArrayListener::class]])]);
}
protected function before()
{
$factory = new Factory();
$this->app = $factory->getInstance(WebApplication::class);
$this->app->prepare();
$this->app->fields->add(new ActionField($this->app->fields, $this->app->actions));
$this->app->renderers->add(new PrimitiveRenderer());
$this->app->fields->add(new StringField());
}
protected function before()
{
$this->cookies = Mockster::of(CookieStore::class);
$factory = new Factory();
$this->app = $factory->getInstance(WebApplication::class);
$this->resource = new ExecuteResource(new Factory(), $this->app, Mockster::mock($this->cookies));
$this->app->renderers->add(new PrimitiveRenderer());
$this->app->fields->add(new StringField());
}
public function __construct($name = NULL, array $data = array(), $dataName = '')
{
parent::__construct($name, $data, $dataName);
$factory = new Factory();
$this->fixtureProvider = new FixtureProvider($this, $factory);
$factory->setProvider(Fixture::$CLASS, $this->fixtureProvider);
$injector = new Injector($factory);
$injector->injectPropertyAnnotations($this, array($this, 'annotationPropertyFilter'));
$this->setTimeZone();
}
public function givenTheBoxContainer_In_WithBody($boxName, $folder, $body)
{
$namespace = $this->spec->getName(false) . ($folder ? '\\' . str_replace('/', '\\', $folder) : '');
$className = ucfirst($boxName) . WebRouter::SUFFIX;
$code = "namespace {$namespace}; class {$className} extends \\spec\\watoki\\boxes\\fixtures\\TestBox {\n function getMockDirectory() {\n return '{$folder}';\n }\n {$body}\n }";
eval($code);
$fileName = ($folder ? $folder . '/' : '') . $className . '.php';
$this->store->create(new File($code), $fileName);
$fullClassName = $namespace . '\\' . $className;
$this->boxes[$boxName] = new $fullClassName($this->factory);
$this->factory->setSingleton($this->boxes[$boxName], $fullClassName);
}
/**
* @param Factory $factory <-
*/
public function __construct(Factory $factory)
{
$this->factory = $factory;
$factory->setSingleton($this, get_class($this));
$this->register((new GenericActionRepresenter(RootAction::class, $factory))->setHandler(function () {
return new RootEntity();
})->setName('Home'));
$this->register((new GenericEntityRepresenter(RootEntity::class))->setName('Qrator'));
$printDateTime = function (\DateTimeInterface $d) {
return $d->format('Y-m-d H:i:s');
};
$this->register((new GenericEntityRepresenter(\DateTime::class))->setStringifier($printDateTime));
$this->register((new GenericEntityRepresenter(\DateTimeImmutable::class))->setStringifier($printDateTime));
}
public function whenIGet_From($path, $resourceClass)
{
$request = $this->request->withTarget(Path::fromString($path))->withMethod('get');
$stub = new TestDelivererStub($request);
$router = new NoneRouter(RespondingTarget::factory($this->factory, $this->factory->getInstance($resourceClass)));
$delivery = new WebDelivery($router, $stub, $stub);
$stub->onDeliver(function (WebResponse $response) {
if ($response instanceof ErrorResponse) {
throw $response->getException();
}
$this->model = $response->getBody();
});
$delivery->run();
}
/**
* @param Console $console
* @param array $arguments Arguments as produced by the Parser
* @throws \Exception If the class does not implement a "doExecute" method
* @return void
*/
public function execute(Console $console, array $arguments)
{
$injector = new Injector($this->factory);
$methodName = $this->getExecutionMethodName();
try {
$method = new \ReflectionMethod($this, $methodName);
} catch (\ReflectionException $e) {
throw new \Exception("Command [" . get_class($this) . "] must implement the method [{$methodName}].");
}
$this->factory->setSingleton($console, Console::$CLASS);
$resolved = $this->resolveFlags($method, $arguments);
$filtered = $this->filter($method, $resolved);
$arguments = $injector->injectMethodArguments($method, $filtered, $this->parameterInjectionFilter);
$this->checkArguments($method, $resolved);
$method->invokeArgs($this, $arguments);
}
/**
* @param array $constructorArguments
* @return object The Unit Under Test - an instance of the class, methods are not stubbed and the parent
* constructor is called, mocks of dependencies are injected
*/
public function __uut($constructorArguments = [])
{
$this->stubs->stubbedByDefault(false);
$instance = $this->prepMock($this->factory->getInstance($this->class, $constructorArguments));
$this->uuts[] = $instance;
foreach ($this->propertyMocksters as $property => $mockster) {
$this->properties[$property]->set($instance, $mockster->__mock());
}
return $instance;
}
private function createTargetFromClass($fullClassName, Request $request, Path $context)
{
$object = $this->factory->getInstance($fullClassName);
$nextRequest = $request->withContext($request->getContext()->appendedAll($context->getElements()));
$nextRequest = $nextRequest->withTarget(new Path(array_slice($request->getTarget()->getElements(), count($context->getElements()))));
if ($object instanceof Responding) {
return new RespondingTarget($nextRequest, $object);
} else {
return new ObjectTarget($nextRequest, $object, $this->factory);
}
}
/**
* @param $name
* @throws \BadMethodCallException If the method does not exist
* @return mixed
*/
protected function invoke($name)
{
try {
$reflection = new \ReflectionMethod($this->object, $name);
} catch (\ReflectionException $e) {
$class = get_class($this->object);
throw new \BadMethodCallException("Method [{$name}] does not exist in [{$class}]");
}
$this->factory->setProvider(Request::$REQUEST_CLASS, new CallbackProvider(function () {
return $this->request;
}));
$analyzer = new MethodAnalyzer($reflection);
$arguments = $this->request->getArguments()->toArray();
$arguments = $this->filter($analyzer, $arguments);
$factory = $this->factory;
$arguments = $analyzer->fillParameters($arguments, function ($class) use($factory) {
return $factory->getInstance($class);
}, $this->parameterInjectionFilter);
return $reflection->invokeArgs($this->object, $arguments);
}
/**
* @param callable|object|string $handler
* @return callable
*/
protected function makeCallable($handler)
{
if (is_callable($handler)) {
return $handler;
} else {
$classReflection = new \ReflectionClass($this->getClass());
$methodName = lcfirst($classReflection->getShortName());
return function ($action) use($handler, $methodName) {
$handler = is_object($handler) ? $handler : $this->factory->getInstance($handler);
if (!method_exists($handler, $methodName) && !method_exists($handler, '__call')) {
$class = get_class($handler);
throw new \InvalidArgumentException("Method [{$class}::{$methodName}] does not exist.");
}
return call_user_func(array($handler, $methodName), $action);
};
}
}
function after(Factory $factory)
{
assert($factory->getInstance(\DateTime::class) == new \DateTime('yesterday'));
}
public function __construct(Factory $factory)
{
$this->domin = $factory->getInstance(WebApplication::class);
}
function withRegisteredListener()
{
$this->factory->setSingleton($this->listener, TimeConsoleListener::class);
$this->whenIExecuteTheCommandWithTheArguments(['-lTime']);
$this->thenTheListenerShouldHaveReceivedSomething();
}
function __construct(Factory $factory, TestRunConfiguration $config, TestName $parent)
{
$factory->setSingleton($this, get_class($config));
$this->config = $config;
$this->parent = $parent;
}
/**
* @param Factory $factory <-
* @param ActionRegistry $actions <-
* @param FieldRegistry $fields <-
* @param RendererRegistry $renderers <-
* @param LinkRegistry $links <-
* @param IdentifiersProvider $identifiers <-
* @param TypeFactory $types <-
* @param MobileDetector $detect <-
* @param WebCommentParser $parser <-
* @param AccessControl $access <-
*/
public function __construct(Factory $factory, ActionRegistry $actions, FieldRegistry $fields, RendererRegistry $renderers, LinkRegistry $links, IdentifiersProvider $identifiers, TypeFactory $types, MobileDetector $detect, WebCommentParser $parser, AccessControl $access)
{
$factory->setSingleton($this);
$this->factory = $factory;
$this->actions = $actions;
$this->renderers = $renderers;
$this->links = $links;
$this->types = $types;
$this->fields = $fields;
$this->identifiers = $identifiers;
$this->detector = $detect;
$this->parser = $parser;
$this->access = $access;
$this->menu = new Menu($actions);
$this->groups = new ActionGroups($actions);
}
public function thenAnInstanceOf_ShouldBeTheSingletonOf($userClass, $baseClass)
{
$this->instance = $this->myFactory->getInstance($baseClass);
$this->spec->assertInstanceOf($userClass, $this->instance);
}
/**
* @param Request $request
* @return Target
*/
public function create(Request $request)
{
return $this->factory->getInstance($this->targetClass, array_merge(array('request' => $request), $this->arguments));
}
/**
* @param Assert $assert <-
* @param Factory $factory <-
*/
function __construct(Assert $assert, Factory $factory)
{
parent::__construct($assert);
$factory->setSingleton($this);
}
private function executeCommand(Assert $assert, $arguments = [], $shouldReturn = 0)
{
$factory = new Factory();
$factory->setSingleton(new RunTestByName_Configuration($this->files->fullPath(), $this->test, $this->listener), TestRunConfiguration::class);
$command = new ScrutCommand(new ConfigurationReader($this->files->fullPath(), $factory));
$returned = $command->execute($arguments);
$assert($returned, $shouldReturn);
}
public static function run(Factory $factory, Console $console = null)
{
global $argv;
/** @var self $app */
$app = $factory->getInstance(self::class);
return $app->doRun($console ?: new Console($argv));
}
/**
* @return Renderer
*/
protected function createDefaultRenderer()
{
return $this->factory->getInstance(Renderer::RENDERER);
}
public function __construct(Factory $factory, callable $internalInjector = null)
{
$this->injector = $internalInjector ?: function ($class) use($factory) {
return $factory->getInstance($class);
};
}
public static function quickResponse($respondingClass, Factory $factory = null)
{
$targetFactory = RespondingTarget::factory(self::$factory, self::$factory->getInstance($respondingClass));
self::quickRoute(new NoneRouter($targetFactory));
}
/**
* @param Factory $factory <-
* @param string $directory
* @param string $namespace
* @param string $suffix
*/
function __construct(Factory $factory, $directory, $namespace, $suffix = self::SUFFIX)
{
$store = $factory->getInstance(FlatFileStore::class, array('basePath' => $directory));
parent::__construct($factory, $store, $namespace, $suffix);
}
/**
* @param null|string $file
* @param array $mergeWith
* @return TestRunConfiguration
*/
public function read($file = null, array $mergeWith = [])
{
$config = array_replace_recursive(self::$defaultConfiguration, $this->readFromFile($file), $mergeWith);
return $this->factory->getInstance(TestRunConfiguration::class, [$this->factory, $this->cwd, $config]);
}