Issues in BlogTest.php (master) - Issues in master - silverstripe/silverstripe-blog - Measure and Improve Code Quality continuously with Scrutinizer

Issues (110)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

tests/BlogTest.php (4 issues)

Labels

Duplication 4

Severity

Informational 4

Andrew Aitken-Fincham 4

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace SilverStripe\Blog\Tests;

use PHPUnit_Framework_TestCase;
use SilverStripe\Blog\Model\Blog;
use SilverStripe\Blog\Model\BlogController;
use SilverStripe\Blog\Model\BlogPost;
use SilverStripe\CMS\Controllers\ContentController;
use SilverStripe\Control\Controller;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\Session;
use SilverStripe\Core\Config\Config;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\ORM\FieldType\DBDatetime;
use SilverStripe\ORM\SS_List;
use SilverStripe\Security\Member;

/**
 * @mixin PHPUnit_Framework_TestCase
 */
class BlogTest extends SapphireTest
{
    protected static $fixture_file = 'blog.yml';

    protected function setUp()
    {
        parent::setUp();

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

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');
        $blog->publishRecursive();
    }

    protected function tearDown()
    {
        DBDatetime::clear_mock_now();

        parent::tearDown();
    }

    public function testGetExcludedSiteTreeClassNames()
    {
        $this->logOut();

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');

        Config::inst()->update(BlogPost::class, 'show_in_sitetree', true);
        $classes = $blog->getExcludedSiteTreeClassNames();

        $this->assertNotContains(BlogPost::class, $classes, 'BlogPost class should be hidden.');

        Config::inst()->update(BlogPost::class, 'show_in_sitetree', false);
        $classes = $blog->getExcludedSiteTreeClassNames();

        $this->assertContains(BlogPost::class, $classes, 'BlogPost class should be hidden.');
    }

