/**
* @param string $locator
* @param integer|null $line
*
* @return Suite
*/
public function load($locator, $line = null)
{
$suite = new Suite();
foreach ($this->manager->locateResources($locator) as $resource) {
if (!class_exists($resource->getSpecClassname()) && is_file($resource->getSpecFilename())) {
require_once $resource->getSpecFilename();
}
if (!class_exists($resource->getSpecClassname())) {
continue;
}
$reflection = new ReflectionClass($resource->getSpecClassname());
if ($reflection->isAbstract()) {
continue;
}
if (!$reflection->implementsInterface('PhpSpec\\SpecificationInterface')) {
continue;
}
$spec = new Node\SpecificationNode($resource->getSrcClassname(), $reflection, $resource);
foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
if (!preg_match('/^(it|its)[^a-zA-Z]/', $method->getName())) {
continue;
}
if (null !== $line && !$this->lineIsInsideMethod($line, $method)) {
continue;
}
$example = new Node\ExampleNode(str_replace('_', ' ', $method->getName()), $method);
if ($this->methodIsEmpty($method)) {
$example->markAsPending();
}
$spec->addExample($example);
}
$suite->addSpecification($spec);
}
return $suite;
}
/**
* @param ExampleNode $example
* @param SpecificationInterface $context
* @param MatcherManager $matchers
* @param CollaboratorManager $collaborators
*/
public function prepare(ExampleNode $example, SpecificationInterface $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
$spec = $example->getSpecification()->getClassReflection()->newInstance();
$beforeMethod = $example->getSpecification()->getClassReflection()->getMethod($this->beforeMethod);
$this->createMissingCollabolators($collaborators, $beforeMethod);
$beforeMethod->invokeArgs($spec, $collaborators->getArgumentsFor($beforeMethod));
}
/**
* @param ExampleNode $example
* @param Specification $context
* @param MatcherManager $matchers
* @param CollaboratorManager $collaborators
*/
public function prepare(ExampleNode $example, Specification $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
$subjectFactory = new Wrapper($matchers, $this->presenter, $this->dispatcher, $example, $this->accessInspector);
$subject = $subjectFactory->wrap(null);
$subject->beAnInstanceOf($example->getSpecification()->getResource()->getSrcClassname());
$context->setSpecificationSubject($subject);
}
/**
* Generates DI related stuff via parameter validator
*
* @param ExampleNode $example
* @param Specification $context
* @param MatcherManager $matchers
* @param CollaboratorManager $collaborators
*
* @return $this
*/
public function prepare(ExampleNode $example, Specification $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
if ($example->getSpecification()->getClassReflection()->hasMethod('let')) {
$this->parameterValidator->validate($example->getSpecification()->getClassReflection()->getMethod('let'));
}
$this->parameterValidator->validate($example->getFunctionReflection());
return $this;
}
/**
* @param ExampleNode $example
* @param SpecificationInterface $context
* @param MatcherManager $matchers
* @param CollaboratorManager $collaborators
*/
public function teardown(ExampleNode $example, SpecificationInterface $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
if (!$example->getSpecification()->getClassReflection()->hasMethod('letgo')) {
return;
}
$reflection = $example->getSpecification()->getClassReflection()->getMethod('letgo');
$reflection->invokeArgs($context, $collaborators->getArgumentsFor($reflection));
}
/**
* @param ExampleNode $example
* @param SpecificationInterface $context
* @param MatcherManager $matchers
* @param CollaboratorManager $collaborators
*/
public function prepare(ExampleNode $example, SpecificationInterface $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
$this->prophet = new Prophet(null, $this->unwrapper, null);
$classRefl = $example->getSpecification()->getClassReflection();
if ($classRefl->hasMethod('let')) {
$this->generateCollaborators($collaborators, $classRefl->getMethod('let'));
}
$this->generateCollaborators($collaborators, $example->getFunctionReflection());
}
function it_orders_an_array_of_example_nodes(ExampleNode $a, ExampleNode $b, ExampleNode $c)
{
$a->getTitle()->willReturn('bar1');
$b->getTitle()->willReturn('bar2');
$c->getTitle()->willReturn('bar3');
$nodes = [$a, $b, $c];
$expected = [$c, $b, $a];
$this->setSpecificationTitle('foo');
$this->filter($nodes)->shouldReturn($expected);
}
function prepareExampleBeforeAnnotation(ExampleNode $exampleNode, \ReflectionMethod $method, SpecificationNode $specificationNode, \ReflectionClass $specClass)
{
$exampleNode->getFunctionReflection()->willReturn($method);
$method->getDocComment()->willReturn(<<<ANNOTATION
/**
* @before prepareMethod
*/
ANNOTATION
);
$exampleNode->getSpecification()->willReturn($specificationNode);
$specificationNode->getClassReflection()->willReturn($specClass);
}
function it_prepares_the_subject(ExampleNode $example, ObjectBehavior $context, MatcherManager $matchers, CollaboratorManager $collaborators, SpecificationNode $specification, ResourceInterface $resource, VarienWrapper $wrapper, Subject $subject, $factory)
{
$factory->create(Argument::cetera())->willReturn($wrapper);
$wrapper->wrap(null)->willReturn($subject);
$subject->beAnInstanceOf('\\stdObject');
$subject = $subject->getWrappedObject();
$resource->getSrcClassname()->willReturn('\\stdObject');
$specification->getResource()->willReturn($resource);
$example->getSpecification()->willReturn($specification);
$context->setSpecificationSubject($subject)->shouldBeCalled();
$this->prepare($example, $context, $matchers, $collaborators);
}
function it_does_pass_regular_example_into_parameter_validator_and_let_method_if_they_are_defined(ExampleNode $example, Specification $context, MatcherManager $matchers, CollaboratorManager $collaborators, SpecificationNode $specificationNode, \ReflectionClass $reflectionClass)
{
$example->getSpecification()->willReturn($specificationNode);
$specificationNode->getClassReflection()->willReturn($reflectionClass);
$reflectionClass->hasMethod('let')->willReturn(true);
$exampleClosureReflection = new \ReflectionFunction(function () {
});
$letClosureReflection = new \ReflectionFunction(function () {
});
$reflectionClass->getMethod('let')->willReturn($letClosureReflection)->shouldBeCalled();
$example->getFunctionReflection()->willReturn($exampleClosureReflection)->shouldBeCalled();
$this->parameterValidator->validate($letClosureReflection)->shouldBeCalled();
$this->parameterValidator->validate($exampleClosureReflection)->shouldBeCalled();
$this->prepare($example, $context, $matchers, $collaborators)->shouldReturn($this);
}
function let(Laravel $laravel, ExampleNode $example, SpecificationInterface $context)
{
$this->beConstructedWith($laravel);
$p = new Prophet();
$this->refMethod = $p->prophesize('ReflectionMethod');
$this->refMethod->invokeArgs(Argument::type('PhpSpec\\SpecificationInterface'), Argument::type('array'))->shouldBeCalled();
$refClass = $p->prophesize('ReflectionClass');
$refClass->hasMethod('setLaravel')->willReturn(true);
$refClass->hasMethod('setLaravel')->shouldBeCalled();
$refClass->getMethod('setLaravel')->willReturn($this->refMethod->reveal());
$refClass->getMethod('setLaravel')->shouldBeCalled();
$specNode = $p->prophesize('PhpSpec\\Loader\\Node\\SpecificationNode');
$specNode->getClassReflection()->willReturn($refClass->reveal());
$example->getSpecification()->willReturn($specNode->reveal());
}
private function getIterators(ExampleNode $example)
{
$classRefl = $example->getSpecification()->getClassReflection();
if ($classRefl->hasMethod('let')) {
foreach ($classRefl->getMethod('let')->getParameters() as $parameter) {
if ($this->isIterator($parameter->getClass())) {
(yield $parameter->getName() => $parameter->getClass()->getName());
}
}
}
foreach ($example->getFunctionReflection()->getParameters() as $parameter) {
if ($this->isIterator($parameter->getClass())) {
(yield $parameter->getName() => $parameter->getClass()->getName());
}
}
}
function it_runs_let_and_letgo_maintainer_before_and_after_each_example_if_the_example_throws_an_exception(ExampleNode $example, SpecificationNode $specification, ReflectionClass $specReflection, $context, ReflectionMethod $exampReflection, LetAndLetgoMaintainer $maintainer, SpecificationInterface $context)
{
$example->isPending()->willReturn(false);
$example->getFunctionReflection()->willReturn($exampReflection);
$example->getSpecification()->willReturn($specification);
$specification->getClassReflection()->willReturn($specReflection);
$specReflection->newInstanceArgs()->willReturn($context);
$exampReflection->getParameters()->willReturn(array());
$exampReflection->invokeArgs($context, array())->willThrow('RuntimeException');
$maintainer->getPriority()->willReturn(1);
$maintainer->supports($example)->willReturn(true);
$maintainer->prepare($example, Argument::cetera())->shouldBeCalled();
$maintainer->teardown($example, Argument::cetera())->shouldBeCalled();
$this->registerMaintainer($maintainer);
$this->run($example);
}
function it_outputs_exceptions_for_failed_examples(SuiteEvent $event, ExampleEvent $pendingEvent, ConsoleIO $io, StatisticsCollector $stats, SpecificationNode $specification, ExampleNode $example)
{
$example->getLineNumber()->willReturn(37);
$example->getTitle()->willReturn('it tests something');
$pendingEvent->getException()->willReturn(new PendingException());
$pendingEvent->getSpecification()->willReturn($specification);
$pendingEvent->getExample()->willReturn($example);
$stats->getEventsCount()->willReturn(1);
$stats->getFailedEvents()->willReturn(array());
$stats->getBrokenEvents()->willReturn(array());
$stats->getPendingEvents()->willReturn(array($pendingEvent));
$stats->getSkippedEvents()->willReturn(array());
$stats->getTotalSpecs()->willReturn(1);
$stats->getCountsHash()->willReturn(array('passed' => 0, 'pending' => 1, 'skipped' => 0, 'failed' => 0, 'broken' => 0));
$this->afterSuite($event);
$expected = '<lineno> 37</lineno> <pending>- it tests something</pending>';
$io->writeln($expected)->shouldHaveBeenCalled();
}
/**
* @param ExampleNode $example
* @return bool|mixed
*/
private function getDataFromProvider(ExampleNode $example)
{
$parser = new Parser();
$dataProviderMethod = $parser->getDataProvider($example->getFunctionReflection());
if (!isset($dataProviderMethod)) {
return array();
}
if (!$example->getSpecification()->getClassReflection()->hasMethod($dataProviderMethod)) {
return array();
}
$subject = $example->getSpecification()->getClassReflection()->newInstance();
$providedData = $example->getSpecification()->getClassReflection()->getMethod($dataProviderMethod)->invoke($subject);
return is_array($providedData) ? $providedData : array();
}
/**
* @return \PhpSpec\Loader\Suite
*/
public function getSuite()
{
return $this->example->getSpecification()->getSuite();
}
/**
* @param SpecificationInterface $context
* @param ExampleNode $example
*
* @throws \PhpSpec\Exception\Example\PendingException
* @throws \Exception
*/
protected function executeExample(SpecificationInterface $context, ExampleNode $example)
{
if ($example->isPending()) {
throw new ExampleException\PendingException();
}
$matchers = new MatcherManager($this->presenter);
$collaborators = new CollaboratorManager($this->presenter);
$maintainers = array_filter($this->maintainers, function ($maintainer) use($example) {
return $maintainer->supports($example);
});
// run maintainers prepare
foreach ($maintainers as $maintainer) {
$maintainer->prepare($example, $context, $matchers, $collaborators);
}
// execute example
$reflection = $example->getFunctionReflection();
try {
$reflection->invokeArgs($context, $collaborators->getArgumentsFor($reflection));
} catch (\Exception $e) {
$this->runMaintainersTeardown($this->searchExceptionMaintainers($maintainers), $example, $context, $matchers, $collaborators);
throw $e;
}
$this->runMaintainersTeardown($maintainers, $example, $context, $matchers, $collaborators);
}
private function exampleEvent(ExampleNode $node, $result = ExampleEvent::PASSED, $time = 0, $exceptionMessage = '')
{
return new ExampleEvent($node->getWrappedObject(), $time, $result, new \Exception($exceptionMessage));
}
/**
* {@inheritdoc}
*/
public function prepare(ExampleNode $example, SpecificationInterface $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
$reflection = $example->getSpecification()->getClassReflection()->getMethod('setLumen');
$reflection->invokeArgs($context, array($this->lumen));
}
public function supports(ExampleNode $example)
{
return $example->getSpecification()->getResource() instanceof ModelResource;
}
/**
* @param ExampleNode $example
*/
public function addExample(ExampleNode $example)
{
$this->examples[] = $example;
$example->setSpecification($this);
}
/**
* {@inheritdoc}
*/
public function prepare(ExampleNode $example, Specification $context, MatcherManager $matchers, CollaboratorManager $collaborators)
{
$reflection = $example->getSpecification()->getClassReflection()->getMethod('setLaravel');
$reflection->invokeArgs($context, [$this->laravel]);
}
/**
* @return string
*/
public function getTitle()
{
return $this->example->getTitle();
}
