FilesystemPublisherTest::testErrorPageWhenPHP() - 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-09 12:41 UTC

FilesystemPublisherTest::testErrorPageWhenPHP() A

↳ Parent: FilesystemPublisherTest

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	16
rs	9.4285
cc	2
eloc	11
nc	2
nop	0

<?php

namespace SilverStripe\StaticPublishQueue\Test;

use SilverStripe\Assets\Filesystem;
use SilverStripe\CMS\Model\RedirectorPage;
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 staticpublishqueue
 */
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();

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

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

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

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

        $fsp = FilesystemPublisher::create();

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

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

        $url = Director::absoluteBaseUrl() . 'parent/child';
        $this->assertEquals(
            'parent/child',
            $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',
            $urlToPath->invokeArgs($fsp, [$url])
        );

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

        $url = 'http://domain2.com/parent/child';
        $this->assertEquals(
            'domain2.com/parent/child',
            $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.'.html');
        $this->assertFileExists($static2_1FilePath.'.php');
        $this->assertContains(
            'current',
            file_get_contents($static2_1FilePath.'.html')
        );

        $level2_2 = StaticPublisherTestPage::create();
        $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.'.html');
        $this->assertFileExists($static2_2FilePath.'.php');
        $this->assertContains(
            'linkcurrent',
            file_get_contents($static2_2FilePath.'.html')
        );

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

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

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

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

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

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

        $fsp = FilesystemPublisher::create()
            ->setFileExtension('html')
            ->setDestFolder('cache/testing/');
        $fsp->publishURL('not_really_there', true);
        $this->assertFileNotExists($fsp->getDestPath() . 'not_really_there.html');
        $this->assertFileNotExists($fsp->getDestPath() . 'not_really_there.php');

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

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

        $fsp = FilesystemPublisher::create()
            ->setDestFolder('cache/testing/');
        $fsp->publishURL('not_really_there', true);
        $this->assertFileExists($fsp->getDestPath() . 'not_really_there.html');
        $this->assertFileExists($fsp->getDestPath() . 'not_really_there.php');
        $phpCacheConfig = require $fsp->getDestPath() . 'not_really_there.php';
        $this->assertEquals(404, $phpCacheConfig['responseCode']);

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

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

        $fsp = FilesystemPublisher::create()
            ->setDestFolder('cache/testing/');
        $redirectorPage = RedirectorPage::create();
        $redirectorPage->URLSegment = 'somewhere-else';
        $redirectorPage->RedirectionType = 'External';
        $redirectorPage->ExternalURL = 'silverstripe.org';
        $redirectorPage->write();
        $redirectorPage->publishRecursive();

        $fsp->publishURL('somewhere-else', true);

        $this->assertFileExists($fsp->getDestPath() . 'somewhere-else.html');
        $this->assertContains(
            'Click this link if your browser does not redirect you',
            file_get_contents($fsp->getDestPath() . 'somewhere-else.html')
        );
        $this->assertFileExists($fsp->getDestPath() . 'somewhere-else.php');
        $phpCacheConfig = require $fsp->getDestPath() . 'somewhere-else.php';
        $this->assertEquals(301, $phpCacheConfig['responseCode']);
        $this->assertContains('location: http://silverstripe.org', $phpCacheConfig['headers']);

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

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

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

        $redirectorPage = RedirectorPage::create();
        $redirectorPage->URLSegment = 'somewhere-else';
        $redirectorPage->RedirectionType = 'External';
        $redirectorPage->ExternalURL = 'silverstripe.org';
        $redirectorPage->write();
        $redirectorPage->publishRecursive();

        $fsp->publishURL('somewhere-else', true);

        $this->assertFileExists($fsp->getDestPath() . 'somewhere-else.html');
        $this->assertContains(
            'Click this link if your browser does not redirect you',
            file_get_contents($fsp->getDestPath() . 'somewhere-else.html')
        );
        $this->assertFileNotExists($fsp->getDestPath() . 'somewhere-else.php');

        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\RedirectorPage;
