Doctrine\Tests\ORM\Tools\SchemaValidatorTest

Complexity

Total Complexity

12

Size/Duplication

Total Lines	190
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
A	modelSetProvider()	0	9	1
A	testCmsModelSet()	0	7	1
A	testInvalidTripleAssociationAsKeyMapping()	0	14	1
A	testInvalidOrderByCollectionValuedAssociation()	0	10	1
A	testInvalidReferencedJoinTableColumnIsNotPrimary()	0	10	1
A	testInvalidOrderByInvalidField()	0	10	1
A	testInvalidManyToManyJoinColumnSchema()	0	16	1
A	testInvalidBiDirectionalRelationMappingMissingInversedByAttribute()	0	11	1
A	testValidOneToOneAsIdentifierSchema()	0	8	1
A	testInvalidOrderByAssociationInverseSide()	0	10	1
A	testInvalidToOneJoinColumnSchema()	0	16	1

<?php

declare(strict_types=1);

namespace Doctrine\Tests\ORM\Tools;

use Doctrine\ORM\Annotation as ORM;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Tools\SchemaValidator;
use Doctrine\Tests\OrmTestCase;
use function sprintf;

class SchemaValidatorTest extends OrmTestCase
{
    /** @var EntityManagerInterface */
    private $em;

    /** @var SchemaValidator */
    private $validator;

    public function setUp() : void
    {
        $this->em        = $this->getTestEntityManager();
        $this->validator = new SchemaValidator($this->em);
    }

    /**
     * @dataProvider modelSetProvider
     */
    public function testCmsModelSet(string $path) : void
    {
        $this->em->getConfiguration()
                 ->getMetadataDriverImpl()
                 ->addPaths([$path]);

The method addPaths() does not exist on Doctrine\ORM\Mapping\Driver\MappingDriver. It seems like you code against a sub-type of Doctrine\ORM\Mapping\Driver\MappingDriver such as Doctrine\ORM\Mapping\Driver\AnnotationDriver.

        self::assertEmpty($this->validator->validateMapping());
    }

    public function modelSetProvider() : array
    {
        return [
            'cms'        => [__DIR__ . '/../../Models/CMS'],
            'company'    => [__DIR__ . '/../../Models/Company'],
            'ecommerce'  => [__DIR__ . '/../../Models/ECommerce'],
            'forum'      => [__DIR__ . '/../../Models/Forum'],
            'navigation' => [__DIR__ . '/../../Models/Navigation'],
            'routing'    => [__DIR__ . '/../../Models/Routing'],
        ];
    }

    /**
     * @group DDC-1439
     */
    public function testInvalidManyToManyJoinColumnSchema() : void
    {
        $class1 = $this->em->getClassMetadata(InvalidEntity1::class);
        $class2 = $this->em->getClassMetadata(InvalidEntity2::class);

The assignment to $class2 is dead and can be removed.

        $errors = $this->validator->validateClass($class1);

        $message1 = "The inverse join columns of the many-to-many table '%s' have to contain to ALL identifier columns of the target entity '%s', however '%s' are missing.";
        $message2 = "The join columns of the many-to-many table '%s' have to contain to ALL identifier columns of the source entity '%s', however '%s' are missing.";

        self::assertEquals(
            [
                sprintf($message1, 'Entity1Entity2', InvalidEntity2::class, 'key4'),
                sprintf($message2, 'Entity1Entity2', InvalidEntity1::class, 'key2'),
            ],
            $errors
        );
    }

    /**
     * @group DDC-1439
     */
    public function testInvalidToOneJoinColumnSchema() : void
    {
        $class1 = $this->em->getClassMetadata(InvalidEntity1::class);

The assignment to $class1 is dead and can be removed.

        $class2 = $this->em->getClassMetadata(InvalidEntity2::class);

        $errors = $this->validator->validateClass($class2);

        $message1 = "The referenced column name '%s' has to be a primary key column on the target entity class '%s'.";
        $message2 = "The join columns of the association '%s' have to match to ALL identifier columns of the target entity '%s', however '%s' are missing.";

        self::assertEquals(
            [
                sprintf($message1, 'id', InvalidEntity1::class),
                sprintf($message2, 'assoc', InvalidEntity1::class, "key1', 'key2"),
            ],
            $errors
        );
    }

