private function assertLimit(IDataSource $source)
{
$all = $source->fetchAll();
Assert::count(self::LIMIT, $all);
Assert::count(self::FULL_USER_COUNT, $source->fetchFullData());
Assert::count(self::FULL_USER_COUNT, $source->fetchAllForExport());
Assert::same(self::FULL_USER_COUNT, $source->getTotalCount());
Assert::same(self::LIMIT, $source->count());
return $all;
}
public function testFetchLastRawRows()
{
$source = $this->createArraySourceWithDataStructure();
Assert::exception(function () use($source) {
$source->fetchLastRawRows();
}, InvalidStateException::class);
$source->fetchAll();
$rawData = $source->fetchLastRawRows();
Assert::count(self::FULL_USER_COUNT, $rawData);
foreach ($rawData as $item) {
Assert::type(ArrayHash::class, $item);
}
}
protected static function matchCounts(IFilterSource $source, $filteredCount, $fullCount, $rawClassType)
{
static $lastRowsDescription = 'Output from fetchLastRawRows after %s';
$users = $source->fetchAll();
if (count($users) > 0) {
Assert::type(ArrayHash::class, reset($users));
}
Assert::count($filteredCount, $users, 'Output from fetchAll');
$lastRows = $source->fetchLastRawRows();
if (count($lastRows) > 0) {
Assert::type($rawClassType, reset($lastRows));
}
Assert::count($filteredCount, $lastRows, sprintf($lastRowsDescription, 'fetchAll'));
$fullData = $source->fetchFullData();
if (count($fullData) > 0) {
Assert::type(ArrayHash::class, reset($fullData));
}
Assert::count($fullCount, $fullData, 'Output from fetchFullData');
$lastRows = $source->fetchLastRawRows();
if (count($lastRows) > 0) {
Assert::type($rawClassType, reset($lastRows));
}
Assert::count($fullCount, $lastRows, sprintf($lastRowsDescription, 'fetchFullData'));
}
public function testReferencedData()
{
$selection = clone $this->user;
$selection->select('users.*');
$source = new NetteDbTableSource($this->tableName, 'id', $selection, $this->context, $this->columnMapping);
$dataStructure = $source->getDataStructure();
$dataStructure->renameColumn('user_addresses', 'addresses');
$dataStructure->renameColumn('groups', 'group');
$dataStructure->renameColumn('wallets', 'wallet');
/** @var ManyToManyColumnStructure $companiesColumn */
$companiesColumn = $dataStructure->getColumn('companies');
$companiesColumn->setPattern('{name}');
/** @var OneToManyColumnStructure $addressesColumn */
$addressesColumn = $dataStructure->getColumn('addresses');
$addressesColumn->setPattern('{street}, {zip} {city}, {country}');
/** @var ManyToOneColumnStructure $groupColumn */
$groupColumn = $dataStructure->getColumn('group');
$groupColumn->setPattern('{name} - {type}');
/** @var OneToOneColumnStructure $walletColumn */
$walletColumn = $dataStructure->getColumn('wallet');
$walletColumn->setPattern('{amount}');
$item = $source->fetchAll();
Assert::equal(reset($item), $firstItem = $source->fetch());
Assert::count(self::COLUMN_COUNT, array_keys((array) $firstItem));
Assert::count(3, $firstItem['companies']);
Assert::equal($this->getFirstExpectedCompany(), $firstItem['companies'][0]);
Assert::equal($this->getFirstExpectedAddress(), $firstItem['addresses'][0]);
Assert::equal($this->getFirstExpectedGroup(), $firstItem['group']);
Assert::equal($this->getFirstExpectedWallet(), $firstItem['wallet']);
}
public function testSetAssociationValueManyToManyBidirectional()
{
$user1 = new User();
$user2 = new User();
$user2->groups = new ArrayCollection();
// see User constructor
$group1 = new Group();
$group2 = new Group();
$group3 = new Group();
// User side
$userMetadata = $this->getMetadataFor('User');
$userMetadata->setAssociationValue($user1, 'groups', array($group1, $group2));
Assert::count(2, $user1->groups);
Assert::true($user1->groups->contains($group1));
Assert::true($user1->groups->contains($group2));
Assert::count(0, $user2->groups);
Assert::count(1, $group1->users);
Assert::true($group1->users->contains($user1));
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user1));
Assert::count(0, $group3->users);
$userMetadata->setAssociationValue($user2, 'groups', array($group1, $group3));
Assert::count(2, $user1->groups);
Assert::true($user1->groups->contains($group1));
Assert::true($user1->groups->contains($group2));
Assert::count(2, $user2->groups);
Assert::true($user2->groups->contains($group1));
Assert::true($user2->groups->contains($group3));
Assert::count(2, $group1->users);
Assert::true($group1->users->contains($user1));
Assert::true($group1->users->contains($user2));
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user1));
Assert::count(1, $group3->users);
Assert::true($group3->users->contains($user2));
$userMetadata->setAssociationValue($user1, 'groups', array($group1, $group2, $group3));
Assert::count(3, $user1->groups);
Assert::true($user1->groups->contains($group1));
Assert::true($user1->groups->contains($group2));
Assert::true($user1->groups->contains($group3));
Assert::count(2, $user2->groups);
Assert::true($user2->groups->contains($group1));
Assert::true($user2->groups->contains($group3));
Assert::count(2, $group1->users);
Assert::true($group1->users->contains($user1));
Assert::true($group1->users->contains($user2));
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user1));
Assert::count(2, $group3->users);
Assert::true($group3->users->contains($user1));
Assert::true($group3->users->contains($user2));
$userMetadata->setAssociationValue($user2, 'groups', array($group3));
Assert::count(3, $user1->groups);
Assert::true($user1->groups->contains($group1));
Assert::true($user1->groups->contains($group2));
Assert::true($user1->groups->contains($group3));
Assert::count(1, $user2->groups);
Assert::true($user2->groups->contains($group3));
Assert::count(1, $group1->users);
Assert::true($group1->users->contains($user1));
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user1));
Assert::count(2, $group3->users);
Assert::true($group3->users->contains($user1));
Assert::true($group3->users->contains($user2));
$userMetadata->setAssociationValue($user1, 'groups', array());
Assert::count(0, $user1->groups);
Assert::count(1, $user2->groups);
Assert::true($user2->groups->contains($group3));
Assert::count(0, $group1->users);
Assert::count(0, $group2->users);
Assert::count(1, $group3->users);
Assert::true($group3->users->contains($user2));
$userMetadata->setAssociationValue($user1, 'groups', array($group2));
$userMetadata->setAssociationValue($user2, 'groups', array());
Assert::count(1, $user1->groups);
Assert::true($user1->groups->contains($group2));
Assert::count(0, $user2->groups);
Assert::count(0, $group1->users);
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user1));
Assert::count(0, $group3->users);
// Group side
$groupMetadata = $this->getMetadataFor('Group');
$groupMetadata->setAssociationValue($group2, 'users', array());
Assert::count(0, $user1->groups);
Assert::count(0, $user2->groups);
Assert::count(0, $group1->users);
Assert::count(0, $group2->users);
Assert::count(0, $group3->users);
$groupMetadata->setAssociationValue($group1, 'users', array($user1));
$groupMetadata->setAssociationValue($group2, 'users', array($user2));
Assert::count(1, $user1->groups);
Assert::true($user1->groups->contains($group1));
Assert::count(1, $user2->groups);
Assert::true($user2->groups->contains($group2));
Assert::count(1, $group1->users);
Assert::true($group1->users->contains($user1));
Assert::count(1, $group2->users);
Assert::true($group2->users->contains($user2));
Assert::count(0, $group3->users);
}
