DefaultControllerTest::xtestReadTextnodeWithoutLogin()

Complexity

Conditions	1
Paths	1

Size

Total Lines	41
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	DefaultControllerTest::testReadTopicActionForInvalidTopicId()	13	13	1

<?php

declare(strict_types = 1);

/* Copyright (C) 2015-2017 Michael Giesler, Stephan Kreutzer
 *
 * This file is part of Dembelo.
 *
 * Dembelo is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Dembelo is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License 3 for more details.
 *
 * You should have received a copy of the GNU Affero General Public License 3
 * along with Dembelo. If not, see <http://www.gnu.org/licenses/>.
 */


/**
 * @package DembeloMain
 */

namespace DembeloMain\Tests\Controller;

use DembeloMain\Document\Textnode;
use DembeloMain\Document\User;
use DembeloMain\Model\FavoriteManager;
use DembeloMain\Model\FeatureToggle;
use DembeloMain\Model\Readpath;
use DembeloMain\Model\Repository\TextNodeRepositoryInterface;
use DembeloMain\Model\Repository\UserRepositoryInterface;
use DembeloMain\Service\ReadpathUndoService;
use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use DembeloMain\Controller\DefaultController;
use Symfony\Bundle\FrameworkBundle\Routing\Router;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
use Symfony\Bundle\FrameworkBundle\Templating\EngineInterface as Templating;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;

/**
 * Class DefaultControllerTest
 */
class DefaultControllerTest extends WebTestCase
{
    /**
     * @var DefaultController
     */
    private $controller;

    /**
     * @var FeatureToggle|\PHPUnit_Framework_MockObject_MockObject
     */
    private $featureToggleMock;

    /**
     * @var AuthorizationCheckerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private $authorizationCheckerMock;

    /**
     * @var UserRepositoryInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private $userRepositoryMock;

    /**
     * @var TextNodeRepositoryInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private $textnodeRepositoryMock;

    /**
     * @var Templating|\PHPUnit_Framework_MockObject_MockObject
     */
    private $templatingMock;

    /**
     * @var Router|\PHPUnit_Framework_MockObject_MockObject
     */
    private $routerMock;

    /**
     * @var TokenStorage|\PHPUnit_Framework_MockObject_MockObject
     */
    private $tokenStorageMock;

    /**
     * @var ReadPath|\PHPUnit_Framework_MockObject_MockObject
     */
    private $readpathMock;

    /**
     * @var FavoriteManager|\PHPUnit_Framework_MockObject_MockObject
     */
    private $favoriteManagerMock;

    /**
     * @var ReadpathUndoService|\PHPUnit_Framework_MockObject_MockObject
     */
    private $readpathUndoServiceMock;

    /**
     * @inheritdoc
     */
    public function setUp(): void
    {
        $this->featureToggleMock = $this->createFeatureToggleMock();

It seems like $this->createFeatureToggleMock() of type DembeloMain\Model\FeatureToggle is incompatible with the declared type DembeloMain\Model\FeatureToggle&PHPUnit_Framework_MockObject_MockObject of property $featureToggleMock.

        $this->authorizationCheckerMock = $this->createAuthorizationCheckerMock();

It seems like $this->createAuthorizationCheckerMock() of type Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface is incompatible with the declared type Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface&PHPUnit_Framework_MockObject_MockObject of property $authorizationCheckerMock.

        $this->userRepositoryMock = $this->createUserRepositoryMock();

It seems like $this->createUserRepositoryMock() of type DembeloMain\Model\Repository\UserRepositoryInterface is incompatible with the declared type DembeloMain\Model\Repository\UserRepositoryInterface&PHPUnit_Framework_MockObject_MockObject of property $userRepositoryMock.

        $this->textnodeRepositoryMock = $this->createTextnodeRepositoryMock();

It seems like $this->createTextnodeRepositoryMock() of type DembeloMain\Model\Repository\TextNodeRepositoryInterface is incompatible with the declared type DembeloMain\Model\Repository\TextNodeRepositoryInterface&PHPUnit_Framework_MockObject_MockObject of property $textnodeRepositoryMock.

        $this->templatingMock = $this->createTemplatingMock();

It seems like $this->createTemplatingMock() of type Symfony\Bundle\FrameworkBundle\Templating\EngineInterface is incompatible with the declared type Symfony\Bundle\FrameworkBundle\Templating\EngineInterface&PHPUnit_Framework_MockObject_MockObject of property $templatingMock.

        $this->routerMock = $this->createRouterMock();

It seems like $this->createRouterMock() of type Symfony\Bundle\FrameworkBundle\Routing\Router is incompatible with the declared type PHPUnit_Framework_MockObject_MockObject&Symfony\Bundle\FrameworkBundle\Routing\Router of property $routerMock.

        $this->tokenStorageMock = $this->createTokenStorageMock();

It seems like $this->createTokenStorageMock() of type Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage is incompatible with the declared type Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage&PHPUnit_Framework_MockObject_MockObject of property $tokenStorageMock.

        $this->readpathMock = $this->createReadpathMock();

It seems like $this->createReadpathMock() of type DembeloMain\Model\Readpath is incompatible with the declared type DembeloMain\Model\Readpath&PHPUnit_Framework_MockObject_MockObject of property $readpathMock.

        $this->favoriteManagerMock = $this->createFavoriteManagerMock();

It seems like $this->createFavoriteManagerMock() of type DembeloMain\Model\FavoriteManager is incompatible with the declared type DembeloMain\Model\FavoriteManager&PHPUnit_Framework_MockObject_MockObject of property $favoriteManagerMock.

        $this->readpathUndoServiceMock = $this->createReadpathUndoServiceMock();

It seems like $this->createReadpathUndoServiceMock() of type DembeloMain\Service\ReadpathUndoService is incompatible with the declared type DembeloMain\Service\ReadpathUndoService&PHPUnit_Framework_MockObject_MockObject of property $readpathUndoServiceMock.

        $this->controller = new DefaultController(
            $this->featureToggleMock,
            $this->authorizationCheckerMock,
            $this->userRepositoryMock,
            $this->textnodeRepositoryMock,
            $this->templatingMock,
            $this->routerMock,
            $this->tokenStorageMock,
            $this->readpathMock,
            $this->favoriteManagerMock,
            $this->readpathUndoServiceMock
        );
    }

