ParameterConfirmationTokenTest::testCurrentAbsoluteURLHandlesSlashes() - Code Metrics - Inspection of "Merge pull request #7993 from creative-commoners/p..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0b9e95...0208b2 )

by Damian

created 2018-04-13 02:59 UTC

testCurrentAbsoluteURLHandlesSlashes() A

↳ Parent: ParameterConfirmationTokenTest

Complexity

Conditions	2
Paths	1

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace SilverStripe\Core\Tests\Startup;

use SilverStripe\Control\Controller;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Control\Session;
use SilverStripe\Core\Startup\ParameterConfirmationToken;
use SilverStripe\Core\Tests\Startup\ParameterConfirmationTokenTest\ParameterConfirmationTokenTest_Token;
use SilverStripe\Core\Tests\Startup\ParameterConfirmationTokenTest\ParameterConfirmationTokenTest_ValidToken;
use SilverStripe\Dev\SapphireTest;

class ParameterConfirmationTokenTest extends SapphireTest
{
    /**
     * @var HTTPRequest
     */
    protected $request = null;

    protected function setUp()
    {
        parent::setUp();
        $get = [];
        $get['parameterconfirmationtokentest_notoken'] = 'value';
        $get['parameterconfirmationtokentest_empty'] = '';
        $get['parameterconfirmationtokentest_withtoken'] = '1';
        $get['parameterconfirmationtokentest_withtokentoken'] = 'dummy';
        $get['parameterconfirmationtokentest_nulltoken'] = '1';
        $get['parameterconfirmationtokentest_nulltokentoken'] = null;
        $get['parameterconfirmationtokentest_emptytoken'] = '1';
        $get['parameterconfirmationtokentest_emptytokentoken'] = '';
        $get['BackURL'] = 'page?parameterconfirmationtokentest_backtoken=1';
        $this->request = new HTTPRequest('GET', 'anotherpage', $get);
        $this->request->setSession(new Session([]));
    }

