ModelAsControllerTest::testAllowMultibyte() - Code Metrics - Inspection of "Merge branch '4'" - silverstripe/silverstripe-cms - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 301f96...5c3d68 )

by Robbie
created 2019-02-06 19:29 UTC
ModelAsControllerTest::testAllowMultibyte() A

↳ Parent: ModelAsControllerTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	30
Code Lines	22
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	22
nc	1
nop	0
dl	0
loc	30
rs	9.568
c	0
b	0
f	0
<?php

namespace SilverStripe\CMS\Tests\Controllers;

use Page;
filter:
    dependency_paths: ["lib/*"]
use SilverStripe\CMS\Controllers\ContentController;
use SilverStripe\CMS\Controllers\ModelAsController;
use SilverStripe\CMS\Controllers\OldPageRedirector;
use SilverStripe\CMS\Controllers\RootURLController;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\FunctionalTest;
use SilverStripe\Versioned\Versioned;
use SilverStripe\View\Parsers\URLSegmentFilter;

class ModelAsControllerTest extends FunctionalTest
{
    protected $usesDatabase = true;

    protected $autoFollowRedirection = false;

    protected static $required_extensions = [
        ModelAsController::class => [
            OldPageRedirector::class,
        ],
        ContentController::class => [
            OldPageRedirector::class,
        ],
    ];

    /**
     * New tests require nested urls to be enabled, but the site might not
     * support nested URLs.
     * This setup will enable nested-urls for this test and resets the state
     * after the tests have been performed.
     */
    public function setUp()
    {
        parent::setUp();
        Config::modify()->set(SiteTree::class, 'nested_urls', true);
    }


    protected function generateNestedPagesFixture()
    {
        $level1 = SiteTree::create();
        $level1->Title      = 'First Level';
        $level1->URLSegment = 'level1';
        $level1->write();
        $level1->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $level1->URLSegment = 'newlevel1';
        $level1->write();
        $level1->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $level2 = SiteTree::create();
        $level2->Title      = 'Second Level';
        $level2->URLSegment = 'level2';
        $level2->ParentID = $level1->ID;
        $level2->write();
        $level2->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $level2->URLSegment = 'newlevel2';
        $level2->write();
        $level2->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $level3 = SiteTree::create();
        $level3->Title = "Level 3";
        $level3->URLSegment = 'level3';
        $level3->ParentID = $level2->ID;
        $level3->write();
        $level3->copyVersionToStage('Stage', 'Live');

        $level3->URLSegment = 'newlevel3';
        $level3->write();
        $level3->copyVersionToStage('Stage', 'Live');
    }

    /**
     * We're building up a page hierarchy ("nested URLs") and rename
     * all the individual pages afterwards. The assumption is that
     * all pages will be found by their old segments.
     *
     * NOTE: This test requires nested_urls
     *
     * Original: level1/level2/level3
     * Republished as: newlevel1/newlevel2/newlevel3
     */
    public function testRedirectsNestedRenamedPages()
    {
        $this->generateNestedPagesFixture();

        // check a first level URLSegment
        $response = $this->get('level1/action');
        $this->assertEquals($response->getStatusCode(), 301);
        $this->assertEquals(
            Controller::join_links(Director::baseURL() . 'newlevel1/action'),
            $response->getHeader('Location')
        );

        // check second level URLSegment
        $response = $this->get('newlevel1/level2');
        $this->assertEquals($response->getStatusCode(), 301);
        $this->assertEquals(
            Controller::join_links(Director::baseURL() . 'newlevel1/newlevel2/'),
            $response->getHeader('Location')
        );

        // check third level URLSegment
        $response = $this->get('newlevel1/newlevel2/level3');
        $this->assertEquals($response->getStatusCode(), 301);
        $this->assertEquals(
            Controller::join_links(Director::baseURL() . 'newlevel1/newlevel2/newlevel3/'),
            $response->getHeader('Location')
        );

        $response = $this->get('newlevel1/newlevel2/level3');

    }

