ORMDataProviderTest::testGetCollection() - 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::testGetCollection() B

↳ Parent: ORMDataProviderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	90
rs	8.2181
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?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::testGetCollection() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

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::testGetCollection() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

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