doctrine2/tests/Doctrine/Tests/ORM/Functional/AdvancedAssociationTest.php

<?php

namespace Doctrine\Tests\ORM\Functional;

use Doctrine\ORM\Query;

require_once __DIR__ . '/../../TestInit.php';

/**
 * Functional tests for the Single Table Inheritance mapping strategy.
 *
 * @author robo
 */
class AdvancedAssociationTest extends \Doctrine\Tests\OrmFunctionalTestCase
{
    protected function setUp() {
        parent::setUp();
        try {
            $this->_schemaTool->createSchema(array(            
                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Phrase'), 
                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\PhraseType'),
                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Definition'),
                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Lemma'),
                $this->_em->getClassMetadata('Doctrine\Tests\ORM\Functional\Type')
            ));
        } catch (\Exception $e) {
            // Swallow all exceptions. We do not test the schema tool here.
        }
    }

    public function testIssue()
    {
        //setup
        $phrase = new Phrase;
        $phrase->setPhrase('lalala');
        
        $type = new PhraseType;
        $type->setType('nonsense');
        $type->setAbbreviation('non');
        
        $def1 = new Definition;
        $def1->setDefinition('def1');
        $def2 = new Definition;
        $def2->setDefinition('def2');
                
        $phrase->setType($type);
        $phrase->addDefinition($def1);
        $phrase->addDefinition($def2);
        
        $this->_em->persist($phrase);
        $this->_em->persist($type);
        
        $this->_em->flush();
        $this->_em->clear();
        //end setup
        
        // test1 - lazy-loading many-to-one after find()
        $phrase2 = $this->_em->find('Doctrine\Tests\ORM\Functional\Phrase', $phrase->getId());
        $this->assertTrue(is_numeric($phrase2->getType()->getId()));
        
        $this->_em->clear();
        
        // test2 - eager load in DQL query
        $query = $this->_em->createQuery("SELECT p,t FROM Doctrine\Tests\ORM\Functional\Phrase p JOIN p.type t");
        $res = $query->getResult();
        $this->assertEquals(1, count($res));
        $this->assertTrue($res[0]->getType() instanceof PhraseType);
        $this->assertTrue($res[0]->getType()->getPhrases() instanceof \Doctrine\ORM\PersistentCollection);
        $this->assertFalse($res[0]->getType()->getPhrases()->isInitialized());
        
        $this->_em->clear();
        
        // test2 - eager load in DQL query with double-join back and forth
        $query = $this->_em->createQuery("SELECT p,t,pp FROM Doctrine\Tests\ORM\Functional\Phrase p JOIN p.type t JOIN t.phrases pp");
        $res = $query->getResult();
        $this->assertEquals(1, count($res));
        $this->assertTrue($res[0]->getType() instanceof PhraseType);
        $this->assertTrue($res[0]->getType()->getPhrases() instanceof \Doctrine\ORM\PersistentCollection);
        $this->assertTrue($res[0]->getType()->getPhrases()->isInitialized());
        
        $this->_em->clear();
        
        // test3 - lazy-loading one-to-many after find()
        $phrase3 = $this->_em->find('Doctrine\Tests\ORM\Functional\Phrase', $phrase->getId());
        $definitions = $phrase3->getDefinitions();
        $this->assertTrue($definitions instanceof \Doctrine\ORM\PersistentCollection);
        $this->assertTrue($definitions[0] instanceof Definition);
        
        $this->_em->clear();
        
        // test4 - lazy-loading after DQL query
        $query = $this->_em->createQuery("SELECT p FROM Doctrine\Tests\ORM\Functional\Phrase p");
        $res = $query->getResult();
        $definitions = $res[0]->getDefinitions();
        
        $this->assertEquals(1, count($res));
        
        $this->assertTrue($definitions[0] instanceof Definition);
        $this->assertEquals(2, $definitions->count());
    }
    
    public function testManyToMany()
    {
        $lemma = new Lemma;
        $lemma->setLemma('abu');
        
        $type = new Type();
        $type->setType('nonsense');
        $type->setAbbreviation('non');
        
        $lemma->addType($type);
        
        $this->_em->persist($lemma);
        $this->_em->persist($type);
        $this->_em->flush();
        
        // test5 ManyToMany
        $query = $this->_em->createQuery("SELECT l FROM Doctrine\Tests\ORM\Functional\Lemma l");
        $res = $query->getResult();
        $types = $res[0]->getTypes();
        
        $this->assertTrue($types[0] instanceof Type);
    }
}

