FilesystemPublisherTest::testUrlToPathWithRelativeUrls() - Code Metrics - Inspection of "SS4 Compatability" - silverstripe/silverstripe-staticpublishqueue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#70)

by Daniel

created 2018-01-08 13:02 UTC

testUrlToPathWithRelativeUrls() A

↳ Parent: FilesystemPublisherTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	23
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	23
rs	9.0856
cc	1
eloc	14
nc	1
nop	0

<?php

namespace SilverStripe\StaticPublishQueue\Test;

use SilverStripe\Assets\Filesystem;
use SilverStripe\CMS\Model\SiteTree;
use SilverStripe\Control\Director;
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;
use Symbiote\QueuedJobs\Services\QueuedJobService;

/**
 * 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/');
        Config::modify()->set(QueuedJobService::class, 'use_shutdown_function', false);
    }

    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);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

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

        $fsp = FilesystemPublisher::create()
            ->setDestFolder('cache/testing/');

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

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

        $fsp->publishURL($level1->Link(), true);
        $fsp->publishURL($level2_1->Link(), true);
        $static2_1FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_1->Link()]);

        $this->assertFileExists($static2_1FilePath);
        $this->assertContains(
            'current',
            file_get_contents($static2_1FilePath)
        );

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

        $fsp->publishURL($level2_2->Link(), true);
        $static2_2FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_2->Link()]);

        $this->assertFileExists($static2_2FilePath);
        $this->assertContains(
            'linkcurrent',
            file_get_contents($static2_2FilePath)
        );

        if (file_exists($fsp->getDestPath())) {
            Filesystem::removeFolder($fsp->getDestPath());
        }
    }

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

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

        $fsp->publishURL($level1->Link(), true);
        $staticFilePath = $fsp->getDestPath().'mimetype.html';

        $this->assertFileExists($staticFilePath);
        $this->assertEquals(
            "<div class=\"statically-published\" style=\"display: none\"></div>",
            trim(file_get_contents($staticFilePath))
        );
        if (file_exists($fsp->getDestPath())) {
            Filesystem::removeFolder($fsp->getDestPath());
        }
    }
}


1			<?php
2
3			namespace SilverStripe\StaticPublishQueue\Test;
4
5			use SilverStripe\Assets\Filesystem;
6			use SilverStripe\CMS\Model\SiteTree;
7			use SilverStripe\Control\Director;
8			use SilverStripe\Core\Config\Config;
9			use SilverStripe\Dev\SapphireTest;
10			use SilverStripe\StaticPublishQueue\Extension\Publishable\PublishableSiteTree;
11			use SilverStripe\StaticPublishQueue\Publisher\FilesystemPublisher;
12			use SilverStripe\StaticPublishQueue\Test\StaticPublisherTest\Model\StaticPublisherTestPage;
13			use SilverStripe\View\SSViewer;
14			use Symbiote\QueuedJobs\Services\QueuedJobService;
15
16			/**
17			* Tests for the {@link FilesystemPublisher} class.
18			*
19			* @package staticpublisher
20			*/
21			class FilesystemPublisherTest extends SapphireTest
22			{
23			protected $usesDatabase = true;
24
25			protected function setUp()
26			{
27			parent::setUp();
28
29			SiteTree::add_extension(PublishableSiteTree::class);
30
31			Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', false);
32			Config::modify()->set(Director::class, 'alternate_base_url', 'http://foo/');
33			Config::modify()->set(QueuedJobService::class, 'use_shutdown_function', false);
34			}
35
36			protected function tearDown()
37			{
38			SiteTree::remove_extension(PublishableSiteTree::class);
39
40			parent::tearDown();
41			}
42
43			public function testUrlToPathWithRelativeUrls()
44			{
45			$reflection = new \ReflectionClass(FilesystemPublisher::class);
46			$urlToPath = $reflection->getMethod('URLtoPath');
47			$urlToPath->setAccessible(true);
48
49			$fsp = FilesystemPublisher::create()->setFileExtension('html');
50
51			$this->assertEquals(
52			'index.html',
53			$urlToPath->invokeArgs($fsp, ['/'])
54			);
55
56			$this->assertEquals(
57			'about-us.html',
58			$urlToPath->invokeArgs($fsp, ['about-us'])
59			);
60
61			$this->assertEquals(
62			'parent/child.html',
63			$urlToPath->invokeArgs($fsp, ['parent/child'])
64			);
65			}
66
67			public function testUrlToPathWithAbsoluteUrls()
68			{
69			$reflection = new \ReflectionClass(FilesystemPublisher::class);
70			$urlToPath = $reflection->getMethod('URLtoPath');
71			$urlToPath->setAccessible(true);
72
73			$fsp = FilesystemPublisher::create()->setFileExtension('html');
74
75			$url = Director::absoluteBaseUrl();
76			$this->assertEquals(
77			'index.html',
78			$urlToPath->invokeArgs($fsp, [$url])
79			);
80
81			$url = Director::absoluteBaseUrl() . 'about-us';
82			$this->assertEquals(
83			'about-us.html',
84			$urlToPath->invokeArgs($fsp, [$url])
85			);
86
87			$url = Director::absoluteBaseUrl() . 'parent/child';
88			$this->assertEquals(
89			'parent/child.html',
90			$urlToPath->invokeArgs($fsp, [$url])
91			);
92			}
93
94			public function testUrlToPathWithDomainBasedCaching()
95			{
96			Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', true);
97
98			$reflection = new \ReflectionClass(FilesystemPublisher::class);
99			$urlToPath = $reflection->getMethod('URLtoPath');
100			$urlToPath->setAccessible(true);
101
102			$fsp = FilesystemPublisher::create()->setFileExtension('html');
103
104			$url = 'http://domain1.com/';
105			$this->assertEquals(
106			'domain1.com/index.html',
107			$urlToPath->invokeArgs($fsp, [$url])
108			);
109
110			$url = 'http://domain1.com/about-us';
111			$this->assertEquals(
112			'domain1.com/about-us.html',
113			$urlToPath->invokeArgs($fsp, [$url])
114			);
115
116			$url = 'http://domain2.com/parent/child';
117			$this->assertEquals(
118			'domain2.com/parent/child.html',
119			$urlToPath->invokeArgs($fsp, [$url])
120			);
121			}
122
123			public function testMenu2LinkingMode()
124			{
125			$this->logInWithPermission('ADMIN');
126
127			SSViewer::set_themes(null);
			0 ignored issues – show Documentation introduced 2018-01-08 11:28 UTC by Report Bug Copy Issue Report `null` is of type `null`, but the function expects a `array`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
128
129			$reflection = new \ReflectionClass(FilesystemPublisher::class);
130			$urlToPath = $reflection->getMethod('URLtoPath');
131			$urlToPath->setAccessible(true);
132
133			$fsp = FilesystemPublisher::create()
134			->setDestFolder('cache/testing/');
135
136			$level1 = StaticPublisherTestPage::create();
137			$level1->URLSegment = 'test-level-1';
138			$level1->write();
139			$level1->publishRecursive();
140
141			$level2_1 = StaticPublisherTestPage::create();
142			$level2_1->URLSegment = 'test-level-2-1';
143			$level2_1->ParentID = $level1->ID;
144			$level2_1->write();
145			$level2_1->publishRecursive();
146
147			$fsp->publishURL($level1->Link(), true);
148			$fsp->publishURL($level2_1->Link(), true);
149			$static2_1FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_1->Link()]);
150
151			$this->assertFileExists($static2_1FilePath);
152			$this->assertContains(
153			'current',
154			file_get_contents($static2_1FilePath)
155			);
156
157			$level2_2 = new StaticPublisherTestPage();
158			$level2_2->URLSegment = 'test-level-2-2';
159			$level2_2->ParentID = $level1->ID;
160			$level2_2->write();
161			$level2_2->publishRecursive();
162
163			$fsp->publishURL($level2_2->Link(), true);
164			$static2_2FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_2->Link()]);
165
166			$this->assertFileExists($static2_2FilePath);
167			$this->assertContains(
168			'linkcurrent',
169			file_get_contents($static2_2FilePath)
170			);
171
172			if (file_exists($fsp->getDestPath())) {
173			Filesystem::removeFolder($fsp->getDestPath());
174			}
175			}
176
177			public function testContentTypeHTML()
178			{
179			$this->logInWithPermission('ADMIN');
180
181			$fsp = FilesystemPublisher::create()
182			->setFileExtension('html')
183			->setDestFolder('cache/testing/');
184			$level1 = new StaticPublisherTestPage();
185			$level1->URLSegment = 'mimetype';
186			$level1->write();
187			$level1->publishRecursive();
188
189			$fsp->publishURL($level1->Link(), true);
190			$staticFilePath = $fsp->getDestPath().'mimetype.html';
191
192			$this->assertFileExists($staticFilePath);
193			$this->assertEquals(
194			"<div class=\"statically-published\" style=\"display: none\"></div>",
195			trim(file_get_contents($staticFilePath))
196			);
197			if (file_exists($fsp->getDestPath())) {
198			Filesystem::removeFolder($fsp->getDestPath());
199			}
200			}
201			}
202

silverstripe / silverstripe-staticpublishqueue

Pull Request — master (#70)

testUrlToPathWithRelativeUrls() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like