BlogTest::testRoles() - Code Metrics - Inspection of "SilverStripe 4 compatibility" - silverstripe/silverstripe-blog - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#421)

by Robbie

created 2017-01-24 00:45 UTC

BlogTest::testRoles() B

↳ Parent: BlogTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	120
Code Lines	74

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	120
rs	8.2857
c	0
b	0
f	0
cc	1
eloc	74
nc	1
nop	0

How to fix Long Method

<?php

use SilverStripe\Blog\Model\BlogController;
use SilverStripe\CMS\Controllers\ContentController;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPRequest;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\DataModel;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\ORM\SS_List;
use SilverStripe\Security\Member;

/**
 * @mixin PHPUnit_Framework_TestCase
 */
class BlogTest extends SapphireTest
namespace YourVendor;

class YourClass { }
{
    /**
     * @var string
     */
    public static $fixture_file = 'blog.yml';

    /**
     * {@inheritdoc}
     */
    public function setUp()
    {
        parent::setUp();

        Config::nest();
        DBDatetime::set_mock_now('2013-10-10 20:00:00');

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');

        $blog->publish('Stage', 'Live');
    }

    /**
     * {@inheritdoc}
     */
    public function tearDown()
    {
        DBDatetime::clear_mock_now();
        Config::unnest();

        parent::tearDown();
    }

    public function testGetExcludedSiteTreeClassNames()
    {
        $member = Member::currentUser();

        if ($member) {
            $member->logout();
        }

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');

        Config::inst()->update('SilverStripe\\Blog\\Model\\BlogPost', 'show_in_sitetree', true);
        $classes = $blog->getExcludedSiteTreeClassNames();

        $this->assertNotContains('SilverStripe\\Blog\\Model\\BlogPost', $classes, 'BlogPost class should be hidden.');

        Config::inst()->update('SilverStripe\\Blog\\Model\\BlogPost', 'show_in_sitetree', false);
        $classes = $blog->getExcludedSiteTreeClassNames();

        $this->assertContains('SilverStripe\\Blog\\Model\\BlogPost', $classes, 'BlogPost class should be hidden.');
    }

    public function testGetArchivedBlogPosts()
    {
        $member = Member::currentUser();

        if ($member) {
            $member->logout();
        }

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');

        $archive = $blog->getArchivedBlogPosts(2013);

        $this->assertEquals(2, $archive->count(), 'Incorrect Yearly Archive count for 2013');
        $this->assertEquals('First Post', $archive->first()->Title, 'Incorrect First Blog post');
        $this->assertEquals('Second Post', $archive->last()->Title, 'Incorrect Last Blog post');

        $archive = $blog->getArchivedBlogPosts(2013, 10);

        $this->assertEquals(1, $archive->count(), 'Incorrect monthly archive count.');

        $archive = $blog->getArchivedBlogPosts(2013, 10, 01);

        $this->assertEquals(1, $archive->count(), 'Incorrect daily archive count.');
    }

    public function testArchiveLinks()
    {
        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');

        $link = Controller::join_links($blog->Link('archive'), '2013', '10', '01');

        $this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');

        $link = Controller::join_links($blog->Link('archive'), '2013', '10');

        $this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');

        $link = Controller::join_links($blog->Link('archive'), '2013');

        $this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');

        $link = Controller::join_links($blog->Link('archive'), '2011', '10', '01');

        $this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');

        $link = Controller::join_links($blog->Link('archive'));
        $this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');

        $link = Controller::join_links($blog->Link('archive'), 'invalid-year');

        $this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');

        $link = Controller::join_links($blog->Link('archive'), '2013', '99');

        $this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');

        $link = Controller::join_links($blog->Link('archive'), '2013', '10', '99');

        $this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
    }

    /*
     * Test archive year
     */
    public function testArchiveYear()
    {
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
        $controller = new BlogController($blog);
        $this->requestURL($controller, 'first-post/archive/');
        $this->assertEquals(2013, $controller->getArchiveYear(), 'getArchiveYear should return 2013');
    }

    /**
     * @param string $link
     *
     * @return int
     */
    protected function getStatusOf($link)
    {
        return Director::test($link)->getStatusCode();
    }

