Doctrine\Tests\ORM\Functional\Ticket\GH7941Test

Complexity

Total Complexity

4

Size/Duplication

Total Lines	56
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	typesShouldBeConvertedForDQLFunctions()	0	30	2
A	setUp()	0	12	2

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Functional\Ticket;

use DateTimeImmutable;
use Doctrine\Tests\OrmFunctionalTestCase;
use function ltrim;
use function strlen;

/** @group GH7941 */
final class GH7941Test extends OrmFunctionalTestCase
{
    private const PRODUCTS = [
        ['name' => 'Test 1', 'price' => '1.5', 'square_root' => '1.22474487139159'],
        ['name' => 'Test 2', 'price' => '3.5', 'square_root' => '1.87082869338697'],
        ['name' => 'Test 3', 'price' => '10', 'square_root' => '3.16227766016838'],
        ['name' => 'Test 4', 'price' => '2', 'square_root' => '1.4142135623731'],
        ['name' => 'Test 5', 'price' => '1.28', 'square_root' => '1.13137084989848'],
        ['name' => 'Test 6', 'price' => '-1.28', 'square_root' => null],
    ];

    protected function setUp() : void
    {
        parent::setUp();

        $this->setUpEntitySchema([GH7941Product::class]);

        foreach (self::PRODUCTS as $product) {
            $this->_em->persist(new GH7941Product($product['name'], $product['price']));
        }

        $this->_em->flush();
        $this->_em->clear();
    }

    /** @test */
    public function typesShouldBeConvertedForDQLFunctions() : void
    {
        $query = $this->_em->createQuery(
            'SELECT
                 COUNT(product.id) as count,
                 SUM(product.price) as sales,
                 AVG(product.price) as average
             FROM ' . GH7941Product::class . ' product'
        );

        $result = $query->getSingleResult();

        self::assertSame(6, $result['count']);
        self::assertSame('17.0', $result['sales']);
        self::assertSame('2.83333333333333', $result['average']);

        $query = $this->_em->createQuery(
            'SELECT
                 ABS(product.price) as absolute,
                 SQRT(product.price) as square_root,
                 LENGTH(product.name) as length
             FROM ' . GH7941Product::class . ' product'
        );

        foreach ($query->getResult() as $i => $item) {
            $product = self::PRODUCTS[$i];

            self::assertSame(ltrim($product['price'], '-'), $item['absolute']);
            self::assertSame($product['square_root'], $item['square_root']);
            self::assertSame(strlen($product['name']), $item['length']);
        }
    }
}

/**
 * @Entity
 * @Table()
 */
class GH7941Product
{
    /**
     * @Id
     * @GeneratedValue
     * @Column(type="integer")
     */
    public $id;

    /** @Column(type="string") */
    public $name;

    /** @Column(type="decimal") */
    public $price;

    /** @Column(type="datetime_immutable") */
    public $createdAt;

    public function __construct(string $name, string $price)
    {
        $this->name      = $name;
        $this->price     = $price;
        $this->createdAt = new DateTimeImmutable();
    }
}