Addiks\SymfonyGenerics\Events\EntityInteractionEventTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	12	1
A	shouldRejectNonExistingClass()	0	12	1
A	shouldRejectNonObjectEntity()	0	12	1
A	shouldHaveEntityClass()	0	4	1
A	shouldHaveEntityId()	0	4	1
A	shouldHaveEntity()	0	4	1
A	shouldHaveMethod()	0	4	1
A	shouldHaveArguments()	0	4	1

<?php
/**
 * Copyright (C) 2017  Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <gerrit@addiks.de>
 */

namespace Addiks\SymfonyGenerics\Events;

use PHPUnit\Framework\TestCase;
use Addiks\SymfonyGenerics\Events\EntityInteractionEvent;
use stdClass;
use InvalidArgumentException;

final class EntityInteractionEventTest extends TestCase
{

    /**
     * @var EntityInteractionEvent
     */
    private $event;

    /**
     * @var stdClass
     */
    private $entity;

    public function setUp()
    {
        $this->entity = $this->createMock(stdClass::class);

It seems like $this->createMock(\stdClass::class) of type object<PHPUnit\Framework\MockObject\MockObject> is incompatible with the declared type object<stdClass> of property $entity.

        $this->event = new EntityInteractionEvent(
            "stdClass",
            "some-entity-id",
            $this->entity,
            "someMethod",
            ['foo', 'bar']
        );
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingClass()
    {
        $this->expectException(InvalidArgumentException::class);

        new EntityInteractionEvent(
            "doesNotExist",
            "some-entity-id",
            $this->entity,
            "someMethod",
            ['foo', 'bar']
        );
    }

    /**
     * @test
     */
    public function shouldRejectNonObjectEntity()
    {
        $this->expectException(InvalidArgumentException::class);

        new EntityInteractionEvent(
            "stdClass",
            "some-entity-id",
            "entity",

'entity' is of type string, but the function expects a object|null.

            "someMethod",
            ['foo', 'bar']
        );
    }

    /**
     * @test
     */
    public function shouldHaveEntityClass()
    {
        $this->assertEquals("stdClass", $this->event->getEntityClass());
    }

    /**
     * @test
     */
    public function shouldHaveEntityId()
    {
        $this->assertEquals("some-entity-id", $this->event->getEntityId());
    }

    /**
     * @test
     */
    public function shouldHaveEntity()
    {
        $this->assertSame($this->entity, $this->event->getEntity());
    }

    /**
     * @test
     */
    public function shouldHaveMethod()
    {
        $this->assertEquals("someMethod", $this->event->getMethod());
    }

    /**
     * @test
     */
    public function shouldHaveArguments()
    {
        $this->assertEquals(['foo', 'bar'], $this->event->getArguments());
    }

}