Doctrine\Tests\ORM\Query\SelectSqlMappingTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	63
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	testTypeFromMathematicNodeFunction()	0	16	1
A	setUp()	0	3	1
A	assertScalarTypes()	0	25	3

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Query;

use Doctrine\DBAL\Types\DateTimeType;

Type Doctrine\DBAL\Types\DateTimeType is not used in this file.

use Doctrine\DBAL\Types\FloatType;
use Doctrine\DBAL\Types\IntegerType;
use Doctrine\ORM\Query as ORMQuery;
use Doctrine\Tests\Models\CMS\CmsProduct;
use Doctrine\Tests\OrmTestCase;
use Exception;
use function get_class;

Type get_class is not used in this file.

class SelectSqlMappingTest extends OrmTestCase
{
    private $em;

    protected function setUp() : void
    {
        $this->em = $this->getTestEntityManager();
    }

    /**
     * Assert a valid SQL generation.
     *
     * @param string $dqlToBeTested
     * @param array $types

Expected 2 spaces after parameter type; 1 found

     */
    public function assertScalarTypes($dqlToBeTested, array $types)
    {
        try {
            $query = $this->em->createQuery($dqlToBeTested);

            $query
                ->setHint(ORMQuery::HINT_FORCE_PARTIAL_LOAD, true)
                ->useQueryCache(false);

            $r = new \ReflectionObject($query);

Equals sign not aligned with surrounding assignments; expected 6 spaces but found 1 space

Class \ReflectionObject should not be referenced via a fully qualified name, but via a use statement.

            $method = $r->getMethod('getResultSetMapping');
            $method->setAccessible(true);
            /** @var ORMQuery\ResultSetMapping $mapping */
            $mapping = $method->invoke($query);
            foreach($types as $key => $expectedType) {

Expected 1 space(s) after FOREACH keyword; 0 found

                $alias = array_search($key, $mapping->scalarMappings);

Function array_search() should not be referenced via a fallback global name, but via a use statement.

                self::assertInstanceOf(
                    $expectedType,
                    $mapping->typeMappings[$alias],
                    "The field \"$key\" was expected as a $expectedType"

Variable "%s" not allowed in double quoted string; use sprintf() or concatenation instead

                );
            }
            $query->free();
        } catch (Exception $e) {
            $this->fail($e->getMessage() . "\n" . $e->getTraceAsString());
        }

    }

Function closing brace must go on the next line following the body; found 1 blank lines before brace

    /**
     * @group DDC-2235
     */
    public function testTypeFromMathematicNodeFunction() : void
    {
        $entity = CmsProduct::class;
        $this->assertScalarTypes("SELECT p, 

Variable "%s" not allowed in double quoted string; use sprintf() or concatenation instead

          count(p.id) as count, 
          SUM(p.price) as sales, 
          AVG(p.price) as average, 
          ABS(p.price) as absolute,
          LENGTH(p.name) as length
          FROM {$entity} p",
            [
                'count' => IntegerType::class,
                'sales' => FloatType::class,
                'average' => FloatType::class,
                'absolute' => FloatType::class,
                'length' => IntegerType::class

MultiLine arrays must have a trailing comma after the last element.

            ]
        );
    }
}