    public function testParameterDetectsParameters()
    {
        $withoutToken = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_notoken',
            $this->request
        );
        $emptyParameter = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_empty',
            $this->request
        );
        $withToken = new ParameterConfirmationTokenTest_ValidToken(
            'parameterconfirmationtokentest_withtoken',
            $this->request
        );
        $withoutParameter = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_noparam',
            $this->request
        );
        $nullToken = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_nulltoken',
            $this->request
        );
        $emptyToken = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_emptytoken',
            $this->request
        );
        $backToken = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_backtoken',
            $this->request
        );

        // Check parameter
        $this->assertTrue($withoutToken->parameterProvided());
        $this->assertTrue($emptyParameter->parameterProvided());  // even if empty, it's still provided
        $this->assertTrue($withToken->parameterProvided());
        $this->assertFalse($withoutParameter->parameterProvided());
        $this->assertTrue($nullToken->parameterProvided());
        $this->assertTrue($emptyToken->parameterProvided());
        $this->assertFalse($backToken->parameterProvided());

        // Check backurl
        $this->assertFalse($withoutToken->existsInReferer());
        $this->assertFalse($emptyParameter->existsInReferer());  // even if empty, it's still provided
        $this->assertFalse($withToken->existsInReferer());
        $this->assertFalse($withoutParameter->existsInReferer());
        $this->assertFalse($nullToken->existsInReferer());
        $this->assertFalse($emptyToken->existsInReferer());
        $this->assertTrue($backToken->existsInReferer());

        // Check token
        $this->assertFalse($withoutToken->tokenProvided());
        $this->assertFalse($emptyParameter->tokenProvided());
        $this->assertTrue($withToken->tokenProvided()); // Actually forced to true for this test
        $this->assertFalse($withoutParameter->tokenProvided());
        $this->assertFalse($nullToken->tokenProvided());
        $this->assertFalse($emptyToken->tokenProvided());
        $this->assertFalse($backToken->tokenProvided());

        // Check if reload is required
        $this->assertTrue($withoutToken->reloadRequired());
        $this->assertTrue($emptyParameter->reloadRequired());
        $this->assertFalse($withToken->reloadRequired());
        $this->assertFalse($withoutParameter->reloadRequired());
        $this->assertTrue($nullToken->reloadRequired());
        $this->assertTrue($emptyToken->reloadRequired());
        $this->assertFalse($backToken->reloadRequired());

        // Check if a reload is required in case of error
        $this->assertTrue($withoutToken->reloadRequiredIfError());
        $this->assertTrue($emptyParameter->reloadRequiredIfError());
        $this->assertFalse($withToken->reloadRequiredIfError());
        $this->assertFalse($withoutParameter->reloadRequiredIfError());
        $this->assertTrue($nullToken->reloadRequiredIfError());
        $this->assertTrue($emptyToken->reloadRequiredIfError());
        $this->assertTrue($backToken->reloadRequiredIfError());

        // Check redirect url
        $home = (BASE_URL ?: '/') . '?';
        $current = Controller::join_links(BASE_URL, '/', 'anotherpage') . '?';
        $this->assertStringStartsWith($current, $withoutToken->redirectURL());
        $this->assertStringStartsWith($current, $emptyParameter->redirectURL());
        $this->assertStringStartsWith($current, $nullToken->redirectURL());
        $this->assertStringStartsWith($current, $emptyToken->redirectURL());
        $this->assertStringStartsWith($home, $backToken->redirectURL());

        // Check suppression
        $this->assertEquals('value', $this->request->getVar('parameterconfirmationtokentest_notoken'));
        $withoutToken->suppress();
        $this->assertNull($this->request->getVar('parameterconfirmationtokentest_notoken'));
    }

    public function testPrepareTokens()
    {
        // Test priority ordering
        $token = ParameterConfirmationToken::prepare_tokens(
            [
                'parameterconfirmationtokentest_notoken',
                'parameterconfirmationtokentest_empty',
                'parameterconfirmationtokentest_noparam'
            ],
            $this->request
        );
        // Test no invalid tokens
        $this->assertEquals('parameterconfirmationtokentest_empty', $token->getName());
        $token = ParameterConfirmationToken::prepare_tokens(
            [ 'parameterconfirmationtokentest_noparam' ],
            $this->request
        );
        $this->assertEmpty($token);

        // Test backurl token
        $token = ParameterConfirmationToken::prepare_tokens(
            [ 'parameterconfirmationtokentest_backtoken' ],
            $this->request
        );
        $this->assertEquals('parameterconfirmationtokentest_backtoken', $token->getName());
    }

    public function dataProviderURLs()
    {
        return [
            [''],
            ['/'],
            ['bar'],
            ['bar/'],
            ['/bar'],
            ['/bar/'],
        ];
    }

    /**
     * currentAbsoluteURL needs to handle base or url being missing, or any combination of slashes.
     *
     * There should always be exactly one slash between each part in the result, and any trailing slash
     * should be preserved.
     *
     * @dataProvider dataProviderURLs
     */
    public function testCurrentAbsoluteURLHandlesSlashes($url)
    {
        $this->request->setUrl($url);

        $token = new ParameterConfirmationTokenTest_Token(
            'parameterconfirmationtokentest_parameter',
            $this->request
        );
        $expected = rtrim(Controller::join_links(BASE_URL, '/', $url), '/') ?: '/';
        $this->assertEquals($expected, $token->currentURL(), "Invalid redirect for request url $url");
    }
}


