DomainManagerTest - Code Metrics - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

DomainManagerTest D
last analyzed 2017-01-05 10:16 UTC

↳ Parent: Project
Complexity

Total Complexity
151
Size/Duplication

Total Lines	1285
Duplicated Lines	54.86 %
Coupling/Cohesion

Components	1
Dependencies	4
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
wmc	151
c	1
b	0
f	0
lcom	1
cbo	4
dl	705
loc	1285
rs	4.4102
26 Methods

Rating	Name	Duplication	Size	Complexity
C	testUpdateWithManagedObject()	71	71	9
C	testUpdateWithoutManagedObject()	72	72	9
A	setUp()	0	14	1
A	testInheritance()	0	4	1
B	testFind()	0	42	5
B	testFindThrowException()	0	56	6
B	testFindByPassException()	0	46	5
C	testCreate()	66	66	9
B	testCreateWithoutFlush()	42	42	5
C	testCreateThrowException()	81	81	10
C	testCreateByPassException()	71	71	9
B	testUpdateWithoutFlush()	42	42	5
C	testUpdateThrowException()	0	87	10
C	testUpdateByPassException()	0	77	9
C	testDelete()	66	66	9
B	testDeleteWithoutFlush()	42	42	5
C	testDeleteThrowException()	81	81	10
C	testDeleteByPassException()	71	71	9
B	testFlush()	0	39	5
B	testFlushWithoutObject()	0	37	5
B	testFlushThrowException()	0	52	6
B	testFlushByPassException()	0	42	5
A	createResourceMock()	0	4	1
A	createEventDispatcherMock()	0	4	1
A	createObjectManagerMock()	0	4	1
A	createRepositoryMock()	0	4	1
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like DomainManagerTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use DomainManagerTest, and based on these observations, apply Extract Interface, too.
<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Component\Resource\Tests\Domain;

use Doctrine\Common\Persistence\ObjectManager;
use Lug\Component\Resource\Domain\DomainEvent;
use Lug\Component\Resource\Domain\DomainManager;
use Lug\Component\Resource\Domain\DomainManagerInterface;
use Lug\Component\Resource\Exception\DomainException;
use Lug\Component\Resource\Model\ResourceInterface;
use Lug\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\Response;

/**
 * @author GeLo <[email protected]>
 */
class DomainManagerTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var DomainManager
     */
    private $domainManager;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|ResourceInterface
     */
    private $resource;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|EventDispatcherInterface
     */
    private $eventDispatcher;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|ObjectManager
     */
    private $objectManager;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|RepositoryInterface
     */
    private $repository;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        $this->resource = $this->createResourceMock();
        $this->eventDispatcher = $this->createEventDispatcherMock();
        $this->objectManager = $this->createObjectManagerMock();
        $this->repository = $this->createRepositoryMock();

        $this->domainManager = new DomainManager(
            $this->resource,
            $this->eventDispatcher,
            $this->objectManager,
            $this->repository
        );
    }

    public function testInheritance()
    {
        $this->assertInstanceOf(DomainManagerInterface::class, $this->domainManager);
    }

    public function testFind()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->repository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method($repositoryMethod = 'findForShow')
            ->with(
                $this->identicalTo($criteria = ['criteria']),
                $this->identicalTo($sorting = ['sorting'])
            )
            ->will($this->returnValue($data = new \stdClass()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_find.'.($action = 'action')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === 'find.'.$action;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_find.'.$action),
                $this->callback(function (DomainEvent $event) use ($data, $action) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === 'find.'.$action;
                })
            );

        $this->assertSame($data, $this->domainManager->find($action, $repositoryMethod, $criteria, $sorting));
    }

    public function testFindThrowException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->repository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method($repositoryMethod = 'findForShow')
            ->with(
                $this->identicalTo($criteria = ['criteria']),
                $this->identicalTo($sorting = ['sorting'])
            )
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_find.'.($action = 'action')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === 'find.'.$action;
                })
            );

        $statusCode = Response::HTTP_BAD_REQUEST;
        $message = 'message';

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_find.'.$action),
                $this->callback(function (DomainEvent $event) use ($action, $statusCode, $message) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === 'find.'.$action;

                    $event->setStatusCode($statusCode);
                    $event->setMessage($message);

                    return $result;
                })
            );

        try {
            $this->domainManager->find($action, $repositoryMethod, $criteria, $sorting);
            $this->fail();
        } catch (DomainException $e) {
            $this->assertSame($statusCode, $e->getStatusCode());
            $this->assertSame($message, $e->getMessage());
        }
    }

    public function testFindByPassException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->repository
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method($repositoryMethod = 'findForShow')
            ->with(
                $this->identicalTo($criteria = ['criteria']),
                $this->identicalTo($sorting = ['sorting'])
            )
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_find.'.($action = 'action')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === null
                    && $event->getAction() === 'find.'.$action;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_find.'.$action),
                $this->callback(function (DomainEvent $event) use ($action) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === 'find.'.$action;

                    $event->setStopped(false);

                    return $result;
                })
            );

        $this->assertNull($this->domainManager->find($action, $repositoryMethod, $criteria, $sorting));
    }

    public function testCreate()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($createAction = 'create')),
                $this->callback(function (DomainEvent $event) use ($createAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $createAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$createAction),
                $this->callback(function (DomainEvent $event) use ($data, $createAction) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $createAction;
                })
            );

        $this->domainManager->create($data);
    }

    public function testCreateWithoutFlush()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->never())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($createAction = 'create')),
                $this->callback(function (DomainEvent $event) use ($createAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $createAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$createAction),
                $this->callback(function (DomainEvent $event) use ($data, $createAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $createAction;
                })
            );

        $this->domainManager->create($data, false);
    }

    public function testCreateThrowException()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($createAction = 'create')),
                $this->callback(function (DomainEvent $event) use ($createAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $createAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $flushAction;
                })
            );

        $statusCode = Response::HTTP_BAD_REQUEST;
        $message = 'message';

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$createAction),
                $this->callback(function (DomainEvent $event) use ($data, $createAction, $statusCode, $message) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $createAction;

                    $event->setStatusCode($statusCode);
                    $event->setMessage($message);

                    return $result;
                })
            );

        try {
            $this->domainManager->create($data);
            $this->fail();
        } catch (DomainException $e) {
            $this->assertSame($statusCode, $e->getStatusCode());
            $this->assertSame($message, $e->getMessage());
        }
    }

    public function testCreateByPassException()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($createAction = 'create')),
                $this->callback(function (DomainEvent $event) use ($createAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $createAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$createAction),
                $this->callback(function (DomainEvent $event) use ($data, $createAction) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $createAction;

                    $event->setStopped(false);

                    return $result;
                })
            );

        $this->domainManager->create($data);
    }

    public function testUpdateWithManagedObject()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('contains')
            ->with($this->identicalTo($data = new \stdClass()))
            ->will($this->returnValue(true));

        $this->objectManager
            ->expects($this->never())
            ->method('persist');

        $this->objectManager
            ->expects($this->once())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($updateAction = 'update')),
                $this->callback(function (DomainEvent $event) use ($updateAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$updateAction),
                $this->callback(function (DomainEvent $event) use ($data, $updateAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->domainManager->update($data);
    }

    public function testUpdateWithoutManagedObject()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('contains')
            ->with($this->identicalTo($data = new \stdClass()))
            ->will($this->returnValue(false));

        $this->objectManager
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data));

        $this->objectManager
            ->expects($this->once())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($updateAction = 'update')),
                $this->callback(function (DomainEvent $event) use ($updateAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$updateAction),
                $this->callback(function (DomainEvent $event) use ($data, $updateAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->domainManager->update($data);
    }

    public function testUpdateWithoutFlush()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->never())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($updateAction = 'update')),
                $this->callback(function (DomainEvent $event) use ($updateAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$updateAction),
                $this->callback(function (DomainEvent $event) use ($data, $updateAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->domainManager->update($data, false);
    }

    public function testUpdateThrowException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('contains')
            ->with($this->identicalTo($data = new \stdClass()))
            ->will($this->returnValue(false));

        $this->objectManager
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($updateAction = 'update')),
                $this->callback(function (DomainEvent $event) use ($updateAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $statusCode = Response::HTTP_BAD_REQUEST;
        $message = 'message';

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$updateAction),
                $this->callback(function (DomainEvent $event) use ($data, $updateAction, $statusCode, $message) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $updateAction;

                    $event->setStatusCode($statusCode);
                    $event->setMessage($message);

                    return $result;
                })
            );

        try {
            $this->domainManager->update($data);
            $this->fail();
        } catch (DomainException $e) {
            $this->assertSame($statusCode, $e->getStatusCode());
            $this->assertSame($message, $e->getMessage());
        }
    }

    public function testUpdateByPassException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('contains')
            ->with($this->identicalTo($data = new \stdClass()))
            ->will($this->returnValue(false));

        $this->objectManager
            ->expects($this->once())
            ->method('persist')
            ->with($this->identicalTo($data));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($updateAction = 'update')),
                $this->callback(function (DomainEvent $event) use ($updateAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $updateAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$updateAction),
                $this->callback(function (DomainEvent $event) use ($data, $updateAction) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $updateAction;

                    $event->setStopped(false);

                    return $result;
                })
            );

        $this->domainManager->update($data);
    }

    public function testDelete()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('remove')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($deleteAction = 'delete')),
                $this->callback(function (DomainEvent $event) use ($deleteAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$deleteAction),
                $this->callback(function (DomainEvent $event) use ($data, $deleteAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->domainManager->delete($data);
    }

    public function testDeleteWithoutFlush()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('remove')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->never())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($deleteAction = 'delete')),
                $this->callback(function (DomainEvent $event) use ($deleteAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$deleteAction),
                $this->callback(function (DomainEvent $event) use ($data, $deleteAction) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->domainManager->delete($data, false);
    }

    public function testDeleteThrowException()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('remove')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($deleteAction = 'delete')),
                $this->callback(function (DomainEvent $event) use ($deleteAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $statusCode = Response::HTTP_BAD_REQUEST;
        $message = 'message';

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$deleteAction),
                $this->callback(function (DomainEvent $event) use ($data, $deleteAction, $statusCode, $message) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $deleteAction;

                    $event->setStatusCode($statusCode);
                    $event->setMessage($message);

                    return $result;
                })
            );

        try {
            $this->domainManager->delete($data);
            $this->fail();
        } catch (DomainException $e) {
            $this->assertSame($statusCode, $e->getStatusCode());
            $this->assertSame($message, $e->getMessage());
        }
    }

    public function testDeleteByPassException()

    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(4))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('remove')
            ->with($this->identicalTo($data = new \stdClass()));

        $this->objectManager
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($deleteAction = 'delete')),
                $this->callback(function (DomainEvent $event) use ($deleteAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $deleteAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($flushAction = 'flush')),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(2))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$flushAction),
                $this->callback(function (DomainEvent $event) use ($flushAction, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $flushAction;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(3))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$deleteAction),
                $this->callback(function (DomainEvent $event) use ($data, $deleteAction) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === $data
                        && $event->getAction() === $deleteAction;

                    $event->setStopped(false);

                    return $result;
                })
            );

        $this->domainManager->delete($data);
    }

    public function testFlush()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('flush');

        $data = new \stdClass();

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($action = 'flush')),
                $this->callback(function (DomainEvent $event) use ($action, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $action;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$action),
                $this->callback(function (DomainEvent $event) use ($action, $data) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === $data
                    && $event->getAction() === $action;
                })
            );

        $this->domainManager->flush($data);
    }

    public function testFlushWithoutObject()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('flush');

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($action = 'flush')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === null
                    && $event->getAction() === $action;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.post_'.$action),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === null
                    && $event->getAction() === $action;
                })
            );

        $this->domainManager->flush();
    }

    public function testFlushThrowException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($action = 'flush')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                    && $event->getData() === null
                    && $event->getAction() === $action;
                })
            );

        $statusCode = Response::HTTP_BAD_REQUEST;
        $message = 'message';

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$action),
                $this->callback(function (DomainEvent $event) use ($action, $statusCode, $message) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === $action;

                    $event->setStatusCode($statusCode);
                    $event->setMessage($message);

                    return $result;
                })
            );

        try {
            $this->domainManager->flush();
            $this->fail();
        } catch (DomainException $e) {
            $this->assertSame($statusCode, $e->getStatusCode());
            $this->assertSame($message, $e->getMessage());
        }
    }

    public function testFlushByPassException()
    {
        $this->resource
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->exactly(2))
            ->method('getName')
            ->will($this->returnValue($name = 'name'));

        $this->objectManager
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('flush')
            ->will($this->throwException(new \Exception()));

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(0))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.pre_'.($action = 'flush')),
                $this->callback(function (DomainEvent $event) use ($action) {
                    return $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === $action;
                })
            );

        $this->eventDispatcher
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->at(1))
            ->method('dispatch')
            ->with(
                $this->identicalTo('lug.'.$name.'.error_'.$action),
                $this->callback(function (DomainEvent $event) use ($action) {
                    $result = $event->getResource() === $this->resource
                        && $event->getData() === null
                        && $event->getAction() === $action;

                    $event->setStopped(false);

                    return $result;
                })
            );

        $this->domainManager->flush();
    }

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

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

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

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

php-lug / lug

DomainManagerTest D last analyzed 2017-01-05 10:16 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

26 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

DomainManagerTest D
last analyzed 2017-01-05 10:16 UTC
