DomainManagerTest::testDeleteThrowException() - Code Metrics - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

DomainManagerTest::testDeleteThrowException() C
last analyzed 2017-01-05 10:16 UTC

↳ Parent: DomainManagerTest
Complexity

Conditions	10
Paths	3
Size

Total Lines	81
Code Lines	60
Duplication

Lines	81
Ratio	100 %
Importance

Changes
Metric	Value
dl	81
loc	81
rs	5.5056
c	0
b	0
f	0
cc	10
eloc	60
nc	3
nop	0
How to fix Long Method Complexity

<?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);
    }
}

1			<?php
2
3			/*
4			* This file is part of the Lug package.
5			*
6			* (c) Eric GELOEN <[email protected]>
7			*
8			* For the full copyright and license information, please read the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Lug\Component\Resource\Tests\Domain;
13
14			use Doctrine\Common\Persistence\ObjectManager;
15			use Lug\Component\Resource\Domain\DomainEvent;
16			use Lug\Component\Resource\Domain\DomainManager;
17			use Lug\Component\Resource\Domain\DomainManagerInterface;
18			use Lug\Component\Resource\Exception\DomainException;
19			use Lug\Component\Resource\Model\ResourceInterface;
20			use Lug\Component\Resource\Repository\RepositoryInterface;
21			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
22			use Symfony\Component\HttpFoundation\Response;
23
24			/**
25			* @author GeLo <[email protected]>
26			*/
27			class DomainManagerTest extends \PHPUnit_Framework_TestCase
28			{
29			/**
30			* @var DomainManager
31			*/
32			private $domainManager;
33
34			/**
35			* @var \PHPUnit_Framework_MockObject_MockObject\|ResourceInterface
36			*/
37			private $resource;
38
39			/**
40			* @var \PHPUnit_Framework_MockObject_MockObject\|EventDispatcherInterface
php-lug / lug

DomainManagerTest::testDeleteThrowException() C last analyzed 2017-01-05 10:16 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

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

Available Fixes

Available Fixes

DomainManagerTest::testDeleteThrowException() C
last analyzed 2017-01-05 10:16 UTC