    /**
     * Test that the redirect works even with a lot of nested pages
     * Original: /oldurl/level2/level3/level4/level5
     * New: /newurl/level2/level3/level4/level5
     */
    public function testHeavilyNestedRenamedRedirectedPages()
    {
        $page = SiteTree::create();
        $page->Title      = 'First Level';
        $page->URLSegment = 'oldurl';
        $page->write();
        $page->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page->URLSegment = 'newurl';
        $page->write();
        $page->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page2 = SiteTree::create();
        $page2->Title      = 'Second Level Page';
        $page2->URLSegment = 'level2';
        $page2->ParentID = $page->ID;
        $page2->write();
        $page2->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page3 = SiteTree::create();
        $page3->Title      = 'Third Level Page';
        $page3->URLSegment = 'level3';
        $page3->ParentID = $page2->ID;
        $page3->write();
        $page3->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page4 = SiteTree::create();
        $page4->Title      = 'Fourth Level Page';
        $page4->URLSegment = 'level4';
        $page4->ParentID = $page3->ID;
        $page4->write();
        $page4->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page5 = SiteTree::create();
        $page5->Title      = 'Fifth Level Page';
        $page5->URLSegment = 'level5';
        $page5->ParentID = $page4->ID;
        $page5->write();
        $page5->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        // Test that the redirect still works fine when trying to access the most nested page
        $response = $this->get('oldurl/level2/level3/level4/level5/');
        $this->assertEquals($response->getStatusCode(), 301);
        $this->assertEquals(
            Controller::join_links(Director::baseURL() . 'newurl/level2/level3/level4/level5/'),
            $response->getHeader('Location')
        );
    }


    public function testRedirectionForPreNestedurlsBookmarks()
    {
        $this->generateNestedPagesFixture();

        // Up-to-date URLs will be redirected to the appropriate subdirectory
        $response = $this->get('newlevel3');
        $this->assertEquals(301, $response->getStatusCode());
        $this->assertEquals(
            Director::baseURL() . 'newlevel1/newlevel2/newlevel3/',
            $response->getHeader("Location")
        );

        // So will the legacy ones
        $response = $this->get('level3');
        $this->assertEquals(301, $response->getStatusCode());
        $this->assertEquals(
            Director::baseURL() . 'newlevel1/newlevel2/newlevel3/',
            $response->getHeader("Location")
        );
    }

    public function testDoesntRedirectToNestedChildrenOutsideOfOwnHierarchy()
    {
        $this->generateNestedPagesFixture();

        $otherParent = SiteTree::create([
            'URLSegment' => 'otherparent',
        ]);
        $otherParent->write();
        $otherParent->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $response = $this->get('level1/otherparent');
        $this->assertEquals($response->getStatusCode(), 301);

        $response = $this->get('newlevel1/otherparent');
        $this->assertEquals(
            $response->getStatusCode(),
            404,
            'Requesting an unrelated page on a renamed parent should be interpreted as a missing action, not a redirect'
        );
    }

    /**
     *
     * NOTE: This test requires nested_urls
     *
     */
    public function testRedirectsNestedRenamedPagesWithGetParameters()
    {
        $this->generateNestedPagesFixture();

        // check third level URLSegment
        $response = $this->get('newlevel1/newlevel2/level3/?foo=bar&test=test');
        $this->assertEquals($response->getStatusCode(), 301);
        $this->assertEquals(
            Controller::join_links(Director::baseURL() . 'newlevel1/newlevel2/newlevel3/', '?foo=bar&test=test'),
            $response->getHeader('Location')
        );
    }

