ORMDataProviderTest::testSaveItem() - Code Metrics - Inspection of "Add test for the ORM data provider" - larriereguichet/AdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — refonte ( 225502...fa24e9 )

by Arnaud

created 2018-09-04 20:33 UTC

ORMDataProviderTest::testSaveItem() A

↳ Parent: ORMDataProviderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	40
rs	9.28
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace LAG\AdminBundle\Tests\Bridge\Doctrine\ORM\DataProvider;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\QueryBuilder;
use LAG\AdminBundle\Admin\AdminInterface;
use LAG\AdminBundle\Bridge\Doctrine\ORM\DataProvider\ORMDataProvider;
use LAG\AdminBundle\Configuration\AdminConfiguration;
use LAG\AdminBundle\Event\AdminEvents;
use LAG\AdminBundle\Event\DoctrineOrmFilterEvent;
use LAG\AdminBundle\Exception\Exception;
use LAG\AdminBundle\Tests\AdminTestBase;
use LAG\AdminBundle\Tests\Fixtures\EntityFixture;
use PHPUnit\Framework\MockObject\MockObject;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RequestStack;

class ORMDataProviderTest extends AdminTestBase
{
    public function testGetCollection()
    {
        // Create an admin configuration to test the collection method
        $configuration = $this->createMock(AdminConfiguration::class);
        $configuration
            ->expects($this->atLeastOnce())
            ->method('getParameter')
            ->willReturnMap([
                ['entity', 'MyClass'],
                ['pager', null],
                ['page_parameter', 'page'],
            ])
        ;

        /** @var AdminInterface|MockObject $admin */
        $admin = $this->createMock(AdminInterface::class);
        $admin
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->atLeastOnce())
            ->method('getConfiguration')
            ->willReturn($configuration)
        ;

        // Create fake entities to return
        $entities = [
            new EntityFixture(uniqid()),
            new EntityFixture(uniqid()),
        ];

        // The query should return entities
        $query = $this->createMock(AbstractQuery::class);
        $query
            ->expects($this->once())
            ->method('getResult')
            ->willReturn($entities)
        ;

        // The query builder should call the getQuery() method
        $queryBuilder = $this->createMock(QueryBuilder::class);
        $queryBuilder
            ->expects($this->once())
            ->method('getQuery')
            ->willReturn($query)
        ;

        // The repository should return a query builder
        $repository = $this->createMock(EntityRepository::class);
        $repository
            ->expects($this->once())
            ->method('createQueryBuilder')
            ->with('entity')
            ->willReturn($queryBuilder)
        ;

        // The entity manager should return a repository
        /** @var EntityManagerInterface|MockObject $entityManager */
        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager
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('getRepository')
            ->willReturn($repository)
        ;

