public function testIfWillRecognizeAnnotationAfterDynamicallyAddingNamespace()
{
$model = new ModelWithTwoNsAnnotations();
$options = new MetaOptions();
$options->namespaces[] = NamespacedAnnotation::Ns;
$meta = Meta::create($model, $options)->title;
$this->assertTrue($meta->namespaced);
// Not added second namespace
$this->assertNull($meta->second);
$this->assertNull($meta->third);
// Second ns
$options->namespaces[] = SecondNsAnnotation::Ns;
$metaContainer2 = Meta::create($model, $options);
$this->assertNotNull($metaContainer2);
$meta2 = $metaContainer2->title;
$this->assertTrue($meta2->namespaced);
// Added second namespace
$this->assertTrue($meta2->second, 'That namespace added via options id detected');
// Third ns
Addendum::fly()->addNamespace(ThirdNsAnnotation::Ns);
$meta3 = Meta::create($model, $options)->title;
$this->assertTrue($meta3->namespaced);
$this->assertTrue($meta3->second);
// Added second namespace
$this->assertTrue($meta3->third, 'That namespace added via Addendum::addNamespace is detected');
}
public function testIfWillAnnotatateSameAnnotationOnMultipleFields()
{
$model = new ModelWithLabels();
$meta = Meta::create($model);
$this->assertSame(ModelWithLabels::TitleLabel, $meta->title->label);
$this->assertSame(ModelWithLabels::StateLabel, $meta->state->label);
}
public function testIgnoreAnnotationsSurroundedByFence()
{
$model = new ModelWithFences();
$meta = Meta::create($model)->type();
codecept_debug($meta);
$this->assertSame('LABEL', $meta->label, 'That @Label was evaluated');
$this->assertTrue(empty($meta->description), 'That @Description was ignoded');
}
private function check($model)
{
$meta = Meta::create($model)->published;
$this->assertNotFalse($meta);
$this->assertNotNull($meta->decorators);
$this->assertCount(2, $meta->decorators);
$this->assertContains(Published::class, $meta->decorators);
$this->assertContains(CellEnumCss::class, $meta->decorators);
return $meta;
}
public function testIfWillConflict()
{
$model = new ModelWithConflictedAnnotation();
try {
Meta::create($model);
$this->assertTrue(false);
} catch (ConflictException $ex) {
$this->assertTrue(true);
}
}
public function testIfWillReadBasicMethodMetaInformation()
{
$meta = Meta::create(ModelWithoutAnnotations::class);
$this->assertNotNull($meta);
$method = $meta->method('show');
$this->assertTrue($method instanceof MetaMethod);
$this->assertFalse($method->isAbstract);
$this->assertFalse($method->isStatic);
$this->assertSame($method->name, 'show');
}
/**
* TODO Does not pass
*/
public function testIfWillMatchConstant()
{
$model = new ModelWithConstantValue();
$options = new MetaOptions();
$options->namespaces[] = NamespacedAnnotation::Ns;
$meta = Meta::create($model, $options);
// ModelWithConstantLabel defined in ModelWithConstantValue.php
$this->assertTrue(defined('ModelWithConstantLabel'));
$this->assertSame(ModelWithConstantLabel, $meta->title->label);
$this->assertSame(ModelWithConstantValue::NameLabel, $meta->name->label);
}
public function testIfWillProperlyGetMetaFromNestedTrait()
{
$model = new ModelWithNestedTraits();
$meta = Meta::create($model);
$hasLabelMeta = $meta->hasLabel;
$parentMeta = $meta->parentId;
codecept_debug($hasLabelMeta);
codecept_debug($parentMeta);
$this->assertTrue(!empty($hasLabelMeta->label), 'That @Label is properly configured');
$this->assertTrue(!empty($parentMeta->label), 'That @Label is detected on nested trait');
}
public function testIfPropertyAndMethodAreIgnored()
{
$model = new ModelWithIgnoredEntities();
$meta = Meta::create($model);
// Default behavior
$this->assertInstanceOf(MetaProperty::class, $meta->title);
$this->assertInstanceOf(MetaMethod::class, $meta->method('getTitle'));
// Must not have metadata
$this->assertFalse($meta->meta);
$this->assertFalse($meta->method('getMeta'));
// Must have metadata
$this->assertInstanceOf(MetaProperty::class, $meta->must);
$this->assertInstanceOf(MetaMethod::class, $meta->method('getMust'));
}
public function testIfWillExtractTopValues()
{
$model = new ModelWithTopValues();
// Raw matcher for debug
$reflection = new ReflectionAnnotatedProperty($model, 'straight');
$matcher = new AnnotationsMatcher();
$matcher->setPlugins(new MatcherConfig(['addendum' => new Addendum(), 'reflection' => $reflection]));
$data = [];
$comment = Addendum::getDocComment($reflection);
$matcher->matches($comment, $data);
$meta = Meta::create($model);
// All fields have same annotation
foreach ($meta->fields() as $fieldMeta) {
$title = sprintf('Annotation is defined on %s', $fieldMeta->name);
$this->assertSame(ModelWithTopValues::ClassValue, $fieldMeta->class);
$this->assertSame(ModelWithTopValues::UpdatableValue, $fieldMeta->updatable);
}
}
public function testIfWillProperlyGetMetaFromTrait()
{
$model = new ModelWithSimpleTree();
// Parse error in annotation
try {
$infoBad = new ReflectionAnnotatedProperty(SimpleTreeTrait::class, 'children');
$relatedBad = $infoBad->getAnnotation('RelatedArray');
$this->fail('Should throw exception');
} catch (ParseException $e) {
$this->assertTrue(true);
codecept_debug('Exception was thrown properly');
}
$info = new ReflectionAnnotatedProperty(SimpleTreeTraitProper::class, 'children');
$related = $info->getAnnotation('RelatedArray');
$this->assertInstanceOf(RelatedArrayAnnotation::class, $related);
$this->assertNotNull($related->value);
try {
$meta = Meta::create($model);
$this->fail('Should throw exception');
} catch (ParseException $e) {
$this->assertTrue(true);
codecept_debug('Exception was thrown properly');
}
}
public function testIfWillResolveSelfConstantValueUsingStaticKeyword()
{
$model = new ModelWithRequiredValueValidator();
$meta = Meta::create($model);
$this->assertSame(ModelWithRequiredValueValidator::RequiredValue, $meta->loginStatic->requiredValue);
}
public function testIfSignaledAnnotationIsIncluded()
{
$model = new ModelWithSignaledAnnotation();
$meta = Meta::create($model);
$this->assertTrue($meta->type()->signaled);
}
public function testIfWillResolveNonNamespacedAnnotation()
{
$model = new ModelWithNonNsAnnotation();
$meta = Meta::create($model);
$this->assertTrue($meta->type()->nonNamespaced);
}
public function testIfHasWrongTargetMethod()
{
$model = new ModelWithBadTargetMethod();
try {
Meta::create($model);
$this->assertTrue(false);
} catch (TargetException $ex) {
$this->assertTrue(true);
}
}
/**
* Get method meta data
* @param type $name
* @return DocumentMethodMeta
*/
public function method($name)
{
return parent::method($name);
}
/**
* Get document type meta
* @return DocumentTypeMeta
*/
public function type()
{
return parent::type();
}