    public function testRoles()
    {
        /**
         * @var Blog $firstBlog
         */
        $firstBlog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');

        /**
         * @var Blog $fourthBlog
         */
        $fourthBlog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FourthBlog');

        /**
         * @var BlogPost $postA
         */
        $postA = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostA');

        /**
         * @var BlogPost $postB
         */
        $postB = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostB');

        /**
         * @var BlogPost $postC
         */
        $postC = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostC');

        /**
         * @var Member $editor
         */
        $editor = $this->objFromFixture('SilverStripe\\Security\\Member', 'BlogEditor');

        /**
         * @var Member $writer
         */
        $writer = $this->objFromFixture('SilverStripe\\Security\\Member', 'Writer');

        /**
         * @var Member $contributor
         */
        $contributor = $this->objFromFixture('SilverStripe\\Security\\Member', 'Contributor');

        /**
         * @var Member $visitor
         */
        $visitor = $this->objFromFixture('SilverStripe\\Security\\Member', 'Visitor');

        $this->assertEquals('Editor', $fourthBlog->RoleOf($editor));
        $this->assertEquals('Contributor', $fourthBlog->RoleOf($contributor));
        $this->assertEquals('Writer', $fourthBlog->RoleOf($writer));
        $this->assertEmpty($fourthBlog->RoleOf($visitor));
        $this->assertEquals('Author', $postA->RoleOf($writer));
        $this->assertEquals('Author', $postA->RoleOf($contributor));
        $this->assertEquals('Editor', $postA->RoleOf($editor));
        $this->assertEmpty($postA->RoleOf($visitor));

        // Test RoleOf with string values given
        $this->assertEquals('Editor', $fourthBlog->RoleOf((string)(int)$editor->ID));
        $this->assertEquals('Contributor', $fourthBlog->RoleOf((string)(int)$contributor->ID));
        $this->assertEquals('Writer', $fourthBlog->RoleOf((string)(int)$writer->ID));
        $this->assertEmpty($fourthBlog->RoleOf((string)(int)$visitor->ID));
        $this->assertEquals('Author', $postA->RoleOf((string)(int)$writer->ID));
        $this->assertEquals('Author', $postA->RoleOf((string)(int)$contributor->ID));
        $this->assertEquals('Editor', $postA->RoleOf((string)(int)$editor->ID));
        $this->assertEmpty($postA->RoleOf((string)(int)$visitor->ID));

        // Test RoleOf with int values given
        $this->assertEquals('Editor', $fourthBlog->RoleOf((int)$editor->ID));
        $this->assertEquals('Contributor', $fourthBlog->RoleOf((int)$contributor->ID));
        $this->assertEquals('Writer', $fourthBlog->RoleOf((int)$writer->ID));
        $this->assertEmpty($fourthBlog->RoleOf((int)$visitor->ID));
        $this->assertEquals('Author', $postA->RoleOf((int)$writer->ID));
        $this->assertEquals('Author', $postA->RoleOf((int)$contributor->ID));
        $this->assertEquals('Editor', $postA->RoleOf((int)$editor->ID));
        $this->assertEmpty($postA->RoleOf((int)$visitor->ID));

        $this->assertTrue($fourthBlog->canEdit($editor));
        $this->assertFalse($firstBlog->canEdit($editor));
        $this->assertTrue($fourthBlog->canAddChildren($editor));
        $this->assertFalse($firstBlog->canAddChildren($editor));
        $this->assertTrue($postA->canEdit($editor));
        $this->assertTrue($postB->canEdit($editor));
        $this->assertTrue($postC->canEdit($editor));
        $this->assertTrue($postA->canPublish($editor));
        $this->assertTrue($postB->canPublish($editor));
        $this->assertTrue($postC->canPublish($editor));

        $this->assertFalse($fourthBlog->canEdit($writer));
        $this->assertFalse($firstBlog->canEdit($writer));
        $this->assertTrue($fourthBlog->canAddChildren($writer));
        $this->assertFalse($firstBlog->canAddChildren($writer));
        $this->assertTrue($postA->canEdit($writer));
        $this->assertFalse($postB->canEdit($writer));
        $this->assertTrue($postC->canEdit($writer));
        $this->assertTrue($postA->canPublish($writer));
        $this->assertFalse($postB->canPublish($writer));
        $this->assertTrue($postC->canPublish($writer));

        $this->assertFalse($fourthBlog->canEdit($contributor));
        $this->assertFalse($firstBlog->canEdit($contributor));
        $this->assertTrue($fourthBlog->canAddChildren($contributor));
        $this->assertFalse($firstBlog->canAddChildren($contributor));
        $this->assertTrue($postA->canEdit($contributor));
        $this->assertFalse($postB->canEdit($contributor));
        $this->assertTrue($postC->canEdit($contributor));
        $this->assertFalse($postA->canPublish($contributor));
        $this->assertFalse($postB->canPublish($contributor));
        $this->assertFalse($postC->canPublish($contributor));

        $this->assertFalse($fourthBlog->canEdit($visitor));
        $this->assertFalse($firstBlog->canEdit($visitor));
        $this->assertFalse($fourthBlog->canAddChildren($visitor));
        $this->assertFalse($firstBlog->canAddChildren($visitor));
        $this->assertFalse($postA->canEdit($visitor));
        $this->assertFalse($postB->canEdit($visitor));
        $this->assertFalse($postC->canEdit($visitor));
        $this->assertFalse($postA->canPublish($visitor));
        $this->assertFalse($postB->canPublish($visitor));
        $this->assertFalse($postC->canPublish($visitor));
    }