    /**
     * tests readTopicAction with guest user and enabled login feature
     * Tests the index action.
     */
    public function testReadTopicActionWithLoggedOutUserAndEnabledLoginFeature(): void

This method seems to be duplicated in your project.

    {
        $topicId = 'someTopicId';

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(true);
        $this->authorizationCheckerMock->expects(self::any())
            ->method('isGranted')
            ->willReturn(false);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('login_route', []);

'login_route' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

        $result = $this->controller->readTopicAction($topicId);
        self::assertInstanceOf(RedirectResponse::class, $result);
    }

    /**
     * tests readTOpicAction for invalid topic id
     * @expectedException \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     */
    public function testReadTopicActionForInvalidTopicId(): void

This method seems to be duplicated in your project.

    {
        $topicId = 'someTopicId';

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('getTextnodeToRead')
            ->with($topicId)

$topicId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn(null);

        $this->controller->readTopicAction($topicId);
    }

    /**
     * test readtopicAction for valid topic and guest user
     */
    public function testReadTopicActionForValidTopicIdAndGuestUser(): void
    {
        $topicId = 'someTopicId';

        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');
        $textnode->appendHitch([
            'textnodeId' => '1',
            'description' => 2,
            'status' => Textnode::HITCH_STATUS_ACTIVE,
        ]);

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('getTextnodeToRead')
            ->with($topicId)

$topicId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);
        $this->tokenStorageMock->expects(self::once())
            ->method('getToken')
            ->willReturn(null);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('text', ['textnodeArbitraryId' => 'someArbitraryId']);

