private function givenIHaveCreatedAValidRecordForThisTable()
{
$generator = new FieldValuesGenerator();
$data = $generator->getRequiredRandomRecordData($this->table->getFields());
$this->record = $this->table->createRecord($data);
$this->thenTheRecordShouldBeValid();
}
public function testGenerateValidFieldValues()
{
$rm = self::createDefaultRecordManager();
$table = $rm->getTable('data_types');
$fieldValues = $this->generator->getRandomRecordData($table->getFields(), array(), FieldValuesGenerator::MAXIMAL_WITHOUT_AUTOINCREMENT);
$dataTypeMapper = $rm->getDriver()->getDataTypeMapper();
foreach ($fieldValues as $fieldName => $value) {
$field = $table->getField($fieldName);
$fieldValidator = $dataTypeMapper->getOrmTypeInstance($field['type']);
$this->assertTrue($fieldValidator->validateType($value, $field), "Field type for '{$fieldName}' is not valid!");
$this->assertTrue($fieldValidator->validateLength($value, $field), "Field length for '{$fieldName}' is not valid!");
}
}
/**
* Saves record
*
* @param Table $table
* @param array $row
* @param string $key
* @return string
*/
private function saveRecord(Table $table, array $row, $key)
{
$tableName = $table->getTableName();
if ($key && $this->isInRecordMap($tableName, $key)) {
return $this->getRecordIdFromMap($tableName, $key);
}
// keep foreign key relations in array to process after record has been saved
$owningRelations = array();
$beforeSaveGeneratedRecords = $this->generatedRecords;
$this->generatedRecords = array();
foreach ($row as $relationName => $value) {
if ($table->hasRelation($relationName)) {
$relation = $table->getRelation($relationName);
if ($relation->isReferencedSide($relationName)) {
$row = $this->saveRecordOnReferencedRelation($row, $relation, $value);
} else {
$owningRelations[$relationName] = array('related' => $value, 'relation' => $relation);
}
unset($row[$relationName]);
}
}
$row = $this->saveRequiredRelations($table, $row);
// save record
$row = $this->fieldValueGenerator->getRandomRecordData($table->getFields(), $row);
$record = $this->rm->getOrCreateRecord($tableName, $row);
$this->rm->scheduleSave($record);
$this->rm->commit();
// keep record identifier in the record map
$id = $record->getIdentifierAsString();
if ($key !== null) {
$this->recordAliasIdMap[$tableName][$key] = $id;
}
$this->generatedRecords = array_merge($beforeSaveGeneratedRecords, array(array('tableName' => $tableName, 'id' => $id)), $this->generatedRecords);
// save owning relations
foreach ($owningRelations as $relationData) {
/** @var $relation Relation */
$relation = $relationData['relation'];
$relatedRows = $relationData['related'];
$this->saveRecordsOnOwningRelation($relation, $relatedRows, $id);
}
return $id;
}
/**
* @param RecordManager $rm
* @param Relation $relation
* @return string
*/
protected function insertRequiredLocalRelationGraph(RecordManager $rm, Relation $relation)
{
$randomGenerator = new FieldValuesGenerator();
$conn = $rm->getConnection();
$refTableName = $relation->getReferencedTable();
$refTable = $rm->getTable($refTableName);
$refFields = $refTable->getFields();
$data = array();
// recursion: walk through all local relations that are required and handle this by calling this method with
// next relation
$owningRelations = $refTable->getReferencedRelationsIndexedByOwningField();
foreach ($owningRelations as $owningField => $owningRelation) {
// check if field is required (default of matchType) and insert required related data
if ($randomGenerator->matchType($refFields[$owningField])) {
$data[$owningField] = $this->insertRequiredLocalRelationGraph($rm, $owningRelation);
}
}
// insert a record and return its id
$data = $randomGenerator->getRandomRecordData($refFields, $data);
$conn->insert($refTable, $data);
return $conn->getLastInsertId($refTableName);
}
/**
* @param Table $table
* @param array $defaultFieldValues
* @return Record
*/
protected function getRecordWithRandomData(Table $table, array $defaultFieldValues = array())
{
$fieldValueGenerator = new FieldValuesGenerator();
$recordData = $fieldValueGenerator->getRandomRecordData($table->getFields(), $defaultFieldValues);
return $table->createRecord($recordData);
}
/**
* @param array $recordData
* @return \Dive\Record
*/
private function createRecordWithRandomData(array $recordData)
{
$table = $this->rm->getTable('unique_constraint_test');
$fieldValueGenerator = new FieldValuesGenerator();
$recordData = $fieldValueGenerator->getRandomRecordData($table->getFields(), $recordData, FieldValuesGenerator::MAXIMAL_WITHOUT_AUTOINCREMENT);
return $table->createRecord($recordData);
}