    /**
     *
     * NOTE: This test requires nested_urls
     *
     */
    public function testDoesntRedirectToNestedRenamedPageWhenNewExists()
    {
        $this->generateNestedPagesFixture();

        $otherLevel1 = SiteTree::create([
            'Title' => "Other Level 1",
            'URLSegment' => 'level1',
        ]);
        $otherLevel1->write();
        $otherLevel1->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $response = $this->get('level1');
        $this->assertEquals(
            $response->getStatusCode(),
            200
        );

        $response = $this->get('level1/newlevel2');
        $this->assertEquals(
            $response->getStatusCode(),
            404,
            'The old newlevel2/ URLSegment is checked as an action on the new page, which shouldnt exist.'
        );
    }

    /**
     *
     * NOTE: This test requires nested_urls
     *
     */
    public function testFindOldPage()
    {
        $page = SiteTree::create();
        $page->Title      = 'First Level';
        $page->URLSegment = 'oldurl';
        $page->write();
        $page->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page->URLSegment = 'newurl';
        $page->write();
        $page->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $url = OldPageRedirector::find_old_page('oldurl');
        $url = OldPageRedirector::find_old_page(/** @scrutinizer ignore-type */ 'oldurl');
        $matchedPage = SiteTree::get_by_link($url);
        $matchedPage = SiteTree::get_by_link(/** @scrutinizer ignore-type */ $url);
        $this->assertEquals('First Level', $matchedPage->Title);

        $page2 = SiteTree::create();
        $page2->Title      = 'Second Level Page';
        $page2->URLSegment = 'oldpage2';
        $page2->ParentID = $page->ID;
        $page2->write();
        $page2->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $page2->URLSegment = 'newpage2';
        $page2->write();
        $page2->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $url = OldPageRedirector::find_old_page('oldpage2', $page2->ParentID);
        $matchedPage = SiteTree::get_by_link($url);
        $this->assertEquals('Second Level Page', $matchedPage->Title);

        $url = OldPageRedirector::find_old_page('oldpage2', $page2->ID);
        $matchedPage = SiteTree::get_by_link($url);
        $this->assertEquals(false, $matchedPage);
    }

    /**
     * go to a page that's been published but is child of an unpublished page
     *
     * NOTE: This test requires nested_urls
     */
    public function testChildOfDraft()
    {
        RootURLController::reset();
        Config::modify()->set(SiteTree::class, 'nested_urls', true);

        $draft = SiteTree::create();
        $draft->Title = 'Root Leve Draft Page';
        $draft->URLSegment = 'root';
        $draft->write();

        $published = SiteTree::create();
        $published->Title = 'Published Page Under Draft Page';
        $published->URLSegment = 'sub-root';
        $published->write();
        $published->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);
        $response = $this->get('root/sub-root');

        $this->assertEquals(
            $response->getStatusCode(),
            404,
            'The page should not be found since its parent has not been published, in this case ' .
            'http://<yousitename>/root/sub-root or http://<yousitename>/sub-root'
        );
    }

    public function testAllowMultibyte()
    {
        Config::modify()->set(URLSegmentFilter::class, 'default_allow_multibyte', true);

        $parent = new Page();
        $parent->Title = 'Multibyte test';
        $parent->URLSegment = 'بلاگ';
        $parent->write();
        $parent->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        $child = new Page();
        $child->Title = 'Multibyte test';
        $child->URLSegment = 'فضة';
        $child->ParentID = $parent->ID;
        $child->write();
        $child->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);

        // Emulate browser behaviour around multibyte URL encodings
        $response = $this->get(rawurlencode('بلاگ'));
        $this->assertEquals(
            $response->getStatusCode(),
            200,
            'Routes toplevel paths'
        );

        $response = $this->get(join('/', [rawurlencode('بلاگ'), rawurlencode('فضة')]));
        $this->assertEquals(
            $response->getStatusCode(),
            200,
            'Routes nested paths'
        );
    }
}

silverstripe / silverstripe-cms

Push — master ( 301f96...5c3d68 )

ModelAsControllerTest::testAllowMultibyte() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