        // The event dispatcher should dispatched once a ORM_FILTER event
        /** @var EventDispatcherInterface|MockObject $eventDispatcher */
        $eventDispatcher = $this->createMock(EventDispatcherInterface::class);
        $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->once())
            ->method('dispatch')
            ->willReturnCallback(function ($eventName, $event) use ($queryBuilder, $admin) {
                $this->assertEquals(AdminEvents::DOCTRINE_ORM_FILTER, $eventName);
                /** @var DoctrineOrmFilterEvent $event */
                $this->assertInstanceOf(DoctrineOrmFilterEvent::class, $event);
                $this->assertEquals($queryBuilder, $event->getQueryBuilder());
                $this->assertEquals($admin, $event->getAdmin());
                $this->assertEquals([], $event->getFilters());
            })
        ;
        /** @var RequestStack|MockObject $requestStack */
        $requestStack = $this->createMock(RequestStack::class);

        $provider = new ORMDataProvider(
            $entityManager,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $eventDispatcher,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $requestStack
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
        $returnedEntities = $provider->getCollection($admin);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        // The returned entities should be the same as those provided by the repository
        $this->assertEquals($entities, $returnedEntities);
    }

    public function testGetItem()
    {
        /** @var EventDispatcherInterface|MockObject $eventDispatcher */
        $eventDispatcher = $this->createMock(EventDispatcherInterface::class);

        /** @var RequestStack|MockObject $requestStack */
        $requestStack = $this->createMock(RequestStack::class);

        $repository = $this->createMock(EntityRepository::class);
        $repository
            ->expects($this->atLeastOnce())
            ->method('find')
            ->with(42)
            ->willReturn(new EntityFixture(42))
        ;

        /** @var EntityManagerInterface|MockObject $entityManager */
        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager
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->atLeastOnce())
            ->method('getRepository')
            ->with('MyClass')
            ->willReturn($repository)
        ;

        $configuration = $this->createMock(AdminConfiguration::class);
        $configuration
            ->expects($this->atLeastOnce())
            ->method('getParameter')
            ->willReturnMap([
                ['entity', 'MyClass'],
                ['pager', null],
                ['page_parameter', 'page'],
            ])
        ;

        /** @var AdminInterface|MockObject $admin */
        $admin = $this->createMock(AdminInterface::class);
        $admin
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->atLeastOnce())
            ->method('getConfiguration')
            ->willReturn($configuration)
        ;

        $provider = new ORMDataProvider(
            $entityManager,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $eventDispatcher,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $requestStack
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $item = $provider->getItem($admin, 42);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertEquals(42, $item->getId());
    }

    public function testGetItemWithException()
    {
        /** @var EventDispatcherInterface|MockObject $eventDispatcher */
        $eventDispatcher = $this->createMock(EventDispatcherInterface::class);

        /** @var RequestStack|MockObject $requestStack */
        $requestStack = $this->createMock(RequestStack::class);

        $repository = $this->createMock(EntityRepository::class);
        $repository
            ->expects($this->atLeastOnce())
            ->method('find')
            ->with(42)
            ->willReturn(null)
        ;

        /** @var EntityManagerInterface|MockObject $entityManager */
        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager
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->atLeastOnce())
            ->method('getRepository')
            ->with('MyClass')
            ->willReturn($repository)
        ;

        $configuration = $this->createMock(AdminConfiguration::class);
        $configuration
            ->expects($this->atLeastOnce())
            ->method('getParameter')
            ->willReturnMap([
                ['entity', 'MyClass'],
                ['pager', null],
                ['page_parameter', 'page'],
            ])
        ;

        /** @var AdminInterface|MockObject $admin */
        $admin = $this->createMock(AdminInterface::class);
        $admin
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->atLeastOnce())
            ->method('getConfiguration')
            ->willReturn($configuration)
        ;

        $provider = new ORMDataProvider(
            $entityManager,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $eventDispatcher,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $requestStack
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $this->assertExceptionRaised(Exception::class, function () use ($provider, $admin) {
            $provider->getItem($admin, 42);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        });
    }

    public function testSaveItem()
    {
        /** @var EventDispatcherInterface|MockObject $eventDispatcher */
        $eventDispatcher = $this->createMock(EventDispatcherInterface::class);

        /** @var RequestStack|MockObject $requestStack */
        $requestStack = $this->createMock(RequestStack::class);

        $entity =new EntityFixture(42);

        /** @var EntityManagerInterface|MockObject $entityManager */
        $entityManager = $this->createMock(EntityManagerInterface::class);
        $entityManager
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->atLeastOnce())
            ->method('persist')
            ->with($entity)
        ;
        $entityManager
            ->expects($this->atLeastOnce())
            ->method('flush')
        ;

        /** @var AdminInterface|MockObject $admin */
        $admin = $this->createMock(AdminInterface::class);
        $admin
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->atLeastOnce())
            ->method('getEntities')
            ->willReturn(new ArrayCollection([
                $entity,
            ]))
        ;

        $provider = new ORMDataProvider(
            $entityManager,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $eventDispatcher,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $requestStack
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );

        $provider->saveItem($admin);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
    }
}


Push — refonte ( 225502...fa24e9 )

ORMDataProviderTest::testSaveItem() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace LAG\AdminBundle\Tests\Bridge\Doctrine\ORM\DataProvider;
4
5			use Doctrine\Common\Collections\ArrayCollection;
6			use Doctrine\ORM\AbstractQuery;
7			use Doctrine\ORM\EntityManagerInterface;
8			use Doctrine\ORM\EntityRepository;
9			use Doctrine\ORM\QueryBuilder;
10			use LAG\AdminBundle\Admin\AdminInterface;
11			use LAG\AdminBundle\Bridge\Doctrine\ORM\DataProvider\ORMDataProvider;
12			use LAG\AdminBundle\Configuration\AdminConfiguration;
13			use LAG\AdminBundle\Event\AdminEvents;
14			use LAG\AdminBundle\Event\DoctrineOrmFilterEvent;
15			use LAG\AdminBundle\Exception\Exception;
16			use LAG\AdminBundle\Tests\AdminTestBase;
17			use LAG\AdminBundle\Tests\Fixtures\EntityFixture;
18			use PHPUnit\Framework\MockObject\MockObject;
19			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
20			use Symfony\Component\HttpFoundation\RequestStack;
21
22			class ORMDataProviderTest extends AdminTestBase
23			{
24			public function testGetCollection()
25			{
26			// Create an admin configuration to test the collection method
27			$configuration = $this->createMock(AdminConfiguration::class);
28			$configuration
29			->expects($this->atLeastOnce())
30			->method('getParameter')
31			->willReturnMap([
32			['entity', 'MyClass'],
33			['pager', null],
34			['page_parameter', 'page'],
35			])
36			;
37
38			/** @var AdminInterface\|MockObject $admin */
39			$admin = $this->createMock(AdminInterface::class);
40			$admin

larriereguichet / AdminBundle

Push — refonte ( 225502...fa24e9 )

ORMDataProviderTest::testSaveItem() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like