SiteTreePublishingEngineTest::testCollectChangesForUnpublishing() - 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-02 13:11 UTC

testCollectChangesForUnpublishing() A

↳ Parent: SiteTreePublishingEngineTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	9

Duplication

Lines	14
Ratio	100 %

Importance

Changes

Metric	Value
dl	14
loc	14
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	9
nc	1
nop	0

<?php

namespace SilverStripe\StaticPublishQueue\Test;

use SilverStripe\Control\Director;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\ArrayList;
use SilverStripe\StaticPublishQueue\Extension\Engine\SiteTreePublishingEngine;
use SilverStripe\StaticPublishQueue\Extension\Publisher\FilesystemPublisher;
use SilverStripe\StaticPublishQueue\Model\StaticPagesQueue;
use SilverStripe\StaticPublishQueue\Model\URLArrayObject;
use SilverStripe\StaticPublishQueue\Test\SiteTreePublishingEngineTest\Model\StaticallyPublishablePage;
use SilverStripe\StaticPublishQueue\Test\SiteTreePublishingEngineTest\Model\StaticPublishingTriggerPage;

class SiteTreePublishingEngineTest extends SapphireTest
{
    protected static $required_extensions = array(
        StaticallyPublishablePage::class => array(
            SiteTreePublishingEngine::class,
            FilesystemPublisher::class,
        ),
        StaticPublishingTriggerPage::class => array(
            SiteTreePublishingEngine::class,
            FilesystemPublisher::class,
        )
    );

    protected function setUp()
    {
        parent::setUp();
        Config::modify()->set(StaticPagesQueue::class, 'realtime', true);
    }

    public function testCollectChangesForPublishing()

    {
        $obj = StaticPublishingTriggerPage::create();
        $obj->collectChanges(array('action' => 'publish'));

        $this->assertEquals(
            array('/updateOnPublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
            $obj->getToUpdate()
        );
        $this->assertEquals(
            array('/deleteOnPublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
            $obj->getToDelete()
        );
    }

    public function testCollectChangesForUnpublishing()

    {
        $obj = StaticPublishingTriggerPage::create();
        $obj->collectChanges(array('action' => 'unpublish'));

        $this->assertEquals(
            array('/updateOnUnpublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
            $obj->getToUpdate()
        );
        $this->assertEquals(
            array('/deleteOnUnpublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
            $obj->getToDelete()
        );
    }

    public function testFlushChangesToUpdateEnqueuesAndDeletesRegular()
    {

        $toUpdate = array('/toUpdate?_ID=1&_ClassName=StaticallyPublishableTest' => 10);

        $stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
            ->setMethods(array('convertUrlsToPathMap', 'deleteRegularFiles', 'deleteStaleFiles'))
            ->getMock();

        $stub->expects($this->once())
            ->method('convertUrlsToPathMap')
            ->will($this->returnValue(array('url' => 'file')));

        // Test: enqueues the updated URLs
        $stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('addUrls'))->getMock());
        $stub->getUrlArrayObject()->expects($this->once())
            ->method('addUrls')
            ->with($this->equalTo($toUpdate));

        // Test: deletes just the regular files
        $stub->expects($this->never())
            ->method('deleteStaleFiles');
        $stub->expects($this->once())
            ->method('deleteRegularFiles')
            ->with($this->equalTo(array('file')));

        // Test: clears the update queue
        $stub->setToUpdate($toUpdate);
        $stub->flushChanges();
        $this->assertEmpty($stub->getToUpdate());
    }

    public function testFlushChangesToDeleteDeletesRegularAndStale()
    {
        $toDelete = array('/toDelete?_ID=1&_ClassName=StaticallyPublishableTest' => 10);

        $stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
            ->setMethods(array('convertUrlsToPathMap', 'deleteRegularFiles', 'deleteStaleFiles'))
            ->getMock();

        $stub->expects($this->once())
            ->method('convertUrlsToPathMap')
            ->will($this->returnValue(array('url' => 'file')));

        // Test: deletes both regular and stale files
        $stub->expects($this->once())
            ->method('deleteRegularFiles')
            ->with($this->equalTo(array('file')));
        $stub->expects($this->once())
            ->method('deleteStaleFiles')
            ->with($this->equalTo(array('file')));

        // Test: clears the queue
        $stub->setToDelete($toDelete);
        $stub->flushChanges();
        $this->assertEmpty($stub->getToDelete());
    }

    public function testConvertUrlsToPathMapNoObject()
    {
        Config::modify()->set('FilesystemPublisher', 'static_base_url', 'http://foo');
        Config::modify()->set('Director', 'alternate_base_url', '/');

        $urls = array('/xyzzy');

        $stub = StaticPublishingTriggerPage::create();

        // Test (inclusively with urlsToPaths, these interfaces should be refactored together)
        $result = $stub->convertUrlsToPathMap($urls);
        $this->assertEquals(
            $result,
            array(
                '/xyzzy' => './xyzzy.html'
            )
        );
    }

    public function testConvertUrlsToPathMapMainSite()
    {
        Config::modify()->set(FilesystemPublisher::class, 'static_base_url', 'http://foo');
        Config::modify()->set(Director::class, 'alternate_base_url', '/');
        $urls = array('/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable');

        // Pretend this object supports subsites, and is from the main site.
        $page = $this->getMockBuilder(StaticallyPublishablePage::class)
            ->setMethods(array('Subsite', 'hasExtension'))
            ->getMock();

        $page->expects($this->any())
            ->method('Subsite')
            ->will($this->returnValue(null));
        $page->expects($this->any())
            ->method('hasExtension')
            ->will($this->returnValue(true));

        $stub = StaticPublishingTriggerPage::create();
        $stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('getObject'))->getMock());
        $stub->getUrlArrayObject()->expects($this->any())
            ->method('getObject')
            ->will($this->returnValue($page));

        // Test (inclusively with urlsToPaths, these interfaces should be refactored together)
        $result = $stub->convertUrlsToPathMap($urls);
        $this->assertEquals(
            array('http://foo/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
                'foo/xyzzy.html'),
            $result
        );
    }