    /**
     * @group DDC-1587
     */
    public function testValidOneToOneAsIdentifierSchema() : void
    {
        $class1 = $this->em->getClassMetadata(DDC1587ValidEntity2::class);
        $class2 = $this->em->getClassMetadata(DDC1587ValidEntity1::class);

The assignment to $class2 is dead and can be removed.

        $errors = $this->validator->validateClass($class1);

        self::assertEquals([], $errors);
    }

    /**
     * @group DDC-1649
     */
    public function testInvalidTripleAssociationAsKeyMapping() : void
    {
        $classThree = $this->em->getClassMetadata(DDC1649Three::class);
        $errors     = $this->validator->validateClass($classThree);

        $message1 = "Cannot map association %s#%s as identifier, because the target entity '%s' also maps an association as identifier.";
        $message2 = "The referenced column name '%s' has to be a primary key column on the target entity class '%s'.";

        self::assertEquals(
            [
                sprintf($message1, DDC1649Three::class, 'two', DDC1649Two::class),
                sprintf($message2, 'id', DDC1649Two::class),
            ],
            $errors
        );
    }

    /**
     * @group DDC-3274
     */
    public function testInvalidBiDirectionalRelationMappingMissingInversedByAttribute() : void
    {
        $class  = $this->em->getClassMetadata(DDC3274One::class);
        $errors = $this->validator->validateClass($class);

        $message = 'The property %s#%s is on the inverse side of a bi-directional relationship, but the '
            . "specified mappedBy association on the target-entity %s#%s does not contain the required 'inversedBy=\"%s\"' attribute.";

        self::assertEquals(
            [sprintf($message, DDC3274One::class, 'two', DDC3274Two::class, 'one', 'two')],
            $errors
        );
    }

    /**
     * @group DDC-3322
     */
    public function testInvalidOrderByInvalidField() : void
    {
        $class  = $this->em->getClassMetadata(DDC3322One::class);
        $errors = $this->validator->validateClass($class);

        $message = "The association %s#%s is ordered by a property '%s' that is non-existing field on the target entity '%s'.";

        self::assertEquals(
            [sprintf($message, DDC3322One::class, 'invalidAssoc', 'invalidField', DDC3322ValidEntity1::class)],
            $errors
        );
    }

    /**
     * @group DDC-3322
     */
    public function testInvalidOrderByCollectionValuedAssociation() : void
    {
        $class  = $this->em->getClassMetadata(DDC3322Two::class);
        $errors = $this->validator->validateClass($class);

        $message = "The association %s#%s is ordered by a property '%s' on '%s' that is a collection-valued association.";

        self::assertEquals(
            [sprintf($message, DDC3322Two::class, 'invalidAssoc', 'oneToMany', DDC3322ValidEntity1::class)],
            $errors
        );
    }

    /**
     * @group DDC-3322
     */
    public function testInvalidOrderByAssociationInverseSide() : void
    {
        $class  = $this->em->getClassMetadata(DDC3322Three::class);
        $errors = $this->validator->validateClass($class);

        $message = "The association %s#%s is ordered by a property '%s' on '%s' that is the inverse side of an association.";

        self::assertEquals(
            [sprintf($message, DDC3322Three::class, 'invalidAssoc', 'oneToOneInverse', DDC3322ValidEntity1::class)],
            $errors
        );
    }

    public function testInvalidReferencedJoinTableColumnIsNotPrimary() : void
    {
        $class  = $this->em->getClassMetadata(InvalidEntity3::class);
        $errors = $this->validator->validateClass($class);

        $message = "The referenced column name '%s' has to be a primary key column on the target entity class '%s'.";

        self::assertEquals(
            [sprintf($message, 'nonId4', InvalidEntity4::class)],
            $errors
        );
    }
}