/**
 * @Entity
 * @Table(name="lemma")
 */
class Lemma {

	const CLASS_NAME = __CLASS__;

	/**
	 * @var int
	 * @Id
	 * @Column(type="integer", name="lemma_id")
	 * @GeneratedValue(strategy="AUTO")
	 */
	private $id;

	/**
	 *
	 * @var string
	 * @Column(type="string", name="lemma_name", unique=true, length=255)
	 */
	private $lemma;

	/**
	 * @var kateglo\application\utilities\collections\ArrayCollection
	 * @ManyToMany(targetEntity="Type", mappedBy="lemmas", cascade={"persist"})
	 */
	private $types;

	public function __construct() {
		$this->types = new \Doctrine\Common\Collections\ArrayCollection();
	}


	/**
	 *
	 * @return int
	 */
	public function getId(){
		return $this->id;
	}

	/**
	 *
	 * @param string $lemma
	 * @return void
	 */
	public function setLemma($lemma){
		$this->lemma = $lemma;
	}

	/**
	 *
	 * @return string
	 */
	public function getLemma(){
		return $this->lemma;
	}
	
	/**
     * 
     * @param kateglo\application\models\Type $type
     * @return void
     */
	public function addType(Type $type){
        if (!$this->types->contains($type)) {
            $this->types[] = $type;
            $type->addLemma($this);
        }
    }

    /**
     * 
     * @param kateglo\application\models\Type $type
     * @return void
     */
    public function removeType(Type $type)
    {
        $removed = $this->sources->removeElement($type);
        if ($removed !== null) {
            $removed->removeLemma($this);
        }
    }

    /**
     * 
     * @return kateglo\application\helpers\collections\ArrayCollection
     */
    public function getTypes()
    {
        return $this->types;
    }
}

/**
 * @Entity
 * @Table(name="type")
 */
class Type {

	const CLASS_NAME = __CLASS__;

	/**
	 *
	 * @var int
	 * @Id
	 * @Column(type="integer", name="type_id")
	 * @GeneratedValue(strategy="AUTO")
	 */
	private $id;

	/**
	 *
	 * @var string
	 * @Column(type="string", name="type_name", unique=true)
	 */
	private $type;

	/**
	 *
	 * @var string
	 * @Column(type="string", name="type_abbreviation", unique=true)
	 */
	private $abbreviation;

	/**
	 * @var kateglo\application\helpers\collections\ArrayCollection
	 * @ManyToMany(targetEntity="Lemma")
	 * @JoinTable(name="lemma_type",
	 * 		joinColumns={@JoinColumn(name="type_id", referencedColumnName="type_id")},
	 * 		inverseJoinColumns={@JoinColumn(name="lemma_id", referencedColumnName="lemma_id")}
	 * )
	 */
	private $lemmas;

	public function __construct(){
		$this->lemmas = new \Doctrine\Common\Collections\ArrayCollection();
	}
	
	/**
	 *
	 * @return int
	 */
	public function getId(){
		return $this->id;
	}

	/**
	 *
	 * @param string $type
	 * @return void
	 */
	public function setType($type){
		$this->type = $type;
	}

	/**
	 *
	 * @return string
	 */
	public function getType(){
		return $this->type;
	}

	/**
	 *
	 * @param string $abbreviation
	 * @return void
	 */
	public function setAbbreviation($abbreviation){
		$this->abbreviation = $abbreviation;
	}

	/**
	 *
	 * @return string
	 */
	public function getAbbreviation(){
		return $this->abbreviation;
	}

	/**
	 * 
	 * @param kateglo\application\models\Lemma $lemma
	 * @return void
	 */
	public function addLemma(Lemma $lemma)
	{
		if (!$this->lemmas->contains($lemma)) {
			$this->lemmas[] = $lemma;
			$lemma->addType($this);
		}
	}

	/**
	 * 
	 * @param kateglo\application\models\Lemma $lemma
	 * @return void
	 */
	public function removeLEmma(Lemma $lemma)
	{
		$removed = $this->lemmas->removeElement($lemma);
		if ($removed !== null) {
			$removed->removeType($this);
		}
	}

	/**
	 * 
	 * @return kateglo\application\helpers\collections\ArrayCollection
	 */
	public function getCategories()
	{
		return $this->categories;
	}

}


/**
 * @Entity
 * @Table(name="phrase")
 */
class Phrase {

    const CLASS_NAME = __CLASS__;

