public function test_can_add_no_prefix()
{
$this->embedded->noPrefix();
$this->embedded->build();
$embedded = $this->builder->getClassMetadata()->embeddedClasses['field'];
$this->assertFalse($embedded['columnPrefix']);
}
public function test_can_set_map_as_array()
{
$this->inheritance->map(['stub1' => StubEntity::class, 'stub2' => StubEntity2::class, 'stub3' => StubEntity3::class]);
$map = $this->builder->getClassMetadata()->discriminatorMap;
$this->assertEquals(StubEntity::class, $map['stub1']);
$this->assertEquals(StubEntity2::class, $map['stub2']);
$this->assertEquals(StubEntity3::class, $map['stub3']);
}
private function doEventTest($event)
{
$this->assertFalse($this->fluent->getClassMetadata()->hasLifecycleCallbacks($event), "Event [{$event}] is already associated!");
for ($i = 0, $max = mt_rand(1, 5); $i < $max; ++$i) {
$this->builder->{$event}(uniqid());
}
$this->builder->build();
$this->assertTrue($this->fluent->getClassMetadata()->hasLifecycleCallbacks($event), "Event [{$event}] was not associated!");
$this->assertCount($max, $actual = $this->fluent->getClassMetadata()->getLifecycleCallbacks($event), "Expected [{$max}] events associated for [{$event}], got " . count($actual));
}
public function test_adding_new_options_will_merge_them()
{
$this->builder->addField('nullable_attribute', 'string', ['options' => ['default' => 'some_default']]);
$override = $this->override('nullable_attribute', function ($field) {
return $field->name('overridden_name')->option('some_option', 'some_value');
});
$override->build();
$this->assertEquals('overridden_name', $this->builder->getClassMetadata()->getColumnName('nullable_attribute'));
$this->assertEquals('some_value', $this->builder->getClassMetadata()->getFieldMapping('nullable_attribute')['options']['some_option']);
$this->assertEquals('some_default', $this->builder->getClassMetadata()->getFieldMapping('nullable_attribute')['options']['default']);
}
public function test_can_set_a_custom_index_name()
{
$index = new Index($this->builder, ['name']);
$index->name('custom_index');
$this->assertCount(1, $index->getColumns());
$this->assertEquals('custom_index', $index->getName());
$index->build();
$indexes = $this->builder->getClassMetadata()->table['indexes'];
$this->assertTrue(isset($indexes['custom_index']));
$this->assertCount(1, $indexes['custom_index']['columns']);
}
public function test_can_set_a_custom_unique_name()
{
$index = new UniqueConstraint($this->builder, ['name']);
$index->name('custom_unique');
$this->assertCount(1, $index->getColumns());
$this->assertEquals('custom_unique', $index->getName());
$index->build();
$uniqueConstraints = $this->builder->getClassMetadata()->table['uniqueConstraints'];
$this->assertTrue(isset($uniqueConstraints['custom_unique']));
$this->assertCount(1, $uniqueConstraints['custom_unique']['columns']);
}
public function test_can_add_primary_for_multiple_columns()
{
$index = new Primary($this->builder, ['relation1', 'relation2']);
$this->assertCount(2, $index->getFields());
$this->assertContains('relation1', $index->getFields());
$this->assertContains('relation2', $index->getFields());
$index->build();
$indexes = $this->builder->getClassMetadata()->getIdentifier();
$this->assertCount(2, $indexes);
$this->assertContains('relation1', $indexes);
$this->assertContains('relation2', $indexes);
}
public function test_has_one_implies_an_inverse_one_to_one()
{
$relation = $this->fluent->hasOne(FakeEntity::class, 'one');
$relation->build();
$result = $this->builder->getClassMetadata()->associationMappings['one'];
$this->assertFalse($result['isOwningSide'], "HasOne relation is an inversed one-to-one, but resulted in the owning side.");
}
public function test_can_change_target_on_many_to_one()
{
$this->assertEquals('manyToOne_id', $this->builder->getClassMetadata()->getAssociationMapping('manyToOne')['joinColumns'][0]['name']);
$override = $this->override('manyToOne', function (ManyToOne $relation) {
return $relation->target('foreign_key');
});
$override->build();
$this->assertEquals('foreign_key', $this->builder->getClassMetadata()->getAssociationMapping('manyToOne')['joinColumns'][0]['name']);
}
/**
* @param ClassMetadataBuilder $builder
* @param NamingStrategy $namingStrategy
* @param $name
* @param callable $callback
*
* @return
*/
public static function create(ClassMetadataBuilder $builder, NamingStrategy $namingStrategy, $name, callable $callback)
{
foreach (self::getFactories() as $buildable => $check) {
if ($check($builder->getClassMetadata(), $name)) {
return new $buildable($builder, $namingStrategy, $name, $callback);
}
}
throw new InvalidArgumentException('No attribute or association could be found for ' . $name);
}
public function test_can_enable_2nd_level_cache()
{
$this->assertFalse($this->builder->getClassMetadata()->isReadOnly);
$this->entity->cacheable();
$this->assertEquals(ClassMetadataInfo::CACHE_USAGE_READ_ONLY, $this->builder->getClassMetadata()->cache['usage']);
$this->assertEquals('tests_stubs_entities_stubentity', $this->builder->getClassMetadata()->cache['region']);
$this->entity->cacheable(ClassMetadataInfo::CACHE_USAGE_READ_WRITE, 'custom_region');
$this->assertEquals(ClassMetadataInfo::CACHE_USAGE_READ_WRITE, $this->builder->getClassMetadata()->cache['usage']);
$this->assertEquals('custom_region', $this->builder->getClassMetadata()->cache['region']);
}
/**
* @return ClassMetadataBuilder
*
* @throws \InvalidArgumentException
*/
public function build()
{
$mapping = $this->mapping;
if ($this->joinColumns) {
$mapping['joinColumns'] = $this->joinColumns;
}
$cm = $this->builder->getClassMetadata();
if ($this->type == ClassMetadata::MANY_TO_ONE) {
$cm->mapManyToOne($mapping);
} else {
if ($this->type == ClassMetadata::ONE_TO_ONE) {
$cm->mapOneToOne($mapping);
} else {
throw new \InvalidArgumentException("Type should be a ToOne Association here");
}
}
return $this->builder;
}
/**
* @return ClassMetadata
*/
public function getClassMetadata()
{
return $this->builder->getClassMetadata();
}
/**
* @return ClassMetadataBuilder
*/
protected function newClassMetadataBuilder()
{
return new ClassMetadataBuilder(new ClassMetadataInfo($this->builder->getClassMetadata()->name));
}
/**
* @return string
*/
protected function generateIndexName()
{
$table = $this->builder->getClassMetadata()->getTableName();
return $table . $this->separator . implode($this->separator, $this->getColumns()) . $this->separator . $this->suffix;
}
public function test_sets_right_type()
{
$this->assertTrue($this->builder->getClassMetadata()->isInheritanceTypeSingleTable());
}
/**
* Execute the build process
*/
public function build()
{
$this->builder->getClassMetadata()->setIdentifier($this->getFields());
}
public function test_can_make_field_primary()
{
$this->field->primary();
$this->field->build();
$this->assertTrue($this->builder->getClassMetadata()->getFieldMapping('name')['id']);
}
/**
* @param ClassMetadataBuilder $builder
* @param string $type
* @param string $name
*
* @throws \Doctrine\DBAL\DBALException
* @return Field
*/
public static function make(ClassMetadataBuilder $builder, $type, $name)
{
$type = Type::getType($type);
$field = $builder->createField($name, $type->getName());
return new static($field, $builder->getClassMetadata());
}
/**
* @param string $usage
* @param string|null $region
*
* @return AssociationBuilder
*/
public function cache($usage = 'READ_ONLY', $region = null)
{
$cache = new AssociationCache($this->builder->getClassMetadata(), $this->relation, $usage, $region);
$this->queue($cache);
return $this;
}