/**
 * @ORM\Entity
 */
class InvalidEntity1
{
    /** @ORM\Id @ORM\Column */
    protected $key1;
    /** @ORM\Id @ORM\Column */
    protected $key2;
    /**
     * @ORM\ManyToMany (targetEntity=InvalidEntity2::class)
     * @ORM\JoinTable (name="Entity1Entity2",
     *      joinColumns={@ORM\JoinColumn(name="key1", referencedColumnName="key1")},
     *      inverseJoinColumns={@ORM\JoinColumn(name="key3", referencedColumnName="key3")}
     *      )
     */
    protected $entity2;
}

/**
 * @ORM\Entity
 */
class InvalidEntity2
{
    /** @ORM\Id @ORM\Column */
    protected $key3;

    /** @ORM\Id @ORM\Column */
    protected $key4;

    /** @ORM\ManyToOne(targetEntity=InvalidEntity1::class) */
    protected $assoc;
}

/**
 * @ORM\Entity
 */
class InvalidEntity3
{
    /** @ORM\Id @ORM\Column */
    protected $id3;

    /**
     * @ORM\ManyToMany(targetEntity=InvalidEntity4::class)
     * @ORM\JoinTable(name="invalid_entity_3_4")
     * @ORM\JoinTable (name="Entity1Entity2",
     *      joinColumns={@ORM\JoinColumn(name="id3_fk", referencedColumnName="id3")},
     *      inverseJoinColumns={@ORM\JoinColumn(name="id4_fk", referencedColumnName="nonId4")}
     * )
     */
    protected $invalid4;
}

/**
 * @ORM\Entity
 */
class InvalidEntity4
{
    /** @ORM\Id @ORM\Column */
    protected $id4;
    /** @ORM\Column */
    protected $nonId4;
}

/**
 * @ORM\Entity(repositoryClass="Entity\Repository\Agent")
 * @ORM\Table(name="agent")
 */
class DDC1587ValidEntity1
{
    /**
     * @ORM\Id @ORM\GeneratedValue
     * @ORM\Column(name="pk", type="integer")
     *
     * @var int
     */
    private $pk;

The private property $pk is not used, and could be removed.

    /**
     * @ORM\Column(name="name", type="string", length=32)
     *
     * @var string
     */
    private $name;

The private property $name is not used, and could be removed.

    /**
     * @ORM\OneToOne(targetEntity=DDC1587ValidEntity2::class, cascade={"all"}, mappedBy="agent")
     * @ORM\JoinColumn(name="pk", referencedColumnName="pk_agent")
     *
     * @var Identifier

The type Doctrine\Tests\ORM\Tools\Identifier was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private $identifier;

The private property $identifier is not used, and could be removed.

}

/**
 * @ORM\Entity
 * @ORM\Table
 */
class DDC1587ValidEntity2
{
    /**
     * @ORM\Id
     * @ORM\OneToOne(targetEntity=DDC1587ValidEntity1::class, inversedBy="identifier")
     * @ORM\JoinColumn(name="pk_agent", referencedColumnName="pk", nullable=false)
     *
     * @var DDC1587ValidEntity1
     */
    private $agent;

The private property $agent is not used, and could be removed.

    /**
     * @ORM\Column(name="num", type="string", length=16, nullable=true)
     *
     * @var string
     */
    private $num;

The private property $num is not used, and could be removed.

}

/**
 * @ORM\Entity
 */
class DDC1649One
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    public $id;
}

/**
 * @ORM\Entity
 */
class DDC1649Two
{
    /** @ORM\Id @ORM\ManyToOne(targetEntity=DDC1649One::class)@ORM\JoinColumn(name="id", referencedColumnName="id")  */
    public $one;
}

/**
 * @ORM\Entity
 */
class DDC1649Three
{
    /** @ORM\Id @ORM\ManyToOne(targetEntity=DDC1649Two::class) @ORM\JoinColumn(name="id",  referencedColumnName="id") */
    private $two;

The private property $two is not used, and could be removed.

}

