Doctrine\Tests\ORM\Functional\Ticket\GH6139Person

Complexity

Total Complexity

1

Size/Duplication

Total Lines	19
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	0

Importance

Changes

0

1 Method

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1

<?php
namespace Doctrine\Tests\ORM\Functional\Ticket;

use Doctrine\DBAL\Platforms\AbstractPlatform;
use Doctrine\DBAL\Types\StringType;
use Doctrine\DBAL\Types\Type;
use Doctrine\Tests\OrmFunctionalTestCase;

class GH6139Test extends OrmFunctionalTestCase
{
    protected function setUp()
    {
        parent::setUp();

        Type::addType(GH6139PeopleType::NAME, __NAMESPACE__ . '\\GH6139PeopleType');

        $this->_schemaTool->createSchema(array(
            $this->_em->getClassMetadata(__NAMESPACE__ . '\\GH6139Person'),
            $this->_em->getClassMetadata(__NAMESPACE__ . '\\GH6139Boss'),
            $this->_em->getClassMetadata(__NAMESPACE__ . '\\GH6139Employee'),
        ));
    }

    public function testEnumDiscriminatorsShouldBeConvertedToString()
    {
        $boss = new GH6139Boss('John');
        $employee = new GH6139Employee('Bob');

        $this->_em->persist($boss);
        $this->_em->persist($employee);
        $this->_em->flush();
        $this->_em->clear();

        $query = $this->_em->createQueryBuilder()
            ->select('person')
            ->from(__NAMESPACE__ . '\\GH6139Person', 'person')
            ->where('person.name = :name')
            ->setMaxResults(1)
            ->getQuery();

        $query->setParameter('name', 'John');
        self::assertEquals($boss, $query->getOneOrNullResult());

        $query->setParameter('name', 'Bob');
        self::assertEquals($employee, $query->getOneOrNullResult());
    }
}

class GH6139PeopleType extends StringType
{
    const NAME = 'gh6139people';

    /**
     * {@inheritdoc}
     */
    public function convertToDatabaseValue($value, AbstractPlatform $platform)
    {
        if (!$value instanceof GH6139People) {
            $value = GH6139People::get($value);
        }

        return (string) $value;
    }

    public function convertToPhpValue($value, AbstractPlatform $platform)
    {
        return GH6139People::get($value);
    }

    /**
     * {@inheritdoc}
     */
    public function getName()
    {
        return self::NAME;
    }
}

class GH6139People
{
    const BOSS = 'boss';
    const EMPLOYEE = 'employee';

    private $value;

    public static function get($value)
    {
        if (!self::isValid($value)) {
            throw new \InvalidArgumentException();
        }

        return new self($value);
    }

    public static function isValid($valid)
    {
        return in_array($valid, [self::BOSS, self::EMPLOYEE]);
    }

    private function __construct($value)
    {
        $this->value = $value;
    }

    public function getValue()
    {
        return $this->value;
    }

    public function __toString()
    {
        return $this->value;
    }
}

/**
 * @Entity
 * @InheritanceType("JOINED")
 * @DiscriminatorColumn(name="discr", type="gh6139people")
 * @DiscriminatorMap({
 *      "boss"     = "Doctrine\Tests\ORM\Functional\Ticket\GH6139Boss",
 *      "employee" = "Doctrine\Tests\ORM\Functional\Ticket\GH6139Employee"
 * })
 */
abstract class GH6139Person
{
    /**
     * @Id
     * @Column(type="integer")
     * @GeneratedValue(strategy="AUTO")
     */
    public $id;

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

    public function __construct($name)
    {
        $this->name = $name;
    }
}

/** @Entity */
class GH6139Boss extends GH6139Person
{
}

/** @Entity */
class GH6139Employee extends GH6139Person
{
}