    /**
     * @Id
     * @Column(type="integer", name="phrase_id")
     * @GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @Column(type="string", name="phrase_name", unique=true, length=255)
     */
    private $phrase;

    /**
     * @ManyToOne(targetEntity="PhraseType")
     * @JoinColumn(name="phrase_type_id", referencedColumnName="phrase_type_id")
     */
    private $type;
    
    /**
     * @OneToMany(targetEntity="Definition", mappedBy="phrase", cascade={"persist"})
     */
    private $definitions;

    public function __construct() {
        $this->definitions = new \Doctrine\Common\Collections\ArrayCollection;
    }
    
    /**
     * 
     * @param Definition $definition
     * @return void
     */
    public function addDefinition(Definition $definition){
        $this->definitions[] = $definition;
        $definition->setPhrase($this);
    }
    
    /**
     * @return int
     */
    public function getId(){
        return $this->id;
    }
    
    /**
     * @param string $phrase
     * @return void
     */
    public function setPhrase($phrase){
        $this->phrase = $phrase;
    }
    
    /**
     * @return string
     */
    public function getPhrase(){
        return $this->phrase;
    }
    
    /**
     *
     * @param PhraseType $type
     * @return void
     */
    public function setType(PhraseType $type){
        $this->type = $type;
    }
    
    /**
     *
     * @return PhraseType
     */
    public function getType(){
        return $this->type;
    }
    
    /**
     * 
     * @return ArrayCollection
     */
    public function getDefinitions(){
        return $this->definitions;
    }
}

/**
 * @Entity
 * @Table(name="phrase_type")
 */
class PhraseType {
    
    const CLASS_NAME = __CLASS__;
    
    /**
     * @Id
     * @Column(type="integer", name="phrase_type_id")
     * @GeneratedValue(strategy="AUTO")
     */
    private $id;
    
    /**
     * @Column(type="string", name="phrase_type_name", unique=true)
     */
    private $type;
    
    /**
     * @Column(type="string", name="phrase_type_abbreviation", unique=true)
     */
    private $abbreviation;
    
    /**
     * @OneToMany(targetEntity="Phrase", mappedBy="type")
     */
    private $phrases;
    
    public function __construct() {
        $this->phrases = new \Doctrine\Common\Collections\ArrayCollection;
    }
    
    /**
     * @return int
     */
    public function getId(){
        return $this->id;
    }
    
    /**
     * @param string $type
     * @return void
     */
    public function setType($type){
        $this->type = $type;
    }
    
    /**
     * @return string
     */
    public function getType(){
        return $this->type;
    }
    
    /**
     * @param string $abbreviation
     * @return void
     */
    public function setAbbreviation($abbreviation){
        $this->abbreviation = $abbreviation;
    }
    
    /**
     * @return string
     */
    public function getAbbreviation(){
        return $this->abbreviation;
    }
    
    /**
     * @param ArrayCollection $phrases
     * @return void
     */
    public function setPhrases($phrases){
        $this->phrases = $phrases;
    }
    
    /**
     * 
     * @return ArrayCollection
     */
    public function getPhrases(){
        return $this->phrases;
    }
    
}

/**
 * @Entity
 * @Table(name="definition")
 */
class Definition {
    
    const CLASS_NAME = __CLASS__;
    
    /**
     * @Id
     * @Column(type="integer", name="definition_id")
     * @GeneratedValue(strategy="AUTO")
     */
    private $id;
    
    /**
     * @ManyToOne(targetEntity="Phrase")
     * @JoinColumn(name="definition_phrase_id", referencedColumnName="phrase_id")
     */
    private $phrase;
    
    /**
     * @Column(type="text", name="definition_text")
     */
    private $definition;
    
    /**
     * @return int
     */
    public function getId(){
        return $this->id;
    }
    
    /**
     * @param Phrase $phrase
     * @return void
     */
    public function setPhrase(Phrase $phrase){
        $this->phrase = $phrase;
    }
    
    /**
     * @return Phrase
     */
    public function getPhrase(){
        return $this->phrase;
    }
    
    public function removePhrase() {
        if ($this->phrase !== null) {
            /*@var $phrase kateglo\application\models\Phrase */
            $phrase = $this->phrase;
            $this->phrase = null;
            $phrase->removeDefinition($this);
        }
    }
    
    /**
     * @param string $definition
     * @return void
     */
    public function setDefinition($definition){
        $this->definition = $definition;
    }
    
    /**
     * @return string
     */
    public function getDefinition(){
        return $this->definition;
    }
}