SilverStripe\MFA\Tests\BackupCode\VerifyHandlerTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	testVerifyValidatesCodes()	0	7	1
A	getVerifyTests()	0	8	1
A	testVerifySendsNotification()	0	6	1
A	scaffoldVerifyParams()	0	17	1
A	testVerifyInvalidatesCodesThatHaveBeenUsed()	0	17	1

<?php

namespace SilverStripe\MFA\Tests\BackupCode;

use PHPUnit_Framework_MockObject_MockObject;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\MFA\BackupCode\VerifyHandler;
use SilverStripe\MFA\Extension\MemberExtension;
use SilverStripe\MFA\Model\RegisteredMethod;
use SilverStripe\MFA\Service\Notification;
use SilverStripe\MFA\Store\StoreInterface;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\Member;

class VerifyHandlerTest extends SapphireTest
{
    protected static $fixture_file = 'VerifyHandlerTest.yml';

    /**
     * @dataProvider getVerifyTests
     */
    public function testVerifyValidatesCodes($expectedResult, $input, $message)
    {
        $handler = (new VerifyHandler())->setNotificationService($this->createMock(Notification::class));

        // Test a code with invalid characters
        list ($request, $store, $method) = $this->scaffoldVerifyParams($input);
        $this->assertSame($expectedResult, $handler->verify($request, $store, $method)->isSuccessful(), $message);
    }

    public function testVerifySendsNotification()
    {
        $handler = (new VerifyHandler())->setNotificationService((Notification::create()));
        list ($request, $store, $method) = $this->scaffoldVerifyParams('123456');
        $this->assertTrue($handler->verify($request, $store, $method)->isSuccessful());
        $this->assertEmailSent($store->getMember()->Email, null, '/recovery code was used/');
    }

    public function testVerifyInvalidatesCodesThatHaveBeenUsed()
    {
        $handler = (new VerifyHandler())->setNotificationService($this->createMock(Notification::class));

        // Test a code with invalid characters
        list ($request, $store, $method) = $this->scaffoldVerifyParams('123456');
        $this->assertTrue($handler->verify($request, $store, $method)->isSuccessful());

        $method = DataObject::get_by_id(RegisteredMethod::class, $method->ID);
        $codes = json_decode($method->Data, true);

        $this->assertCount(3, $codes, 'Only 3 codes remain against the method');

        list ($request, $store, $method) = $this->scaffoldVerifyParams('123456');
        $this->assertFalse(
            $handler->verify($request, $store, $method)->isSuccessful(),
            'Attempting to validate the previously used code now returns false'
        );
    }

    public function getVerifyTests()
    {
        return [
            [false, 'asw123', 'Invalid characters are handled'],
            [false, '', 'Empty codes are handled'],
            [false, null, 'Null input is handled'],
            [false, str_pad('', 10000, 'code'), 'Long codes are handled'],
            [true, '123456', 'Valid codes are valid'],
        ];
    }

    protected function scaffoldVerifyParams($userInput)
    {
        /** @var Member|MemberExtension $member */
        $member = $this->objFromFixture(Member::class, 'guy');

        /** @var HTTPRequest|PHPUnit_Framework_MockObject_MockObject $request */
        $request = $this->createMock(HTTPRequest::class);
        $request->expects($this->once())->method('getBody')->willReturn("{\"code\":\"{$userInput}\"}");

        /** @var StoreInterface|PHPUnit_Framework_MockObject_MockObject $store */
        $store = $this->createMock(StoreInterface::class);
        $store->expects($this->any())->method('getMember')->willReturn($member);

        /** @var RegisteredMethod $registeredMethod */
        $registeredMethod = $member->RegisteredMFAMethods()->first();

        return [$request, $store, $registeredMethod];
    }
}