7			use SilverStripe\CMS\Model\SiteTree;
8			use SilverStripe\Control\Director;
9			use SilverStripe\Core\Config\Config;
10			use SilverStripe\Dev\SapphireTest;
11			use SilverStripe\StaticPublishQueue\Extension\Publishable\PublishableSiteTree;
12			use SilverStripe\StaticPublishQueue\Publisher\FilesystemPublisher;
13			use SilverStripe\StaticPublishQueue\Test\StaticPublisherTest\Model\StaticPublisherTestPage;
14			use SilverStripe\View\SSViewer;
15			use Symbiote\QueuedJobs\Services\QueuedJobService;
16
17			/**
18			* Tests for the {@link FilesystemPublisher} class.
19			*
20			* @package staticpublishqueue
21			*/
22			class FilesystemPublisherTest extends SapphireTest
23			{
24			protected $usesDatabase = true;
25
26			protected function setUp()
27			{
28			parent::setUp();
29
30			SiteTree::add_extension(PublishableSiteTree::class);
31
32			Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', false);
33			Config::modify()->set(Director::class, 'alternate_base_url', 'http://foo/');
34			Config::modify()->set(QueuedJobService::class, 'use_shutdown_function', false);
35			}
36
37			protected function tearDown()
38			{
39			SiteTree::remove_extension(PublishableSiteTree::class);
40
41			parent::tearDown();
42			}
43
44			public function testUrlToPathWithRelativeUrls()
45			{
46			$reflection = new \ReflectionClass(FilesystemPublisher::class);
47			$urlToPath = $reflection->getMethod('URLtoPath');
48			$urlToPath->setAccessible(true);
49
50			$fsp = FilesystemPublisher::create();
51
52			$this->assertEquals(
53			'index',
54			$urlToPath->invokeArgs($fsp, ['/'])
55			);
56
57			$this->assertEquals(
58			'about-us',
59			$urlToPath->invokeArgs($fsp, ['about-us'])
60			);
61
62			$this->assertEquals(
63			'parent/child',
64			$urlToPath->invokeArgs($fsp, ['parent/child'])
65			);
66			}
67
68			public function testUrlToPathWithAbsoluteUrls()
69			{
70			$reflection = new \ReflectionClass(FilesystemPublisher::class);
71			$urlToPath = $reflection->getMethod('URLtoPath');
72			$urlToPath->setAccessible(true);
73
74			$fsp = FilesystemPublisher::create();
75
76			$url = Director::absoluteBaseUrl();
77			$this->assertEquals(
78			'index',
79			$urlToPath->invokeArgs($fsp, [$url])
80			);
81
82			$url = Director::absoluteBaseUrl() . 'about-us';
83			$this->assertEquals(
84			'about-us',
85			$urlToPath->invokeArgs($fsp, [$url])
86			);
87
88			$url = Director::absoluteBaseUrl() . 'parent/child';
89			$this->assertEquals(
90			'parent/child',
91			$urlToPath->invokeArgs($fsp, [$url])
92			);
93			}
94
95			public function testUrlToPathWithDomainBasedCaching()
96			{
97			Config::modify()->set(FilesystemPublisher::class, 'domain_based_caching', true);
98
99			$reflection = new \ReflectionClass(FilesystemPublisher::class);
100			$urlToPath = $reflection->getMethod('URLtoPath');
101			$urlToPath->setAccessible(true);
102
103			$fsp = FilesystemPublisher::create()->setFileExtension('html');
104
105			$url = 'http://domain1.com/';
106			$this->assertEquals(
107			'domain1.com/index',
108			$urlToPath->invokeArgs($fsp, [$url])
109			);
110
111			$url = 'http://domain1.com/about-us';
112			$this->assertEquals(
113			'domain1.com/about-us',
114			$urlToPath->invokeArgs($fsp, [$url])
115			);
116
117			$url = 'http://domain2.com/parent/child';
118			$this->assertEquals(
119			'domain2.com/parent/child',
120			$urlToPath->invokeArgs($fsp, [$url])
121			);
122			}
123
124			public function testMenu2LinkingMode()
125			{
126			$this->logInWithPermission('ADMIN');
127
128			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...
129
130			$reflection = new \ReflectionClass(FilesystemPublisher::class);
131			$urlToPath = $reflection->getMethod('URLtoPath');
132			$urlToPath->setAccessible(true);
133
134			$fsp = FilesystemPublisher::create()
135			->setDestFolder('cache/testing/');
136
137			$level1 = StaticPublisherTestPage::create();
138			$level1->URLSegment = 'test-level-1';
139			$level1->write();
140			$level1->publishRecursive();
141
142			$level2_1 = StaticPublisherTestPage::create();
143			$level2_1->URLSegment = 'test-level-2-1';
144			$level2_1->ParentID = $level1->ID;
145			$level2_1->write();
146			$level2_1->publishRecursive();
147
148			$fsp->publishURL($level1->Link(), true);
149			$fsp->publishURL($level2_1->Link(), true);
150			$static2_1FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_1->Link()]);
151
152			$this->assertFileExists($static2_1FilePath.'.html');
153			$this->assertFileExists($static2_1FilePath.'.php');
154			$this->assertContains(
155			'current',
156			file_get_contents($static2_1FilePath.'.html')
157			);
158
159			$level2_2 = StaticPublisherTestPage::create();
160			$level2_2->URLSegment = 'test-level-2-2';
161			$level2_2->ParentID = $level1->ID;
162			$level2_2->write();
163			$level2_2->publishRecursive();
164
165			$fsp->publishURL($level2_2->Link(), true);
166			$static2_2FilePath = $fsp->getDestPath().$urlToPath->invokeArgs($fsp, [$level2_2->Link()]);
167
168			$this->assertFileExists($static2_2FilePath.'.html');
169			$this->assertFileExists($static2_2FilePath.'.php');
170			$this->assertContains(
171			'linkcurrent',
172			file_get_contents($static2_2FilePath.'.html')
173			);
174
175			if (file_exists($fsp->getDestPath())) {
176			Filesystem::removeFolder($fsp->getDestPath());
177			}
178			}
179
180			public function testOnlyHTML()
181			{
182			$this->logInWithPermission('ADMIN');
183
184			$fsp = FilesystemPublisher::create()
185			->setFileExtension('html')
186			->setDestFolder('cache/testing/');
187			$level1 = StaticPublisherTestPage::create();
188			$level1->URLSegment = 'mimetype';
189			$level1->write();
190			$level1->publishRecursive();
191
192			$fsp->publishURL($level1->Link(), true);
193			$staticFilePath = $fsp->getDestPath().'mimetype';
194
195			$this->assertFileExists($staticFilePath.'.html');
196			$this->assertFileNotExists($staticFilePath.'.php');
197			$this->assertEquals(
198			"<div class=\"statically-published\" style=\"display: none\"></div>",
199			trim(file_get_contents($staticFilePath.'.html'))
200			);
201			if (file_exists($fsp->getDestPath())) {
202			Filesystem::removeFolder($fsp->getDestPath());
203			}
204			}
205
206			public function testNoErrorPagesWhenHTMLOnly()
207			{
208			$this->logInWithPermission('ADMIN');
209
210			$fsp = FilesystemPublisher::create()
211			->setFileExtension('html')
212			->setDestFolder('cache/testing/');
213			$fsp->publishURL('not_really_there', true);
214			$this->assertFileNotExists($fsp->getDestPath() . 'not_really_there.html');
215			$this->assertFileNotExists($fsp->getDestPath() . 'not_really_there.php');
216
217			if (file_exists($fsp->getDestPath())) {
218			Filesystem::removeFolder($fsp->getDestPath());
219			}
220			}
221
222			public function testErrorPageWhenPHP()
223			{
224			$this->logInWithPermission('ADMIN');
225
226			$fsp = FilesystemPublisher::create()
227			->setDestFolder('cache/testing/');
228			$fsp->publishURL('not_really_there', true);
229			$this->assertFileExists($fsp->getDestPath() . 'not_really_there.html');
230			$this->assertFileExists($fsp->getDestPath() . 'not_really_there.php');
231			$phpCacheConfig = require $fsp->getDestPath() . 'not_really_there.php';
232			$this->assertEquals(404, $phpCacheConfig['responseCode']);
233
234			if (file_exists($fsp->getDestPath())) {
235			Filesystem::removeFolder($fsp->getDestPath());
236			}
237			}
238
239			public function testRedirectorPageWhenPHP()
240			{
241			$this->logInWithPermission('ADMIN');
242
243			$fsp = FilesystemPublisher::create()
244			->setDestFolder('cache/testing/');
245			$redirectorPage = RedirectorPage::create();
246			$redirectorPage->URLSegment = 'somewhere-else';
247			$redirectorPage->RedirectionType = 'External';
248			$redirectorPage->ExternalURL = 'silverstripe.org';
249			$redirectorPage->write();
250			$redirectorPage->publishRecursive();
251
252			$fsp->publishURL('somewhere-else', true);
253
254			$this->assertFileExists($fsp->getDestPath() . 'somewhere-else.html');
255			$this->assertContains(
256			'Click this link if your browser does not redirect you',
257			file_get_contents($fsp->getDestPath() . 'somewhere-else.html')
258			);
259			$this->assertFileExists($fsp->getDestPath() . 'somewhere-else.php');
260			$phpCacheConfig = require $fsp->getDestPath() . 'somewhere-else.php';
261			$this->assertEquals(301, $phpCacheConfig['responseCode']);
262			$this->assertContains('location: http://silverstripe.org', $phpCacheConfig['headers']);
263
264			if (file_exists($fsp->getDestPath())) {
265			Filesystem::removeFolder($fsp->getDestPath());
266			}
267			}
268
269			public function testRedirectorPageWhenHTMLOnly()
270			{
271			$this->logInWithPermission('ADMIN');
272
273			$fsp = FilesystemPublisher::create()
274			->setFileExtension('html')
275			->setDestFolder('cache/testing/');
276
277			$redirectorPage = RedirectorPage::create();
278			$redirectorPage->URLSegment = 'somewhere-else';
279			$redirectorPage->RedirectionType = 'External';
280			$redirectorPage->ExternalURL = 'silverstripe.org';
281			$redirectorPage->write();
282			$redirectorPage->publishRecursive();
283
284			$fsp->publishURL('somewhere-else', true);
285
286			$this->assertFileExists($fsp->getDestPath() . 'somewhere-else.html');
287			$this->assertContains(
288			'Click this link if your browser does not redirect you',
289			file_get_contents($fsp->getDestPath() . 'somewhere-else.html')
290			);
291			$this->assertFileNotExists($fsp->getDestPath() . 'somewhere-else.php');
292
293			if (file_exists($fsp->getDestPath())) {
294			Filesystem::removeFolder($fsp->getDestPath());
295			}
296			}
297			}
298

silverstripe / silverstripe-staticpublishqueue

Pull Request — master (#70)

FilesystemPublisherTest::testErrorPageWhenPHP() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like