public function testWillUpsertAndUpdateModelWithSameKeyAsCriteria()
{
$model = new ModelWithCustomIdAsSecondaryKey();
$model->id = '123';
$model->name = 'john';
$em = new EntityManager($model);
$finder = new Finder($model, $em);
$criteria = new Criteria();
$criteria->id = $model->id;
$result1 = $em->updateOne($criteria);
$this->assertTrue($result1, 'That update was successfull');
$count = $finder->count();
$this->assertSame(1, $count, 'That one document was inserted');
$found = $finder->find($criteria);
//found
$this->assertSame('john', $found->name, 'That stored document has proper `name`');
//found
$model->id = '666';
$model->name = 'joe';
$criteria->id = 123;
$result2 = $em->updateOne($criteria);
$this->assertTrue($result2, 'That second update was successfull');
$count2 = $finder->count();
$this->assertSame(1, $count2, 'That one document was updated, not inserted');
$criteria->id = 666;
$model = $finder->find($criteria);
$this->assertNotNull($model, 'That id was in fact changed');
$this->assertSame('joe', $model->name, 'That stored document has proper `name`');
$this->assertSame('666', $model->id, 'That stored document has proper `id`');
}
public function testIfWillResizeSavedImage()
{
// Temp file location
$fileName = __DIR__ . '/logo-1024.png';
$md5 = md5_file($fileName);
$model = new ModelWithEmbeddedFile();
$model->file = new Image();
$model->file->set($fileName);
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
/* @var $found ModelWithEmbeddedFile */
$file = $found->file->get()->getBytes();
$this->assertSame($fileName, $found->file->filename);
$this->assertSame($md5, md5($file));
$image = $found->file;
$params = new ImageParams();
$params->width = 100;
$params->height = 100;
/* @var $image Image */
$scaledName = tempnam('/tmp/', 'image-test') . '.png';
$image->get($params)->write($scaledName);
$this->assertTrue(file_exists($scaledName));
$gd = new GD($scaledName);
$dimensions = (object) $gd->getCurrentDimensions();
codecept_debug($dimensions);
$this->assertSame($params->width, $dimensions->width);
$this->assertSame($params->height, $dimensions->height);
}
public function testIfWillDeleteEmbeddedImage()
{
$fileName = __DIR__ . '/logo-1024.png';
$md5 = md5_file($fileName);
// NOTE: Must work fine even if _id is not set
$model = new ModelWithEmbeddedImage();
$model->file = new Image();
$model->file->set($fileName);
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
/* @var $found ModelWithEmbeddedImage */
$file = $found->file->get()->getBytes();
$this->assertSame($md5, md5($file));
// Resize image
$params = new ImageParams();
$params->width = 100;
$params->height = 100;
$resized = $found->file->get($params)->getBytes();
// Check if was resized
$this->assertTrue($file > $resized);
$mangan = new Mangan();
$gfs = $mangan->getDbInstance()->getGridFS();
$tmp = $mangan->getDbInstance()->getGridFS(File::TmpPrefix);
$criteria = ['parentId' => $found->file->_id];
$this->assertSame(1, $gfs->count($criteria));
$this->assertSame(1, $tmp->count($criteria));
$deleted = $found->delete();
$this->assertTrue($deleted);
$this->assertSame(0, $gfs->count($criteria));
$this->assertSame(0, $tmp->count($criteria));
}
public function testIfWillCountByAttributes()
{
$model = new WithBaseAttributes();
$model->string = 'foo';
$em = new EntityManager($model);
$em->insert();
$model = new WithBaseAttributes();
$model->string = 'foo';
$em->insert($model);
$model = new WithBaseAttributes();
$model->string = 'foo';
$em->insert($model);
// Some other models
$model = new WithBaseAttributes();
$model->string = 'blah';
$em->insert($model);
$model = new WithBaseAttributes();
$model->string = 'blah';
$em->insert($model);
$finder = new Finder($model);
$count = $finder->count();
$this->assertSame(5, $count);
$attributesCount = $finder->countByAttributes(['string' => 'foo']);
$this->assertSame(3, $attributesCount);
}
public function testIfWillDeepEmbed()
{
$model = new PlainDeepEmbedded();
$model->_id = new MongoId();
$withPlain = new WithPlainEmbedded();
$stats = new SimplePlainEmbedded();
$stats->active = false;
$stats->name = 'buried stats';
$stats->visits = 100002;
$withPlain->title = 'first level';
$withPlain->stats = $stats;
$model->withPlain = $withPlain;
$model->title = 'deep blue';
$em = new EntityManager($model);
$em->insert();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
$this->assertNotNull($found);
$this->assertTrue($found instanceof PlainDeepEmbedded);
$this->assertSame($found->title, $model->title);
$this->assertNotNull($found->withPlain);
$this->assertTrue($found->withPlain instanceof WithPlainEmbedded);
$this->assertSame($found->withPlain->title, $model->withPlain->title);
$this->assertNotNull($found->withPlain->stats);
$this->assertTrue($found->withPlain->stats instanceof SimplePlainEmbedded);
}
public function testIfWillSaveAndLoadRelatedModel()
{
$model = new ModelWithSingleSimpleRelation();
$id = $model->_id = new MongoId();
$model->stats = new RelatedStats();
$model->stats->name = 'one';
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model);
$found = $finder->findByPk($id);
$this->assertInstanceOf(RelatedStats::class, $model->stats);
$this->assertSame($model->stats->name, $found->stats->name);
}
public function testIfCanFindByAttributes()
{
$model = new WithBaseAttributes();
$model->int = 10;
$em = new EntityManager($model);
$em->insert();
$model = new WithBaseAttributes();
$model->int = 20;
$em->insert($model);
$finder = new Finder($model);
$found = $finder->findByAttributes(['int' => 10]);
$this->assertInstanceof(WithBaseAttributes::class, $found);
$this->assertSame(10, $found->int);
}
public function canRollbackTest()
{
$model = new ModelTransactional();
$finder = new Finder($model);
$tx = new Transaction($model);
$model->_id = new MongoId();
$model->title = 'blah';
$model->save();
$found = $finder->findByPk($model->_id);
$this->assertInstanceOf(ModelTransactional::class, $found);
$tx->rollback();
$found2 = $finder->findByPk($model->_id);
$this->assertNull($found2);
}
public function testIfExistsByCriteriaI18N()
{
$langs = ['en', 'pl'];
$model = new ModelWithI18N();
$model->setLanguages($langs);
$model->title = 'foot';
$finder = new Finder($model);
$criteria = new Criteria();
$criteria->title = 'foot';
// Should not exists
$this->assertFalse($finder->exists($criteria));
(new EntityManager($model))->insert();
// Should exists
$this->assertTrue($finder->exists($criteria));
}
public function testIfWIllConvertDbRefToJsonArray()
{
$model = new WithPlainDbRef();
$model->_id = new MongoId();
$model->title = 'stats';
$model->stats = new SimplePlainDbRef();
$model->stats->active = true;
$model->stats->name = 'www';
$model->stats->visits = 10000;
$em = new EntityManager($model);
$em->insert();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
$json = JsonArray::fromModel($found);
$this->assertSame($found->title, $json['title']);
$this->assertSame($found->stats->active, $json['stats']['active']);
$this->assertSame($found->stats->name, $json['stats']['name']);
}
public function testIfPlainObjectWillRefer()
{
$model = new WithPlainDbRef();
$model->_id = new MongoId();
$model->title = 'stats';
$model->stats = new SimplePlainDbRef();
$model->stats->active = true;
$model->stats->name = 'www';
$model->stats->visits = 10000;
$em = new EntityManager($model);
$em->insert();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
$this->assertNotNull($found);
$this->assertSame($found->title, $model->title);
$this->assertTrue($found instanceof WithPlainDbRef);
$this->assertTrue($found->stats instanceof SimplePlainDbRef);
}
public function testIfWillNoUpdateRefObject()
{
$model = new ModelWithNotUpdatableDbRef();
$stats = new SimplePlainDbRef();
$stats->name = 'one';
$statsId = $stats->_id = new MongoId();
$saved = (new EntityManager($stats))->save();
$this->assertTrue($saved);
$model->stats = $stats;
$statsFinder = new Finder($stats);
$found = $statsFinder->findByPk($statsId);
$this->assertSame('one', $found->name);
$model->stats->name = 'two';
$saved2 = (new EntityManager($model))->save();
$this->assertTrue($saved2);
$found = $statsFinder->findByPk($statsId);
$this->assertSame('one', $found->name);
}
public function testIfWillUpdateAll()
{
$model = new DocumentBaseAttributes();
$model->bool = false;
$model->string = 'Las Vegas';
$model->save();
$model = new DocumentBaseAttributes();
$model->bool = true;
$model->string = 'Las Palmas';
$model->save();
$model = new DocumentBaseAttributes();
$model->bool = false;
$model->string = 'Las Cruces';
$model->save();
$em = new EntityManager($model);
// With true
$modifier = new Modifier(['int' => ['set' => 1]]);
$criteria = new Criteria();
$criteria->bool = true;
$ok = $em->updateAll($modifier, $criteria);
$this->assertTrue($ok);
$criteria = new Criteria();
$criteria->int = 1;
$finder = new Finder($model);
$modified = $finder->count($criteria);
$this->assertSame(1, $modified);
$found = $finder->find($criteria);
$this->assertSame(1, $found->int);
// With false
$modifier = new Modifier();
$modifier->set('int', 2);
$criteria = new Criteria();
$criteria->bool = false;
$ok = $em->updateAll($modifier, $criteria);
$this->assertTrue($ok);
$criteria = new Criteria();
$criteria->int = 2;
$finder = new Finder($model);
$modified = $finder->count($criteria);
$this->assertSame(2, $modified);
$found = $finder->find($criteria);
$this->assertSame(2, $found->int);
}
public function testIfWillGenerateAndStoreNonActivationKeyWithArrayCallback()
{
$model = new ModelWithSecretField();
$em = new EntityManager($model);
$finder = new Finder($model);
$model->activationKey = true;
$em->upsert();
$found = $finder->find();
$this->assertSame(1, $finder->count(), 'That only one document is in collection');
$this->assertSame(40, strlen($found->activationKey), 'That non empty activation key was saved as hash');
$hash1 = $found->activationKey;
$found->activationKey = '';
$em = new EntityManager($found);
$em->upsert();
$found2 = $finder->find();
$this->assertSame(1, $finder->count(), 'That only one document is in collection');
$this->assertSame(40, strlen($found2->activationKey), 'That empty activation key is hash');
$this->assertSame($hash1, $found2->activationKey, 'That empty activation key was NOT saved');
}
public function testIfWillStoreI18NFields()
{
$model = new ModelWithI18N();
$model->setLanguages(['en', 'pl']);
$model->_id = new MongoId();
$model->setLang('en');
$model->title = 'english';
$model->active = true;
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model);
$found = $finder->findByPk($model->_id);
$this->assertNotNull($found);
$found->setLang('en');
$this->assertSame($model->title, $found->title);
$this->assertSame($model->active, $found->active);
$found->setLang('pl');
$model->title = 'english';
$model->active = true;
}
public function testIfWillSkipUnsafeAttributeOnSaveWhenUpdatingModel()
{
$model = new ModelWithUnsafeAttribute();
$model->active = true;
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model, $em);
$found = $finder->findByPk($model->_id);
$this->assertNotNull($found, 'That model was saved');
$this->assertTrue($found->active, 'That value was set');
// Update model from external data
// NOTE: Creating model from external data will not work, as there is no way to take value from
$data = ['active' => false];
$model2 = SafeArray::toModel($data, null, $found);
$this->assertTrue($model2->active, 'That value was ignored on mass set, as it is unsafe');
$em2 = new EntityManager($model2);
$em2->save();
$found2 = $finder->findByPk($found->_id);
$this->assertTrue($found2->active, 'That value was not updated in db');
$this->assertSame(1, $finder->count(), 'That only one model was saved');
}
public function testIfWillFindAllUsingCursor()
{
$model = new WithBaseAttributes();
$model->string = 'foo';
$em = new EntityManager($model);
$em->insert();
$model = new WithBaseAttributes();
$model->string = 'foo';
$em->insert($model);
$model = new WithBaseAttributes();
$model->string = 'foo';
$em->insert($model);
$finder = new Finder($model);
$cursor = $finder->withCursor()->findAll();
$this->assertSame(3, count($cursor));
$this->assertInstanceOf(Cursor::class, $cursor);
foreach ($cursor as $found) {
$this->assertInstanceof(WithBaseAttributes::class, $found);
$this->assertSame('foo', $found->string);
}
}
public function testIfWillUpdateByModifyDocument()
{
$model = new ModelWithI18N();
$model->_id = new \MongoId();
$model->active = true;
$model->title = 'foo';
$em = new EntityManager($model);
$finder = new Finder($model);
$em->save();
$found = $finder->findByPk($model->_id);
$this->assertSame($model->title, $found->title);
$this->assertSame($model->active, $found->active);
$em = new EntityManager($found);
$found->title = 'bar';
// This attribute should be ignored
$found->active = false;
$em->update(['title'], true);
$updated = $finder->findByPk($model->_id);
$this->assertSame($found->title, $updated->title);
$this->assertSame($model->active, $updated->active);
}
public function testIfWillReferenceArrayOfDifferentTypeDocuments()
{
$model = new WithPlainDbRefArrayDifferentTypes();
$id = new MongoId();
$model->_id = $id;
$model->title = 'some title';
$data = [['active' => false, 'name' => 'stats one', 'visits' => 100, '_type' => SimplePlainDbRef::class], ['active' => true, 'name' => 'stats two', 'visits' => 1000, '_type' => SimplePlainDbRefSecond::class], ['active' => false, 'name' => 'stats three', 'visits' => 10000, '_type' => SimplePlainDbRefSecond::class]];
$stats = [];
foreach ($data as $key => $value) {
$referenced = new $value['_type']();
foreach ($value as $field => $fieldValue) {
if ($field == '_type') {
continue;
}
$referenced->{$field} = $fieldValue;
}
$stats[$key] = $referenced;
$model->stats[$key] = $referenced;
}
$em = new EntityManager($model);
$em->insert();
$finder = new Finder($model);
$found = $finder->findByPk($id);
$this->assertNotNull($found);
$this->assertTrue($found instanceof WithPlainDbRefArray);
$this->assertSame(count($stats), count($found->stats));
foreach ($data as $key => $value) {
$this->assertNotNull($found->stats[$key]);
// $this->write(sprintf('Should be of type: %s', $value['_type']));
$this->assertSame(get_class($found->stats[$key]), $value['_type']);
$this->assertTrue($found->stats[$key] instanceof $value['_type']);
foreach ($value as $field => $fieldValue) {
if ($field == '_type') {
continue;
}
$this->assertSame($found->stats[$key]->{$field}, $fieldValue);
}
}
}
public function testIfWillResolveNotFoundClass()
{
define('BogusClass', 'SomeClass');
$model = new WithPlainEmbedded();
$model->_id = new MongoId();
$model->stats = new SimplePlainEmbedded();
$em = new EntityManager($model);
$em->save();
$pkCriteria = PkManager::prepareFromModel($model)->getConditions();
$set = ['$set' => ['stats._class' => BogusClass]];
$em->getCollection()->update($pkCriteria, $set);
$finder = new Finder($model);
try {
$finder->findByPk($model->_id);
$this->assertFalse(true);
} catch (ManganException $ex) {
$this->assertTrue(true);
}
// Attach class not found handlers
new NotFoundResolver($model, [BogusClass => SimplePlainEmbedded::class]);
$found = $finder->findByPk($model->_id);
$this->assertInstanceOf(WithPlainEmbedded::class, $found);
$this->assertInstanceOf(SimplePlainEmbedded::class, $found->stats);
}
public function testIfWillFindPlainDocumentWithCompositePkWithWrongPkTypes()
{
//exit;
$model = new CompositePrimaryKey();
$model->title = 'fooo';
$IdOne = new MongoId();
$IdTwo = 2;
$IdThree = (string) new MongoId();
$model->primaryOne = $IdOne;
$model->primaryTwo = $IdTwo;
$model->primaryThree = $IdThree;
$em = new EntityManager($model);
$em->insert();
$finder = new Finder($model);
// Wrong types on purpose
$found = $finder->findByPk(['primaryOne' => (string) $IdOne, 'primaryTwo' => (string) $IdTwo, 'primaryThree' => new MongoId($IdThree)]);
$this->assertNotNull($found);
$this->assertTrue($found instanceof CompositePrimaryKey);
$this->assertSame($model->title, $found->title);
}
/**
* Fetches the data from the persistent data storage.
* @return Document[]|Cursor list of data items
* @since v1.0
*/
protected function fetchData()
{
$criteria = $this->configureFetch();
// Finally apply all to finder
return $this->finder->findAll($criteria);
}
public function testIfWillFindAllByCompositePks()
{
$pks[] = ['primaryOne' => new \MongoId(), 'primaryTwo' => 1, 'primaryThree' => 'one', 'title' => 'xxx'];
$pks[] = ['primaryOne' => new \MongoId(), 'primaryTwo' => 2, 'primaryThree' => 'two', 'title' => 'yyy'];
$pks[] = ['primaryOne' => new \MongoId(), 'primaryTwo' => 3, 'primaryThree' => 'three', 'title' => 'zzz'];
foreach ($pks as $i => $keys) {
$model = new CompositePrimaryKey();
$em = new EntityManager($model);
foreach ($keys as $field => $value) {
$model->{$field} = $value;
}
$em->insert();
}
$model = new CompositePrimaryKey();
$em = new EntityManager($model);
$model->primaryOne = new \MongoId();
$model->primaryTwo = 12;
$model->primaryThree = 'ddd';
$em->insert();
$finder = new Finder($model);
$all = $finder->findAllByPk($pks);
$this->assertSame(3, count($all));
foreach ($all as $found) {
$this->assertInstanceof(CompositePrimaryKey::class, $found);
$this->assertTrue(in_array($found->title, ['xxx', 'yyy', 'zzz']));
}
}
/**
* Get finder instance
* @return FinderInterface
*/
private function _getFinder()
{
if (null === $this->_finder) {
$this->_finder = Finder::create($this);
}
return $this->_finder;
}
public function __construct($model, $em = null)
{
parent::__construct($model, $em);
// Cannot use cursors in raw finder, as it will clash with PkManager
$this->withCursor(false);
}
public function testIfWillDeleteAllPlainDocument()
{
$model = new PlainWithBasicAttributes();
$model->_id = new MongoId();
$em = new EntityManager($model);
$em->save();
$model = new PlainWithBasicAttributes();
$model->_id = new MongoId();
$em = new EntityManager($model);
$em->save();
$finder = new Finder($model);
$count = $finder->count();
$this->assertSame(2, $count);
$em->deleteAll();
$deletedCount = $finder->count();
$this->assertSame(0, $deletedCount);
}
/**
* Restore trashed item
* @return boolean
* @throws Exception
* @Ignored
*/
public function restore()
{
if (!$this instanceof TrashInterface) {
// When trying to restore normal document instead of trash item
throw new Exception(sprintf('Restore can be performed only on `%s` instance', TrashInterface::class));
}
$em = new EntityManager($this->data);
// Set scenario to `restore` for model, which is just about to be restored
ScenarioManager::setScenario($this->data, TrashInterface::ScenarioRestore);
if (!Event::valid($this->data, TrashInterface::EventBeforeRestore)) {
return false;
}
$saved = $em->save();
if (!$saved) {
return false;
}
$finder = new Finder($this->data);
$model = $finder->find(PkManager::prepareFromModel($this->data));
if (!$model) {
return false;
}
$eventAfter = new RestoreEvent();
$eventAfter->setTrashed($this->data);
$eventAfter->setTrash($this);
if (!Event::valid($model, TrashInterface::EventAfterRestore, $eventAfter)) {
return false;
}
$trashEm = new EntityManager($this);
$this->data = null;
// Use deleteOne, to avoid beforeDelete event,
// which should be raised only when really removing document:
// when emtying trash
return $trashEm->deleteOne(PkManager::prepareFromModel($this));
}
/**
* Validates the attribute of the object.
* If there is any error, the error message is added to the object.
* @param AnnotatedInterface $model the object being validated
* @param string $attribute the attribute being validated
*/
public function isValid(AnnotatedInterface $model, $attribute)
{
$value = $model->{$attribute};
if ($this->allowEmpty && empty($value)) {
return true;
}
$className = empty($this->className) ? get_class($model) : $this->className;
$compareModel = new $className();
$criteria = (new Criteria())->decorateWith($compareModel);
$criteria->addCond($attribute, '==', $value);
if ($this->criteria !== []) {
$criteria->mergeWith($this->criteria);
}
ScenarioManager::setScenario($compareModel, ValidatorInterface::ScenarioValidate);
$finder = new Finder($compareModel);
$found = $finder->find($criteria);
// Not found entirely
if (null === $found) {
return true;
}
// Same pk
if (PkManager::compare($found, $model)) {
return true;
}
$label = ManganMeta::create($model)->field($attribute)->label;
$this->addError('msgTaken', ['{attribute}' => $label, '{value}' => $value]);
return false;
}