‪TYPO3CMS  9.5
•All Classes Namespaces Files Functions Variables Pages
ClassSchemaTest.php
Go to the documentation of this file.
1 <?php
2 namespace ‪TYPO3\CMS\Extbase\Tests\Unit\Reflection;
3 
4 /*
5  * This file is part of the TYPO3 CMS project.
6  *
7  * It is free software; you can redistribute it and/or modify it under
8  * the terms of the GNU General Public License, either version 2
9  * of the License, or any later version.
10  *
11  * For the full copyright and license information, please read the
12  * LICENSE.txt file that was distributed with this source code.
13  *
14  * The TYPO3 project - inspiring people to share!
15  */
16 
17 use ‪TYPO3\CMS\Core\Utility\GeneralUtility;
18 use ‪TYPO3\CMS\Extbase\Persistence\ObjectStorage;
19 use ‪TYPO3\CMS\Extbase\Reflection\ClassSchema;
20 use ‪TYPO3\CMS\Extbase\Validation\Exception\InvalidTypeHintException;
21 use ‪TYPO3\CMS\Extbase\Validation\Exception\InvalidValidationConfigurationException;
22 use ‪TYPO3\CMS\Extbase\Validation\Validator\NotEmptyValidator;
23 use ‪TYPO3\CMS\Extbase\Validation\Validator\StringLengthValidator;
24 use TYPO3\TestingFramework\Core\Unit\UnitTestCase;
25 
29 class ‪ClassSchemaTest extends UnitTestCase
30 {
34  public function ‪classSchemaForModelIsSetAggregateRootIfRepositoryClassIsFoundForNamespacedClasses()
35  {
36  $this->resetSingletonInstances = true;
37  $service = GeneralUtility::makeInstance(\‪TYPO3\CMS\‪Extbase\Reflection\ReflectionService::class);
38  $classSchema = $service->getClassSchema(Fixture\DummyModel::class);
39  $this->assertTrue($classSchema->isAggregateRoot());
40  }
41 
45  public function ‪classSchemaHasConstructor()
46  {
47  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithConstructorAndConstructorArguments::class);
48  static::assertTrue($classSchema->hasConstructor());
49  }
50 
54  public function ‪classSchemaDetectsConstructorArguments()
55  {
56  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithConstructorAndConstructorArguments::class);
57  static::assertTrue($classSchema->hasConstructor());
58 
59  $constructorArguments = $classSchema->getConstructorArguments();
60  static::assertArrayHasKey('foo', $constructorArguments);
61  static::assertArrayHasKey('bar', $constructorArguments);
62 
63  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithConstructorAndWithoutConstructorArguments::class);
64  static::assertTrue($classSchema->hasConstructor());
65  static::assertSame([], $classSchema->getConstructorArguments());
66 
67  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithoutConstructor::class);
68  static::assertFalse($classSchema->hasConstructor());
69  static::assertSame([], $classSchema->getConstructorArguments());
70  }
71 
75  public function ‪classSchemaDetectsConstructorArgumentsWithDependencies()
76  {
77  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithConstructorAndConstructorArgumentsWithDependencies::class);
78  static::assertTrue($classSchema->hasConstructor());
79 
80  $methodDefinition = $classSchema->getMethod('__construct');
81  static::assertArrayHasKey('foo', $methodDefinition['params']);
82  static::assertSame(Fixture\DummyClassWithGettersAndSetters::class, $methodDefinition['params']['foo']['dependency']);
83  }
84 
88  public function ‪classSchemaGetProperties()
89  {
90  static::assertSame(
91  [
92  'publicProperty',
93  'protectedProperty',
94  'privateProperty',
95  'publicStaticProperty',
96  'protectedStaticProperty',
97  'privateStaticProperty',
98  'propertyWithIgnoredTags',
99  'propertyWithInjectAnnotation',
100  'propertyWithTransientAnnotation',
101  'propertyWithCascadeAnnotation',
102  'propertyWithCascadeAnnotationWithoutVarAnnotation',
103  'propertyWithObjectStorageAnnotation',
104  'uid',
105  '_localizedUid',
106  '_languageUid',
107  '_versionedUid',
108  'pid',
109  ],
110  array_keys((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->getProperties())
111  );
112  }
113 
117  public function ‪classSchemaHasMethod()
118  {
119  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
120  static::assertTrue($classSchema->hasMethod('publicMethod'));
121  static::assertFalse($classSchema->hasMethod('nonExistentMethod'));
122  }
123 
127  public function ‪classSchemaGetMethods()
128  {
129  static::assertSame(
130  [
131  'publicMethod',
132  'protectedMethod',
133  'privateMethod',
134  'methodWithIgnoredTags',
135  'injectSettings',
136  'injectMethodWithoutParam',
137  'injectMethodThatIsProtected',
138  'injectFoo',
139  'staticMethod',
140  'methodWithMandatoryParam',
141  'methodWithNullableParam',
142  'methodWithDefaultValueParam',
143  'methodWithTypeHintedParam'
144  ],
145  array_keys((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class))->getMethods())
146  );
147  }
148 
152  public function ‪classSchemaDetectsMethodVisibility()
153  {
154  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
155 
156  $methodDefinition = $classSchema->getMethod('publicMethod');
157  static::assertTrue($methodDefinition['public']);
158  static::assertFalse($methodDefinition['protected']);
159  static::assertFalse($methodDefinition['private']);
160 
161  $methodDefinition = $classSchema->getMethod('protectedMethod');
162  static::assertFalse($methodDefinition['public']);
163  static::assertTrue($methodDefinition['protected']);
164  static::assertFalse($methodDefinition['private']);
165 
166  $methodDefinition = $classSchema->getMethod('privateMethod');
167  static::assertFalse($methodDefinition['public']);
168  static::assertFalse($methodDefinition['protected']);
169  static::assertTrue($methodDefinition['private']);
170  }
171 
175  public function ‪classSchemaDetectsInjectProperties()
176  {
177  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithInjectDoctrineAnnotation::class);
178  static::assertTrue($classSchema->hasInjectProperties());
179 
180  $injectProperties = $classSchema->getInjectProperties();
181  static::assertArrayHasKey('propertyWithFullQualifiedClassName', $injectProperties);
182  static::assertSame(Fixture\DummyClassWithInjectDoctrineAnnotation::class, $injectProperties['propertyWithFullQualifiedClassName']);
183 
184  static::assertArrayHasKey('propertyWithRelativeClassName', $injectProperties);
185  static::assertSame('DummyClassWithInjectDoctrineAnnotation', $injectProperties['propertyWithRelativeClassName']);
186 
187  static::assertArrayHasKey('propertyWithImportedClassName', $injectProperties);
188  static::assertSame('ClassSchemaTest', $injectProperties['propertyWithImportedClassName']);
189 
190  static::assertArrayHasKey('propertyWithImportedAndAliasedClassName', $injectProperties);
191  static::assertSame('AliasedClassSchemaTest', $injectProperties['propertyWithImportedAndAliasedClassName']);
192  }
193 
197  public function ‪classSchemaDetectsInjectMethods()
198  {
199  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
200  static::assertTrue($classSchema->hasInjectMethods());
201 
202  $methodDefinition = $classSchema->getMethod('injectSettings');
203  static::assertFalse($methodDefinition['injectMethod']);
204 
205  $methodDefinition = $classSchema->getMethod('injectMethodWithoutParam');
206  static::assertFalse($methodDefinition['injectMethod']);
207 
208  $methodDefinition = $classSchema->getMethod('injectMethodThatIsProtected');
209  static::assertFalse($methodDefinition['injectMethod']);
210 
211  $methodDefinition = $classSchema->getMethod('injectFoo');
212  static::assertTrue($methodDefinition['injectMethod']);
213 
214  $injectMethods = $classSchema->getInjectMethods();
215  static::assertArrayHasKey('injectFoo', $injectMethods);
216  }
217 
221  public function ‪classSchemaDetectsPropertiesWithLazyAnnotation()
222  {
223  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithLazyDoctrineAnnotation::class);
224  static::assertTrue($classSchema->getProperty('propertyWithLazyAnnotation')['annotations']['lazy']);
225  }
226 
230  public function ‪classSchemaDetectsStaticMethods()
231  {
232  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
233 
234  $methodDefinition = $classSchema->getMethod('staticMethod');
235  static::assertTrue($methodDefinition['static']);
236  }
237 
241  public function ‪classSchemaDetectsMandatoryParams()
242  {
243  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
244 
245  $methodDefinition = $classSchema->getMethod('methodWithMandatoryParam');
246  static::assertFalse($methodDefinition['params']['param']['optional']);
247  }
248 
252  public function ‪classSchemaDetectsNullableParams()
253  {
254  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
255 
256  $methodDefinition = $classSchema->getMethod('methodWithNullableParam');
257  static::assertTrue($methodDefinition['params']['param']['nullable']);
258  }
259 
263  public function ‪classSchemaDetectsDefaultValueParams()
264  {
265  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
266 
267  $methodDefinition = $classSchema->getMethod('methodWithDefaultValueParam');
268  static::assertSame('foo', $methodDefinition['params']['param']['default']);
269  }
270 
274  public function ‪classSchemaDetectsParamTypeFromTypeHint()
275  {
276  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfMethods::class);
277 
278  $methodDefinition = $classSchema->getMethod('methodWithTypeHintedParam');
279  static::assertSame('string', $methodDefinition['params']['param']['type']);
280  }
281 
285  public function ‪classSchemaDetectsPropertyVisibility()
286  {
287  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
288 
289  $propertyDefinition = $classSchema->getProperty('publicProperty');
290  static::assertTrue($propertyDefinition['public']);
291  static::assertFalse($propertyDefinition['protected']);
292  static::assertFalse($propertyDefinition['private']);
293 
294  $propertyDefinition = $classSchema->getProperty('protectedProperty');
295  static::assertFalse($propertyDefinition['public']);
296  static::assertTrue($propertyDefinition['protected']);
297  static::assertFalse($propertyDefinition['private']);
298 
299  $propertyDefinition = $classSchema->getProperty('privateProperty');
300  static::assertFalse($propertyDefinition['public']);
301  static::assertFalse($propertyDefinition['protected']);
302  static::assertTrue($propertyDefinition['private']);
303  }
304 
308  public function ‪classSchemaDetectsInjectProperty()
309  {
310  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
311 
312  $propertyDefinition = $classSchema->getProperty('propertyWithInjectAnnotation');
313  static::assertTrue($propertyDefinition['annotations']['inject']);
314  }
315 
319  public function ‪classSchemaDetectsTransientProperty()
320  {
321  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
322 
323  $propertyDefinition = $classSchema->getProperty('propertyWithTransientAnnotation');
324  static::assertTrue($propertyDefinition['annotations']['transient']);
325  }
326 
330  public function ‪classSchemaDetectsCascadeProperty()
331  {
332  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
333 
334  $propertyDefinition = $classSchema->getProperty('propertyWithCascadeAnnotation');
335  static::assertSame('remove', $propertyDefinition['annotations']['cascade']);
336  }
337 
341  public function ‪classSchemaDetectsCascadePropertyOnlyWithVarAnnotation()
342  {
343  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
344 
345  $propertyDefinition = $classSchema->getProperty('propertyWithCascadeAnnotationWithoutVarAnnotation');
346  static::assertNull($propertyDefinition['annotations']['cascade']);
347  }
348 
352  public function ‪classSchemaDetectsIgnoreValidationAnnotation()
353  {
354  $classSchema = new ‪ClassSchema(Fixture\DummyControllerWithIgnoreValidationDoctrineAnnotation::class);
355  static::assertTrue(isset($classSchema->getMethod('someAction')['tags']['ignorevalidation']));
356  static::assertTrue(in_array('foo', $classSchema->getMethod('someAction')['tags']['ignorevalidation'], true));
357  static::assertTrue(in_array('bar', $classSchema->getMethod('someAction')['tags']['ignorevalidation'], true));
358  static::assertFalse(in_array('baz', $classSchema->getMethod('someAction')['tags']['ignorevalidation'], true));
359  }
360 
364  public function ‪classSchemaDetectsTypeAndElementType()
365  {
366  $classSchema = new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class);
367 
368  $propertyDefinition = $classSchema->getProperty('propertyWithObjectStorageAnnotation');
369  static::assertSame(ObjectStorage::class, $propertyDefinition['type']);
370  static::assertSame(Fixture\DummyClassWithAllTypesOfProperties::class, $propertyDefinition['elementType']);
371  }
372 
376  public function ‪classSchemaDetectsSingletons()
377  {
378  static::assertTrue((new ‪ClassSchema(Fixture\DummySingleton::class))->isSingleton());
379  }
380 
384  public function ‪classSchemaDetectsModels()
385  {
386  static::assertTrue((new ‪ClassSchema(Fixture\DummyEntity::class))->isModel());
387  static::assertTrue((new ‪ClassSchema(Fixture\DummyValueObject::class))->isModel());
388  }
389 
393  public function ‪classSchemaDetectsEntities()
394  {
395  static::assertTrue((new ‪ClassSchema(Fixture\DummyEntity::class))->isEntity());
396  }
397 
401  public function ‪classSchemaDetectsValueObjects()
402  {
403  static::assertTrue((new ‪ClassSchema(Fixture\DummyValueObject::class))->isValueObject());
404  }
405 
409  public function ‪classSchemaDetectsClassName()
410  {
411  $this->resetSingletonInstances = true;
412  static::assertSame(Fixture\DummyModel::class, (new ‪ClassSchema(Fixture\DummyModel::class))->getClassName());
413  }
414 
418  public function ‪classSchemaDetectsNonStaticProperties()
419  {
420  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('publicProperty'));
421  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('protectedProperty'));
422  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('privateProperty'));
423  }
424 
428  public function ‪classSchemaDetectsStaticProperties()
429  {
430  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('publicStaticProperty'));
431  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('protectedStaticProperty'));
432  static::assertTrue((new ‪ClassSchema(Fixture\DummyClassWithAllTypesOfProperties::class))->hasProperty('privateStaticProperty'));
433  }
434 
438  public function ‪testClassSchemaGetTags()
439  {
440  $tags = (new ‪ClassSchema(Fixture\DummyClassWithTags::class))->getTags();
441  static::assertArrayHasKey('see', $tags);
442 
443  // test ignored tags
444  static::assertArrayNotHasKey('package', $tags);
445  static::assertArrayNotHasKey('subpackage', $tags);
446  static::assertArrayNotHasKey('license', $tags);
447  static::assertArrayNotHasKey('copyright', $tags);
448  static::assertArrayNotHasKey('author', $tags);
449  static::assertArrayNotHasKey('version', $tags);
450  }
451 
455  public function ‪classSchemaDetectsValidateAnnotationsModelProperties(): void
456  {
457  $this->resetSingletonInstances = true;
458  $classSchema = new ‪ClassSchema(Fixture\DummyModel::class);
459  static::assertSame(
460  [
461  [
462  'name' => 'StringLength',
463  'options' => [
464  'minimum' => 1,
465  'maximum' => 10,
466  ],
467  'className' => StringLengthValidator::class
468  ],
469  [
470  'name' => 'NotEmpty',
471  'options' => [],
472  'className' => NotEmptyValidator::class
473  ],
474  [
475  'name' => 'TYPO3.CMS.Extbase:NotEmpty',
476  'options' => [],
477  'className' => NotEmptyValidator::class
478  ],
479  [
480  'name' => 'TYPO3.CMS.Extbase.Tests.Unit.Reflection.Fixture:DummyValidator',
481  'options' => [],
482  'className' => Fixture\Validation\Validator\DummyValidator::class
483  ],
484  [
485  'name' => '\TYPO3\CMS\Extbase\Validation\Validator\NotEmptyValidator',
486  'options' => [],
487  'className' => NotEmptyValidator::class
488  ],
489  [
490  'name' => NotEmptyValidator::class,
491  'options' => [],
492  'className' => NotEmptyValidator::class
493  ]
494  ],
495  $classSchema->getProperty('propertyWithValidateAnnotations')['validators']
496  );
497  }
498 
502  public function ‪classSchemaDetectsValidateAnnotationsOfControllerActions(): void
503  {
504  $this->resetSingletonInstances = true;
505  $classSchema = new ‪ClassSchema(Fixture\DummyController::class);
506  static::assertSame(
507  [
508  [
509  'name' => 'StringLength',
510  'options' => [
511  'minimum' => 1,
512  'maximum' => 10,
513  ],
514  'className' => StringLengthValidator::class
515  ],
516  [
517  'name' => 'NotEmpty',
518  'options' => [],
519  'className' => NotEmptyValidator::class
520  ],
521  [
522  'name' => 'TYPO3.CMS.Extbase:NotEmpty',
523  'options' => [],
524  'className' => NotEmptyValidator::class
525  ],
526  [
527  'name' => 'TYPO3.CMS.Extbase.Tests.Unit.Reflection.Fixture:DummyValidator',
528  'options' => [],
529  'className' => Fixture\Validation\Validator\DummyValidator::class
530  ],
531  [
532  'name' => '\TYPO3\CMS\Extbase\Validation\Validator\NotEmptyValidator',
533  'options' => [],
534  'className' => NotEmptyValidator::class
535  ],
536  [
537  'name' => NotEmptyValidator::class,
538  'options' => [],
539  'className' => NotEmptyValidator::class
540  ]
541  ],
542  $classSchema->getMethod('methodWithValidateAnnotationsAction')['params']['fooParam']['validators']
543  );
544  }
545 
549  public function ‪classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForParamWithoutTypeHint()
550  {
551  $this->resetSingletonInstances = true;
552  $this->expectException(InvalidTypeHintException::class);
553  $this->expectExceptionMessage('Missing type information for parameter "$fooParam" in TYPO3\CMS\Extbase\Tests\Unit\Reflection\Fixture\DummyControllerWithValidateAnnotationWithoutParamTypeHint->methodWithValidateAnnotationsAction(): Either use an @param annotation or use a type hint.');
554  $this->expectExceptionCode(1515075192);
555 
556  new ‪ClassSchema(Fixture\DummyControllerWithValidateAnnotationWithoutParamTypeHint::class);
557  }
558 
562  public function ‪classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForMissingParam()
563  {
564  $this->resetSingletonInstances = true;
565  $this->expectException(InvalidValidationConfigurationException::class);
566  $this->expectExceptionMessage('Invalid validate annotation in TYPO3\CMS\Extbase\Tests\Unit\Reflection\Fixture\DummyControllerWithValidateAnnotationWithoutParam->methodWithValidateAnnotationsAction(): The following validators have been defined for missing param "$fooParam": NotEmpty, StringLength');
567  $this->expectExceptionCode(1515073585);
568 
569  new ‪ClassSchema(Fixture\DummyControllerWithValidateAnnotationWithoutParam::class);
570  }
571 }
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsTypeAndElementType
‪classSchemaDetectsTypeAndElementType()
Definition: ClassSchemaTest.php:364
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsIgnoreValidationAnnotation
‪classSchemaDetectsIgnoreValidationAnnotation()
Definition: ClassSchemaTest.php:352
‪TYPO3\CMS\Extbase\Annotation
Definition: IgnoreValidation.php:4
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsPropertiesWithLazyAnnotation
‪classSchemaDetectsPropertiesWithLazyAnnotation()
Definition: ClassSchemaTest.php:221
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsInjectProperties
‪classSchemaDetectsInjectProperties()
Definition: ClassSchemaTest.php:175
‪TYPO3\CMS\Extbase\Validation\Exception\InvalidValidationConfigurationException
Definition: InvalidValidationConfigurationException.php:21
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\testClassSchemaGetTags
‪testClassSchemaGetTags()
Definition: ClassSchemaTest.php:438
‪TYPO3
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsCascadePropertyOnlyWithVarAnnotation
‪classSchemaDetectsCascadePropertyOnlyWithVarAnnotation()
Definition: ClassSchemaTest.php:341
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsValueObjects
‪classSchemaDetectsValueObjects()
Definition: ClassSchemaTest.php:401
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaForModelIsSetAggregateRootIfRepositoryClassIsFoundForNamespacedClasses
‪classSchemaForModelIsSetAggregateRootIfRepositoryClassIsFoundForNamespacedClasses()
Definition: ClassSchemaTest.php:34
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsEntities
‪classSchemaDetectsEntities()
Definition: ClassSchemaTest.php:393
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsClassName
‪classSchemaDetectsClassName()
Definition: ClassSchemaTest.php:409
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsValidateAnnotationsOfControllerActions
‪classSchemaDetectsValidateAnnotationsOfControllerActions()
Definition: ClassSchemaTest.php:502
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsStaticProperties
‪classSchemaDetectsStaticProperties()
Definition: ClassSchemaTest.php:428
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaGetMethods
‪classSchemaGetMethods()
Definition: ClassSchemaTest.php:127
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsInjectProperty
‪classSchemaDetectsInjectProperty()
Definition: ClassSchemaTest.php:308
‪TYPO3\CMS\Extbase\Validation\Validator\StringLengthValidator
Definition: StringLengthValidator.php:21
‪TYPO3\CMS\Extbase\Persistence\ObjectStorage
Definition: ObjectStorage.php:26
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest
Definition: ClassSchemaTest.php:30
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForParamWithoutTypeHint
‪classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForParamWithoutTypeHint()
Definition: ClassSchemaTest.php:549
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsModels
‪classSchemaDetectsModels()
Definition: ClassSchemaTest.php:384
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsMandatoryParams
‪classSchemaDetectsMandatoryParams()
Definition: ClassSchemaTest.php:241
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsStaticMethods
‪classSchemaDetectsStaticMethods()
Definition: ClassSchemaTest.php:230
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsMethodVisibility
‪classSchemaDetectsMethodVisibility()
Definition: ClassSchemaTest.php:152
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsValidateAnnotationsModelProperties
‪classSchemaDetectsValidateAnnotationsModelProperties()
Definition: ClassSchemaTest.php:455
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaHasConstructor
‪classSchemaHasConstructor()
Definition: ClassSchemaTest.php:45
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsNonStaticProperties
‪classSchemaDetectsNonStaticProperties()
Definition: ClassSchemaTest.php:418
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsPropertyVisibility
‪classSchemaDetectsPropertyVisibility()
Definition: ClassSchemaTest.php:285
‪TYPO3\CMS\Extbase\Validation\Exception\InvalidTypeHintException
Definition: InvalidTypeHintException.php:21
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsNullableParams
‪classSchemaDetectsNullableParams()
Definition: ClassSchemaTest.php:252
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsSingletons
‪classSchemaDetectsSingletons()
Definition: ClassSchemaTest.php:376
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsCascadeProperty
‪classSchemaDetectsCascadeProperty()
Definition: ClassSchemaTest.php:330
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsParamTypeFromTypeHint
‪classSchemaDetectsParamTypeFromTypeHint()
Definition: ClassSchemaTest.php:274
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsInjectMethods
‪classSchemaDetectsInjectMethods()
Definition: ClassSchemaTest.php:197
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForMissingParam
‪classSchemaGenerationThrowsExceptionWithValidateDoctrineAnnotationsForMissingParam()
Definition: ClassSchemaTest.php:562
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsConstructorArgumentsWithDependencies
‪classSchemaDetectsConstructorArgumentsWithDependencies()
Definition: ClassSchemaTest.php:75
‪TYPO3\CMS\Extbase\Validation\Validator\NotEmptyValidator
Definition: NotEmptyValidator.php:21
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsConstructorArguments
‪classSchemaDetectsConstructorArguments()
Definition: ClassSchemaTest.php:54
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaGetProperties
‪classSchemaGetProperties()
Definition: ClassSchemaTest.php:88
‪TYPO3\CMS\Extbase\Reflection\ClassSchema
Definition: ClassSchema.php:41
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsDefaultValueParams
‪classSchemaDetectsDefaultValueParams()
Definition: ClassSchemaTest.php:263
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaDetectsTransientProperty
‪classSchemaDetectsTransientProperty()
Definition: ClassSchemaTest.php:319
‪TYPO3\CMS\Core\Utility\GeneralUtility
Definition: GeneralUtility.php:45
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection\ClassSchemaTest\classSchemaHasMethod
‪classSchemaHasMethod()
Definition: ClassSchemaTest.php:117
‪TYPO3\CMS\Extbase\Tests\Unit\Reflection
Definition: ClassSchemaTest.php:2