    public function testGetArchivedBlogPosts()
    {
        $this->logOut();

        /**
         * @var Blog $blog
         */
        $blog = $this->objFromFixture(Blog::class, '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(Blog::class, '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(Blog::class, '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(Blog::class, 'FirstBlog');

        /**
         * @var Blog $fourthBlog
         */
        $fourthBlog = $this->objFromFixture(Blog::class, 'FourthBlog');

        /**
         * @var BlogPost $postA
         */
        $postA = $this->objFromFixture(BlogPost::class, 'PostA');

        /**
         * @var BlogPost $postB
         */
        $postB = $this->objFromFixture(BlogPost::class, 'PostB');

        /**
         * @var BlogPost $postC
         */
        $postC = $this->objFromFixture(BlogPost::class, 'PostC');

        /**
         * @var Member $editor
         */
        $editor = $this->objFromFixture(Member::class, 'BlogEditor');

        /**
         * @var Member $writer
         */
        $writer = $this->objFromFixture(Member::class, 'Writer');

        /**
         * @var Member $contributor
         */
        $contributor = $this->objFromFixture(Member::class, 'Contributor');

        /**
         * @var Member $visitor
         */
        $visitor = $this->objFromFixture(Member::class, '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 testFilteredCategoriesRoot()

    {
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');
        $controller = new BlogController($blog);
        $this->requestURL($controller, 'first-post');
        $this->assertIDsEquals(
            $blog->AllChildren()->column('ID'),
            $controller->PaginatedList()->column('ID')
        );
    }

    public function testFilteredCategoriesRSS()

    {
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');
        $controller = new BlogController($blog);
        $this->requestURL($controller, 'first-post/rss');
        $this->assertIDsEquals(
            $blog->AllChildren()->column('ID'),
            $controller->PaginatedList()->column('ID')
        );
    }

    public function testFilteredCategoriesTags()

    {
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');
        $controller = new BlogController($blog);

        // Posts
        $firstPostID = $this->idFromFixture(BlogPost::class, 'FirstBlogPost');
        $firstFuturePostID = $this->idFromFixture(BlogPost::class, 'FirstFutureBlogPost');
        $secondFuturePostID = $this->idFromFixture(BlogPost::class, 'SecondFutureBlogPost');

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

    public function testFilteredCategoriesArchive()

    {
        $blog = $this->objFromFixture(Blog::class, 'FirstBlog');
        $controller = new BlogController($blog);

        // Posts
        $firstPostID = $this->idFromFixture(BlogPost::class, 'FirstBlogPost');
        $secondPostID = $this->idFromFixture(BlogPost::class, 'SecondBlogPost');
        $secondFuturePostID = $this->idFromFixture(BlogPost::class, 'SecondFutureBlogPost');

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

    /**
     * @expectedException \SilverStripe\Control\HTTPResponse_Exception
     * @expectedExceptionCode 404
     */
    public function testDisabledProfiles()
    {
        Config::modify()->set(BlogController::class, 'disable_profiles', true);

        $controller = BlogController::create();
        $controller->setRequest(Controller::curr()->getRequest());
        $controller->profile();
    }

    /**
     * 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();
        $session = new Session(null);
        $session->start($request);
        $request->setSession($session);
        $controller->doInit();
        $controller->handleRequest($request);
        $session->clearAll();
        $session->destroy();
    }

    /**
     * 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		namespace SilverStripe\Blog\Tests;
4
5		use PHPUnit_Framework_TestCase;
6		use SilverStripe\Blog\Model\Blog;
7		use SilverStripe\Blog\Model\BlogController;
8		use SilverStripe\Blog\Model\BlogPost;
9		use SilverStripe\CMS\Controllers\ContentController;
10		use SilverStripe\Control\Controller;
11		use SilverStripe\Control\Director;
12		use SilverStripe\Control\HTTPRequest;
13		use SilverStripe\Control\Session;
14		use SilverStripe\Core\Config\Config;
15		use SilverStripe\Dev\SapphireTest;
16		use SilverStripe\ORM\FieldType\DBDatetime;
17		use SilverStripe\ORM\SS_List;
18		use SilverStripe\Security\Member;
19
20		/**
21		* @mixin PHPUnit_Framework_TestCase
22		*/
23		class BlogTest extends SapphireTest
24		{
25		protected static $fixture_file = 'blog.yml';
26
27		protected function setUp()
28		{
29		parent::setUp();
30
31		DBDatetime::set_mock_now('2013-10-10 20:00:00');
32
33		/**
34		* @var Blog $blog
35		*/
36		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
37		$blog->publishRecursive();
38		}
39
40		protected function tearDown()
41		{
42		DBDatetime::clear_mock_now();
43
44		parent::tearDown();
45		}
46
47		public function testGetExcludedSiteTreeClassNames()
48		{
49		$this->logOut();
50
51		/**
52		* @var Blog $blog
53		*/
54		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
55
56		Config::inst()->update(BlogPost::class, 'show_in_sitetree', true);
57		$classes = $blog->getExcludedSiteTreeClassNames();
58
59		$this->assertNotContains(BlogPost::class, $classes, 'BlogPost class should be hidden.');
60
61		Config::inst()->update(BlogPost::class, 'show_in_sitetree', false);
62		$classes = $blog->getExcludedSiteTreeClassNames();
63
64		$this->assertContains(BlogPost::class, $classes, 'BlogPost class should be hidden.');
65		}
66
67		public function testGetArchivedBlogPosts()
68		{
69		$this->logOut();
70
71		/**
72		* @var Blog $blog
73		*/
74		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
75
76		$archive = $blog->getArchivedBlogPosts(2013);
77
78		$this->assertEquals(2, $archive->count(), 'Incorrect Yearly Archive count for 2013');
79		$this->assertEquals('First Post', $archive->first()->Title, 'Incorrect First Blog post');
80		$this->assertEquals('Second Post', $archive->last()->Title, 'Incorrect Last Blog post');
81
82		$archive = $blog->getArchivedBlogPosts(2013, 10);
83
84		$this->assertEquals(1, $archive->count(), 'Incorrect monthly archive count.');
85
86		$archive = $blog->getArchivedBlogPosts(2013, 10, 01);
87
88		$this->assertEquals(1, $archive->count(), 'Incorrect daily archive count.');
89		}
90
91		public function testArchiveLinks()
92		{
93		/**
94		* @var Blog $blog
95		*/
96		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
97
98		$link = Controller::join_links($blog->Link('archive'), '2013', '10', '01');
99
100		$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
101
102		$link = Controller::join_links($blog->Link('archive'), '2013', '10');
103
104		$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
105
106		$link = Controller::join_links($blog->Link('archive'), '2013');
107
108		$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
109
110		$link = Controller::join_links($blog->Link('archive'), '2011', '10', '01');
111
112		$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
113
114		$link = Controller::join_links($blog->Link('archive'));
115		$this->assertEquals(200, $this->getStatusOf($link), 'HTTP Status should be 200');
116
117		$link = Controller::join_links($blog->Link('archive'), 'invalid-year');
118
119		$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
120
121		$link = Controller::join_links($blog->Link('archive'), '2013', '99');
122
123		$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
124
125		$link = Controller::join_links($blog->Link('archive'), '2013', '10', '99');
126
127		$this->assertEquals(404, $this->getStatusOf($link), 'HTTP Status should be 404');
128		}
129
130		/*
131		* Test archive year
132		*/
133		public function testArchiveYear()
134		{
135		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
136		$controller = new BlogController($blog);
137		$this->requestURL($controller, 'first-post/archive/');
138		$this->assertEquals(2013, $controller->getArchiveYear(), 'getArchiveYear should return 2013');
139		}
140
141		/**
142		* @param string $link
143		*
144		* @return int
145		*/
146		protected function getStatusOf($link)
147		{
148		return Director::test($link)->getStatusCode();
149		}
150
151		public function testRoles()
152		{
153		/**
154		* @var Blog $firstBlog
155		*/
156		$firstBlog = $this->objFromFixture(Blog::class, 'FirstBlog');
157
158		/**
159		* @var Blog $fourthBlog
160		*/
161		$fourthBlog = $this->objFromFixture(Blog::class, 'FourthBlog');
162
163		/**
164		* @var BlogPost $postA
165		*/
166		$postA = $this->objFromFixture(BlogPost::class, 'PostA');
167
168		/**
169		* @var BlogPost $postB
170		*/
171		$postB = $this->objFromFixture(BlogPost::class, 'PostB');
172
173		/**
174		* @var BlogPost $postC
175		*/
176		$postC = $this->objFromFixture(BlogPost::class, 'PostC');
177
178		/**
179		* @var Member $editor
180		*/
181		$editor = $this->objFromFixture(Member::class, 'BlogEditor');
182
183		/**
184		* @var Member $writer
185		*/
186		$writer = $this->objFromFixture(Member::class, 'Writer');
187
188		/**
189		* @var Member $contributor
190		*/
191		$contributor = $this->objFromFixture(Member::class, 'Contributor');
192
193		/**
194		* @var Member $visitor
195		*/
196		$visitor = $this->objFromFixture(Member::class, 'Visitor');
197
198		$this->assertEquals('Editor', $fourthBlog->RoleOf($editor));
199		$this->assertEquals('Contributor', $fourthBlog->RoleOf($contributor));
200		$this->assertEquals('Writer', $fourthBlog->RoleOf($writer));
201		$this->assertEmpty($fourthBlog->RoleOf($visitor));
202		$this->assertEquals('Author', $postA->RoleOf($writer));
203		$this->assertEquals('Author', $postA->RoleOf($contributor));
204		$this->assertEquals('Editor', $postA->RoleOf($editor));
205		$this->assertEmpty($postA->RoleOf($visitor));
206
207		// Test RoleOf with string values given
208		$this->assertEquals('Editor', $fourthBlog->RoleOf((string)(int)$editor->ID));
209		$this->assertEquals('Contributor', $fourthBlog->RoleOf((string)(int)$contributor->ID));
210		$this->assertEquals('Writer', $fourthBlog->RoleOf((string)(int)$writer->ID));
211		$this->assertEmpty($fourthBlog->RoleOf((string)(int)$visitor->ID));
212		$this->assertEquals('Author', $postA->RoleOf((string)(int)$writer->ID));
213		$this->assertEquals('Author', $postA->RoleOf((string)(int)$contributor->ID));
214		$this->assertEquals('Editor', $postA->RoleOf((string)(int)$editor->ID));
215		$this->assertEmpty($postA->RoleOf((string)(int)$visitor->ID));
216
217		// Test RoleOf with int values given
218		$this->assertEquals('Editor', $fourthBlog->RoleOf((int)$editor->ID));
219		$this->assertEquals('Contributor', $fourthBlog->RoleOf((int)$contributor->ID));
220		$this->assertEquals('Writer', $fourthBlog->RoleOf((int)$writer->ID));
221		$this->assertEmpty($fourthBlog->RoleOf((int)$visitor->ID));
222		$this->assertEquals('Author', $postA->RoleOf((int)$writer->ID));
223		$this->assertEquals('Author', $postA->RoleOf((int)$contributor->ID));
224		$this->assertEquals('Editor', $postA->RoleOf((int)$editor->ID));
225		$this->assertEmpty($postA->RoleOf((int)$visitor->ID));
226
227		$this->assertTrue($fourthBlog->canEdit($editor));
228		$this->assertFalse($firstBlog->canEdit($editor));
229		$this->assertTrue($fourthBlog->canAddChildren($editor));
230		$this->assertFalse($firstBlog->canAddChildren($editor));
231		$this->assertTrue($postA->canEdit($editor));
232		$this->assertTrue($postB->canEdit($editor));
233		$this->assertTrue($postC->canEdit($editor));
234		$this->assertTrue($postA->canPublish($editor));
235		$this->assertTrue($postB->canPublish($editor));
236		$this->assertTrue($postC->canPublish($editor));
237
238		$this->assertFalse($fourthBlog->canEdit($writer));
239		$this->assertFalse($firstBlog->canEdit($writer));
240		$this->assertTrue($fourthBlog->canAddChildren($writer));
241		$this->assertFalse($firstBlog->canAddChildren($writer));
242		$this->assertTrue($postA->canEdit($writer));
243		$this->assertFalse($postB->canEdit($writer));
244		$this->assertTrue($postC->canEdit($writer));
245		$this->assertTrue($postA->canPublish($writer));
246		$this->assertFalse($postB->canPublish($writer));
247		$this->assertTrue($postC->canPublish($writer));
248
249		$this->assertFalse($fourthBlog->canEdit($contributor));
250		$this->assertFalse($firstBlog->canEdit($contributor));
251		$this->assertTrue($fourthBlog->canAddChildren($contributor));
252		$this->assertFalse($firstBlog->canAddChildren($contributor));
253		$this->assertTrue($postA->canEdit($contributor));
254		$this->assertFalse($postB->canEdit($contributor));
255		$this->assertTrue($postC->canEdit($contributor));
256		$this->assertFalse($postA->canPublish($contributor));
257		$this->assertFalse($postB->canPublish($contributor));
258		$this->assertFalse($postC->canPublish($contributor));
259
260		$this->assertFalse($fourthBlog->canEdit($visitor));
261		$this->assertFalse($firstBlog->canEdit($visitor));
262		$this->assertFalse($fourthBlog->canAddChildren($visitor));
263		$this->assertFalse($firstBlog->canAddChildren($visitor));
264		$this->assertFalse($postA->canEdit($visitor));
265		$this->assertFalse($postB->canEdit($visitor));
266		$this->assertFalse($postC->canEdit($visitor));
267		$this->assertFalse($postA->canPublish($visitor));
268		$this->assertFalse($postB->canPublish($visitor));
269		$this->assertFalse($postC->canPublish($visitor));
270		}
271
272	View Code Duplication	public function testFilteredCategoriesRoot()
		0 ignored issues – show Duplication introduced 2017-07-04 17:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
273		{
274		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
275		$controller = new BlogController($blog);
276		$this->requestURL($controller, 'first-post');
277		$this->assertIDsEquals(
278		$blog->AllChildren()->column('ID'),
279		$controller->PaginatedList()->column('ID')
280		);
281		}
282
283	View Code Duplication	public function testFilteredCategoriesRSS()
		0 ignored issues – show Duplication introduced 2017-08-24 22:02 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
284		{
285		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
286		$controller = new BlogController($blog);
287		$this->requestURL($controller, 'first-post/rss');
288		$this->assertIDsEquals(
289		$blog->AllChildren()->column('ID'),
290		$controller->PaginatedList()->column('ID')
291		);
292		}
293
294	View Code Duplication	public function testFilteredCategoriesTags()
		0 ignored issues – show Duplication introduced 2017-08-24 22:02 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
295		{
296		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
297		$controller = new BlogController($blog);
298
299		// Posts
300		$firstPostID = $this->idFromFixture(BlogPost::class, 'FirstBlogPost');
301		$firstFuturePostID = $this->idFromFixture(BlogPost::class, 'FirstFutureBlogPost');
302		$secondFuturePostID = $this->idFromFixture(BlogPost::class, 'SecondFutureBlogPost');
303
304		// Request first tag
305		$this->requestURL($controller, 'first-post/tag/first-tag');
306		$this->assertIDsEquals(
307		[$firstPostID, $firstFuturePostID, $secondFuturePostID],
308		$controller->PaginatedList()
309		);
310		}
311
312	View Code Duplication	public function testFilteredCategoriesArchive()
		0 ignored issues – show Duplication introduced 2017-08-24 22:02 UTC by Report Bug Copy Issue Report Show Similar Issues like this 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...
313		{
314		$blog = $this->objFromFixture(Blog::class, 'FirstBlog');
315		$controller = new BlogController($blog);
316
317		// Posts
318		$firstPostID = $this->idFromFixture(BlogPost::class, 'FirstBlogPost');
319		$secondPostID = $this->idFromFixture(BlogPost::class, 'SecondBlogPost');
320		$secondFuturePostID = $this->idFromFixture(BlogPost::class, 'SecondFutureBlogPost');
321
322		// Request 2013 posts
323		$this->requestURL($controller, 'first-post/archive/2013');
324		$this->assertIDsEquals(
325		[$firstPostID, $secondPostID, $secondFuturePostID],
326		$controller->PaginatedList()
327		);
328		}
329
330		/**
331		* @expectedException \SilverStripe\Control\HTTPResponse_Exception
332		* @expectedExceptionCode 404
333		*/
334		public function testDisabledProfiles()
335		{
336		Config::modify()->set(BlogController::class, 'disable_profiles', true);
337
338		$controller = BlogController::create();
339		$controller->setRequest(Controller::curr()->getRequest());
340		$controller->profile();
341		}
342
343		/**
344		* Mock a request against a given controller
345		*
346		* @param ContentController $controller
347		* @param string $url
348		*/
349		protected function requestURL(ContentController $controller, $url)
350		{
351		$request = new HTTPRequest('get', $url);
352		$request->match('$URLSegment//$Action/$ID/$OtherID');
353		$request->shift();
354		$session = new Session(null);
355		$session->start($request);
356		$request->setSession($session);
357		$controller->doInit();
358		$controller->handleRequest($request);
359		$session->clearAll();
360		$session->destroy();
361		}
362
363		/**
364		* Assert these id lists match
365		*
366		* @param array\|SS_List $left
367		* @param array\|SS_List $right
368		*/
369		protected function assertIDsEquals($left, $right)
370		{
371		if ($left instanceof SS_List) {
372		$left = $left->column('ID');
373		}
374		if ($right instanceof SS_List) {
375		$right = $right->column('ID');
376		}
377		asort($left);
378		asort($right);
379		$this->assertEquals(array_values($left), array_values($right));
380		}
381		}
382

silverstripe / silverstripe-blog

Issues (110)

Security Analysis not enabled

tests/BlogTest.php (4 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like