TopPageTest::populateTopPageForAllObjects() - Code Metrics - Inspection of "Top page feature (performance enhancement)" - dnadesign/silverstripe-elemental - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#774)

unknown
created 2020-02-06 20:56 UTC
TopPageTest::populateTopPageForAllObjects() A

↳ Parent: TopPageTest
Complexity

Conditions	2
Paths	2
Size

Total Lines	13
Code Lines	9
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	9
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	13
rs	9.9666
<?php

namespace DNADesign\Elemental\Tests\TopPage;

use DNADesign\Elemental\Models\BaseElement;
use DNADesign\Elemental\Models\ElementalArea;
use DNADesign\Elemental\TopPage;
use Page;
filter:
    dependency_paths: ["lib/*"]
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\DataObject;

class TopPageTest extends SapphireTest
{
    /**
     * @var string
     */
    protected static $fixture_file = 'TopPageTest.yml';

    /**
     * @var array
     */
    protected static $required_extensions = [
        Page::class => [
            TopPage\SiteTreeExtension::class,
        ],
        ElementalArea::class => [
            TopPage\DataExtension::class,
        ],
        BaseElement::class => [
            TopPage\DataExtension::class,
        ],
    ];

    /**
     * @var array
     */
    protected static $extra_dataobjects = [
        TestContent::class,
        TestList::class,
        TestBlockPage::class,
        TestChildPage::class,
    ];

    protected function setUp(): void
    {
        /** @var TopPage\DataExtension $extension */
        $extension = singleton(TopPage\DataExtension::class);

        // this makes sure that the data objects start with no top page data
        $extension->withoutTopPageUpdate(function () {
            parent::setUp();
        });
    }

    /**
     * @param string $pageIdentifier
     * @param string $pageClass
     * @param string $objectIdentifier
     * @param string $objectClass
     * @dataProvider objectsProvider
     */
    public function testTestGetTopPage(
        string $pageIdentifier,
        string $pageClass,
        string $objectIdentifier,
        string $objectClass
    ): void {
        /** @var Page|TopPage\SiteTreeExtension $content */
        $page = $this->objFromFixture($pageClass, $pageIdentifier);

        /** @var DataObject|TopPage\DataExtension $object */
        $object = $this->objFromFixture($objectClass, $objectIdentifier);

        $topPage = $object->getTopPage();

        $this->assertNotNull($topPage);
        $this->assertEquals((int) $page->ID, (int) $topPage->ID);
    }

    /**
     * @param string $pageIdentifier
     * @param string $pageClass
     * @param string $objectIdentifier
     * @param string $objectClass
     * @dataProvider objectsProvider
     */
    public function testTestUpdateTopPageEmptyCache(
        string $pageIdentifier,
        string $pageClass,
        string $objectIdentifier,
        string $objectClass
    ): void {
        /** @var Page|TopPage\SiteTreeExtension $content */
        $page = $this->objFromFixture($pageClass, $pageIdentifier);

        /** @var DataObject|TopPage\DataExtension $object */
        $object = $this->objFromFixture($objectClass, $objectIdentifier);

        $this->assertEquals(0, (int) $object->TopPageID);

        $object->forceChange();
        $id = $object->write();
        $object = DataObject::get($object->ClassName)->byID($id);

        $this->assertEquals((int) $page->ID, (int) $object->TopPageID);

        // do a second write to make sure that we won't override existing top page
        $object->forceChange();
        $id = $object->write();
        $object = DataObject::get($object->ClassName)->byID($id);

        $this->assertEquals((int) $page->ID, (int) $object->TopPageID);
    }

    public function testNewPage(): void
    {
        $page = TestBlockPage::create();
        $page->Title = 'New page test';
        $page->write();

        /** @var ElementalArea|TopPage\DataExtension $area */
        $area = $page->ElementalArea();
        $this->assertEquals((int) $page->ID, (int) $area->TopPageID);

    }

