silverstripe-tagfield/tests/TagFieldTest.php
Will Rossiter 527c5b2224
FIX Selected tag is not shown when isMutliple is false (#201)
* doc: add note about `setTitleField` (Fixes #153)

* NEW Add support for saving tag value into has_one components

FIX Value not shown if isMultiple is false (#195)

* fix: don't default to ID column as pgsql throws an error if comparing string value
2022-06-07 13:00:12 +12:00

492 lines
14 KiB
PHP
Executable File

<?php
namespace SilverStripe\TagField\Tests;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\TagField\ReadonlyTagField;
use SilverStripe\TagField\TagField;
use SilverStripe\TagField\Tests\Stub\TagFieldTestBlogPost;
use SilverStripe\TagField\Tests\Stub\TagFieldTestBlogTag;
use SilverStripe\TagField\Tests\Stub\TagFieldTestController;
class TagFieldTest extends SapphireTest
{
/**
* @var string
*/
protected static $fixture_file = 'TagFieldTest.yml';
/**
* @var array
*/
protected static $extra_dataobjects = [
TagFieldTestBlogTag::class,
TagFieldTestBlogPost::class,
];
public function testItSavesLinksToNewTagsOnNewRecords()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue(['Tag3', 'Tag4']);
$field->saveInto($record);
$record->write();
$this->compareExpectedAndActualTags(
['Tag3', 'Tag4'],
$record
);
}
public function testItSavesToHasOne()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$tag = new TagFieldTestBlogTag();
$tag->Title = 'Foobar';
$tag->write();
$field = new TagField('PrimaryTagID', '', new DataList(TagFieldTestBlogTag::class));
$field->setIsMultiple(false);
$field->setValue('Foobar');
$field->saveInto($record);
$record->write();
$this->assertEquals($tag->ID, $record->PrimaryTagID, 'The tag is saved to a has_one');
$tag = new TagFieldTestBlogTag();
$tag->Title = 'Foobarbaz';
$tag->write();
$field->setValue(['Foobarbaz']);
$field->saveInto($record);
$record->write();
$this->assertEquals($tag->ID, $record->PrimaryTagID, 'The tag is saved to a has_one');
}
/**
* @param string $name
*
* @return TagFieldTestBlogPost
*/
protected function getNewTagFieldTestBlogPost($name)
{
return $this->objFromFixture(
TagFieldTestBlogPost::class,
$name
);
}
/**
* @param array $expected
* @param TagFieldTestBlogPost $record
*/
protected function compareExpectedAndActualTags(array $expected, TagFieldTestBlogPost $record)
{
$this->compareTagLists($expected, $record->Tags());
}
/**
* Ensure a source of tags matches the given string tag names
*
* @param array $expected
* @param DataList $actualSource
*/
protected function compareTagLists(array $expected, DataList $actualSource)
{
$actual = array_values($actualSource->map('ID', 'Title')->toArray() ?? []);
sort($expected);
sort($actual);
$this->assertEquals(
$expected,
$actual
);
}
public function testItSavesLinksToNewTagsOnExistingRecords()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$record->write();
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue(['Tag3', 'Tag4']);
$field->saveInto($record);
$this->compareExpectedAndActualTags(
array('Tag3', 'Tag4'),
$record
);
}
public function testItSavesLinksToExistingTagsOnNewRecords()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue(['Tag1', 'Tag2']);
$field->saveInto($record);
$record->write();
$this->compareExpectedAndActualTags(
['Tag1', 'Tag2'],
$record
);
}
public function testItSavesLinksToExistingTagsOnExistingRecords()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$record->write();
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue(['Tag1', 'Tag2']);
$field->saveInto($record);
$this->compareExpectedAndActualTags(
['Tag1', 'Tag2'],
$record
);
}
public function testSavesReactTags()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$record->write();
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue([
[
'Title' => 'Tag1',
'Value' => 'Tag1',
],
[
'Title' => 'Tag2',
'Value' => 'Tag2',
],
]);
$field->saveInto($record);
$this->compareExpectedAndActualTags(
['Tag1', 'Tag2'],
$record
);
}
/**
* Ensure that {@see TagField::saveInto} respects existing tags
*/
public function testSaveDuplicateTags()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost2');
$record->write();
$tag2ID = $this->idFromFixture(TagFieldTestBlogTag::class, 'Tag2');
// Check tags before write
$this->compareExpectedAndActualTags(
['Tag1', '222'],
$record
);
$this->compareTagLists(
['Tag1', '222'],
TagFieldTestBlogTag::get()
);
$this->assertContains($tag2ID, TagFieldTestBlogTag::get()->column('ID'));
// Write new tags
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
$field->setValue(['222', 'Tag3']);
$field->saveInto($record);
// Check only one new tag was added
$this->compareExpectedAndActualTags(
['222', 'Tag3'],
$record
);
// Ensure that only one new dataobject was added and that tag2s id has not changed
$this->compareTagLists(
['Tag1', '222', 'Tag3'],
TagFieldTestBlogTag::get()
);
$this->assertContains($tag2ID, TagFieldTestBlogTag::get()->column('ID'));
}
public function testItSuggestsTags()
{
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class));
/**
* Partial tag title match.
*/
$request = $this->getNewRequest(['term' => 'Tag']);
$this->assertEquals(
'{"items":[{"Title":"Tag1","Value":"Tag1"}]}',
$field->suggest($request)->getBody()
);
/**
* Exact tag title match.
*/
$request = $this->getNewRequest(['term' => '222']);
$this->assertEquals(
'{"items":[{"Title":"222","Value":"222"}]}',
$field->suggest($request)->getBody()
);
/**
* Case-insensitive tag title match.
*/
$request = $this->getNewRequest(['term' => 'TAG1']);
$this->assertEquals(
'{"items":[{"Title":"Tag1","Value":"Tag1"}]}',
$field->suggest($request)->getBody()
);
/**
* No tag title match.
*/
$request = $this->getNewRequest(['term' => 'unknown']);
$this->assertEquals(
'{"items":[]}',
$field->suggest($request)->getBody()
);
}
/**
* Tests that TagField supports pre-filtered data sources
*/
public function testRestrictedSuggestions()
{
$source = TagFieldTestBlogTag::get()->exclude('Title', 'Tag2');
$field = new TagField('Tags', '', $source);
/**
* Partial tag title match.
*/
$request = $this->getNewRequest(['term' => 'Tag']);
$this->assertEquals(
'{"items":[{"Title":"Tag1","Value":"Tag1"}]}',
$field->suggest($request)->getBody()
);
/**
* Exact tag title match.
*/
$request = $this->getNewRequest(['term' => 'Tag1']);
$this->assertEquals(
'{"items":[{"Title":"Tag1","Value":"Tag1"}]}',
$field->suggest($request)->getBody()
);
/**
* Excluded item doesn't appear in matches
*/
$request = $this->getNewRequest(['term' => 'Tag2']);
$this->assertEquals(
'{"items":[]}',
$field->suggest($request)->getBody()
);
}
/**
* @param array $parameters
*
* @return HTTPRequest
*/
protected function getNewRequest(array $parameters)
{
return new HTTPRequest(
'get',
'TagFieldTestController/TagFieldTestForm/fields/Tags/suggest',
$parameters
);
}
public function testItDisplaysValuesFromRelations()
{
$record = $this->getNewTagFieldTestBlogPost('BlogPost1');
$record->write();
$form = new Form(
new TagFieldTestController(),
'Form',
new FieldList(
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class))
),
new FieldList()
);
$form->loadDataFrom(
$this->objFromFixture(TagFieldTestBlogPost::class, 'BlogPost2')
);
$ids = TagFieldTestBlogTag::get()->column('ID');
$this->assertEquals($field->Value(), $ids);
}
public function testItIgnoresNewTagsIfCannotCreate()
{
$this->markTestSkipped(
'This test has not been updated yet.'
);
$record = new TagFieldTestBlogPost();
$record->write();
$tag = TagFieldTestBlogTag::get()->filter('Title', 'Tag1')->first();
$field = new TagField('Tags', '', new DataList(TagFieldTestBlogTag::class), [$tag->Title, 'Tag3']);
$field->setCanCreate(false);
$field->saveInto($record);
/**
* @var TagFieldTestBlogPost $record
*/
$record = DataObject::get_by_id(TagFieldTestBlogPost::class, $record->ID);
$this->compareExpectedAndActualTags(
['Tag1'],
$record
);
}
/**
* Test you can save without a source set
*/
public function testSaveEmptySource()
{
$record = new TagFieldTestBlogPost();
$record->write();
// Clear database of tags
TagFieldTestBlogTag::get()->removeAll();
$field = new TagField('Tags', '', TagFieldTestBlogTag::get());
$field->setValue(['New Tag']);
$field->setCanCreate(true);
$field->saveInto($record);
$tag = TagFieldTestBlogTag::get()->first();
$this->assertNotEmpty($tag);
$this->assertEquals('New Tag', $tag->Title);
$record = TagFieldTestBlogPost::get()->byID($record->ID);
$this->assertEquals(
$tag->ID,
$record->Tags()->first()->ID
);
}
/**
* Test read only fields are returned
*/
public function testReadonlyTransformation()
{
$field = new TagField('Tags', '', TagFieldTestBlogTag::get());
$readOnlyField = $field->performReadonlyTransformation();
$this->assertInstanceOf(ReadonlyTagField::class, $readOnlyField);
// Custom title field
$field = new TagField('Tags', '', TagFieldTestBlogTag::get());
$field->setTitleField('Name');
$readOnlyField = $field->performReadonlyTransformation();
$this->assertEquals('Name', $readOnlyField->getTitleField());
}
public function testItDisplaysWithSelectedValuesFromDataList()
{
$source = TagFieldTestBlogTag::get();
$selectedTag = $source->First();
$unselectedTag = $source->Last();
$value = $source->filter('ID', $selectedTag->ID); // arbitrary subset
$field = new TagField('TestField', null, $source, $value);
// Not the cleanest way to assert this, but getOptions() is protected
$schema = $field->getSchemaDataDefaults();
$this->assertTrue(
$this->getFromOptionsByTitle($schema['options'], $selectedTag->Title)['Selected']
);
$this->assertFalse(
$this->getFromOptionsByTitle($schema['options'], $unselectedTag->Title)['Selected']
);
}
public function testGetSchemaDataDefaults()
{
$form = new Form(null, 'Form', new FieldList(), new FieldList());
$field = new TagField('TestField', 'Test Field', TagFieldTestBlogTag::get());
$field->setForm($form);
$field
->setShouldLazyLoad(false)
->setCanCreate(false);
$schema = $field->getSchemaDataDefaults();
$this->assertSame('TestField[]', $schema['name']);
$this->assertFalse($schema['lazyLoad']);
$this->assertFalse($schema['creatable']);
$this->assertEquals([
['Title' => 'Tag1', 'Value' => 'Tag1', 'Selected' => false],
['Title' => '222', 'Value' => '222', 'Selected' => false],
], $schema['options']);
$field->setValue(['222']);
$schema = $field->getSchemaDataDefaults();
$this->assertEquals([
['Title' => 'Tag1', 'Value' => 'Tag1', 'Selected' => false],
['Title' => '222', 'Value' => '222', 'Selected' => true],
], $schema['options']);
$field
->setShouldLazyLoad(true)
->setCanCreate(true);
$schema = $field->getSchemaDataDefaults();
$this->assertTrue($schema['lazyLoad']);
$this->assertTrue($schema['creatable']);
$this->assertStringContainsString('suggest', $schema['optionUrl']);
}
public function testSchemaIsAddedToAttributes()
{
$field = new TagField('TestField');
$attributes = $field->getAttributes();
$this->assertNotEmpty($attributes['data-schema']);
}
/**
* @param array $options
* @param string $title
* @return array|null
*/
protected function getFromOptionsByTitle(array $options, $title)
{
foreach ($options as $option) {
if ($option['Title'] == $title) {
return $option;
}
}
return null;
}
}