    public function testFilteredCategories()
    {
        $blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
        $controller = new BlogController($blog);

        // Root url
        $this->requestURL($controller, 'first-post');
        $this->assertIDsEquals(
            $blog->AllChildren()->column('ID'),
            $controller->PaginatedList()->column('ID')
        );


        // RSS
        $this->requestURL($controller, 'first-post/rss');
        $this->assertIDsEquals(
            $blog->AllChildren()->column('ID'),
            $controller->PaginatedList()->column('ID')
        );

        // Posts
        $firstPostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'FirstBlogPost');
        $secondPostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'SecondBlogPost');
        $firstFuturePostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'FirstFutureBlogPost');
        $secondFuturePostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'SecondFutureBlogPost');

        // Request first tag
        $this->requestURL($controller, 'first-post/tag/first-tag');
        $this->assertIDsEquals(
            array($firstPostID, $firstFuturePostID, $secondFuturePostID),
            $controller->PaginatedList()
        );

        // Request 2013 posts
        $this->requestURL($controller, 'first-post/archive/2013');
        $this->assertIDsEquals(
            array($firstPostID, $secondPostID, $secondFuturePostID),
            $controller->PaginatedList()
        );
    }

    /**
     * Mock a request against a given controller
     *
     * @param ContentController $controller
     * @param string $url
     */
    protected function requestURL(ContentController $controller, $url)
    {
        $request = new HTTPRequest('get', $url);
        $request->match('$URLSegment//$Action/$ID/$OtherID');
        $request->shift();
        $controller->init();
        $controller->handleRequest($request, new DataModel());
    }

    /**
     * Assert these id lists match
     *
     * @param array|SS_List $left
     * @param array|SS_List $right
     */
    protected function assertIDsEquals($left, $right)
    {
        if ($left instanceof SS_List) {
            $left = $left->column('ID');
        }
        if ($right instanceof SS_List) {
            $right = $right->column('ID');
        }
        asort($left);
        asort($right);
        $this->assertEquals(array_values($left), array_values($right));
    }
}


