silverstripe-gridfieldexten.../tests/GridFieldOrderableRowsTest.php

365 lines
13 KiB
PHP
Raw Normal View History

<?php
namespace Symbiote\GridFieldExtensions\Tests;
use ReflectionMethod;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Forms\GridField\GridFieldConfig_RelationEditor;
2022-02-02 03:36:25 +01:00
use SilverStripe\ORM\DataList;
2017-06-16 06:07:09 +02:00
use Symbiote\GridFieldExtensions\GridFieldOrderableRows;
use Symbiote\GridFieldExtensions\Tests\Stub\PolymorphM2MMapper;
use Symbiote\GridFieldExtensions\Tests\Stub\PolymorphM2MParent;
2018-02-21 12:58:48 +01:00
use Symbiote\GridFieldExtensions\Tests\Stub\StubOrderableChild;
use Symbiote\GridFieldExtensions\Tests\Stub\StubOrdered;
use Symbiote\GridFieldExtensions\Tests\Stub\StubOrderedVersioned;
use Symbiote\GridFieldExtensions\Tests\Stub\StubParent;
use Symbiote\GridFieldExtensions\Tests\Stub\StubSubclass;
use Symbiote\GridFieldExtensions\Tests\Stub\StubSubclassOrderedVersioned;
2018-02-21 12:58:48 +01:00
use Symbiote\GridFieldExtensions\Tests\Stub\StubUnorderable;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughBelongs;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughBelongsVersioned;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughDefiner;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughDefinerVersioned;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughIntermediary;
2022-02-02 03:36:25 +01:00
use Symbiote\GridFieldExtensions\Tests\Stub\TitleObject;
use Symbiote\GridFieldExtensions\Tests\Stub\TitleSortedObject;
2023-04-06 00:30:12 +02:00
use Symbiote\GridFieldExtensions\Tests\Stub\TitleArraySortedObject;
use Symbiote\GridFieldExtensions\Tests\Stub\ThroughIntermediaryVersioned;
/**
* Tests for the {@link GridFieldOrderableRows} component.
*/
2016-12-21 03:34:58 +01:00
class GridFieldOrderableRowsTest extends SapphireTest
{
protected static $fixture_file = [
'GridFieldOrderableRowsTest.yml',
'OrderableRowsThroughTest.yml',
// 'OrderablePolymorphicManyToMany.yml' // TODO: introduce this tests in the next minor release
];
2016-07-21 16:04:37 +02:00
2018-02-21 12:58:48 +01:00
protected static $extra_dataobjects = [
// PolymorphM2MChild::class,
// PolymorphM2MMapper::class,
// PolymorphM2MParent::class,
StubParent::class,
StubOrdered::class,
StubSubclass::class,
2018-02-21 12:58:48 +01:00
StubUnorderable::class,
StubOrderableChild::class,
StubOrderedVersioned::class,
StubSubclassOrderedVersioned::class,
ThroughDefiner::class,
ThroughIntermediary::class,
ThroughBelongs::class,
2022-02-02 03:36:25 +01:00
TitleObject::class,
TitleSortedObject::class,
2023-04-06 00:30:12 +02:00
TitleArraySortedObject::class,
ThroughDefinerVersioned::class,
ThroughIntermediaryVersioned::class,
ThroughBelongsVersioned::class,
2018-02-21 12:58:48 +01:00
];
2016-07-21 13:55:03 +02:00
public function reorderItemsProvider()
{
return [
[StubParent::class . '.parent', 'MyHasMany', 'Sort'],
[StubParent::class . '.parent', 'MyHasManySubclass', 'Sort'],
[StubParent::class . '.parent-subclass-ordered-versioned', 'MyHasManySubclassOrderedVersioned', 'Sort'],
[StubParent::class . '.parent', 'MyManyMany', 'ManyManySort'],
[StubParent::class . '.parent', 'MyManyManyVersioned', 'ManyManySort'],
[ThroughDefiner::class . '.DefinerOne', 'Belongings', 'Sort'],
[ThroughDefinerVersioned::class . '.DefinerOne', 'Belongings', 'Sort'],
// [PolymorphM2MParent::class . '.ParentOne', 'Children', 'Sort']
];
}
/**
* @dataProvider reorderItemsProvider
*/
public function testReorderItems($fixtureID, $relationName, $sortName)
2016-12-21 03:34:58 +01:00
{
$orderable = new GridFieldOrderableRows($sortName);
2016-12-21 03:34:58 +01:00
$reflection = new ReflectionMethod($orderable, 'executeReorder');
$reflection->setAccessible(true);
2016-07-21 16:04:37 +02:00
2016-12-21 03:34:58 +01:00
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
2016-07-21 16:04:37 +02:00
2022-04-13 07:44:44 +02:00
list($parentClass, $parentInstanceID) = explode('.', $fixtureID ?? '');
$parent = $this->objFromFixture($parentClass, $parentInstanceID);
2016-12-21 03:34:58 +01:00
$grid = new GridField(
$relationName,
'Testing Many Many',
$parent->$relationName()->sort($sortName),
2016-12-21 03:34:58 +01:00
$config
);
$originalOrder = $parent->$relationName()->sort($sortName)->column('ID');
2018-02-21 12:58:48 +01:00
$desiredOrder = [];
2016-07-21 16:04:37 +02:00
2016-12-21 03:34:58 +01:00
// Make order non-contiguous, and 1-based
2022-04-13 07:44:44 +02:00
foreach (array_reverse($originalOrder ?? []) as $index => $id) {
2016-12-21 03:34:58 +01:00
$desiredOrder[$index * 2 + 1] = $id;
}
2016-07-21 16:04:37 +02:00
2016-12-21 03:34:58 +01:00
$this->assertNotEquals($originalOrder, $desiredOrder);
2016-07-21 16:04:37 +02:00
2016-12-21 03:34:58 +01:00
$reflection->invoke($orderable, $grid, $desiredOrder);
2016-07-21 16:04:37 +02:00
$newOrder = $parent->$relationName()->sort($sortName)->map($sortName, 'ID')->toArray();
2016-07-21 16:04:37 +02:00
2016-12-21 03:34:58 +01:00
$this->assertEquals($desiredOrder, $newOrder);
}
2016-07-21 16:04:37 +02:00
public function testManyManyThroughListSortOrdersAreUsedForInitialRender()
{
/** @var ThroughDefiner $record */
$record = $this->objFromFixture(ThroughDefiner::class, 'DefinerOne');
$orderable = new GridFieldOrderableRows('Sort');
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
$grid = new GridField(
'Belongings',
'Testing Many Many',
$record->Belongings()->sort('Sort'),
$config
);
// Get the first record, which would be the first one to have column contents generated
/** @var ThroughIntermediary $expected */
$intermediary = $this->objFromFixture(ThroughIntermediary::class, 'One');
$result = $orderable->getColumnContent($grid, $record, 'irrelevant');
2021-11-08 23:43:41 +01:00
$this->assertStringContainsString(
'Belongings[GridFieldEditableColumns][' . $record->ID . '][Sort]',
$result,
'The field name is indexed under the record\'s ID'
);
2021-11-08 23:43:41 +01:00
$this->assertStringContainsString(
'value="' . $intermediary->Sort . '"',
$result,
'The value comes from the MMTL intermediary Sort value'
);
}
public function testPolymorphicManyManyListSortOrdersAreUsedForInitialRender()
{
$this->markTestSkipped('TODO: Introduce this test in the next minor release (3.3)');
$record = $this->objFromFixture(PolymorphM2MParent::class, 'ParentOne');
$orderable = new GridFieldOrderableRows('Sort');
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
$grid = new GridField(
'Children',
'Testing Polymorphic Many Many',
$record->Children()->sort('Sort'),
$config
);
// Get the first record, which would be the first one to have column contents generated
$intermediary = $this->objFromFixture(PolymorphM2MMapper::class, 'MapP1ToC1');
$result = $orderable->getColumnContent($grid, $record, 'irrelevant');
2021-11-08 23:43:41 +01:00
$this->assertStringContainsString(
'Children[GridFieldEditableColumns][' . $record->ID . '][Sort]',
$result,
'The field name is indexed under the record\'s ID'
);
2021-11-08 23:43:41 +01:00
$this->assertStringContainsString(
'value="' . $intermediary->Sort . '"',
$result,
'The value comes from the MMTL intermediary Sort value'
);
}
2018-02-21 12:58:48 +01:00
public function testSortableChildClass()
{
$orderable = new GridFieldOrderableRows('Sort');
$reflection = new ReflectionMethod($orderable, 'executeReorder');
$reflection->setAccessible(true);
2018-02-21 12:58:48 +01:00
$parent = $this->objFromFixture(StubOrdered::class, 'nestedtest');
2018-02-21 12:58:48 +01:00
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
2018-02-21 12:58:48 +01:00
$grid = new GridField(
'Children',
'Children',
$parent->Children(),
$config
);
2018-02-21 12:58:48 +01:00
$originalOrder = $parent->Children()->column('ID');
2022-04-13 07:44:44 +02:00
$desiredOrder = array_reverse($originalOrder ?? []);
2018-02-21 12:58:48 +01:00
$this->assertNotEquals($originalOrder, $desiredOrder);
2018-02-21 12:58:48 +01:00
$reflection->invoke($orderable, $grid, $desiredOrder);
2018-02-21 12:58:48 +01:00
$newOrder = $parent->Children()->column('ID');
2018-02-21 12:58:48 +01:00
$this->assertEquals($desiredOrder, $newOrder);
}
2016-12-21 03:34:58 +01:00
/**
2018-02-21 12:58:48 +01:00
* @covers \Symbiote\GridFieldExtensions\GridFieldOrderableRows::getSortTable
2016-12-21 03:34:58 +01:00
*/
public function testGetSortTable()
{
$orderable = new GridFieldOrderableRows();
$parent = new StubParent();
2016-12-21 03:34:58 +01:00
$parent->write();
2016-12-21 03:34:58 +01:00
$this->assertEquals(
'StubOrdered',
2016-12-21 03:34:58 +01:00
$orderable->getSortTable($parent->MyHasMany())
);
2016-12-21 03:34:58 +01:00
$this->assertEquals(
'StubOrdered',
2016-12-21 03:34:58 +01:00
$orderable->getSortTable($parent->MyHasManySubclass())
);
2016-12-21 03:34:58 +01:00
$this->assertEquals(
'StubOrdered',
2016-12-21 03:34:58 +01:00
$orderable->getSortTable($parent->MyManyMany())
);
2016-12-21 03:34:58 +01:00
$this->assertEquals(
'StubParent_MyManyMany',
2016-12-21 03:34:58 +01:00
$orderable->setSortField('ManyManySort')->getSortTable($parent->MyManyMany())
);
$this->assertEquals(
'StubOrderedVersioned',
$orderable->setSortField('Sort')->getSortTable($parent->MyHasManySubclassOrderedVersioned())
);
}
public function testReorderItemsSubclassVersioned()
{
$orderable = new GridFieldOrderableRows('Sort');
$reflection = new ReflectionMethod($orderable, 'executeReorder');
$reflection->setAccessible(true);
$parent = $this->objFromFixture(StubParent::class, 'parent-subclass-ordered-versioned');
// make sure all items are published
foreach ($parent->MyHasManySubclassOrderedVersioned() as $item) {
$item->publishRecursive();
}
// there should be no difference between stages at this point
$differenceFound = false;
foreach ($parent->MyHasManySubclassOrderedVersioned() as $item) {
/** @var StubSubclassOrderedVersioned|Versioned $item */
if ($item->stagesDiffer()) {
$this->fail('Unexpected difference found on stages');
}
}
// reorder items
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
$grid = new GridField(
'TestField',
'TestField',
$parent->MyHasManySubclassOrderedVersioned()->sort('Sort', 'ASC'),
$config
);
$originalOrder = $parent->MyHasManySubclassOrderedVersioned()
->sort('Sort', 'ASC')
->column('ID');
$desiredOrder = [];
// Make order non-contiguous, and 1-based
2022-04-13 07:44:44 +02:00
foreach (array_reverse($originalOrder ?? []) as $index => $id) {
$desiredOrder[$index * 2 + 1] = $id;
}
$this->assertNotEquals($originalOrder, $desiredOrder);
$reflection->invoke($orderable, $grid, $desiredOrder);
$newOrder = $parent->MyHasManySubclassOrderedVersioned()
->sort('Sort', 'ASC')
->map('Sort', 'ID')
->toArray();
$this->assertEquals($desiredOrder, $newOrder);
// reorder should have been handled as versioned - there should be a difference between stages now
$differenceFound = false;
foreach ($parent->MyHasManySubclassOrderedVersioned() as $item) {
if ($item->stagesDiffer()) {
$differenceFound = true;
break;
}
}
$this->assertTrue($differenceFound);
2016-12-21 03:34:58 +01:00
}
2022-02-02 03:36:25 +01:00
public function testGetManipulatedDataWithoutDefaultSort()
{
$sortedList = $this->getTitleSortedListForManipuatedData(TitleObject::class, [
['Title' => 'C'],
['Title' => 'A'],
['Title' => 'B'],
]);
$this->assertSame(['A', 'B', 'C'], $sortedList->column('Title'));
}
public function testGetManipulatedDataWithDefaultSort()
{
$sortedList = $this->getTitleSortedListForManipuatedData(TitleSortedObject::class, [
['Title' => 'Z', 'Iden' => 'C', 'DefaultSort' => 3],
['Title' => 'Z', 'Iden' => 'A', 'DefaultSort' => 2],
['Title' => 'Z', 'Iden' => 'B', 'DefaultSort' => 1],
]);
$this->assertSame(['B', 'A', 'C'], $sortedList->column('Iden'));
}
2023-04-06 00:30:12 +02:00
public function testGetManipulatedDataWithDefaultSortArray()
{
$sortedList = $this->getTitleSortedListForManipuatedData(TitleArraySortedObject::class, [
['Title' => 'X', 'Iden' => 'C', 'OtherSort' => 3],
['Title' => 'Z', 'Iden' => 'A', 'OtherSort' => 2],
['Title' => 'Z', 'Iden' => 'B', 'OtherSort' => 1],
]);
$this->assertSame(['C', 'B', 'A'], $sortedList->column('Iden'));
}
2022-02-02 03:36:25 +01:00
private function getTitleSortedListForManipuatedData(string $dataClass, array $data): DataList
{
$list = new DataList($dataClass);
foreach ($data as $values) {
$item = new $dataClass();
$item->update($values);
$item->write();
$list->add($item);
}
$orderable = new GridFieldOrderableRows('Title');
$config = new GridFieldConfig_RelationEditor();
$config->addComponent($orderable);
$grid = new GridField('MyName', 'MyTitle', $list, $config);
$sortedList = $orderable->getManipulatedData($grid, $list);
return $sortedList;
}
}