        $result = $this->controller->readTopicAction($topicId);
        self::assertInstanceOf(RedirectResponse::class, $result);
    }

    /**
     * tests readTopicACtion for valid topic id and guest user for a finance node
     */
    public function testReadTopicActionForValidTopicIdAndGuestUserForAFinanceNode(): void
    {
        $topicId = 'someTopicId';

        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('getTextnodeToRead')
            ->with($topicId)

$topicId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);
        $this->tokenStorageMock->expects(self::once())
            ->method('getToken')
            ->willReturn(null);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('financenode', ['textnodeArbitraryId' => 'someArbitraryId']);

        $result = $this->controller->readTopicAction($topicId);
        self::assertInstanceOf(RedirectResponse::class, $result);
    }

    /**
     * tests readTopicAction for valid topic Id and logged in user
     */
    public function testReadTopicActionForValidTopicIdAndLoggedInUser(): void
    {
        $topicId = 'someTopicId';

        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');
        $textnode->appendHitch([
            'textnodeId' => '1',
            'description' => 2,
            'status' => Textnode::HITCH_STATUS_ACTIVE,
        ]);

        $user = new User();

        $this->userRepositoryMock->expects(self::once())
            ->method('save')
            ->with($user);

$user of type DembeloMain\Document\User is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

        $tokenMock = $this->createTokenMock();
        $tokenMock->expects(self::once())

The method expects() does not exist on Symfony\Component\Security\Core\Authentication\Token\TokenInterface.

            ->method('getUser')
            ->willReturn($user);

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('getTextnodeToRead')
            ->with($topicId)

$topicId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);
        $this->tokenStorageMock->expects(self::once())
            ->method('getToken')
            ->willReturn($tokenMock);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('text', ['textnodeArbitraryId' => 'someArbitraryId']);

        $result = $this->controller->readTopicAction($topicId);
        self::assertInstanceOf(RedirectResponse::class, $result);
        self::assertSame($topicId, $user->getLastTopicId());
    }

    /**
     * tests imprint action
     */
    public function testImprintAction(): void
    {
        $this->templatingMock->expects(self::once())
            ->method('renderResponse')
            ->with('DembeloMain::default/imprint.html.twig')

'DembeloMain::default/imprint.html.twig' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn('responseString');
        $result = $this->controller->imprintAction();
        self::assertSame('responseString', $result);
    }

    /**
     * tests back action
     */
    public function testBackActionSuccess(): void
    {
        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');

        $this->readpathUndoServiceMock->expects(self::once())
            ->method('undo')
            ->willReturn(true);
        $this->readpathUndoServiceMock->expects(self::once())
            ->method('getCurrentItem')
            ->willReturn(5);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('find')
            ->with(5)

5 of type integer is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('text', ['textnodeArbitraryId' => 'someArbitraryId'])

'text' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn('someUrl');

        $result = $this->controller->backAction();
        self::assertInstanceOf(RedirectResponse::class, $result);
        self::assertSame('someUrl', $result->getTargetUrl());
    }

    /**
     * tests back action when undo() ist not successful
     */
    public function testBackActionUnsuccessfulForGuestUser(): void
    {
        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');

        $this->readpathUndoServiceMock->expects(self::once())
            ->method('undo')
            ->willReturn(false);
        $this->readpathUndoServiceMock->expects(self::never())
            ->method('getCurrentItem');
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('mainpage')

'mainpage' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn('someUrl');

        $result = $this->controller->backAction();
        self::assertInstanceOf(RedirectResponse::class, $result);
        self::assertSame('someUrl', $result->getTargetUrl());
    }

    /**
     * tests back action when undo() ist not successful
     */
    public function testBackActionUnsuccessfulForLoggedInUser(): void
    {
        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbitraryId');

        $user = new User();
        $user->setLastTopicId('someLastTopicId');

        $tokenMock = $this->createTokenMock();
        $tokenMock->expects(self::once())
            ->method('getUser')
            ->willReturn($user);

        $this->tokenStorageMock->expects(self::once())
            ->method('getToken')
            ->willReturn($tokenMock);
        $this->readpathUndoServiceMock->expects(self::once())
            ->method('undo')
            ->willReturn(false);
        $this->readpathUndoServiceMock->expects(self::never())
            ->method('getCurrentItem');
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('themenfeld', ['topicId' => 'someLastTopicId'])

'themenfeld' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn('someUrl');

        $result = $this->controller->backAction();
        self::assertInstanceOf(RedirectResponse::class, $result);
        self::assertSame('someUrl', $result->getTargetUrl());
    }
    /**
     * tests readTextnodeAction with guest user and enabled login feature
     */
    public function testReadTextnodeActionWithGuestUserAndEnabledLoginFeature(): void

This method seems to be duplicated in your project.

    {
        $textnodeArbitraryId = 'someTopicId';

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(true);
        $this->authorizationCheckerMock->expects(self::any())
            ->method('isGranted')
            ->willReturn(false);
        $this->routerMock->expects(self::once())
            ->method('generate')
            ->with('login_route', []);

'login_route' of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

        $result = $this->controller->readTextnodeAction($textnodeArbitraryId);
        self::assertInstanceOf(RedirectResponse::class, $result);
    }

    /**
     * tests readTextnodeAction for invalid Id
     * @expectedException \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
     */
    public function testReadTextnodeActionForInvalidId(): void

