silverstripe-staticpublisher/tests/FilesystemPublisherTest.php

<?php

/**
 * Tests for the {@link FilesystemPublisher} class.
 * 
 * @package staticpublisher
 */
class FilesystemPublisherTest extends SapphireTest
{
    
    protected $usesDatabase = true;
    
    protected $orig = array();
    
    public function setUp()
    {
        parent::setUp();
        
        SiteTree::add_extension("FilesystemPublisher('assets/FilesystemPublisherTest-static-folder/')");
        
        $this->orig['domain_based_caching'] = Config::inst()->get('FilesystemPublisher', 'domain_based_caching');

        Config::inst()->update('FilesystemPublisher', 'domain_based_caching', false);
    }
    
    public function tearDown()
    {
        parent::tearDown();

        SiteTree::remove_extension("FilesystemPublisher('assets/FilesystemPublisherTest-static-folder/')");

        Config::inst()->update('FilesystemPublisher', 'domain_based_caching', $this->orig['domain_based_caching']);

        if (file_exists(BASE_PATH . '/assets/FilesystemPublisherTest-static-folder')) {
            Filesystem::removeFolder(BASE_PATH . '/assets/FilesystemPublisherTest-static-folder');
        }
    }
    
    public function testUrlsToPathsWithRelativeUrls()
    {
        $fsp = new FilesystemPublisher('.', 'html');
        
        $this->assertEquals(
            $fsp->urlsToPaths(array('/')),
            array('/' => './index.html'),
            'Root URL path mapping'
        );
        
        $this->assertEquals(
            $fsp->urlsToPaths(array('about-us')),
            array('about-us' => './about-us.html'),
            'URLsegment path mapping'
        );
        
        $this->assertEquals(
            $fsp->urlsToPaths(array('parent/child')),
            array('parent/child' => 'parent/child.html'),
            'Nested URLsegment path mapping'
        );
    }
    
