pastebin

Paste Search Dynamic
Recent pastes
relationships manyHasMany
  1. <?php declare(strict_types = 1);
  2.  
  3. /**
  4.  * @testCase
  5.  * @dataProvider ../../../sections.ini
  6.  */
  7.  
  8. namespace NextrasTestsOrmIntegrationRelationships;
  9.  
  10. use NextrasOrmRelationshipsManyHasMany;
  11. use NextrasTestsOrmBook;
  12. use NextrasTestsOrmDataTestCase;
  13. use NextrasTestsOrmTag;
  14. use TesterAssert;
  15.  
  16.  
  17. $dic = require_once __DIR__ . '/../../../bootstrap.php';
  18.  
  19.  
  20. class RelationshipsManyHasManyCollectionTest extends DataTestCase
  21. {
  22.         /** @var Book */
  23.         private $book;
  24.  
  25.         /** @var ManyHasMany|Tag[] */
  26.         private $tags;
  27.  
  28.  
  29.         protected function setUp()
  30.         {
  31.                 parent::setUp();
  32.  
  33.                 $this->orm->clear();
  34.                 $this->book = $this->orm->books->getById(1);
  35.                 $this->tags = $this->book->tags;
  36.         }
  37.  
  38.  
  39.         public function testAddA()
  40.         {
  41.                 $queries = $this->getQueries(function () {
  42.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  43.  
  44.                         $this->tags->add($this->createTag());
  45.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  46.  
  47.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT JOIN
  48.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  49.                         assert::count(3, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  50.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  51.  
  52.                         $this->orm->flush(); // COMMIT
  53.                         assert::count(3, iterator_to_array($this->tags));
  54.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  55.                 });
  56.  
  57.                 if ($queries) {
  58.                         assert::count(6, $queries);
  59.                 }
  60.         }
  61.  
  62.  
  63.         public function testAddB()
  64.         {
  65.                 $queries = $this->getQueries(function () {
  66.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  67.  
  68.                         $this->tags->add($this->createTag());
  69.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  70.                         assert::count(3, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  71.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  72.  
  73.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT JOIN
  74.                         assert::count(3, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  75.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  76.  
  77.                         $this->orm->flush(); // COMMIT
  78.                         assert::count(3, iterator_to_array($this->tags));
  79.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  80.                 });
  81.  
  82.                 if ($queries) {
  83.                         assert::count(8, $queries);
  84.                 }
  85.         }
  86.  
  87.  
  88.         public function testAddC()
  89.         {
  90.                 $queries = $this->getQueries(function () {
  91.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  92.                         assert::count(2, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  93.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  94.  
  95.                         $this->tags->add($this->createTag());
  96.                         assert::count(3, iterator_to_array($this->tags));
  97.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  98.  
  99.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT JOIN
  100.                         assert::count(3, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  101.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  102.  
  103.                         $this->orm->flush(); // COMMIT
  104.                         assert::count(3, iterator_to_array($this->tags));
  105.                 });
  106.  
  107.                 if ($queries) {
  108.                         assert::count(8, $queries);
  109.                 }
  110.         }
  111.  
  112.  
  113.         public function testAddD()
  114.         {
  115.                 $queries = $this->getQueries(function () {
  116.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  117.  
  118.                         $this->tags->add($this->createTag());
  119.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  120.  
  121.                         $this->orm->persist($this->book); // BEGIN + INSERT JOIN + INSERT TAG
  122.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  123.                         assert::count(3, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  124.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  125.  
  126.                         $this->tags->add($this->createTag());
  127.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  128.  
  129.                         $this->orm->persist($this->book); // INSERT JOIN + INSERT TAG
  130.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  131.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  132.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  133.  
  134.                         $this->orm->flush(); // COMMIT
  135.                         assert::count(4, iterator_to_array($this->tags));
  136.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  137.                 });
  138.  
  139.                 if ($queries) {
  140.                         assert::count(10, $queries);
  141.                 }
  142.         }
  143.  
  144.  
  145.         public function testAddE()
  146.         {
  147.                 $queries = $this->getQueries(function () {
  148.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  149.  
  150.                         $this->tags->add($this->createTag());
  151.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  152.  
  153.                         $this->orm->persist($this->book); // BEGIN + INSERT JOIN + INSERT TAG
  154.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  155.  
  156.                         $this->tags->add($this->createTag());
  157.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  158.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  159.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  160.  
  161.                         $this->orm->persist($this->book); // INSERT TAG + INSERT JOIN
  162.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  163.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  164.  
  165.                         $this->orm->flush(); // COMMIT
  166.                         assert::count(4, iterator_to_array($this->tags));
  167.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  168.                 });
  169.  
  170.                 if ($queries) {
  171.                         assert::count(10, $queries);
  172.                 }
  173.         }
  174.  
  175.  
  176.         public function testAddF()
  177.         {
  178.                 $queries = $this->getQueries(function () {
  179.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  180.  
  181.                         $this->tags->add($this->createTag());
  182.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  183.  
  184.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT JOIN
  185.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  186.  
  187.                         $this->tags->add($this->createTag());
  188.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  189.  
  190.                         $this->orm->persist($this->book); // INSERT TAG + INSERT JOIN
  191.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  192.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  193.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  194.  
  195.                         $this->orm->flush(); // COMMIT
  196.                         assert::count(4, iterator_to_array($this->tags));
  197.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  198.                 });
  199.  
  200.                 if ($queries) {
  201.                         assert::count(8, $queries);
  202.                 }
  203.         }
  204.  
  205.  
  206.         public function testAddH()
  207.         {
  208.                 $queries = $this->getQueries(function () {
  209.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  210.                         assert::count(2, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  211.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  212.  
  213.                         $this->tags->add($this->createTag()); // intentionally no checks after first add()
  214.                         $this->tags->add($this->createTag());
  215.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  216.  
  217.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT TAG + INSERT JOIN
  218.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  219.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  220.  
  221.                         $this->orm->flush(); // COMMIT
  222.                         assert::count(4, iterator_to_array($this->tags));
  223.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  224.                 });
  225.  
  226.                 if ($queries) {
  227.                         assert::count(9, $queries);
  228.                 }
  229.         }
  230.  
  231.  
  232.         public function testAddI()
  233.         {
  234.                 $queries = $this->getQueries(function () {
  235.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  236.                         assert::count(2, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  237.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  238.  
  239.                         // intentionally no checks after first add()
  240.                         $this->tags->add($this->createTag());
  241.                         // intentionally no checks after first persist()
  242.                         $this->orm->persist($this->book); // BEGIN + INSERT TAG + INSERT JOIN
  243.                         $this->tags->add($this->createTag());
  244.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  245.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  246.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  247.  
  248.                         $this->orm->persist($this->book); // INSERT TAG + INSERT JOIN
  249.                         assert::count(4, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  250.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  251.  
  252.                         $this->orm->flush(); // COMMIT
  253.                         assert::count(4, iterator_to_array($this->tags));
  254.                         assert::count(4, $this->tags->getEntitiesForPersistence());
  255.                 });
  256.  
  257.                 if ($queries) {
  258.                         assert::count(12, $queries);
  259.                 }
  260.         }
  261.  
  262.  
  263.         public function testFetchExistingA()
  264.         {
  265.                 $queries = $this->getQueries(function () {
  266.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  267.  
  268.                         $tagA = $this->getExistingTag(1); // SELECT TAG + SELECT JOIN + SELECT BOOK
  269.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  270.                         assert::count(2, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  271.                         assert::count(2, iterator_to_array($this->tags));
  272.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  273.  
  274.                         $tagB = $this->getExistingTag(2); // SELECT JOIN + SELECT BOOKS
  275.                         assert::count(2, iterator_to_array($this->tags)); // SELECT JOIN + SELECT TAG
  276.                         assert::count(2, $this->tags->getEntitiesForPersistence());
  277.                 });
  278.  
  279.                 if ($queries) {
  280.                         assert::count(9, $queries);
  281.                 }
  282.         }
  283.  
  284.  
  285.         public function testFetchDerivedCollectionA()
  286.         {
  287.                 $queries = $this->getQueries(function () {
  288.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  289.  
  290.                         $this->tags->add($this->createTag());
  291.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  292.  
  293.                         $this->tags->get()->fetchAll(); // SELECT JOIN + SELECT TAG
  294.                         assert::count(3, $this->tags->getEntitiesForPersistence());
  295.                 });
  296.  
  297.                 if ($queries) {
  298.                         assert::count(2, $queries);
  299.                 }
  300.         }
  301.  
  302.  
  303.         public function testFetchDerivedCollectionB()
  304.         {
  305.                 $queries = $this->getQueries(function () {
  306.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  307.  
  308.                         $this->tags->get()->orderBy('id')->limitBy(1)->fetchAll(); // SELECT JOIN + SELECT TAG
  309.                         // one book from releationship
  310.                         assert::count(1, $this->tags->getEntitiesForPersistence());
  311.                 });
  312.  
  313.                 if ($queries) {
  314.                         assert::count(2, $queries);
  315.                 }
  316.         }
  317.  
  318.  
  319.         public function testRemoveA()
  320.         {
  321.                 $queries = $this->getQueries(function () {
  322.                         assert::count(0, $this->tags->getEntitiesForPersistence());
  323.  
  324.                         $tag2 = $this->orm->tags->getById(2); // SELECT
  325.  
  326.                         // 5 SELECTS: all relationships (tag_followers, books_x_tags, tags (???), authors)
  327.                         // TRANSATION BEGIN
  328.                         // 4 DELETES: 2 books_x_tags, tag_follower, tag
  329.                         $this->orm->tags->remove($tag2);
  330.                         assert::false($this->tags->isModified());
  331.                 });
  332.  
  333.                 if ($queries) {
  334.                         assert::count(11, $queries);
  335.                 }
  336.         }
  337.  
  338.  
  339.         public function testRemoveB()
  340.         {
  341.                 $queries = $this->getQueries(function () {
  342.                         $book2 = $this->orm->books->getById(2); // SELECT
  343.                         $book3 = $this->orm->books->getById(3); // SELECT
  344.  
  345.                         $tag = $this->orm->tags->getById(1); // SELECT
  346.                         assert::count(0, $tag->books->getEntitiesForPersistence());
  347.                         $tag->books->set([$book2, $book3]); // SELECT JOIN + SELECT BOOK
  348.                         assert::count(3, $tag->books->getEntitiesForPersistence());
  349.                 });
  350.  
  351.                 if ($queries) {
  352.                         assert::count(5, $queries);
  353.                 }
  354.         }
  355.  
  356.  
  357.         private function createTag()
  358.         {
  359.                 static $id = 0;
  360.  
  361.                 $tag = new Tag();
  362.                 $tag->name = 'New Tag #' . (++$id);
  363.                 return $tag;
  364.         }
  365.  
  366.  
  367.         private function getExistingTag($id)
  368.         {
  369.                 $tag = $this->orm->tags->getById($id);
  370.                 assert::type(Tag::class, $tag);
  371.                 foreach ($tag->books as $book) {
  372.                         if ($this->book === $book) {
  373.                                 return $tag;
  374.                         }
  375.                 }
  376.  
  377.                 assert::fail('At least one bug has to had a tag=1.');
  378.         }
  379. }
  380.  
  381.  
  382. $test = new RelationshipsManyHasManyCollectionTest($dic);
  383. $test->run();
  384. ?>
Parsed in 0.599 seconds