1			<?php
2
3			use SilverStripe\Blog\Model\BlogController;
4			use SilverStripe\CMS\Controllers\ContentController;
5			use SilverStripe\Control\Controller;
6			use SilverStripe\Control\Director;
7			use SilverStripe\Control\HTTPRequest;
			0 ignored issues – show Bug introduced 2017-01-18 04:24 UTC by Report Bug Copy Issue Report This use statement conflicts with another class in this namespace, `HTTPRequest`. Let’s assume that you have a directory layout like this: . \|-- OtherDir \| \|-- Bar.php \| `-- Foo.php `-- SomeDir `-- Foo.php and let’s assume the following content of `Bar.php`: // Bar.php namespace OtherDir; use SomeDir\Foo; // This now conflicts the class OtherDir\Foo If both files `OtherDir/Foo.php` and `SomeDir/Foo.php` are loaded in the same runtime, you will see a PHP error such as the following: PHP Fatal error: Cannot use SomeDir\Foo as Foo because the name is already in use in OtherDir/Foo.php However, as `OtherDir/Foo.php` does not necessarily have to be loaded and the error is only triggered if it is loaded before `OtherDir/Bar.php`, this problem might go unnoticed for a while. In order to prevent this error from surfacing, you must import the namespace with a different alias: // Bar.php namespace OtherDir; use SomeDir\Foo as SomeDirFoo; // There is no conflict anymore. Loading history...
8			use SilverStripe\Core\Config\Config;
9			use SilverStripe\Dev\SapphireTest;
10			use SilverStripe\ORM\DataModel;
11			use SilverStripe\ORM\FieldType\DBDatetime;
12			use SilverStripe\ORM\SS_List;
13			use SilverStripe\Security\Member;
14
15			/**
16			* @mixin PHPUnit_Framework_TestCase
17			*/
18			class BlogTest extends SapphireTest
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-20 23:49 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
19			{
20			/**
21			* @var string
22			*/
23			public static $fixture_file = 'blog.yml';
24
25			/**
26			* {@inheritdoc}
27			*/
28			public function setUp()
29			{
30			parent::setUp();
31
32			Config::nest();
33			DBDatetime::set_mock_now('2013-10-10 20:00:00');
34
35			/**
36			* @var Blog $blog
37			*/
38			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
39
40			$blog->publish('Stage', 'Live');
41			}
42
43			/**
44			* {@inheritdoc}
45			*/
46			public function tearDown()
47			{
48			DBDatetime::clear_mock_now();
49			Config::unnest();
50
51			parent::tearDown();
52			}
53
54			public function testGetExcludedSiteTreeClassNames()
55			{
56			$member = Member::currentUser();
57
58			if ($member) {
59			$member->logout();
60			}
61
62			/**
63			* @var Blog $blog
64			*/
65			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
66
67			Config::inst()->update('SilverStripe\\Blog\\Model\\BlogPost', 'show_in_sitetree', true);
68			$classes = $blog->getExcludedSiteTreeClassNames();
69
70			$this->assertNotContains('SilverStripe\\Blog\\Model\\BlogPost', $classes, 'BlogPost class should be hidden.');
71
72			Config::inst()->update('SilverStripe\\Blog\\Model\\BlogPost', 'show_in_sitetree', false);
73			$classes = $blog->getExcludedSiteTreeClassNames();
74
75			$this->assertContains('SilverStripe\\Blog\\Model\\BlogPost', $classes, 'BlogPost class should be hidden.');
76			}
77
78			public function testGetArchivedBlogPosts()
79			{
80			$member = Member::currentUser();
81
82			if ($member) {
83			$member->logout();
84			}
85
86			/**
87			* @var Blog $blog
88			*/
89			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
90
91			$archive = $blog->getArchivedBlogPosts(2013);
92
93			$this->assertEquals(2, $archive->count(), 'Incorrect Yearly Archive count for 2013');
94			$this->assertEquals('First Post', $archive->first()->Title, 'Incorrect First Blog post');
95			$this->assertEquals('Second Post', $archive->last()->Title, 'Incorrect Last Blog post');
96
97			$archive = $blog->getArchivedBlogPosts(2013, 10);
98
99			$this->assertEquals(1, $archive->count(), 'Incorrect monthly archive count.');
100
101			$archive = $blog->getArchivedBlogPosts(2013, 10, 01);
102
103			$this->assertEquals(1, $archive->count(), 'Incorrect daily archive count.');
104			}
105
106			public function testArchiveLinks()
107			{
108			/**
109			* @var Blog $blog
110			*/
111			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
112
113			$link = Controller::join_links($blog->Link('archive'), '2013', '10', '01');
114
115			$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
116
117			$link = Controller::join_links($blog->Link('archive'), '2013', '10');
118
119			$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
120
121			$link = Controller::join_links($blog->Link('archive'), '2013');
122
123			$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
124
125			$link = Controller::join_links($blog->Link('archive'), '2011', '10', '01');
126
127			$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
128
129			$link = Controller::join_links($blog->Link('archive'));
130			$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
131
132			$link = Controller::join_links($blog->Link('archive'), 'invalid-year');
133
134			$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
135
136			$link = Controller::join_links($blog->Link('archive'), '2013', '99');
137
138			$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
139
140			$link = Controller::join_links($blog->Link('archive'), '2013', '10', '99');
141
142			$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
143			}
144
145			/*
146			* Test archive year
147			*/
148			public function testArchiveYear()
149			{
150			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
151			$controller = new BlogController($blog);
152			$this->requestURL($controller, 'first-post/archive/');
153			$this->assertEquals(2013, $controller->getArchiveYear(), 'getArchiveYear should return 2013');
154			}
155
156			/**
157			* @param string $link
158			*
159			* @return int
160			*/
161			protected function getStatusOf($link)
162			{
163			return Director::test($link)->getStatusCode();
164			}
165
166			public function testRoles()
167			{
168			/**
169			* @var Blog $firstBlog
170			*/
171			$firstBlog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
172
173			/**
174			* @var Blog $fourthBlog
175			*/
176			$fourthBlog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FourthBlog');
177
178			/**
179			* @var BlogPost $postA
180			*/
181			$postA = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostA');
182
183			/**
184			* @var BlogPost $postB
185			*/
186			$postB = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostB');
187
188			/**
189			* @var BlogPost $postC
190			*/
191			$postC = $this->objFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'PostC');
192
193			/**
194			* @var Member $editor
195			*/
196			$editor = $this->objFromFixture('SilverStripe\\Security\\Member', 'BlogEditor');
197
198			/**
199			* @var Member $writer
200			*/
201			$writer = $this->objFromFixture('SilverStripe\\Security\\Member', 'Writer');
202
203			/**
204			* @var Member $contributor
205			*/
206			$contributor = $this->objFromFixture('SilverStripe\\Security\\Member', 'Contributor');
207
208			/**
209			* @var Member $visitor
210			*/
211			$visitor = $this->objFromFixture('SilverStripe\\Security\\Member', 'Visitor');
212
213			$this->assertEquals('Editor', $fourthBlog->RoleOf($editor));
214			$this->assertEquals('Contributor', $fourthBlog->RoleOf($contributor));
215			$this->assertEquals('Writer', $fourthBlog->RoleOf($writer));
216			$this->assertEmpty($fourthBlog->RoleOf($visitor));
217			$this->assertEquals('Author', $postA->RoleOf($writer));
218			$this->assertEquals('Author', $postA->RoleOf($contributor));
219			$this->assertEquals('Editor', $postA->RoleOf($editor));
220			$this->assertEmpty($postA->RoleOf($visitor));
221
222			// Test RoleOf with string values given
223			$this->assertEquals('Editor', $fourthBlog->RoleOf((string)(int)$editor->ID));
224			$this->assertEquals('Contributor', $fourthBlog->RoleOf((string)(int)$contributor->ID));
225			$this->assertEquals('Writer', $fourthBlog->RoleOf((string)(int)$writer->ID));
226			$this->assertEmpty($fourthBlog->RoleOf((string)(int)$visitor->ID));
227			$this->assertEquals('Author', $postA->RoleOf((string)(int)$writer->ID));
228			$this->assertEquals('Author', $postA->RoleOf((string)(int)$contributor->ID));
229			$this->assertEquals('Editor', $postA->RoleOf((string)(int)$editor->ID));
230			$this->assertEmpty($postA->RoleOf((string)(int)$visitor->ID));
231
232			// Test RoleOf with int values given
233			$this->assertEquals('Editor', $fourthBlog->RoleOf((int)$editor->ID));
234			$this->assertEquals('Contributor', $fourthBlog->RoleOf((int)$contributor->ID));
235			$this->assertEquals('Writer', $fourthBlog->RoleOf((int)$writer->ID));
236			$this->assertEmpty($fourthBlog->RoleOf((int)$visitor->ID));
237			$this->assertEquals('Author', $postA->RoleOf((int)$writer->ID));
238			$this->assertEquals('Author', $postA->RoleOf((int)$contributor->ID));
239			$this->assertEquals('Editor', $postA->RoleOf((int)$editor->ID));
240			$this->assertEmpty($postA->RoleOf((int)$visitor->ID));
241
242			$this->assertTrue($fourthBlog->canEdit($editor));
243			$this->assertFalse($firstBlog->canEdit($editor));
244			$this->assertTrue($fourthBlog->canAddChildren($editor));
245			$this->assertFalse($firstBlog->canAddChildren($editor));
246			$this->assertTrue($postA->canEdit($editor));
247			$this->assertTrue($postB->canEdit($editor));
248			$this->assertTrue($postC->canEdit($editor));
249			$this->assertTrue($postA->canPublish($editor));
250			$this->assertTrue($postB->canPublish($editor));
251			$this->assertTrue($postC->canPublish($editor));
252
253			$this->assertFalse($fourthBlog->canEdit($writer));
254			$this->assertFalse($firstBlog->canEdit($writer));
255			$this->assertTrue($fourthBlog->canAddChildren($writer));
256			$this->assertFalse($firstBlog->canAddChildren($writer));
257			$this->assertTrue($postA->canEdit($writer));
258			$this->assertFalse($postB->canEdit($writer));
259			$this->assertTrue($postC->canEdit($writer));
260			$this->assertTrue($postA->canPublish($writer));
261			$this->assertFalse($postB->canPublish($writer));
262			$this->assertTrue($postC->canPublish($writer));
263
264			$this->assertFalse($fourthBlog->canEdit($contributor));
265			$this->assertFalse($firstBlog->canEdit($contributor));
266			$this->assertTrue($fourthBlog->canAddChildren($contributor));
267			$this->assertFalse($firstBlog->canAddChildren($contributor));
268			$this->assertTrue($postA->canEdit($contributor));
269			$this->assertFalse($postB->canEdit($contributor));
270			$this->assertTrue($postC->canEdit($contributor));
271			$this->assertFalse($postA->canPublish($contributor));
272			$this->assertFalse($postB->canPublish($contributor));
273			$this->assertFalse($postC->canPublish($contributor));
274
275			$this->assertFalse($fourthBlog->canEdit($visitor));
276			$this->assertFalse($firstBlog->canEdit($visitor));
277			$this->assertFalse($fourthBlog->canAddChildren($visitor));
278			$this->assertFalse($firstBlog->canAddChildren($visitor));
279			$this->assertFalse($postA->canEdit($visitor));
280			$this->assertFalse($postB->canEdit($visitor));
281			$this->assertFalse($postC->canEdit($visitor));
282			$this->assertFalse($postA->canPublish($visitor));
283			$this->assertFalse($postB->canPublish($visitor));
284			$this->assertFalse($postC->canPublish($visitor));
285			}
286
287			public function testFilteredCategories()
288			{
289			$blog = $this->objFromFixture('SilverStripe\\Blog\\Model\\Blog', 'FirstBlog');
290			$controller = new BlogController($blog);
291
292			// Root url
293			$this->requestURL($controller, 'first-post');
294			$this->assertIDsEquals(
295			$blog->AllChildren()->column('ID'),
296			$controller->PaginatedList()->column('ID')
297			);
298
299
300			// RSS
301			$this->requestURL($controller, 'first-post/rss');
302			$this->assertIDsEquals(
303			$blog->AllChildren()->column('ID'),
304			$controller->PaginatedList()->column('ID')
305			);
306
307			// Posts
308			$firstPostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'FirstBlogPost');
309			$secondPostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'SecondBlogPost');
310			$firstFuturePostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'FirstFutureBlogPost');
311			$secondFuturePostID = $this->idFromFixture('SilverStripe\\Blog\\Model\\BlogPost', 'SecondFutureBlogPost');
312
313			// Request first tag
314			$this->requestURL($controller, 'first-post/tag/first-tag');
315			$this->assertIDsEquals(
316			array($firstPostID, $firstFuturePostID, $secondFuturePostID),
317			$controller->PaginatedList()
318			);
319
320			// Request 2013 posts
321			$this->requestURL($controller, 'first-post/archive/2013');
322			$this->assertIDsEquals(
323			array($firstPostID, $secondPostID, $secondFuturePostID),
324			$controller->PaginatedList()
325			);
326			}
327
328			/**
329			* Mock a request against a given controller
330			*
331			* @param ContentController $controller
332			* @param string $url
333			*/
334			protected function requestURL(ContentController $controller, $url)
335			{
336			$request = new HTTPRequest('get', $url);
337			$request->match('$URLSegment//$Action/$ID/$OtherID');
338			$request->shift();
339			$controller->init();
340			$controller->handleRequest($request, new DataModel());
341			}
342
343			/**
344			* Assert these id lists match
345			*
346			* @param array\|SS_List $left
347			* @param array\|SS_List $right
348			*/
349			protected function assertIDsEquals($left, $right)
350			{
351			if ($left instanceof SS_List) {
352			$left = $left->column('ID');
353			}
354			if ($right instanceof SS_List) {
355			$right = $right->column('ID');
356			}
357			asort($left);
358			asort($right);
359			$this->assertEquals(array_values($left), array_values($right));
360			}
361			}
362

silverstripe / silverstripe-blog

Pull Request — master (#421)

BlogTest::testRoles() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like