    public function testUrlsToPathsWithAbsoluteUrls()
    {
        $fsp = new FilesystemPublisher('.', 'html');
        
        $url = Director::absoluteBaseUrl();
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => './index.html'),
            'Root URL path mapping'
        );
        
        $url = Director::absoluteBaseUrl() . 'about-us';
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => './about-us.html'),
            'URLsegment path mapping'
        );
        
        $url = Director::absoluteBaseUrl() . 'parent/child';
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => 'parent/child.html'),
            'Nested URLsegment path mapping'
        );
    }

    public function testUrlsToPathsWithDomainBasedCaching()
    {
        $origDomainBasedCaching = Config::inst()->get('FilesystemPublisher', 'domain_based_caching');
        Config::inst()->update('FilesystemPublisher', 'domain_based_caching', true);
        
        $fsp = new FilesystemPublisher('.', 'html');
        
        $url = 'http://domain1.com/';
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => 'domain1.com/index.html'),
            'Root URL path mapping'
        );
        
        $url = 'http://domain1.com/about-us';
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => 'domain1.com/about-us.html'),
            'URLsegment path mapping'
        );
        
        $url = 'http://domain2.com/parent/child';
        $this->assertEquals(
            $fsp->urlsToPaths(array($url)),
            array($url => 'domain2.com/parent/child.html'),
            'Nested URLsegment path mapping'
        );
        
        Config::inst()->update('FilesystemPublisher', 'domain_based_caching', $origDomainBasedCaching);
    }
    
    /**
     * Simple test to ensure that FileSystemPublisher::__construct()
     * has called parent::__construct() by checking the class property.
     * The class property is set on {@link Object::__construct()} and
     * this is therefore a good test to ensure it was called.
     * 
     * If FilesystemPublisher doesn't call parent::__construct() then
     * it won't be enabled propery because {@link Object::__construct()}
     * is where extension instances are set up and subsequently used by
     * {@link DataObject::defineMethods()}.
     */
    public function testHasCalledParentConstructor()
    {
        $fsp = new FilesystemPublisher('.', '.html');

        $this->assertEquals($fsp->class, 'FilesystemPublisher');
    }
    
    /*
     * These are a few simple tests to check that we will be retrieving the 
     * correct theme when we need it. StaticPublishing needs to be able to 
     * retrieve a non-null theme at the time publishPages() is called.
     */
    public function testStaticPublisherTheme()
    {
        
        // This will be the name of the default theme of this particular project
        $default_theme = Config::inst()->get('SSViewer', 'theme');
        
        $p1 = new Page();
        $p1->URLSegment = strtolower(__CLASS__).'-page-1';
        $p1->HomepageForDomain = '';
        $p1->write();
        $p1->doPublish();
        
        $current_theme = Config::inst()->get('SSViewer', 'theme_enabled') ? Config::inst()->get('SSViewer', 'theme') : null;
        $this->assertEquals($current_theme, $default_theme, 'After a standard publication, the theme is correct');
        
        //We can set the static_publishing theme to something completely different:
        //Static publishing will use this one instead of the current_custom_theme if it is not false
        Config::inst()->update('StaticPublisher', 'static_publisher_theme', 'otherTheme');
        $current_theme = Config::inst()->get('StaticPublisher', 'static_publisher_theme');

        $this->assertNotEquals($current_theme, $default_theme, 'The static publisher theme overrides the custom theme');
    }

    public function testMenu2LinkingMode()
    {
        $this->logInWithPermission('ADMIN');
        
        Config::inst()->update('SSViewer', 'theme', null);
        
        $l1 = new StaticPublisherTestPage();
        $l1->URLSegment = strtolower(__CLASS__).'-level-1';
        $l1->write();
        $l1->doPublish();
    
        $l2_1 = new StaticPublisherTestPage();
        $l2_1->URLSegment = strtolower(__CLASS__).'-level-2-1';
        $l2_1->ParentID = $l1->ID;
        $l2_1->write();
        
        $l2_1->doPublish();
        $response = Director::test($l2_1->AbsoluteLink());

        $this->assertEquals(trim($response->getBody()), "current", "current page is level 2-1");
                
        $l2_2 = new StaticPublisherTestPage();
        $l2_2->URLSegment = strtolower(__CLASS__).'-level-2-2';
        $l2_2->ParentID = $l1->ID;
        $l2_2->write();
        $l2_2->doPublish();

        $response = Director::test($l2_2->AbsoluteLink());
        $this->assertEquals(trim($response->getBody()), "linkcurrent", "current page is level 2-2");
    }

    public function testContentTypeHTML()
    {
        SiteTree::remove_extension('FilesystemPublisher');
        SiteTree::add_extension("FilesystemPublisher('assets/FilesystemPublisherTest-static-folder/', 'php')");
        $l1 = new StaticPublisherTestPage();
        $l1->URLSegment = 'mimetype';
        $l1->write();
        $l1->doPublish();
        $response = Director::test('mimetype');
        $this->assertEquals($response->getHeader('Content-Type'), 'text/html; charset=utf-8', 'Content-Type should be text/html; charset=utf-8');
    }

    public function testContentTypeJSON()
    {
        SiteTree::remove_extension('FilesystemPublisher');
        SiteTree::add_extension("FilesystemPublisher('assets/FilesystemPublisherTest-static-folder/', 'php')");
        $l1 = new StaticPublisherTestPage();
        $l1->URLSegment = 'mimetype';
        $l1->write();
        $l1->doPublish();
        $response = Director::test('mimetype/json');
        $this->assertEquals($response->getHeader('Content-Type'), 'application/json', 'Content-Type should be application/json');
    }
}

/**
 * @package staticpublisher
 */
class StaticPublisherTestPage extends Page implements TestOnly
{

    private static $allowed_children = array(
        'StaticPublisherTestPage'
    );


    public function canPublish($member = null)
    {
        return true;
    }

    public function getTemplate()
    {
        return STATIC_MODULE_DIR . '/tests/templates/StaticPublisherTestPage.ss';
    }
}

/**
 * @package staticpublisher
 */
class StaticPublisherTestPage_Controller extends Page_Controller implements TestOnly
{

    /**
     *
     * @var array
     */
    private static $allowed_actions = array('json');
    
    public function json(SS_HTTPRequest $request)
    {
        $response = new SS_HTTPResponse('{"firstName": "John"}');
        $response->addHeader('Content-Type', 'application/json');
        return $response;
    }
}