    public function testConvertUrlsToPathMapSubsite()
    {
        Config::modify()->set(FilesystemPublisher::class, 'static_base_url', 'http://foo');
        Config::modify()->set(Director::class, 'alternate_base_url', '/');
        $urls = array('/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable');

        // Mock a set of objects pretending to support Subsites. Subsites might not be installed.
        $domain1 = $this->createMock('SubsiteDomain_mock');
        $domain1->Domain = 'subiste1.domain.org';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        $domain2 = $this->createMock('SubsiteDomain_mock');
        $domain2->Domain = 'subiste2.domain.org';
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $domains = new ArrayList(array($domain1, $domain2));

        $subsite = $this->createMock('Subsite_mock');
        $subsite->expects($this->any())
            ->method('Domains')
            ->will($this->returnValue($domains));
        $subsite->ID = 1;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

        $stub = $this->getMockBuilder(StaticallyPublishablePage::class)
            ->setMethods(array('Subsite', 'hasExtension'))
            ->getMock();

        $stub->expects($this->any())
            ->method('Subsite')
            ->will($this->returnValue($subsite));
        $stub->expects($this->any())
            ->method('hasExtension')
            ->will($this->returnValue(true));

        // Prepare static mocks.
        $stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('getObject'))->getMock());

        $stub->getUrlArrayObject()->expects($this->any())
            ->method('getObject')
            ->will($this->returnValue($stub));

        // Test (inclusively with urlsToPaths, these interfaces should be refactored together)
        $result = $stub->convertUrlsToPathMap($urls);
        $this->assertEquals(
            array(
                'http://subiste1.domain.org/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
                    "subiste1.domain.org/xyzzy.html",
                'http://subiste2.domain.org/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
                    "subiste2.domain.org/xyzzy.html"
            ),
            $result
        );
    }

    public function testDeleteStaleFiles()
    {
        $stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
            ->setMethods(array('deleteFromCacheDir'))
            ->getMock();

        $stub->expects($this->at(0))
            ->method('deleteFromCacheDir')
            ->with($this->equalTo('xyzzy.stale.html'));

        $stub->expects($this->at(1))
            ->method('deleteFromCacheDir')
            ->with($this->equalTo('foo/bar/baz.stale.html'));

        $stub->deleteStaleFiles(array('xyzzy.html', 'foo/bar/baz.html'));
    }
}


