‪TYPO3CMS  ‪main
RelationTest.php
Go to the documentation of this file.
1 <?php
2 
3 declare(strict_types=1);
4 
5 /*
6  * This file is part of the TYPO3 CMS project.
7  *
8  * It is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU General Public License, either version 2
10  * of the License, or any later version.
11  *
12  * For the full copyright and license information, please read the
13  * LICENSE.txt file that was distributed with this source code.
14  *
15  * The TYPO3 project - inspiring people to share!
16  */
17 
19 
20 use PHPUnit\Framework\Attributes\DataProvider;
21 use PHPUnit\Framework\Attributes\Test;
31 use TYPO3\TestingFramework\Core\Functional\FunctionalTestCase;
39 
40 final class ‪RelationTest extends FunctionalTestCase
41 {
42  protected array ‪$testExtensionsToLoad = [
43  'typo3/sysext/extbase/Tests/Functional/Fixtures/Extensions/blog_example',
44  ];
45 
46  private ‪Blog ‪$blog;
48 
49  protected function ‪setUp(): void
50  {
51  parent::setUp();
52  $this->importCSVDataSet(__DIR__ . '/Fixtures/RelationTestImport.csv');
53  $request = (new ‪ServerRequest())->withAttribute('applicationType', ‪SystemEnvironmentBuilder::REQUESTTYPE_BE);
54  ‪$GLOBALS['TYPO3_REQUEST'] = $request;
55  $this->persistenceManager = $this->get(PersistenceManager::class);
56  $this->blog = $this->get(BlogRepository::class)->findByUid(1);
57  ‪$GLOBALS['BE_USER'] = new ‪BackendUserAuthentication();
58  ‪$GLOBALS['BE_USER']->workspace = 0;
59  }
60 
64  #[Test]
65  public function ‪attachPostToBlogAtTheEnd(): void
66  {
67  $newPostTitle = 'sdufhisdhuf';
68  $newPost = new ‪Post();
69  $newPost->setBlog($this->blog);
70  $newPost->setTitle($newPostTitle);
71  $newPost->setContent('Bla Bla Bla');
72  $this->blog->addPost($newPost);
73  $this->‪updateAndPersistBlog();
74  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultAttachPostToBlogAtTheEnd.csv');
75  }
76 
80  #[Test]
81  public function ‪removeLastPostFromBlog(): void
82  {
83  $posts = $this->blog->getPosts();
84  $postsArray = $posts->toArray();
85  $latestPost = array_pop($postsArray);
86  self::assertEquals(10, $latestPost->getUid());
87  $this->blog->removePost($latestPost);
88  $this->‪updateAndPersistBlog();
89  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultRemoveLastPostFromBlog.csv');
90  }
91 
95  #[Test]
96  public function ‪addPostToBlogInTheMiddle(): void
97  {
98  $newPost = new ‪Post();
99  $posts = clone $this->blog->getPosts();
100  $this->blog->getPosts()->removeAll($posts);
101  $counter = 1;
102  $newPostTitle = 'INSERTED POST at position 6';
103  foreach ($posts as $post) {
104  $this->blog->addPost($post);
105  if ($counter === 5) {
106  $newPost->setBlog($this->blog);
107  $newPost->setTitle($newPostTitle);
108  $newPost->setContent('Bla Bla Bla');
109  $this->blog->addPost($newPost);
110  }
111  $counter++;
112  }
113  $this->‪updateAndPersistBlog();
114  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultAddPostToBlogInTheMiddle.csv');
115  }
116 
120  #[Test]
121  public function ‪removeMiddlePostFromBlog(): void
122  {
123  $posts = clone $this->blog->getPosts();
124  $counter = 1;
125  foreach ($posts as $post) {
126  if ($counter === 5) {
127  $this->blog->removePost($post);
128  }
129  $counter++;
130  }
131  $this->‪updateAndPersistBlog();
132  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultRemoveMiddlePostFromBlog.csv');
133  }
134 
138  #[Test]
139  public function ‪movePostFromEndToTheMiddle(): void
140  {
141  $posts = clone $this->blog->getPosts();
142  $postsArray = $posts->toArray();
143  $latestPost = array_pop($postsArray);
144 
145  $this->blog->getPosts()->removeAll($posts);
146  $counter = 0;
147  $postCount = $posts->count();
148  foreach ($posts as $post) {
149  if ($counter !== ($postCount - 1)) {
150  $this->blog->addPost($post);
151  }
152  if ($counter === 4) {
153  $latestPost->setTitle('MOVED POST ' . $latestPost->getTitle());
154  $this->blog->addPost($latestPost);
155  }
156  $counter++;
157  }
158  $this->‪updateAndPersistBlog();
159  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultMovePostFromEndToTheMiddle.csv');
160  }
161 
165  #[Test]
166  public function ‪attachTagToPostAtTheEnd(): void
167  {
168  $newTagTitle = 'sdufhisdhuf';
169  $newTag = new ‪Tag($newTagTitle);
170  $postRepository = $this->get(PostRepository::class);
171  $post = $postRepository->findByUid(1);
172  $post->addTag($newTag);
173  $postRepository->update($post);
174  $this->persistenceManager->persistAll();
175  self::assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultAttachTagToPostAtTheEnd.csv');
176  }
177 
181  #[Test]
182  public function ‪removeLastTagFromPost(): void
183  {
184  $postRepository = $this->get(PostRepository::class);
185  $post = $postRepository->findByUid(1);
186  $tags = $post->getTags();
187  $tagsArray = $tags->toArray();
188  $latestTag = array_pop($tagsArray);
189 
190  self::assertEquals(10, $latestTag->getUid());
191 
192  $post->removeTag($latestTag);
193 
194  $postRepository->update($post);
195  $this->persistenceManager->persistAll();
196 
197  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultRemoveLastTagFromPost.csv');
198  }
199 
203  #[Test]
204  public function ‪addTagToPostInTheMiddle(): void
205  {
206  $postRepository = $this->get(PostRepository::class);
207  $post = $postRepository->findByUid(1);
208  $tags = clone $post->getTags();
210  $emptyTagStorage = new ‪ObjectStorage();
211  $post->setTags($emptyTagStorage);
212  $newTag = new ‪Tag('INSERTED TAG at position 6 : ');
213 
214  $counter = 1;
215  foreach ($tags as $tag) {
216  $post->addTag($tag);
217  if ($counter === 5) {
218  $post->addTag($newTag);
219  }
220  $counter++;
221  }
222 
223  $postRepository->update($post);
224  $this->persistenceManager->persistAll();
225  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultAddTagToPostInTheMiddle.csv');
226  }
227 
231  #[Test]
232  public function ‪removeMiddleTagFromPost(): void
233  {
234  $postRepository = $this->get(PostRepository::class);
235  $post = $postRepository->findByUid(1);
236  $tags = clone $post->getTags();
237  $counter = 1;
238  foreach ($tags as $tag) {
239  if ($counter === 5) {
240  $post->removeTag($tag);
241  }
242  $counter++;
243  }
244 
245  $postRepository->update($post);
246  $this->persistenceManager->persistAll();
247  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultRemoveMiddleTagFromPost.csv');
248  }
249 
253  #[Test]
254  public function ‪moveTagFromEndToTheMiddle(): void
255  {
256  $postRepository = $this->get(PostRepository::class);
257  $post = $postRepository->findByUid(1);
258  $tags = clone $post->getTags();
259  $tagsArray = $tags->toArray();
260  $latestTag = array_pop($tagsArray);
261  $post->removeTag($latestTag);
263  $emptyTagStorage = new ‪ObjectStorage();
264  $post->setTags($emptyTagStorage);
265 
266  $counter = 1;
267  $tagCount = $tags->count();
268  foreach ($tags as $tag) {
269  if ($counter !== $tagCount) {
270  $post->addTag($tag);
271  }
272  if ($counter === 5) {
273  $post->addTag($latestTag);
274  }
275  $counter++;
276  }
277  $post->addTag($latestTag);
278 
279  $postRepository->update($post);
280  $this->persistenceManager->persistAll();
281  $this->assertCSVDataSet(__DIR__ . '/Fixtures/RelationTestResultMoveTagFromEndToTheMiddle.csv');
282  }
283 
284  #[Test]
286  {
287  $queryBuilder = (new ‪ConnectionPool())->getQueryBuilderForTable('sys_category_record_mm');
288  $queryBuilder->getRestrictions()
289  ->removeAll();
290  $countCategories = $queryBuilder
291  ->count('*')
292  ->from('sys_category_record_mm')
293  ->where(
294  $queryBuilder->expr()->and(
295  $queryBuilder->expr()->eq('uid_foreign', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
296  $queryBuilder->expr()->eq(
297  'tablenames',
298  $queryBuilder->createNamedParameter('tx_blogexample_domain_model_post')
299  ),
300  $queryBuilder->expr()->eq(
301  'fieldname',
302  $queryBuilder->createNamedParameter('categories')
303  )
304  )
305  )
306  ->executeQuery()
307  ->fetchOne();
308  self::assertEquals(4, $countCategories);
309 
310  $postRepository = $this->get(PostRepository::class);
311  $post = $postRepository->findByUid(1);
312  self::assertCount(3, $post->getCategories());
313  }
314 
318  #[Test]
320  {
321  $postRepository = $this->get(PostRepository::class);
322  $posts = $postRepository->findByCategory(1);
323  self::assertCount(2, $posts);
324 
325  $posts = $postRepository->findByCategory(4);
326  self::assertCount(0, $posts);
327  }
328 
329  #[Test]
331  {
332  $queryBuilder = (new ‪ConnectionPool())->getQueryBuilderForTable('sys_category_record_mm');
333  $queryBuilder->getRestrictions()
334  ->removeAll();
335  $countCategories = $queryBuilder
336  ->count('*')
337  ->from('sys_category_record_mm')
338  ->where(
339  $queryBuilder->expr()->and(
340  $queryBuilder->expr()->eq('uid_foreign', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
341  $queryBuilder->expr()->eq(
342  'tablenames',
343  $queryBuilder->createNamedParameter('tx_blogexample_domain_model_post')
344  ),
345  $queryBuilder->expr()->eq(
346  'fieldname',
347  $queryBuilder->createNamedParameter('categories')
348  )
349  )
350  )
351  ->executeQuery()
352  ->fetchOne();
353  self::assertEquals(4, $countCategories);
354 
355  $postRepository = $this->get(PostRepository::class);
356  $post = $postRepository->findByUid(1);
357 
358  $newCategory = new ‪Category();
359  $newCategory->setTitle('New Category');
360 
361  $post->addCategory($newCategory);
362 
363  $postRepository->update($post);
364  $this->persistenceManager->persistAll();
365 
366  $queryBuilder = (new ‪ConnectionPool())->getQueryBuilderForTable('sys_category_record_mm');
367  $queryBuilder->getRestrictions()
368  ->removeAll();
369  $countCategories = $queryBuilder
370  ->count('*')
371  ->from('sys_category_record_mm')
372  ->where(
373  $queryBuilder->expr()->and(
374  $queryBuilder->expr()->eq('uid_foreign', $queryBuilder->createNamedParameter(1, ‪Connection::PARAM_INT)),
375  $queryBuilder->expr()->eq(
376  'tablenames',
377  $queryBuilder->createNamedParameter('tx_blogexample_domain_model_post')
378  ),
379  $queryBuilder->expr()->eq(
380  'fieldname',
381  $queryBuilder->createNamedParameter('categories')
382  )
383  )
384  )
385  ->executeQuery()
386  ->fetchOne();
387  self::assertEquals(5, $countCategories);
388  }
389 
393  #[Test]
395  {
396  $postRepository = $this->get(PostRepository::class);
397  $post = $postRepository->findByUid(1);
398  // Move category down
399  foreach ($post->getCategories() as $category) {
400  $post->removeCategory($category);
401  $post->addCategory($category);
402  break;
403  }
404  $postRepository->update($post);
405  $this->persistenceManager->persistAll();
406 
407  // re-fetch Post and Blog
408  $queryBuilder = (new ‪ConnectionPool())->getQueryBuilderForTable('sys_category_record_mm');
409  $queryBuilder->getRestrictions()
410  ->removeAll();
411  $newBlogCategoryCount = $queryBuilder
412  ->count('*')
413  ->from('sys_category_record_mm')
414  ->where(
415  $queryBuilder->expr()->and(
416  $queryBuilder->expr()->eq(
417  'uid_foreign',
418  $queryBuilder->createNamedParameter($this->blog->getUid(), ‪Connection::PARAM_INT)
419  ),
420  $queryBuilder->expr()->eq(
421  'tablenames',
422  $queryBuilder->createNamedParameter('tx_blogexample_domain_model_post')
423  ),
424  $queryBuilder->expr()->eq(
425  'fieldname',
426  $queryBuilder->createNamedParameter('categories')
427  )
428  )
429  )
430  ->executeQuery()
431  ->fetchOne();
432 
433  // one category is hidden, so the expected count has to be one less
434  $newBlogCategoryCount--;
435 
436  self::assertEquals($this->blog->getCategories()->count(), $newBlogCategoryCount);
437  }
438 
439  public static function ‪distinctDataProvider(): array
440  {
441  return [
442  'order default' => [
443  [],
444  ],
445  'order default, offset 0' => [
446  [
447  'offset' => 0,
448  ],
449  ],
450  'order default, limit 100' => [
451  [
452  'limit' => 100,
453  ],
454  ],
455  'order default, offset 0, limit 100' => [
456  [
457  'offset' => 0,
458  'limit' => 100,
459  ],
460  ],
461  'order false' => [
462  [
463  'order' => false,
464  ],
465  ],
466  'order false, offset 0' => [
467  [
468  'order' => false,
469  'offset' => 0,
470  ],
471  ],
472  'order false, limit 100' => [
473  [
474  'order' => false, 'limit' => 100,
475  ],
476  ],
477  'order false, offset 0, limit 100' => [
478  [
479  'order' => false,
480  'offset' => 0,
481  'limit' => 100,
482  ],
483  ],
484  'order uid, offset 0' => [
485  [
486  'order' => ['uid' => ‪QueryInterface::ORDER_ASCENDING],
487  'offset' => 0,
488  ],
489  ],
490  'order uid, limit 100' => [
491  [
492  'order' => ['uid' => ‪QueryInterface::ORDER_ASCENDING],
493  'limit' => 100,
494  ],
495  ],
496  'order uid, offset 0, limit 100' => [
497  [
498  'order' => ['uid' => ‪QueryInterface::ORDER_ASCENDING],
499  'offset' => 0,
500  'limit' => 100,
501  ],
502  ],
503  ];
504  }
505 
506  private function ‪applyQueryRequest(‪QueryInterface $query, array $queryRequest): void
507  {
508  if (isset($queryRequest['order']) && !$queryRequest['order']) {
509  $query->‪setOrderings([]);
510  } elseif (!empty($queryRequest['order'])) {
511  $query->‪setOrderings($queryRequest['order']);
512  }
513  if (isset($queryRequest['offset'])) {
514  $query->‪setOffset($queryRequest['offset']);
515  }
516  if (isset($queryRequest['limit'])) {
517  $query->‪setLimit($queryRequest['limit']);
518  }
519  }
520 
524  #[DataProvider('distinctDataProvider')]
525  #[Test]
526  public function ‪distinctPersonEntitiesAreFoundByPublisher(array $queryRequest): void
527  {
528  $query = $this->‪provideFindPostsByPublisherQuery(1);
529  $this->‪applyQueryRequest($query, $queryRequest);
530  $posts = $query->execute();
531  $postCount = $posts->count();
532 
533  $postIds = $this->‪resolveEntityIds($posts->toArray());
534 
535  self::assertEquals($this->‪countDistinctIds($postIds), $postCount);
536  $this->‪assertDistinctIds($postIds);
537  }
538 
542  #[DataProvider('distinctDataProvider')]
543  #[Test]
544  public function ‪distinctPersonRecordsAreFoundByPublisher(array $queryRequest): void
545  {
546  $query = $this->‪provideFindPostsByPublisherQuery(1);
547  $this->‪applyQueryRequest($query, $queryRequest);
548  $postRecords = $query->execute(true);
549  $postIds = $this->‪resolveRecordIds($postRecords);
550 
551  $this->‪assertDistinctIds($postIds);
552  }
553 
554  private function ‪provideFindPostsByPublisherQuery(int $publisherId): ‪QueryInterface
555  {
556  $postRepository = $this->get(PostRepository::class);
557  $query = $postRepository->createQuery();
558  $query->‪matching(
559  $query->logicalOr(
560  $query->equals('author.uid', $publisherId),
561  $query->equals('reviewer.uid', $publisherId),
562  )
563  );
564  return $query;
565  }
566 
570  #[DataProvider('distinctDataProvider')]
571  #[Test]
572  public function ‪distinctBlogEntitiesAreFoundByPostsSince(array $queryRequest): void
573  {
574  $query = $this->‪provideFindBlogsByPostsSinceQuery(
575  new \DateTime('2017-08-01')
576  );
577  $this->‪applyQueryRequest($query, $queryRequest);
578  $blogs = $query->execute();
579  $blogCount = $blogs->count();
580 
581  $blogIds = $this->‪resolveEntityIds($blogs->toArray());
582 
583  self::assertEquals($this->‪countDistinctIds($blogIds), $blogCount);
584  $this->‪assertDistinctIds($blogIds);
585  }
586 
590  #[DataProvider('distinctDataProvider')]
591  #[Test]
592  public function ‪distinctBlogRecordsAreFoundByPostsSince(array $queryRequest): void
593  {
594  $query = $this->‪provideFindBlogsByPostsSinceQuery(
595  new \DateTime('2017-08-01')
596  );
597  $this->‪applyQueryRequest($query, $queryRequest);
598  $blogRecords = $query->execute(true);
599  $blogIds = $this->‪resolveRecordIds($blogRecords);
600 
601  $this->‪assertDistinctIds($blogIds);
602  }
603 
604  private function ‪provideFindBlogsByPostsSinceQuery(\DateTime $date): ‪QueryInterface
605  {
606  $blogRepository = $this->get(BlogRepository::class);
607  $query = $blogRepository->createQuery();
608  $query->‪matching(
609  $query->greaterThanOrEqual('posts.date', $date)
610  );
611  return $query;
612  }
613 
617  #[DataProvider('distinctDataProvider')]
618  #[Test]
619  public function ‪distinctPersonEntitiesAreFoundByTagNameAreFiltered(array $queryRequest): void
620  {
621  $query = $this->‪provideFindPersonsByTagNameQuery('SharedTag');
622  $this->‪applyQueryRequest($query, $queryRequest);
623  $persons = $query->execute();
624  $personCount = $persons->count();
625 
626  $personIds = $this->‪resolveEntityIds($persons->toArray());
627 
628  self::assertEquals($this->‪countDistinctIds($personIds), $personCount);
629  $this->‪assertDistinctIds($personIds);
630  }
631 
635  #[DataProvider('distinctDataProvider')]
636  #[Test]
637  public function ‪distinctPersonRecordsAreFoundByTagNameAreFiltered(array $queryRequest): void
638  {
639  $query = $this->‪provideFindPersonsByTagNameQuery('SharedTag');
640  $this->‪applyQueryRequest($query, $queryRequest);
641  $personRecords = $query->execute(true);
642  $personIds = $this->‪resolveRecordIds($personRecords);
643 
644  $this->‪assertDistinctIds($personIds);
645  }
646 
647  private function ‪provideFindPersonsByTagNameQuery(string $tagName): ‪QueryInterface
648  {
649  $personRepository = $this->get(PersonRepository::class);
650  $query = $personRepository->createQuery();
651  $query->‪matching(
652  $query->logicalOr(
653  $query->equals('tags.name', $tagName),
654  $query->equals('tagsSpecial.name', $tagName),
655  )
656  );
657  return $query;
658  }
659 
663  #[DataProvider('distinctDataProvider')]
664  #[Test]
665  public function ‪distinctPostEntitiesAreFoundByAuthorTagNameAreFiltered(array $queryRequest): void
666  {
667  $query = $this->‪provideFindPostsByAuthorTagName('SharedTag');
668  $this->‪applyQueryRequest($query, $queryRequest);
669  $posts = $query->execute();
670  $postCount = $posts->count();
671 
672  $postsIds = $this->‪resolveEntityIds($posts->toArray());
673 
674  self::assertEquals($this->‪countDistinctIds($postsIds), $postCount);
675  $this->‪assertDistinctIds($postsIds);
676  }
677 
681  #[DataProvider('distinctDataProvider')]
682  #[Test]
683  public function ‪distinctPostRecordsAreFoundByAuthorTagNameAreFiltered(array $queryRequest): void
684  {
685  $query = $this->‪provideFindPostsByAuthorTagName('SharedTag');
686  $this->‪applyQueryRequest($query, $queryRequest);
687  $postRecords = $query->execute(true);
688  $postsIds = $this->‪resolveRecordIds($postRecords);
689 
690  $this->‪assertDistinctIds($postsIds);
691  }
692 
693  private function ‪provideFindPostsByAuthorTagName(string $tagName): ‪QueryInterface
694  {
695  $postRepository = $this->get(PostRepository::class);
696  $query = $postRepository->createQuery();
697  $query->‪matching(
698  $query->logicalOr(
699  $query->equals('author.tags.name', $tagName),
700  $query->equals('author.tagsSpecial.name', $tagName),
701  )
702  );
703  return $query;
704  }
705 
709  private function ‪updateAndPersistBlog(): void
710  {
711  $blogRepository = $this->get(BlogRepository::class);
712  $blogRepository->update($this->blog);
713  $this->persistenceManager->persistAll();
714  }
715 
720  private function ‪resolveEntityIds(array $entities): array
721  {
722  return array_map(
723  static fn(‪AbstractEntity $entity): int => $entity->‪getUid(),
724  $entities
725  );
726  }
727 
731  private function ‪resolveRecordIds(array $records): array
732  {
733  return array_column($records, 'uid');
734  }
735 
739  private function ‪countDistinctIds(array $ids): int
740  {
741  return count(array_unique($ids));
742  }
743 
748  private function ‪assertDistinctIds(array $ids): void
749  {
750  $counts = array_count_values($ids);
751  self::assertEquals(count($counts), array_sum($counts));
752  }
753 }
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\attachTagToPostAtTheEnd
‪attachTagToPostAtTheEnd()
Definition: RelationTest.php:166
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPersonRecordsAreFoundByTagNameAreFiltered
‪distinctPersonRecordsAreFoundByTagNameAreFiltered(array $queryRequest)
Definition: RelationTest.php:637
‪TYPO3Tests\BlogExample\Domain\Model\Tag
Definition: Tag.php:26
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\moveTagFromEndToTheMiddle
‪moveTagFromEndToTheMiddle()
Definition: RelationTest.php:254
‪TYPO3\CMS\Core\Database\Connection\PARAM_INT
‪const PARAM_INT
Definition: Connection.php:52
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\mmRelationWithMatchFieldIsResolvedFromForeignSide
‪mmRelationWithMatchFieldIsResolvedFromForeignSide()
Definition: RelationTest.php:319
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\updateAndPersistBlog
‪updateAndPersistBlog()
Definition: RelationTest.php:709
‪TYPO3Tests\BlogExample\Domain\Model\Category
Definition: Category.php:28
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\removeMiddleTagFromPost
‪removeMiddleTagFromPost()
Definition: RelationTest.php:232
‪TYPO3Tests\BlogExample\Domain\Repository\PersonRepository
Definition: PersonRepository.php:29
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\$blog
‪Blog $blog
Definition: RelationTest.php:46
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\removeLastPostFromBlog
‪removeLastPostFromBlog()
Definition: RelationTest.php:81
‪TYPO3\CMS\Extbase\Persistence\QueryInterface
Definition: QueryInterface.php:30
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\resolveRecordIds
‪int[] resolveRecordIds(array $records)
Definition: RelationTest.php:731
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\applyQueryRequest
‪applyQueryRequest(QueryInterface $query, array $queryRequest)
Definition: RelationTest.php:506
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\removeMiddlePostFromBlog
‪removeMiddlePostFromBlog()
Definition: RelationTest.php:121
‪TYPO3\CMS\Core\Core\SystemEnvironmentBuilder
Definition: SystemEnvironmentBuilder.php:41
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctDataProvider
‪static distinctDataProvider()
Definition: RelationTest.php:439
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\movePostFromEndToTheMiddle
‪movePostFromEndToTheMiddle()
Definition: RelationTest.php:139
‪TYPO3\CMS\Extbase\Persistence\QueryInterface\setOrderings
‪TYPO3 CMS Extbase Persistence QueryInterface setOrderings(array $orderings)
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPersonEntitiesAreFoundByPublisher
‪distinctPersonEntitiesAreFoundByPublisher(array $queryRequest)
Definition: RelationTest.php:526
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest
Definition: RelationTest.php:41
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\mmRelationWithMatchFieldIsResolvedFromLocalSide
‪mmRelationWithMatchFieldIsResolvedFromLocalSide()
Definition: RelationTest.php:285
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\removeLastTagFromPost
‪removeLastTagFromPost()
Definition: RelationTest.php:182
‪TYPO3\CMS\Core\Core\SystemEnvironmentBuilder\REQUESTTYPE_BE
‪const REQUESTTYPE_BE
Definition: SystemEnvironmentBuilder.php:45
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\$testExtensionsToLoad
‪array $testExtensionsToLoad
Definition: RelationTest.php:42
‪TYPO3\CMS\Extbase\DomainObject\AbstractEntity
Definition: AbstractEntity.php:22
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\resolveEntityIds
‪int[] resolveEntityIds(array $entities)
Definition: RelationTest.php:720
‪TYPO3\CMS\Extbase\Persistence\ObjectStorage
Definition: ObjectStorage.php:34
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPostEntitiesAreFoundByAuthorTagNameAreFiltered
‪distinctPostEntitiesAreFoundByAuthorTagNameAreFiltered(array $queryRequest)
Definition: RelationTest.php:665
‪TYPO3\CMS\Extbase\Persistence\QueryInterface\setOffset
‪TYPO3 CMS Extbase Persistence QueryInterface setOffset($offset)
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctBlogEntitiesAreFoundByPostsSince
‪distinctBlogEntitiesAreFoundByPostsSince(array $queryRequest)
Definition: RelationTest.php:572
‪TYPO3\CMS\Extbase\Persistence\QueryInterface\ORDER_ASCENDING
‪const ORDER_ASCENDING
Definition: QueryInterface.php:99
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPersonRecordsAreFoundByPublisher
‪distinctPersonRecordsAreFoundByPublisher(array $queryRequest)
Definition: RelationTest.php:544
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\provideFindPersonsByTagNameQuery
‪provideFindPersonsByTagNameQuery(string $tagName)
Definition: RelationTest.php:647
‪TYPO3\CMS\Extbase\Persistence\Generic\PersistenceManager
Definition: PersistenceManager.php:30
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\provideFindPostsByAuthorTagName
‪provideFindPostsByAuthorTagName(string $tagName)
Definition: RelationTest.php:693
‪TYPO3\CMS\Extbase\Persistence\QueryInterface\matching
‪TYPO3 CMS Extbase Persistence QueryInterface matching($constraint)
‪TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface\getUid
‪getUid()
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPersonEntitiesAreFoundByTagNameAreFiltered
‪distinctPersonEntitiesAreFoundByTagNameAreFiltered(array $queryRequest)
Definition: RelationTest.php:619
‪TYPO3Tests\BlogExample\Domain\Model\Post
Definition: Post.php:28
‪TYPO3\CMS\Core\Http\ServerRequest
Definition: ServerRequest.php:39
‪TYPO3\CMS\Core\Authentication\BackendUserAuthentication
Definition: BackendUserAuthentication.php:62
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\addTagToPostInTheMiddle
‪addTagToPostInTheMiddle()
Definition: RelationTest.php:204
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence
Definition: AddTest.php:18
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\adjustingMmRelationWithTablesnameAndFieldnameFieldDoNotTouchOtherRelations
‪adjustingMmRelationWithTablesnameAndFieldnameFieldDoNotTouchOtherRelations()
Definition: RelationTest.php:394
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\countDistinctIds
‪countDistinctIds(array $ids)
Definition: RelationTest.php:739
‪TYPO3\CMS\Core\Database\Connection
Definition: Connection.php:41
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctBlogRecordsAreFoundByPostsSince
‪distinctBlogRecordsAreFoundByPostsSince(array $queryRequest)
Definition: RelationTest.php:592
‪TYPO3\CMS\Extbase\Persistence\QueryInterface\setLimit
‪TYPO3 CMS Extbase Persistence QueryInterface setLimit($limit)
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\assertDistinctIds
‪assertDistinctIds(array $ids)
Definition: RelationTest.php:748
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\addPostToBlogInTheMiddle
‪addPostToBlogInTheMiddle()
Definition: RelationTest.php:96
‪TYPO3Tests\BlogExample\Domain\Model\Blog
Definition: Blog.php:30
‪$GLOBALS
‪$GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['adminpanel']['modules']
Definition: ext_localconf.php:25
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\provideFindPostsByPublisherQuery
‪provideFindPostsByPublisherQuery(int $publisherId)
Definition: RelationTest.php:554
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\$persistenceManager
‪PersistenceManager $persistenceManager
Definition: RelationTest.php:47
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\setUp
‪setUp()
Definition: RelationTest.php:49
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\attachPostToBlogAtTheEnd
‪attachPostToBlogAtTheEnd()
Definition: RelationTest.php:65
‪TYPO3Tests\BlogExample\Domain\Repository\BlogRepository
Definition: BlogRepository.php:29
‪TYPO3\CMS\Core\Database\ConnectionPool
Definition: ConnectionPool.php:46
‪TYPO3Tests\BlogExample\Domain\Repository\PostRepository
Definition: PostRepository.php:32
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\mmRelationWithMatchFieldIsCreatedFromLocalSide
‪mmRelationWithMatchFieldIsCreatedFromLocalSide()
Definition: RelationTest.php:330
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\distinctPostRecordsAreFoundByAuthorTagNameAreFiltered
‪distinctPostRecordsAreFoundByAuthorTagNameAreFiltered(array $queryRequest)
Definition: RelationTest.php:683
‪TYPO3\CMS\Extbase\Tests\Functional\Persistence\RelationTest\provideFindBlogsByPostsSinceQuery
‪provideFindBlogsByPostsSinceQuery(\DateTime $date)
Definition: RelationTest.php:604