SpellControllerTest::testInputRejection() - Code Metrics - Inspection of "API Refactor input and output format for TinyMCE 4..." - silverstripe/silverstripe-spellcheck - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#35)

by Robbie

created 2017-12-13 22:24 UTC

SpellControllerTest::testInputRejection() A

↳ Parent: SpellControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	61
Code Lines	44

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	61
rs	9.5147
cc	1
eloc	44
nc	1
nop	0

How to fix Long Method

<?php

namespace SilverStripe\SpellCheck\Tests;

use SilverStripe\Control\Session;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Dev\FunctionalTest;
use SilverStripe\Security\RandomGenerator;
use SilverStripe\Security\SecurityToken;
use SilverStripe\SpellCheck\Data\SpellProvider;
use SilverStripe\SpellCheck\Handling\SpellController;
use SilverStripe\SpellCheck\Tests\Stub\SpellProviderStub;

/**
 * Tests the {@see SpellController} class
 */
class SpellControllerTest extends FunctionalTest
{
    protected $usesDatabase = true;

    protected $securityWasEnabled = false;

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

        $this->securityWasEnabled = SecurityToken::is_enabled();

        // Reset config
        Config::modify()->set(SpellController::class, 'required_permission', 'CMS_ACCESS_CMSMain');
        Config::inst()->remove(SpellController::class, 'locales');
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        Config::modify()->set(SpellController::class, 'locales', array('en_US', 'en_NZ', 'fr_FR'));
        Config::modify()->set(SpellController::class, 'enable_security_token', true);
        SecurityToken::enable();

