public function setUp()
{
if (!class_exists('\\ChildTable')) {
$schema = <<<EOF
<database name="composite_number_range_test">
<table name="parent_table">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="name" type="VARCHAR" required="false" />
</table>
<table name="child_table">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="name" type="VARCHAR" size="50" required="false" />
<behavior name="\\APinnecke\\CompositeNumberRange\\CompositeNumberRangeBehavior">
<parameter name="foreignTable" value="parent_table"/>
</behavior>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setPlatform(new MysqlPlatform());
$builder->setSchema($schema);
$builder->build('mysql:host=127.0.0.1;dbname=' . getenv('DB_NAME'), getenv('DB_USER'), getenv('DB_PASS'), new MysqlAdapter());
}
$this->parent = new \ParentTable();
$this->parent->setName('test');
$this->parent->save();
$this->parent2 = new \ParentTable();
$this->parent2->setName('test2');
$this->parent2->save();
\ChildTableQuery::create()->deleteAll();
\ParentTableSequenceQuery::create()->deleteAll();
}
/**
* @param string $xml
*
* @return Database|boolean
*/
public function applyXml($xml, $changeRequired = false)
{
$this->readDatabase();
$builder = new QuickBuilder();
$builder->setIdentifierQuoting(true);
$builder->setPlatform($this->database->getPlatform());
$builder->setSchema($xml);
$database = $builder->getDatabase();
$database->setSchema('migration');
$database->setPlatform($this->database->getPlatform());
$diff = DatabaseComparator::computeDiff($this->database, $database);
if (false === $diff) {
if ($changeRequired) {
throw new BuildException(sprintf("No changes in schema to current database: \nSchema database:\n%s\n\nCurrent Database:\n%s", $database, $this->database));
}
return false;
}
$sql = $this->database->getPlatform()->getModifyDatabaseDDL($diff);
$this->con->beginTransaction();
if (!$sql) {
throw new BuildException(sprintf('Ooops. There is a diff between current database and schema xml but no SQL has been generated. Change: %s', $diff));
}
$statements = SqlParser::parseString($sql);
foreach ($statements as $statement) {
try {
$stmt = $this->con->prepare($statement);
$stmt->execute();
} catch (\Exception $e) {
throw new BuildException(sprintf("Can not execute SQL: \n%s\nFrom database: \n%s\n\nTo database: \n%s\n", $statement, $this->database, $database), null, $e);
}
}
$this->con->commit();
return $database;
}
public function setUp()
{
if (!class_exists('\\Issue656TestObject')) {
$schema = <<<EOF
<database>
<table name="issue_656_test_object">
<column name="ID" type="INTEGER" size="10" sqlType="int(10) unsigned" primaryKey="true" required="true" autoIncrement="true"/>
<column name="Name" type="VARCHAR" size="45" required="true"/>
</table>
<table name="issue_656_test_object_from" isCrossRef="true">
<column name="From" type="INTEGER" size="10" sqlType="int(10) unsigned" primaryKey="true" required="true"/>
<column name="To" type="INTEGER" size="10" sqlType="int(10) unsigned" primaryKey="true" required="true"/>
<foreign-key name="fk_test_object_from" foreignTable="issue_656_test_object">
<reference local="From" foreign="ID"/>
</foreign-key>
<foreign-key name="fk_test_object_to" foreignTable="issue_656_test_object">
<reference local="To" foreign="ID"/>
</foreign-key>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->buildClasses(null, true);
}
}
/**
* @param string $xml
*
* @return Database
*/
public function applyXml($xml)
{
$this->readDatabase();
$builder = new QuickBuilder();
$builder->setPlatform($this->database->getPlatform());
$builder->setSchema($xml);
$database = $builder->getDatabase();
$database->setSchema('migration');
$database->setPlatform($this->database->getPlatform());
$diff = DatabaseComparator::computeDiff($this->database, $database);
if (false === $diff) {
return null;
}
$sql = $this->database->getPlatform()->getModifyDatabaseDDL($diff);
$this->con->beginTransaction();
$statements = SqlParser::parseString($sql);
foreach ($statements as $statement) {
try {
$stmt = $this->con->prepare($statement);
$stmt->execute();
} catch (\Exception $e) {
$this->con->rollBack();
throw new BuildException(sprintf("Can not execute SQL: \n%s\nFrom database: \n%s\n\nTo database: \n%s\n", $statement, $this->database, $database), null, $e);
}
}
$this->con->commit();
return $database;
}
/**
* Migrates the database.
*
* @param string $schema xml schema
*/
public function migrate($schema)
{
$builder = new QuickBuilder();
$platform = $this->getPlatform();
$builder->setPlatform($platform);
$builder->setParser($this->getParser($this->con));
$builder->getParser()->setPlatform($platform);
$builder->setSchema($schema);
$builder->updateDB($this->con);
}
public function setUp()
{
parent::setUp();
$schema = file_get_contents(__DIR__ . '/../Resources/acl_schema.xml');
if (!class_exists('Propel\\Bundle\\PropelBundle\\Model\\Acl\\Map\\AclClassTableMap')) {
$classTargets = array('tablemap', 'object', 'query');
} else {
$classTargets = array();
}
$builder = new QuickBuilder();
$builder->setSchema($schema);
$this->con = $builder->build($dsn = null, $user = null, $pass = null, $adapter = null, $classTargets);
}
public function setUp()
{
if (!class_exists('\\Base\\Issue1033Book')) {
$schema = <<<EOF
<database>
<table name="Issue1033Book">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" description="Book Id" />
<column name="title" type="VARCHAR" required="true" description="Book Title" primaryString="true" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->buildClasses(null, true);
}
}
public function setUp()
{
if (!class_exists('TableWithStateMachineBehavior')) {
$schema = <<<EOF
<database name="state_machine_behavior" defaultIdMethod="native">
<table name="table_with_state_machine_behavior">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<behavior name="state_machine">
<parameter name="states" value="draft, unpublished, published" />
<parameter name="initial_state" value="draft" />
<parameter name="transition" value="draft to published with publish" />
<parameter name="transition" value="published to unpublished with unpublish" />
<parameter name="transition" value="unpublished to published with publish" />
<parameter name="state_column" value="state" />
</behavior>
</table>
<table name="table_with_state_machine_behavior_with_custom_column">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<behavior name="state_machine">
<parameter name="states" value="draft, published, not_yEt_published, flagged" />
<parameter name="initial_state" value="draft" />
<parameter name="transition" value="draft to published with publish" />
<parameter name="transition" value="published to not_yet_published with unpublish" />
<parameter name="transition" value="not_yEt_published to published with publish" />
<parameter name="transition" value="not_yEt_published to flagged with flag_for_publish" />
<parameter name="transition" value="flagged to published with publish" />
<parameter name="state_column" value="my_state" />
</behavior>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$config = $builder->getConfig();
$builder->setConfig($config);
$builder->setSchema($schema);
$builder->build();
}
}
public function testValidateReturnsTrueForValidSchema()
{
$schema = <<<EOF
<database name="bookstore">
<table name="book">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="title" type="VARCHAR" size="100" primaryString="true" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$database = $builder->getDatabase();
$appData = new AppData();
$appData->addDatabase($database);
$validator = new SchemaValidator($appData);
$this->assertTrue($validator->validate());
}
/**
* Drop the foreign key in the `_user` table and check whether it generates
* the correct `DROP` SQL.
*/
private function dropForeignKey()
{
$this->readDatabase();
$updatedSchema = '
<database name="reverse-bookstore" identifierQuoting="true">
<table name="issue617_user">
<vendor type="mysql">
<parameter name="Engine" value="InnoDB"/>
<parameter name="Charset" value="utf8"/>
</vendor>
<column name="id" type="INTEGER" required="true" primaryKey="true" autoIncrement="true" />
<column name="full_name" type="VARCHAR" size="50" required="true" />
</table>
<table name="issue617_group">
<vendor type="mysql">
<parameter name="Engine" value="InnoDB"/>
<parameter name="Charset" value="utf8"/>
</vendor>
<column name="id" type="INTEGER" required="true" primaryKey="true" autoIncrement="true" />
<column name="name" type="VARCHAR" size="50" required="true" />
</table>
</database>
';
$this->updatedBuilder = new QuickBuilder();
$this->updatedBuilder->setIdentifierQuoting(true);
$this->updatedBuilder->setPlatform($this->database->getPlatform());
$this->updatedBuilder->setSchema($updatedSchema);
$diff = DatabaseComparator::computeDiff($this->database, $this->updatedBuilder->getDatabase());
$sql = $this->database->getPlatform()->getModifyDatabaseDDL($diff);
$expected = '
ALTER TABLE `issue617_user` DROP FOREIGN KEY `issue617_user_fk_5936b3`;
DROP INDEX `issue617_user_fi_5936b3` ON `issue617_user`;
ALTER TABLE `issue617_user`
DROP `group_id`;
';
$this->assertContains($expected, $sql);
$this->updateSchema($this->updatedBuilder->getDatabase());
}
public function setUp()
{
$schema = <<<SCHEMA
<database name="users" defaultIdMethod="native" namespace="Propel\\Bundle\\PropelBundle\\Tests\\Fixtures\\Model">
<table name="user">
<column name="id" type="integer" required="true" primaryKey="true" autoIncrement="true" />
<column name="username" type="varchar" size="255" primaryString="true" />
<column name="algorithm" type="varchar" size="50" />
<column name="salt" type="varchar" size="255" />
<column name="password" type="varchar" size="255" />
<column name="expires_at" type="timestamp" />
<column name="roles" type="array" />
</table>
</database>
SCHEMA;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$classTargets = array('tablemap', 'object', 'query', 'querystub');
$this->con = $builder->build($dsn = null, $user = null, $pass = null, $adapter = null, $classTargets);
}
public function testNamespace()
{
$schema = <<<EOF
<?xml version="1.0" encoding="utf-8"?>
<database name="default" defaultIdMethod="native" namespace="Tests\\Issue730\\">
<table name="issue730_group" idMethod="native" phpName="Group">
<column name="id" phpName="Id" type="INTEGER" primaryKey="true" required="true"/>
<column name="name" phpName="Name" type="VARCHAR" size="100" required="true"/>
</table>
<table name="issue730_department_group" idMethod="native" phpName="Group" namespace="\\Tests\\Issue730\\Department">
<column name="id" phpName="Id" type="INTEGER" primaryKey="true" autoIncrement="true" required="true"/>
<column name="name" type="VARCHAR" size="100" required="true"/>
<column name="group_id" phpName="GroupId" type="INTEGER"/>
<foreign-key foreignTable="issue730_group" phpName="Group" refPhpName="DepartmentGroup">
<reference local="group_id" foreign="id"/>
</foreign-key>
</table>
</database>
EOF;
$quickBuilder = new QuickBuilder();
$quickBuilder->setSchema($schema);
$quickBuilder->setIdentifierQuoting(true);
$platform = new SqlitePlatform();
$quickBuilder->setPlatform($platform);
$quickBuilder->build();
$groupA = new \Tests\Issue730\Group();
$groupA->setName('groupA');
$departmentGroup = new \Tests\Issue730\Department\Group();
$departmentGroup->setName('my department');
$departmentGroup->setGroup($groupA);
$this->assertEquals($groupA, $departmentGroup->getGroup());
$departmentGroups = $groupA->getDepartmentGroups();
$this->assertCount(1, $departmentGroups);
$this->assertEquals($departmentGroup, $departmentGroups->getFirst());
$groupA->save();
$departmentGroups = \Tests\Issue730\Department\GroupQuery::create()->filterByGroup($groupA)->find();
$this->assertCount(1, $departmentGroups);
$this->assertEquals($departmentGroup, $departmentGroups->getFirst());
$this->assertEquals('my department', $departmentGroups->getFirst()->getName());
}
public function testLoadDelegatedOnPrimaryKey()
{
$schema = <<<XML
<database name="default" package="vendor.bundles.Propel.Bundle.PropelBundle.Tests.Fixtures.DataFixtures.Loader" namespace="Propel\\Bundle\\PropelBundle\\Tests\\Fixtures\\DataFixtures\\Loader" defaultIdMethod="native">
<table name="yaml_delegate_on_primary_key_person" phpName="YamlDelegateOnPrimaryKeyPerson">
<column name="id" type="integer" primaryKey="true" autoIncrement="true" />
<column name="name" type="varchar" size="255" />
</table>
<table name="yaml_delegate_on_primary_key_author" phpName="YamlDelegateOnPrimaryKeyAuthor">
<column name="id" type="integer" primaryKey="true" autoIncrement="false" />
<column name="count_books" type="integer" defaultValue="0" required="true" />
<behavior name="delegate">
<parameter name="to" value="yaml_delegate_on_primary_key_person" />
</behavior>
<foreign-key foreignTable="yaml_delegate_on_primary_key_person" onDelete="RESTRICT" onUpdate="CASCADE">
<reference local="id" foreign="id" />
</foreign-key>
</table>
</database>
XML;
$fixtures = <<<YAML
Propel\\Bundle\\PropelBundle\\Tests\\Fixtures\\DataFixtures\\Loader\\YamlDelegateOnPrimaryKeyPerson:
yaml_delegate_on_primary_key_person_1:
name: "Some Persons Name"
Propel\\Bundle\\PropelBundle\\Tests\\Fixtures\\DataFixtures\\Loader\\YamlDelegateOnPrimaryKeyAuthor:
yaml_delegate_on_primary_key_author_1:
id: yaml_delegate_on_primary_key_person_1
count_books: 7
YAML;
$filename = $this->getTempFile($fixtures);
$builder = new QuickBuilder();
$builder->setSchema($schema);
$con = $builder->build();
$loader = new YamlDataLoader(__DIR__ . '/../../Fixtures/DataFixtures/Loader', array());
$loader->load(array($filename), 'default');
$authors = \Propel\Bundle\PropelBundle\Tests\Fixtures\DataFixtures\Loader\YamlDelegateOnPrimaryKeyAuthorQuery::create()->find($con);
$this->assertCount(1, $authors);
$author = $authors[0];
$person = $author->getYamlDelegateOnPrimaryKeyPerson();
$this->assertInstanceOf('Propel\\Bundle\\PropelBundle\\Tests\\Fixtures\\DataFixtures\\Loader\\YamlDelegateOnPrimaryKeyPerson', $person);
}
/**
* Setups the initial schema.
*/
private function setupInitSchema()
{
/*
* Create issue617 tables with foreign keys
*/
$schema = '
<database name="bookstore">
<table name="issue617_user">
<vendor type="mysql">
<parameter name="Engine" value="InnoDB"/>
<parameter name="Charset" value="utf8"/>
</vendor>
<column name="id" type="INTEGER" required="true" primaryKey="true" autoIncrement="true" />
<column name="full_name" type="VARCHAR" size="50" required="true" />
<!-- this column (and FK) will be removed from schema, but not from DB on migrate -->
<column name="group_id" type="INTEGER" />
<foreign-key foreignTable="issue617_group" onDelete="setnull">
<reference local="group_id" foreign="id" />
</foreign-key>
</table>
<table name="issue617_group">
<vendor type="mysql">
<parameter name="Engine" value="InnoDB"/>
<parameter name="Charset" value="utf8"/>
</vendor>
<column name="id" type="INTEGER" required="true" primaryKey="true" autoIncrement="true" />
<column name="name" type="VARCHAR" size="50" required="true" />
</table>
</database>
';
$builder = new QuickBuilder();
$builder->setPlatform($this->database->getPlatform());
$builder->setSchema($schema);
$diff = DatabaseComparator::computeDiff($this->database, $builder->getDatabase());
$sql = $this->database->getPlatform()->getModifyDatabaseDDL($diff);
$expected = '
CREATE TABLE `issue617_user`
(
`id` INTEGER NOT NULL AUTO_INCREMENT,
`full_name` VARCHAR(50) NOT NULL,
`group_id` INTEGER,
PRIMARY KEY (`id`),
INDEX `issue617_user_fi_5936b3` (`group_id`),
CONSTRAINT `issue617_user_fk_5936b3`
FOREIGN KEY (`group_id`)
REFERENCES `issue617_group` (`id`)
ON DELETE SET NULL
) ENGINE=InnoDB CHARACTER SET=\'utf8\';
CREATE TABLE `issue617_group`
(
`id` INTEGER NOT NULL AUTO_INCREMENT,
`name` VARCHAR(50) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB CHARACTER SET=\'utf8\';
';
$this->assertContains($expected, $sql);
$this->updateSchema($builder->getDatabase());
}
public function testToArrayKeyTypePreDefined()
{
$schema = <<<EOF
<database name="test" namespace="MyNameSpace">
<table name="test_key_type_table">
<column name="id_key_type" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="name_key_type" type="VARCHAR" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->getConfig()->setBuildProperty('defaultKeyType', 'studlyPhpName');
$builder->buildClasses();
$expectedKeys = array('idKeyType', 'nameKeyType');
$object = new TestKeyTypeTable();
$this->assertEquals($expectedKeys, array_keys($object->toArray()), 'toArray() returns an associative array with pre-defined key type in properties.');
}
/**
* @dataProvider customPkSchemaDataProvider
*/
public function testModifyTableRelatesI18nTableToMainTableWithCustomPk($schema)
{
$builder = new QuickBuilder();
$builder->setSchema($schema);
$expected = <<<EOF
-----------------------------------------------------------------------
-- i18n_behavior_test_custom_pk_0_i18n
-----------------------------------------------------------------------
DROP TABLE IF EXISTS i18n_behavior_test_custom_pk_0_i18n;
CREATE TABLE i18n_behavior_test_custom_pk_0_i18n
(
custom_id INTEGER NOT NULL,
locale VARCHAR(5) DEFAULT 'en_US' NOT NULL,
bar VARCHAR(100),
PRIMARY KEY (custom_id,locale),
UNIQUE (custom_id,locale),
FOREIGN KEY (custom_id) REFERENCES i18n_behavior_test_custom_pk_0 (id)
EOF;
$this->assertContains($expected, $builder->getSQL());
}
public function testDisableCreatedAt()
{
$schema = <<<EOF
<database name="timestampable_database">
<table name="table_without_created_at">
<column name="id" type="INTEGER" primaryKey="true" autoIncrement="true" />
<column name="name" type="varchar" />
<behavior name="timestampable">
<parameter name="disable_created_at" value="true" />
</behavior>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->build();
$this->assertFalse(method_exists('TableWithoutCreatedAt', 'getCreatedAt'));
$this->assertFalse(method_exists('TableWithoutCreatedAt', 'setCreatedAt'));
$this->assertTrue(method_exists('TableWithoutCreatedAt', 'getUpdatedAt'));
$this->assertTrue(method_exists('TableWithoutCreatedAt', 'setUpdatedAt'));
$obj = new \TableWithoutCreatedAt();
$obj->setName('Peter');
$this->assertNull($obj->getUpdatedAt());
$this->assertEquals(1, $obj->save());
$this->assertNotNull($obj->getUpdatedAt());
}
public function testModiFyTableUsesCustomI18nLocaleLength()
{
$schema = <<<EOF
<database name="i18n_behavior_test_0">
<table name="i18n_behavior_test_0">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<behavior name="i18n">
<parameter name="locale_length" value="6" />
</behavior>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$expected = <<<EOF
-----------------------------------------------------------------------
-- i18n_behavior_test_0_i18n
-----------------------------------------------------------------------
DROP TABLE IF EXISTS i18n_behavior_test_0_i18n;
CREATE TABLE i18n_behavior_test_0_i18n
(
id INTEGER NOT NULL,
locale VARCHAR(6) DEFAULT 'en_US' NOT NULL,
PRIMARY KEY (id,locale),
FOREIGN KEY (id) REFERENCES i18n_behavior_test_0 (id)
ON DELETE CASCADE
);
EOF;
$this->assertContains($expected, $builder->getSQL());
}
public function testHydrateWithMysqlInvalidDate()
{
$schema = <<<EOF
<database name="generated_object_complex_type_test_6">
<table name="complex_column_type_entity_6">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar1" type="DATE" />
<column name="bar2" type="TIME" />
<column name="bar3" type="TIMESTAMP" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->setPlatform(new MysqlPlatform());
$builder->buildClasses();
$r = new \ComplexColumnTypeEntity6();
$r->hydrate(array(123, '0000-00-00', '00:00:00', '0000-00-00 00:00:00'));
$this->assertNull($r->getBar1());
$this->assertEquals('00:00:00', $r->getBar2()->format('H:i:s'));
$this->assertNull($r->getBar3());
}
/**
* @dataProvider tablePrefixDataProvider
*/
public function testGeneratedClassesWithTablePrefix($schema, $expectSQL, $expectClasses)
{
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->buildClasses();
foreach ($expectClasses as $expectClass) {
$this->assertTrue(class_exists($expectClass), sprintf('expect class "%s" is not exists', $expectClass));
}
}
/**
* Setup schema und some default data
*/
public function setUp()
{
parent::setUp();
if (!class_exists('MoreRelationTest\\Page')) {
$schema = <<<EOF
<database name="more_relation_test" namespace="MoreRelationTest">
<table name="more_relation_test_page" phpName="Page">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="title" type="VARCHAR" size="100" primaryString="true" />
</table>
<table name="more_relation_test_content" phpName="Content">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="title" type="VARCHAR" size="100" />
<column name="content" type="LONGVARCHAR" required="false" />
<column name="page_id" type="INTEGER" required="false" />
<foreign-key foreignTable="more_relation_test_page" onDelete="cascade">
<reference local="page_id" foreign="id"/>
</foreign-key>
</table>
<table name="more_relation_test_comment" phpName="Comment">
<column name="user_id" required="true" primaryKey="true" type="INTEGER" />
<column name="page_id" required="true" primaryKey="true" type="INTEGER" />
<column name="comment" type="VARCHAR" size="100" />
<foreign-key foreignTable="more_relation_test_page" onDelete="cascade">
<reference local="page_id" foreign="id"/>
</foreign-key>
</table>
<table name="more_relation_test_content_comment" phpName="ContentComment">
<column name="id" required="true" autoIncrement="true" primaryKey="true" type="INTEGER" />
<column name="content_id" type="INTEGER" />
<column name="comment" type="VARCHAR" size="100" />
<foreign-key foreignTable="more_relation_test_content" onDelete="setnull">
<reference local="content_id" foreign="id"/>
</foreign-key>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->build();
}
\MoreRelationTest\ContentCommentQuery::create()->doDeleteAll();
\MoreRelationTest\ContentQuery::create()->doDeleteAll();
\MoreRelationTest\CommentQuery::create()->doDeleteAll();
\MoreRelationTest\PageQuery::create()->doDeleteAll();
for ($i = 1; $i <= 2; $i++) {
$page = new \MoreRelationTest\Page();
$page->setTitle('Page ' . $i);
for ($j = 1; $j <= 3; $j++) {
$content = new \MoreRelationTest\Content();
$content->setTitle('Content ' . $j);
$content->setContent(str_repeat('Content', $j));
$page->addContent($content);
$comment = new \MoreRelationTest\Comment();
$comment->setUserId($j);
$comment->setComment(str_repeat('Comment', $j));
$page->addComment($comment);
$comment = new \MoreRelationTest\ContentComment();
$comment->setContentId($i * $j);
$comment->setComment(str_repeat('Comment-' . $j . ', ', $j));
$content->addContentComment($comment);
}
$page->save();
}
}
public function testDatabaseLevelBehavior()
{
$schema = <<<EOF
<database name="archivable_behavior_test_0">
<behavior name="archivable" />
<table name="archivable_test_01">
<column name="id" required="true" primaryKey="true" autoIncrement="true" type="INTEGER" />
<column name="title" type="VARCHAR" size="100" primaryString="true" />
<behavior name="archivable" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->getSQL();
}
/**
* @dataProvider tablePrefixSchemaDataProvider
*/
public function testModifyTableAddsVersionTableWithPrefix($schema)
{
$builder = new QuickBuilder();
$builder->setSchema($schema);
$expected = <<<SQL
-----------------------------------------------------------------------
-- prefix_versionable_behavior_test_0_version
-----------------------------------------------------------------------
DROP TABLE IF EXISTS prefix_versionable_behavior_test_0_version;
CREATE TABLE prefix_versionable_behavior_test_0_version
(
id INTEGER NOT NULL,
bar INTEGER,
version INTEGER DEFAULT 0 NOT NULL,
PRIMARY KEY (id,version),
UNIQUE (id,version),
FOREIGN KEY (id) REFERENCES prefix_versionable_behavior_test_0 (id)
ON DELETE CASCADE
);
SQL;
$this->assertContains($expected, $builder->getSQL());
}
public function testSkipSqlParameterOnParentTable()
{
$schema = <<<EOF
<database name="versionable_behavior_test_0">
<table name="versionable_behavior_test_0" skipSql="true">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
<behavior name="versionable" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$this->assertEmpty($builder->getSQL());
}
public function testBuild()
{
$xmlSchema = <<<EOF
<database name="test_quick_build_2" namespace="MyNameSpace2">
<table name="quick_build_foo_2">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($xmlSchema);
$builder->build();
$this->assertEquals(0, QuickBuildFoo2Query::create()->count());
$foo = new QuickBuildFoo2();
$foo->setBar(3);
$foo->save();
$this->assertEquals(1, QuickBuildFoo2Query::create()->count());
$this->assertEquals($foo, QuickBuildFoo2Query::create()->findOne());
}
protected function buildClasses($schema)
{
$builder = new QuickBuilder();
$builder->setSchema($schema);
$builder->buildClasses();
}
public function testModiFyTableUsesCustomLocaleDefault()
{
$schema = <<<EOF
<database name="i18n_behavior_test_0">
<table name="i18n_behavior_test_0">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<behavior name="i18n">
<parameter name="default_locale" value="fr_FR" />
</behavior>
</table>
</database>
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$expected = <<<EOF
-----------------------------------------------------------------------
-- i18n_behavior_test_0_i18n
-----------------------------------------------------------------------
DROP TABLE i18n_behavior_test_0_i18n;
CREATE TABLE i18n_behavior_test_0_i18n
(
id INTEGER NOT NULL,
locale VARCHAR(5) DEFAULT 'fr_FR' NOT NULL,
PRIMARY KEY (id,locale)
);
EOF;
$this->assertContains($expected, $builder->getSQL());
}
public function testDatabaseLevelBehavior()
{
$schema = <<<EOF
<database name="versionable_behavior_test_0">
<behavior name="versionable" />
<table name="versionable_behavior_test_0">
<column name="id" primaryKey="true" type="INTEGER" autoIncrement="true" />
<column name="bar" type="INTEGER" />
</table>
</database>
EOF;
$expected = <<<EOF
-----------------------------------------------------------------------
-- versionable_behavior_test_0_version
-----------------------------------------------------------------------
DROP TABLE versionable_behavior_test_0_version;
CREATE TABLE versionable_behavior_test_0_version
(
id INTEGER NOT NULL,
bar INTEGER,
version INTEGER DEFAULT 0 NOT NULL,
PRIMARY KEY (id,version)
);
-- SQLite does not support foreign keys; this is just for reference
-- FOREIGN KEY (id) REFERENCES versionable_behavior_test_0 (id)
EOF;
$builder = new QuickBuilder();
$builder->setSchema($schema);
$this->assertContains($expected, $builder->getSQL());
}