Pull Request — master (#70)

testCollectChangesForUnpublishing() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

1		<?php
2
3		namespace SilverStripe\StaticPublishQueue\Test;
4
5		use SilverStripe\Control\Director;
6		use SilverStripe\Core\Config\Config;
7		use SilverStripe\Dev\SapphireTest;
8		use SilverStripe\ORM\ArrayList;
9		use SilverStripe\StaticPublishQueue\Extension\Engine\SiteTreePublishingEngine;
10		use SilverStripe\StaticPublishQueue\Extension\Publisher\FilesystemPublisher;
11		use SilverStripe\StaticPublishQueue\Model\StaticPagesQueue;
12		use SilverStripe\StaticPublishQueue\Model\URLArrayObject;
13		use SilverStripe\StaticPublishQueue\Test\SiteTreePublishingEngineTest\Model\StaticallyPublishablePage;
14		use SilverStripe\StaticPublishQueue\Test\SiteTreePublishingEngineTest\Model\StaticPublishingTriggerPage;
15
16		class SiteTreePublishingEngineTest extends SapphireTest
17		{
18		protected static $required_extensions = array(
19		StaticallyPublishablePage::class => array(
20		SiteTreePublishingEngine::class,
21		FilesystemPublisher::class,
22		),
23		StaticPublishingTriggerPage::class => array(
24		SiteTreePublishingEngine::class,
25		FilesystemPublisher::class,
26		)
27		);
28
29		protected function setUp()
30		{
31		parent::setUp();
32		Config::modify()->set(StaticPagesQueue::class, 'realtime', true);
33		}
34
35	View Code Duplication	public function testCollectChangesForPublishing()
		0 ignored issues – show Duplication introduced 2017-12-29 17:10 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
36		{
37		$obj = StaticPublishingTriggerPage::create();
38		$obj->collectChanges(array('action' => 'publish'));
39
40		$this->assertEquals(
41		array('/updateOnPublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
42		$obj->getToUpdate()
43		);
44		$this->assertEquals(
45		array('/deleteOnPublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
46		$obj->getToDelete()
47		);
48		}
49
50	View Code Duplication	public function testCollectChangesForUnpublishing()
		0 ignored issues – show Duplication introduced 2017-12-29 17:10 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
51		{
52		$obj = StaticPublishingTriggerPage::create();
53		$obj->collectChanges(array('action' => 'unpublish'));
54
55		$this->assertEquals(
56		array('/updateOnUnpublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
57		$obj->getToUpdate()
58		);
59		$this->assertEquals(
60		array('/deleteOnUnpublish?_ID=1&_ClassName=StaticallyPublishableTest' => 10),
61		$obj->getToDelete()
62		);
63		}
64
65		public function testFlushChangesToUpdateEnqueuesAndDeletesRegular()
66		{
67
68		$toUpdate = array('/toUpdate?_ID=1&_ClassName=StaticallyPublishableTest' => 10);
69
70		$stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
71		->setMethods(array('convertUrlsToPathMap', 'deleteRegularFiles', 'deleteStaleFiles'))
72		->getMock();
73
74		$stub->expects($this->once())
75		->method('convertUrlsToPathMap')
76		->will($this->returnValue(array('url' => 'file')));
77
78		// Test: enqueues the updated URLs
79		$stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('addUrls'))->getMock());
80		$stub->getUrlArrayObject()->expects($this->once())
81		->method('addUrls')
82		->with($this->equalTo($toUpdate));
83
84		// Test: deletes just the regular files
85		$stub->expects($this->never())
86		->method('deleteStaleFiles');
87		$stub->expects($this->once())
88		->method('deleteRegularFiles')
89		->with($this->equalTo(array('file')));
90
91		// Test: clears the update queue
92		$stub->setToUpdate($toUpdate);
93		$stub->flushChanges();
94		$this->assertEmpty($stub->getToUpdate());
95		}
96
97		public function testFlushChangesToDeleteDeletesRegularAndStale()
98		{
99		$toDelete = array('/toDelete?_ID=1&_ClassName=StaticallyPublishableTest' => 10);
100
101		$stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
102		->setMethods(array('convertUrlsToPathMap', 'deleteRegularFiles', 'deleteStaleFiles'))
103		->getMock();
104
105		$stub->expects($this->once())
106		->method('convertUrlsToPathMap')
107		->will($this->returnValue(array('url' => 'file')));
108
109		// Test: deletes both regular and stale files
110		$stub->expects($this->once())
111		->method('deleteRegularFiles')
112		->with($this->equalTo(array('file')));
113		$stub->expects($this->once())
114		->method('deleteStaleFiles')
115		->with($this->equalTo(array('file')));
116
117		// Test: clears the queue
118		$stub->setToDelete($toDelete);
119		$stub->flushChanges();
120		$this->assertEmpty($stub->getToDelete());
121		}
122
123		public function testConvertUrlsToPathMapNoObject()
124		{
125		Config::modify()->set('FilesystemPublisher', 'static_base_url', 'http://foo');
126		Config::modify()->set('Director', 'alternate_base_url', '/');
127
128		$urls = array('/xyzzy');
129
130		$stub = StaticPublishingTriggerPage::create();
131
132		// Test (inclusively with urlsToPaths, these interfaces should be refactored together)
133		$result = $stub->convertUrlsToPathMap($urls);
134		$this->assertEquals(
135		$result,
136		array(
137		'/xyzzy' => './xyzzy.html'
138		)
139		);
140		}
141
142		public function testConvertUrlsToPathMapMainSite()
143		{
144		Config::modify()->set(FilesystemPublisher::class, 'static_base_url', 'http://foo');
145		Config::modify()->set(Director::class, 'alternate_base_url', '/');
146		$urls = array('/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable');
147
148		// Pretend this object supports subsites, and is from the main site.
149		$page = $this->getMockBuilder(StaticallyPublishablePage::class)
150		->setMethods(array('Subsite', 'hasExtension'))
151		->getMock();
152
153		$page->expects($this->any())
154		->method('Subsite')
155		->will($this->returnValue(null));
156		$page->expects($this->any())
157		->method('hasExtension')
158		->will($this->returnValue(true));
159
160		$stub = StaticPublishingTriggerPage::create();
161		$stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('getObject'))->getMock());
162		$stub->getUrlArrayObject()->expects($this->any())
163		->method('getObject')
164		->will($this->returnValue($page));
165
166		// Test (inclusively with urlsToPaths, these interfaces should be refactored together)
167		$result = $stub->convertUrlsToPathMap($urls);
168		$this->assertEquals(
169		array('http://foo/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
170		'foo/xyzzy.html'),
171		$result
172		);
173		}
174
175		public function testConvertUrlsToPathMapSubsite()
176		{
177		Config::modify()->set(FilesystemPublisher::class, 'static_base_url', 'http://foo');
178		Config::modify()->set(Director::class, 'alternate_base_url', '/');
179		$urls = array('/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable');
180
181		// Mock a set of objects pretending to support Subsites. Subsites might not be installed.
182		$domain1 = $this->createMock('SubsiteDomain_mock');
183		$domain1->Domain = 'subiste1.domain.org';
		0 ignored issues – show Bug introduced 2017-12-29 17:10 UTC by Report Bug Copy Issue Report Accessing `Domain` on the interface `PHPUnit_Framework_MockObject_MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
184		$domain2 = $this->createMock('SubsiteDomain_mock');
185		$domain2->Domain = 'subiste2.domain.org';
		0 ignored issues – show Bug introduced 2017-12-29 17:10 UTC by Report Bug Copy Issue Report Accessing `Domain` on the interface `PHPUnit_Framework_MockObject_MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
186
187		$domains = new ArrayList(array($domain1, $domain2));
188
189		$subsite = $this->createMock('Subsite_mock');
190		$subsite->expects($this->any())
191		->method('Domains')
192		->will($this->returnValue($domains));
193		$subsite->ID = 1;
		0 ignored issues – show Bug introduced 2017-12-29 17:10 UTC by Report Bug Copy Issue Report Accessing `ID` on the interface `PHPUnit_Framework_MockObject_MockObject` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
194
195		$stub = $this->getMockBuilder(StaticallyPublishablePage::class)
196		->setMethods(array('Subsite', 'hasExtension'))
197		->getMock();
198
199		$stub->expects($this->any())
200		->method('Subsite')
201		->will($this->returnValue($subsite));
202		$stub->expects($this->any())
203		->method('hasExtension')
204		->will($this->returnValue(true));
205
206		// Prepare static mocks.
207		$stub->setUrlArrayObject($this->getMockBuilder(URLArrayObject::class)->setMethods(array('getObject'))->getMock());
208
209		$stub->getUrlArrayObject()->expects($this->any())
210		->method('getObject')
211		->will($this->returnValue($stub));
212
213		// Test (inclusively with urlsToPaths, these interfaces should be refactored together)
214		$result = $stub->convertUrlsToPathMap($urls);
215		$this->assertEquals(
216		array(
217		'http://subiste1.domain.org/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
218		"subiste1.domain.org/xyzzy.html",
219		'http://subiste2.domain.org/xyzzy?_ID=1&_ClassName=SiteTreePublishingEngineTest_StaticallyPublishable' =>
220		"subiste2.domain.org/xyzzy.html"
221		),
222		$result
223		);
224		}
225
226		public function testDeleteStaleFiles()
227		{
228		$stub = $this->getMockBuilder(StaticPublishingTriggerPage::class)
229		->setMethods(array('deleteFromCacheDir'))
230		->getMock();
231
232		$stub->expects($this->at(0))
233		->method('deleteFromCacheDir')
234		->with($this->equalTo('xyzzy.stale.html'));
235
236		$stub->expects($this->at(1))
237		->method('deleteFromCacheDir')
238		->with($this->equalTo('foo/bar/baz.stale.html'));
239
240		$stub->deleteStaleFiles(array('xyzzy.html', 'foo/bar/baz.html'));
241		}
242		}
243

silverstripe / silverstripe-staticpublishqueue

Pull Request — master (#70)

testCollectChangesForUnpublishing() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like