    /**
     * @param bool $populateTopPage
     * @dataProvider populateTopPageProvider
     */
    public function testNewBlock(bool $populateTopPage): void
    {
        if ($populateTopPage) {
            $this->populateTopPageForAllObjects();
        }

        /** @var TestBlockPage $page */
        $page = $this->objFromFixture(TestBlockPage::class, 'block-page1');

        /** @var ElementalArea $area */
        $area = $this->objFromFixture(ElementalArea::class, 'area3');

        /** @var TestContent|TopPage\DataExtension $content */
        $content = TestContent::create();
        $content->Title = 'Fresh block';


        $area->Elements()->add($content);
        $area->Elements()->add(/** @scrutinizer ignore-type */ $content);
        $content = DataObject::get($content->ClassName)->byID($content->ID);


        $this->assertEquals((int) $page->ID, (int) $content->TopPageID);
    }

    public function testPageDuplication(): void
    {
        $this->populateTopPageForAllObjects();

        /** @var TestBlockPage $page */
        $page = $this->objFromFixture(TestBlockPage::class, 'block-page1');

        /** @var TestChildPage $childPage */
        $childPage = $this->objFromFixture(TestChildPage::class, 'child-page1');

        $page->duplicate();
        $pages = TestBlockPage::get()->filter(['Title' => 'BlockPage1'])->sort('ID', 'DESC');

        $this->assertCount(2, $pages);

        $pageClone = $pages->first();
        $pageClone = $pages->first();
        $childPages = TestChildPage::get()->filter(['Title' => 'ChildPage1'])->sort('ID', 'DESC');

        $this->assertCount(2, $childPages);

        $childClone = $childPages->first();

        $this->assertNotEquals((int) $childPage->ID, (int) $childClone->ID);

        $objects = [
            [TestList::class, 'List1', $pageClone],
            [TestContent::class, 'Content1', $pageClone],
            [TestList::class, 'List2', $childClone],
            [TestContent::class, 'Content2', $childClone],
        ];

        foreach ($objects as $objectData) {
            $class = array_shift($objectData);
            $title = array_shift($objectData);
            $page = array_shift($objectData);

            $items = DataObject::get($class)->filter(['Title' => $title])->sort('ID', 'DESC');

            $this->assertCount(2, $items);

            /** @var DataObject|TopPage\DataExtension $objectClone */
            $objectClone = $items->first();

            $this->assertEquals((int) $page->ID, (int) $objectClone->TopPageID);

            /** @var ElementalArea|TopPage\DataExtension $area */
            $area = $objectClone->Parent();

            $this->assertEquals((int) $page->ID, (int) $area->TopPageID);

        }
    }

    public function objectsProvider(): array
    {
        return [
            [
                'block-page1',
                TestBlockPage::class,
                'content1',
                TestContent::class,
            ],
            [
                'block-page1',
                TestBlockPage::class,
                'list1',
                TestList::class,
            ],
            [
                'block-page1',
                TestBlockPage::class,
                'area1',
                ElementalArea::class,
            ],
            [
                'block-page1',
                TestBlockPage::class,
                'area3',
                ElementalArea::class,
            ],
            [
                'child-page1',
                TestChildPage::class,
                'content2',
                TestContent::class,
            ],
            [
                'child-page1',
                TestChildPage::class,
                'list2',
                TestList::class,
            ],
            [
                'child-page1',
                TestChildPage::class,
                'area2',
                ElementalArea::class,
            ],
            [
                'child-page1',
                TestChildPage::class,
                'area4',
                ElementalArea::class,
            ],
        ];
    }

    public function populateTopPageProvider(): array
    {
        return [
            [true],
            [false],
        ];
    }

    private function populateTopPageForAllObjects(): void
    {
        $list = $this->objectsProvider();

        foreach ($list as $objects) {
            array_shift($objects);
            array_shift($objects);
            $identifier = array_shift($objects);
            $class = array_shift($objects);

            $object = $this->objFromFixture($class, $identifier);
            $object->forceChange();
            $object->write();
        }
    }
}

dnadesign / silverstripe-elemental

Pull Request — master (#774)

TopPageTest::populateTopPageForAllObjects() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