This method seems to be duplicated in your project.

    {
        $textnodeArbitraryId = 'someId';

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('findOneActiveByArbitraryId')
            ->with($textnodeArbitraryId)

$textnodeArbitraryId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn(null);

        $this->controller->readTextnodeAction($textnodeArbitraryId);
    }

    /**
     * test readTextnodeAction for valid textnode
     */
    public function testReadTextnodeActionForValidTextnode(): void
    {
        $textnodeArbitraryId = 'someArbitraryId';
        $textnodeId = 'someId';

        $textnode = new Textnode();
        $textnode->setId($textnodeId);
        $textnode->setArbitraryId($textnodeArbitraryId);
        $textnode->appendHitch([
            'textnodeId' => '1',
            'description' => 2,
            'status' => Textnode::HITCH_STATUS_ACTIVE,
        ]);

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('findOneActiveByArbitraryId')
            ->with($textnodeArbitraryId)

$textnodeArbitraryId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);
        $this->tokenStorageMock->expects(self::once())
            ->method('getToken')
            ->willReturn(null);
        $this->templatingMock->expects(self::once())
            ->method('renderResponse')
            ->with(
                'DembeloMain::default/read.html.twig',
                [
                    'textnode' => $textnode,
                    'hitches' => [],
                ]
            );
        $this->readpathUndoServiceMock->expects(self::once())
            ->method('add')
            ->with($textnodeId);

        $this->controller->readTextnodeAction($textnodeArbitraryId);
    }

    /**
     * tests readTextnodeAction for finance node
     */
    public function testReadTextnodeActionForFinanceNode(): void
    {
        $textnodeArbitraryId = 'someId';

        $textnode = new Textnode();
        $textnode->setArbitraryId('someArbId');

        $this->featureToggleMock->expects(self::once())
            ->method('hasFeature')
            ->willReturn(false);
        $this->textnodeRepositoryMock->expects(self::once())
            ->method('findOneActiveByArbitraryId')
            ->with($textnodeArbitraryId)

$textnodeArbitraryId of type string is incompatible with the type array expected by parameter $arguments of PHPUnit_Framework_MockObject_Builder_InvocationMocker::with().

            ->willReturn($textnode);

        $result = $this->controller->readTextnodeAction($textnodeArbitraryId);
        self::assertInstanceOf(RedirectResponse::class, $result);
    }

    /**
     * @return TokenInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createTokenMock(): TokenInterface
    {
        return $this->createMock(TokenInterface::class);

The expression return $this->createMock(Symfony\Component\Security\Core\Authentication\Token\TokenInterface::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return Symfony\Component\Security\Core\Authentication\Token\TokenInterface.

    }

    /**
     * @return FeatureToggle|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createFeatureToggleMock(): FeatureToggle
    {
        return $this->createMock(FeatureToggle::class);

The expression return $this->createMock(DembeloMain\Model\FeatureToggle::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Model\FeatureToggle.

    }

    /**
     * @return AuthorizationCheckerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createAuthorizationCheckerMock(): AuthorizationCheckerInterface
    {
        return $this->createMock(AuthorizationCheckerInterface::class);

The expression return $this->createMock(Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface.

    }

    /**
     * @return UserRepositoryInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createUserRepositoryMock(): UserRepositoryInterface
    {
        return $this->createMock(UserRepositoryInterface::class);

The expression return $this->createMock(DembeloMain\Model\Repository\UserRepositoryInterface::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Model\Repository\UserRepositoryInterface.

    }

    /**
     * @return TextNodeRepositoryInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createTextnodeRepositoryMock(): TextNodeRepositoryInterface
    {
        return $this->createMock(TextNodeRepositoryInterface::class);

The expression return $this->createMock(DembeloMain\Model\Repository\TextNodeRepositoryInterface::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Model\Repository\TextNodeRepositoryInterface.

    }

    /**
     * @return Templating|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createTemplatingMock(): Templating
    {
        return $this->createMock(Templating::class);

The expression return $this->createMock(Symfony\Bundle\FrameworkBundle\Templating\EngineInterface::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return Symfony\Bundle\FrameworkBundle\Templating\EngineInterface.

    }

    /**
     * @return Router|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createRouterMock(): Router
    {
        $mock = $this->createMock(Router::class);
        $mock->expects(self::any())
            ->method('generate')
            ->willReturn('someUrl');

        return $mock;

The expression return $mock returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return Symfony\Bundle\FrameworkBundle\Routing\Router.

    }

    /**
     * @return TokenStorage|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createTokenStorageMock(): TokenStorage
    {
        return $this->createMock(TokenStorage::class);

The expression return $this->createMock(Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage.

    }

    /**
     * @return ReadPath|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createReadpathMock(): Readpath
    {
        return $this->createMock(Readpath::class);

The expression return $this->createMock(DembeloMain\Model\Readpath::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Model\Readpath.

    }

    /**
     * @return FavoriteManager|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createFavoriteManagerMock(): FavoriteManager
    {
        return $this->createMock(FavoriteManager::class);

The expression return $this->createMock(DembeloMain\Model\FavoriteManager::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Model\FavoriteManager.

    }

    /**
     * @return ReadpathUndoService|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createReadpathUndoServiceMock(): ReadpathUndoService
    {
        return $this->createMock(ReadpathUndoService::class);

The expression return $this->createMock(DembeloMain\Service\ReadpathUndoService::class) returns the type PHPUnit_Framework_MockObject_MockObject which is incompatible with the type-hinted return DembeloMain\Service\ReadpathUndoService.

    }
}