/**
 * @ORM\Entity
 */
class DDC3274One
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

The private property $id is not used, and could be removed.

    /** @ORM\OneToMany(targetEntity=DDC3274Two::class, mappedBy="one") */
    private $two;
}

/**
 * @ORM\Entity
 */
class DDC3274Two
{
    /**
     * @ORM\Id
     * @ORM\ManyToOne(targetEntity=DDC3274One::class)
     */
    private $one;

The private property $one is not used, and could be removed.

}

/**
 * @ORM\Entity
 */
class DDC3322ValidEntity1
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

    /** @ORM\ManyToOne(targetEntity=DDC3322One::class, inversedBy="validAssoc") */
    private $oneValid;

The private property $oneValid is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322One::class, inversedBy="invalidAssoc") */
    private $oneInvalid;

The private property $oneInvalid is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322Two::class, inversedBy="validAssoc") */
    private $twoValid;

The private property $twoValid is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322Two::class, inversedBy="invalidAssoc") */
    private $twoInvalid;

The private property $twoInvalid is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322Three::class, inversedBy="validAssoc") */
    private $threeValid;

The private property $threeValid is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322Three::class, inversedBy="invalidAssoc") */
    private $threeInvalid;

The private property $threeInvalid is not used, and could be removed.

    /** @ORM\OneToMany(targetEntity=DDC3322ValidEntity2::class, mappedBy="manyToOne") */
    private $oneToMany;

The private property $oneToMany is not used, and could be removed.

    /** @ORM\ManyToOne(targetEntity=DDC3322ValidEntity2::class, inversedBy="oneToMany") */
    private $manyToOne;

The private property $manyToOne is not used, and could be removed.

    /** @ORM\OneToOne(targetEntity=DDC3322ValidEntity2::class, mappedBy="oneToOneOwning") */
    private $oneToOneInverse;

The private property $oneToOneInverse is not used, and could be removed.

    /** @ORM\OneToOne(targetEntity=DDC3322ValidEntity2::class, inversedBy="oneToOneInverse") */
    private $oneToOneOwning;

The private property $oneToOneOwning is not used, and could be removed.

}

/**
 * @ORM\Entity
 */
class DDC3322ValidEntity2
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

    /** @ORM\ManyToOne(targetEntity=DDC3322ValidEntity1::class, inversedBy="oneToMany") */
    private $manyToOne;

    /** @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="manyToOne") */
    private $oneToMany;

    /** @ORM\OneToOne(targetEntity=DDC3322ValidEntity1::class, inversedBy="oneToOneInverse") */
    private $oneToOneOwning;

    /** @ORM\OneToOne(targetEntity=DDC3322ValidEntity1::class, mappedBy="oneToOneOwning") */
    private $oneToOneInverse;
}

/**
 * @ORM\Entity
 */
class DDC3322One
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="oneValid")
     * @ORM\OrderBy({"id" = "ASC"})
     */
    private $validAssoc;

The private property $validAssoc is not used, and could be removed.

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="oneInvalid")
     * @ORM\OrderBy({"invalidField" = "ASC"})
     */
    private $invalidAssoc;

The private property $invalidAssoc is not used, and could be removed.

}

/**
 * @ORM\Entity
 */
class DDC3322Two
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="twoValid")
     * @ORM\OrderBy({"manyToOne" = "ASC"})
     */
    private $validAssoc;

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="twoInvalid")
     * @ORM\OrderBy({"oneToMany" = "ASC"})
     */
    private $invalidAssoc;
}

/**
 * @ORM\Entity
 */
class DDC3322Three
{
    /** @ORM\Id @ORM\Column @ORM\GeneratedValue */
    private $id;

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="threeValid")
     * @ORM\OrderBy({"oneToOneOwning" = "ASC"})
     */
    private $validAssoc;

    /**
     * @ORM\OneToMany(targetEntity=DDC3322ValidEntity1::class, mappedBy="threeInvalid")
     * @ORM\OrderBy({"oneToOneInverse" = "ASC"})
     */
    private $invalidAssoc;
}