        // Setup mock for testing provider
        $spellChecker = new SpellProviderStub;
        Injector::inst()->registerService($spellChecker, SpellProvider::class);
    }

    protected function tearDown()
    {
        if ($this->securityWasEnabled) {
            SecurityToken::enable();
        } else {
            SecurityToken::disable();
        }

        parent::tearDown();
    }

    /**
     * Tests security ID check
     */
    public function testSecurityID()
    {
        // Mock token
        $securityToken = SecurityToken::inst();
        $generator = new RandomGenerator();
        $token = $generator->randomToken('sha1');
        $session = array(
            $securityToken->getName() => $token
        );
        $tokenError = _t(
            'SilverStripe\\SpellCheck\\Handling\\SpellController.SecurityMissing',
            'Your session has expired. Please refresh your browser to continue.'
        );

        // Test request sans token
        $response = $this->get('spellcheck', Injector::inst()->create(Session::class, $session));
        $this->assertEquals(400, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals($tokenError, $jsonBody->error);

        // Test request with correct token (will fail with an unrelated error)
        $response = $this->get(
            'spellcheck/?SecurityID='.urlencode($token),
            Injector::inst()->create(Session::class, $session)
        );
        $jsonBody = json_decode($response->getBody());
        $this->assertNotEquals($tokenError, $jsonBody->error);

        // Test request with check disabled
        Config::modify()->set(SpellController::class, 'enable_security_token', false);
        $response = $this->get('spellcheck', Injector::inst()->create(Session::class, $session));
        $jsonBody = json_decode($response->getBody());
        $this->assertNotEquals($tokenError, $jsonBody->error);
    }

    /**
     * Tests permission check
     */
    public function testPermissions()
    {
        // Disable security ID for this test
        Config::modify()->set(SpellController::class, 'enable_security_token', false);
        $securityError = _t('SilverStripe\\SpellCheck\\Handling\\SpellController.SecurityDenied', 'Permission Denied');

        // Test admin permissions
        Config::modify()->set(SpellController::class, 'required_permission', 'ADMIN');
        $this->logInWithPermission('ADMIN');
        $response = $this->get('spellcheck');
        $jsonBody = json_decode($response->getBody());
        $this->assertNotEquals($securityError, $jsonBody->error);

        // Test insufficient permissions
        $this->logInWithPermission('CMS_ACCESS_CMSMain');
        $response = $this->get('spellcheck');
        $this->assertEquals(403, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals($securityError, $jsonBody->error);

        // Test disabled permissions
        Config::modify()->set(SpellController::class, 'required_permission', false);
        $response = $this->get('spellcheck');
        $jsonBody = json_decode($response->getBody());
        $this->assertNotEquals($securityError, $jsonBody->error);
    }

    /**
     * @param string $lang
     * @param int $expectedStatusCode
     * @dataProvider langProvider
     */
    public function testBothLangAndLocaleInputResolveToLocale($lang, $expectedStatusCode)
    {
        $this->logInWithPermission('ADMIN');
        Config::modify()->set(SpellController::class, 'enable_security_token', false);

        // Test with a language (assumes en_US is the default "en" language locale)
        $mockData = [
            'ajax' => true,
            'method' => 'spellcheck',
            'lang' => $lang,
            'text' => 'Collor is everywhere',
        ];
        $response = $this->post('spellcheck', $mockData);
        $this->assertEquals($expectedStatusCode, $response->getStatusCode());
    }

    /**
     * @return array[]
     */
    public function langProvider()
    {
        return [
            'english_language' => [
                'en', // assumes en_US is the default locale for "en" language
                200,
            ],
            'english_locale' => [
                'en_NZ',
                200,
            ],
            'invalid_language' => [
                'ru',
                400,
            ],
            'other_valid_language' => [
                'fr', // assumes fr_FR is the default locale for "en" language
                200,
            ],
            'other_valid_locale' => [
                'fr_FR',
                200,
            ],
        ];
    }

    /**
     * Ensure that invalid input is correctly rejected
     */
    public function testInputRejection()
    {
        // Disable security ID and permissions for this test
        Config::modify()->set(SpellController::class, 'enable_security_token', false);
        Config::modify()->set(SpellController::class, 'required_permission', false);
        $invalidRequest = _t('SilverStripe\\SpellCheck\\Handling\\SpellController.InvalidRequest', 'Invalid request');

        // Test spellcheck acceptance
        $mockData = [
            'method' => 'spellcheck',
            'lang' => 'en_NZ',
            'text' => 'Collor is everywhere',
        ];
        $response = $this->post('spellcheck', ['ajax' => true] + $mockData);
        $this->assertEquals(200, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertNotEmpty($jsonBody->words);
        $this->assertNotEmpty($jsonBody->words->collor);
        $this->assertEquals(['collar', 'colour'], $jsonBody->words->collor);

        // Test non-ajax rejection
        $response = $this->post('spellcheck', $mockData);
        $this->assertEquals(400, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals($invalidRequest, $jsonBody->error);

        // Test incorrect method
        $dataInvalidMethod = $mockData;
        $dataInvalidMethod['method'] = 'validate';
        $response = $this->post('spellcheck', ['ajax' => true] + $dataInvalidMethod);
        $this->assertEquals(400, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals(
            _t(
                'SilverStripe\\SpellCheck\\Handling\\.UnsupportedMethod',
                "Unsupported method '{method}'",
                array('method' => 'validate')
            ),
            $jsonBody->error
        );

        // Test missing method
        $dataNoMethod = $mockData;
        unset($dataNoMethod['method']);
        $response = $this->post('spellcheck', ['ajax' => true] + $dataNoMethod);
        $this->assertEquals(400, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals($invalidRequest, $jsonBody->error);

        // Test unsupported locale
        $dataWrongLocale = $mockData;
        $dataWrongLocale['lang'] = 'de_DE';

        $response = $this->post('spellcheck', ['ajax' => true] + $dataWrongLocale);
        $this->assertEquals(400, $response->getStatusCode());
        $jsonBody = json_decode($response->getBody());
        $this->assertEquals(_t(
            'SilverStripe\\SpellCheck\\Handling\\.InvalidLocale',
            'Not supported locale'
        ), $jsonBody->error);
    }
}


1			<?php
2
3			namespace SilverStripe\SpellCheck\Tests;
4
5			use SilverStripe\Control\Session;
6			use SilverStripe\Core\Config\Config;
7			use SilverStripe\Core\Injector\Injector;
8			use SilverStripe\Dev\FunctionalTest;
9			use SilverStripe\Security\RandomGenerator;
10			use SilverStripe\Security\SecurityToken;
11			use SilverStripe\SpellCheck\Data\SpellProvider;
12			use SilverStripe\SpellCheck\Handling\SpellController;
13			use SilverStripe\SpellCheck\Tests\Stub\SpellProviderStub;
14
15			/**
16			* Tests the {@see SpellController} class
17			*/
18			class SpellControllerTest extends FunctionalTest
19			{
20			protected $usesDatabase = true;
21
22			protected $securityWasEnabled = false;
23
24			protected function setUp()
25			{
26			parent::setUp();
27
28			$this->securityWasEnabled = SecurityToken::is_enabled();
29
30			// Reset config
31			Config::modify()->set(SpellController::class, 'required_permission', 'CMS_ACCESS_CMSMain');
32			Config::inst()->remove(SpellController::class, 'locales');
			0 ignored issues – show Bug introduced 2017-12-11 21:15 UTC by Report Bug Copy Issue Report It seems like you code against a concrete implementation and not the interface `SilverStripe\Config\Coll...nfigCollectionInterface` as the method `remove()` does only exist in the following implementations of said interface: `SilverStripe\Config\Coll...s\DeltaConfigCollection`, `SilverStripe\Config\Coll...\MemoryConfigCollection`. Let’s take a look at an example: interface User { /** @return string / public function getPassword(); } class MyUser implements User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different implementation of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the interface: interface User { /** @return string / public function getPassword(); /* @return string */ public function getDisplayName(); } Loading history...
33			Config::modify()->set(SpellController::class, 'locales', array('en_US', 'en_NZ', 'fr_FR'));
34			Config::modify()->set(SpellController::class, 'enable_security_token', true);
35			SecurityToken::enable();
36
37			// Setup mock for testing provider
38			$spellChecker = new SpellProviderStub;
39			Injector::inst()->registerService($spellChecker, SpellProvider::class);
40			}
41
42			protected function tearDown()
43			{
44			if ($this->securityWasEnabled) {
45			SecurityToken::enable();
46			} else {
47			SecurityToken::disable();
48			}
49
50			parent::tearDown();
51			}
52
53			/**
54			* Tests security ID check
55			*/
56			public function testSecurityID()
57			{
58			// Mock token
59			$securityToken = SecurityToken::inst();
60			$generator = new RandomGenerator();
61			$token = $generator->randomToken('sha1');
62			$session = array(
63			$securityToken->getName() => $token
64			);
65			$tokenError = _t(
66			'SilverStripe\\SpellCheck\\Handling\\SpellController.SecurityMissing',
67			'Your session has expired. Please refresh your browser to continue.'
68			);
69
70			// Test request sans token
71			$response = $this->get('spellcheck', Injector::inst()->create(Session::class, $session));
72			$this->assertEquals(400, $response->getStatusCode());
73			$jsonBody = json_decode($response->getBody());
74			$this->assertEquals($tokenError, $jsonBody->error);
75
76			// Test request with correct token (will fail with an unrelated error)
77			$response = $this->get(
78			'spellcheck/?SecurityID='.urlencode($token),
79			Injector::inst()->create(Session::class, $session)
80			);
81			$jsonBody = json_decode($response->getBody());
82			$this->assertNotEquals($tokenError, $jsonBody->error);
83
84			// Test request with check disabled
85			Config::modify()->set(SpellController::class, 'enable_security_token', false);
86			$response = $this->get('spellcheck', Injector::inst()->create(Session::class, $session));
87			$jsonBody = json_decode($response->getBody());
88			$this->assertNotEquals($tokenError, $jsonBody->error);
89			}
90
91			/**
92			* Tests permission check
93			*/
94			public function testPermissions()
95			{
96			// Disable security ID for this test
97			Config::modify()->set(SpellController::class, 'enable_security_token', false);
98			$securityError = _t('SilverStripe\\SpellCheck\\Handling\\SpellController.SecurityDenied', 'Permission Denied');
99
100			// Test admin permissions
101			Config::modify()->set(SpellController::class, 'required_permission', 'ADMIN');
102			$this->logInWithPermission('ADMIN');
103			$response = $this->get('spellcheck');
104			$jsonBody = json_decode($response->getBody());
105			$this->assertNotEquals($securityError, $jsonBody->error);
106
107			// Test insufficient permissions
108			$this->logInWithPermission('CMS_ACCESS_CMSMain');
109			$response = $this->get('spellcheck');
110			$this->assertEquals(403, $response->getStatusCode());
111			$jsonBody = json_decode($response->getBody());
112			$this->assertEquals($securityError, $jsonBody->error);
113
114			// Test disabled permissions
115			Config::modify()->set(SpellController::class, 'required_permission', false);
116			$response = $this->get('spellcheck');
117			$jsonBody = json_decode($response->getBody());
118			$this->assertNotEquals($securityError, $jsonBody->error);
119			}
120
121			/**
122			* @param string $lang
123			* @param int $expectedStatusCode
124			* @dataProvider langProvider
125			*/
126			public function testBothLangAndLocaleInputResolveToLocale($lang, $expectedStatusCode)
127			{
128			$this->logInWithPermission('ADMIN');
129			Config::modify()->set(SpellController::class, 'enable_security_token', false);
130
131			// Test with a language (assumes en_US is the default "en" language locale)
132			$mockData = [
133			'ajax' => true,
134			'method' => 'spellcheck',
135			'lang' => $lang,
136			'text' => 'Collor is everywhere',
137			];
138			$response = $this->post('spellcheck', $mockData);
139			$this->assertEquals($expectedStatusCode, $response->getStatusCode());
140			}
141
142			/**
143			* @return array[]
144			*/
145			public function langProvider()
146			{
147			return [
148			'english_language' => [
149			'en', // assumes en_US is the default locale for "en" language
150			200,
151			],
152			'english_locale' => [
153			'en_NZ',
154			200,
155			],
156			'invalid_language' => [
157			'ru',
158			400,
159			],
160			'other_valid_language' => [
161			'fr', // assumes fr_FR is the default locale for "en" language
162			200,
163			],
164			'other_valid_locale' => [
165			'fr_FR',
166			200,
167			],
168			];
169			}
170
171			/**
172			* Ensure that invalid input is correctly rejected
173			*/
174			public function testInputRejection()
175			{
176			// Disable security ID and permissions for this test
177			Config::modify()->set(SpellController::class, 'enable_security_token', false);
178			Config::modify()->set(SpellController::class, 'required_permission', false);
179			$invalidRequest = _t('SilverStripe\\SpellCheck\\Handling\\SpellController.InvalidRequest', 'Invalid request');
180
181			// Test spellcheck acceptance
182			$mockData = [
183			'method' => 'spellcheck',
184			'lang' => 'en_NZ',
185			'text' => 'Collor is everywhere',
186			];
187			$response = $this->post('spellcheck', ['ajax' => true] + $mockData);
188			$this->assertEquals(200, $response->getStatusCode());
189			$jsonBody = json_decode($response->getBody());
190			$this->assertNotEmpty($jsonBody->words);
191			$this->assertNotEmpty($jsonBody->words->collor);
192			$this->assertEquals(['collar', 'colour'], $jsonBody->words->collor);
193
194			// Test non-ajax rejection
195			$response = $this->post('spellcheck', $mockData);
196			$this->assertEquals(400, $response->getStatusCode());
197			$jsonBody = json_decode($response->getBody());
198			$this->assertEquals($invalidRequest, $jsonBody->error);
199
200			// Test incorrect method
201			$dataInvalidMethod = $mockData;
202			$dataInvalidMethod['method'] = 'validate';
203			$response = $this->post('spellcheck', ['ajax' => true] + $dataInvalidMethod);
204			$this->assertEquals(400, $response->getStatusCode());
205			$jsonBody = json_decode($response->getBody());
206			$this->assertEquals(
207			_t(
208			'SilverStripe\\SpellCheck\\Handling\\.UnsupportedMethod',
209			"Unsupported method '{method}'",
210			array('method' => 'validate')
211			),
212			$jsonBody->error
213			);
214
215			// Test missing method
216			$dataNoMethod = $mockData;
217			unset($dataNoMethod['method']);
218			$response = $this->post('spellcheck', ['ajax' => true] + $dataNoMethod);
219			$this->assertEquals(400, $response->getStatusCode());
220			$jsonBody = json_decode($response->getBody());
221			$this->assertEquals($invalidRequest, $jsonBody->error);
222
223			// Test unsupported locale
224			$dataWrongLocale = $mockData;
225			$dataWrongLocale['lang'] = 'de_DE';
226
227			$response = $this->post('spellcheck', ['ajax' => true] + $dataWrongLocale);
228			$this->assertEquals(400, $response->getStatusCode());
229			$jsonBody = json_decode($response->getBody());
230			$this->assertEquals(_t(
231			'SilverStripe\\SpellCheck\\Handling\\.InvalidLocale',
232			'Not supported locale'
233			), $jsonBody->error);
234			}
235			}
236

silverstripe / silverstripe-spellcheck

Pull Request — master (#35)

SpellControllerTest::testInputRejection() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Available Fixes

Duplication Side-by-Side

Filter issues like