1			<?php
2
3			namespace SilverStripe\Core\Tests\Startup;
4
5			use SilverStripe\Control\Controller;
6			use SilverStripe\Control\HTTPRequest;
7			use SilverStripe\Control\Session;
8			use SilverStripe\Core\Startup\ParameterConfirmationToken;
9			use SilverStripe\Core\Tests\Startup\ParameterConfirmationTokenTest\ParameterConfirmationTokenTest_Token;
10			use SilverStripe\Core\Tests\Startup\ParameterConfirmationTokenTest\ParameterConfirmationTokenTest_ValidToken;
11			use SilverStripe\Dev\SapphireTest;
12
13			class ParameterConfirmationTokenTest extends SapphireTest
14			{
15			/**
16			* @var HTTPRequest
17			*/
18			protected $request = null;
19
20			protected function setUp()
21			{
22			parent::setUp();
23			$get = [];
24			$get['parameterconfirmationtokentest_notoken'] = 'value';
25			$get['parameterconfirmationtokentest_empty'] = '';
26			$get['parameterconfirmationtokentest_withtoken'] = '1';
27			$get['parameterconfirmationtokentest_withtokentoken'] = 'dummy';
28			$get['parameterconfirmationtokentest_nulltoken'] = '1';
29			$get['parameterconfirmationtokentest_nulltokentoken'] = null;
30			$get['parameterconfirmationtokentest_emptytoken'] = '1';
31			$get['parameterconfirmationtokentest_emptytokentoken'] = '';
32			$get['BackURL'] = 'page?parameterconfirmationtokentest_backtoken=1';
33			$this->request = new HTTPRequest('GET', 'anotherpage', $get);
34			$this->request->setSession(new Session([]));
35			}
36
37			public function testParameterDetectsParameters()
38			{
39			$withoutToken = new ParameterConfirmationTokenTest_Token(
40			'parameterconfirmationtokentest_notoken',
41			$this->request
42			);
43			$emptyParameter = new ParameterConfirmationTokenTest_Token(
44			'parameterconfirmationtokentest_empty',
45			$this->request
46			);
47			$withToken = new ParameterConfirmationTokenTest_ValidToken(
48			'parameterconfirmationtokentest_withtoken',
49			$this->request
50			);
51			$withoutParameter = new ParameterConfirmationTokenTest_Token(
52			'parameterconfirmationtokentest_noparam',
53			$this->request
54			);
55			$nullToken = new ParameterConfirmationTokenTest_Token(
56			'parameterconfirmationtokentest_nulltoken',
57			$this->request
58			);
59			$emptyToken = new ParameterConfirmationTokenTest_Token(
60			'parameterconfirmationtokentest_emptytoken',
61			$this->request
62			);
63			$backToken = new ParameterConfirmationTokenTest_Token(
64			'parameterconfirmationtokentest_backtoken',
65			$this->request
66			);
67
68			// Check parameter
69			$this->assertTrue($withoutToken->parameterProvided());
70			$this->assertTrue($emptyParameter->parameterProvided()); // even if empty, it's still provided
71			$this->assertTrue($withToken->parameterProvided());
72			$this->assertFalse($withoutParameter->parameterProvided());
73			$this->assertTrue($nullToken->parameterProvided());
74			$this->assertTrue($emptyToken->parameterProvided());
75			$this->assertFalse($backToken->parameterProvided());
76
77			// Check backurl
78			$this->assertFalse($withoutToken->existsInReferer());
79			$this->assertFalse($emptyParameter->existsInReferer()); // even if empty, it's still provided
80			$this->assertFalse($withToken->existsInReferer());
81			$this->assertFalse($withoutParameter->existsInReferer());
82			$this->assertFalse($nullToken->existsInReferer());
83			$this->assertFalse($emptyToken->existsInReferer());
84			$this->assertTrue($backToken->existsInReferer());
85
86			// Check token
87			$this->assertFalse($withoutToken->tokenProvided());
88			$this->assertFalse($emptyParameter->tokenProvided());
89			$this->assertTrue($withToken->tokenProvided()); // Actually forced to true for this test
90			$this->assertFalse($withoutParameter->tokenProvided());
91			$this->assertFalse($nullToken->tokenProvided());
92			$this->assertFalse($emptyToken->tokenProvided());
93			$this->assertFalse($backToken->tokenProvided());
94
95			// Check if reload is required
96			$this->assertTrue($withoutToken->reloadRequired());
97			$this->assertTrue($emptyParameter->reloadRequired());
98			$this->assertFalse($withToken->reloadRequired());
99			$this->assertFalse($withoutParameter->reloadRequired());
100			$this->assertTrue($nullToken->reloadRequired());
101			$this->assertTrue($emptyToken->reloadRequired());
102			$this->assertFalse($backToken->reloadRequired());
103
104			// Check if a reload is required in case of error
105			$this->assertTrue($withoutToken->reloadRequiredIfError());
106			$this->assertTrue($emptyParameter->reloadRequiredIfError());
107			$this->assertFalse($withToken->reloadRequiredIfError());
108			$this->assertFalse($withoutParameter->reloadRequiredIfError());
109			$this->assertTrue($nullToken->reloadRequiredIfError());
110			$this->assertTrue($emptyToken->reloadRequiredIfError());
111			$this->assertTrue($backToken->reloadRequiredIfError());
112
113			// Check redirect url
114			$home = (BASE_URL ?: '/') . '?';
115			$current = Controller::join_links(BASE_URL, '/', 'anotherpage') . '?';
116			$this->assertStringStartsWith($current, $withoutToken->redirectURL());
117			$this->assertStringStartsWith($current, $emptyParameter->redirectURL());
118			$this->assertStringStartsWith($current, $nullToken->redirectURL());
119			$this->assertStringStartsWith($current, $emptyToken->redirectURL());
120			$this->assertStringStartsWith($home, $backToken->redirectURL());
121
122			// Check suppression
123			$this->assertEquals('value', $this->request->getVar('parameterconfirmationtokentest_notoken'));
124			$withoutToken->suppress();
125			$this->assertNull($this->request->getVar('parameterconfirmationtokentest_notoken'));
126			}
127
128			public function testPrepareTokens()
129			{
130			// Test priority ordering
131			$token = ParameterConfirmationToken::prepare_tokens(
132			[
133			'parameterconfirmationtokentest_notoken',
134			'parameterconfirmationtokentest_empty',
135			'parameterconfirmationtokentest_noparam'
136			],
137			$this->request
138			);
139			// Test no invalid tokens
140			$this->assertEquals('parameterconfirmationtokentest_empty', $token->getName());
141			$token = ParameterConfirmationToken::prepare_tokens(
142			[ 'parameterconfirmationtokentest_noparam' ],
143			$this->request
144			);
145			$this->assertEmpty($token);
146
147			// Test backurl token
148			$token = ParameterConfirmationToken::prepare_tokens(
149			[ 'parameterconfirmationtokentest_backtoken' ],
150			$this->request
151			);
152			$this->assertEquals('parameterconfirmationtokentest_backtoken', $token->getName());
153			}
154
155			public function dataProviderURLs()
156			{
157			return [
158			[''],
159			['/'],
160			['bar'],
161			['bar/'],
162			['/bar'],
163			['/bar/'],
164			];
165			}
166
167			/**
168			* currentAbsoluteURL needs to handle base or url being missing, or any combination of slashes.
169			*
170			* There should always be exactly one slash between each part in the result, and any trailing slash
171			* should be preserved.
172			*
173			* @dataProvider dataProviderURLs
174			*/
175			public function testCurrentAbsoluteURLHandlesSlashes($url)
176			{
177			$this->request->setUrl($url);
178
179			$token = new ParameterConfirmationTokenTest_Token(
180			'parameterconfirmationtokentest_parameter',
181			$this->request
182			);
183			$expected = rtrim(Controller::join_links(BASE_URL, '/', $url), '/') ?: '/';
184			$this->assertEquals($expected, $token->currentURL(), "Invalid redirect for request url $url");
185			}
186			}
187

silverstripe / silverstripe-framework

Push — master ( 0b9e95...0208b2 )

testCurrentAbsoluteURLHandlesSlashes() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like