SilverStripe\StaticPublishQueue\Test\FilesystemPublisherTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	162
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	9	1
A	tearDown()	0	6	1
A	testUrlToPathWithRelativeUrls()	0	23	1
B	testUrlToPathWithAbsoluteUrls()	0	26	1
B	testUrlToPathWithDomainBasedCaching()	0	28	1
B	testMenu2LinkingMode()	0	39	3
A	testContentTypeHTML()	0	20	3

<?php

namespace SilverStripe\StaticPublishQueue\Test;

use SilverStripe\Assets\Filesystem;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPResponse_Exception;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\StaticPublishQueue\Extension\Publishable\PublishableSiteTree;
use SilverStripe\StaticPublishQueue\Publisher\FilesystemPublisher;
use SilverStripe\StaticPublishQueue\Test\StaticPublisherTest\Model\StaticPublisherTestPage;
use SilverStripe\View\SSViewer;

/**
 * Tests for the {@link FilesystemPublisher} class.
 *
 * @package staticpublisher
 */
class FilesystemPublisherTest extends SapphireTest
{
    protected $usesDatabase = true;

    protected function setUp()
    {
        parent::setUp();

        SiteTree::add_extension(PublishableSiteTree::class);

        Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', false);
        Config::modify()->set(Director::class, 'alternate_base_url', 'http://foo/');
    }

    protected function tearDown()
    {
        SiteTree::remove_extension(PublishableSiteTree::class);

        parent::tearDown();
    }

    public function testUrlToPathWithRelativeUrls()
    {
        $reflection = new \ReflectionClass(FilesystemPublisher::class);
        $urlToPath = $reflection->getMethod('URLtoPath');
        $urlToPath->setAccessible(true);

        $fsp = FilesystemPublisher::create()->setFileExtension('html');

        $this->assertEquals(
            'index.html',
            $urlToPath->invokeArgs($fsp, ['/'])
        );

        $this->assertEquals(
           'about-us.html',
            $urlToPath->invokeArgs($fsp, ['about-us'])
        );

        $this->assertEquals(
           'parent/child.html',
            $urlToPath->invokeArgs($fsp, ['parent/child'])
        );
    }

    public function testUrlToPathWithAbsoluteUrls()
    {
        $reflection = new \ReflectionClass(FilesystemPublisher::class);
        $urlToPath = $reflection->getMethod('URLtoPath');
        $urlToPath->setAccessible(true);

        $fsp = FilesystemPublisher::create()->setFileExtension('html');

        $url = Director::absoluteBaseUrl();
        $this->assertEquals(
            'index.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );

        $url = Director::absoluteBaseUrl() . 'about-us';
        $this->assertEquals(
            'about-us.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );

        $url = Director::absoluteBaseUrl() . 'parent/child';
        $this->assertEquals(
            'parent/child.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );
    }

    public function testUrlToPathWithDomainBasedCaching()
    {
        Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', true);

        $reflection = new \ReflectionClass(FilesystemPublisher::class);
        $urlToPath = $reflection->getMethod('URLtoPath');
        $urlToPath->setAccessible(true);

        $fsp = FilesystemPublisher::create()->setFileExtension('html');

        $url = 'http://domain1.com/';
        $this->assertEquals(
            'domain1.com/index.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );

        $url = 'http://domain1.com/about-us';
        $this->assertEquals(
            'domain1.com/about-us.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );

        $url = 'http://domain2.com/parent/child';
        $this->assertEquals(
            'domain2.com/parent/child.html',
            $urlToPath->invokeArgs($fsp, [$url])
        );
    }

    public function testMenu2LinkingMode()
    {
        $this->logInWithPermission('ADMIN');

        SSViewer::set_themes(null);

null is of type null, but the function expects a array.

        $level1 = StaticPublisherTestPage::create();
        $level1->URLSegment = strtolower(__CLASS__) . '-level-1';
        $level1->write();
        $level1->publishRecursive();

        $level2_1 = StaticPublisherTestPage::create();
        $level2_1->URLSegment = strtolower(__CLASS__) . '-level-2-1';
        $level2_1->ParentID = $level1->ID;
        $level2_1->write();

        $level2_1->publishRecursive();

        try {
            $response = Director::test($level2_1->AbsoluteLink());
        } catch (HTTPResponse_Exception $e) {
            $response = $e->getResponse();
        }

        $this->assertEquals("current", trim($response->getBody()));

        $level2_2 = new StaticPublisherTestPage();
        $level2_2->URLSegment = strtolower(__CLASS__) . '-level-2-2';
        $level2_2->ParentID = $level1->ID;
        $level2_2->write();
        $level2_2->publishRecursive();

        try {
            $response = Director::test($level2_2->AbsoluteLink());
        } catch (HTTPResponse_Exception $e) {
            $response = $e->getResponse();
        }
        $this->assertEquals("linkcurrent", trim($response->getBody()));
    }

    public function testContentTypeHTML()
    {
        $fsp = FilesystemPublisher::create()
            ->setFileExtension('html')
            ->setDestFolder('/cache/testing/');
        $level1 = new StaticPublisherTestPage();
        $level1->URLSegment = 'mimetype';
        $level1->write();

        $fsp->publishURL($level1->Link(), true);
        try {
            $response = Director::test('mimetype');
        } catch (HTTPResponse_Exception $e) {
            $response = $e->getResponse();
        }
        $this->assertEquals('text/html; charset=utf-8', $response->getHeader('Content-Type'));
        if (file_exists($fsp->getDestPath())) {
            Filesystem::removeFolder($fsp->getDestPath());
        }
    }
}