SortableUploadFieldTest::testExistingSortOrderForManyManyThroughList() - Code Metrics - Inspection of "Feature/many many through list" - bummzack/sortablefile - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#53)

unknown

created 2018-05-30 08:24 UTC

testExistingSortOrderForManyManyThroughList() A

↳ Parent: SortableUploadFieldTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	5
nc	1
nop	0

<?php

namespace Bummzack\SortableFile\Tests;

use Bummzack\SortableFile\Forms\SortableUploadField;
use Bummzack\SortableFile\Tests\Model\FileLinkDataObject;
use Bummzack\SortableFile\Tests\Model\TestDataObject;
use SilverStripe\Assets\Dev\TestAssetStore;
use SilverStripe\Assets\File;
use SilverStripe\Assets\Folder;
use SilverStripe\Control\Controller;
use SilverStripe\Dev\Debug;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\FormAction;
use SilverStripe\ORM\ArrayList;
use SilverStripe\Versioned\Versioned;

class SortableUploadFieldTest extends SapphireTest
{
    protected static $fixture_file = 'SortableUploadFieldTest.yml';

    protected static $extra_dataobjects = [
        TestDataObject::class
    ];

    public function setUp()
    {
        parent::setUp();

        Versioned::set_stage(Versioned::DRAFT);
        $this->logInWithPermission('ADMIN');
        TestAssetStore::activate(__DIR__ . '/assets');

        // Copy test images for each of the fixture references
        /** @var File $file */
        $files = File::get()->exclude('ClassName', Folder::class);
        foreach ($files as $file) {
            $sourcePath = __DIR__ . '/assets/' . $file->Name;
            $file->setFromLocalFile($sourcePath, $file->Filename);
        }
    }

    public function tearDown()
    {
        TestAssetStore::reset();
        parent::tearDown();
    }

    public function testSchemaDefaults()
    {
        $field = SortableUploadField::create('Files');

        // Setup a dummy form, so that `getSchemaDataDefaults` doesn't error out
        Controller::config()->set('url_segment', 'dummy');
        Form::create(
            Controller::curr(),
            'TestForm',
            FieldList::create($field),
            FieldList::create(FormAction::create('test'))
        );

        $data = $field->getSchemaDataDefaults();

        $this->assertArrayHasKey('sortable', $data);
        $this->assertTrue($data['sortable']);
    }

    public function testSortColumn()
    {
        $field = SortableUploadField::create('Files');

        $this->assertEquals('SortOrder', $field->getSortColumn(), 'Default value should be "SortOrder"');

        $field->setSortColumn('Sort');

        $this->assertEquals('Sort', $field->getSortColumn(), 'Changed value should be "Sort"');
    }

    public function testExistingSortOrder()
    {
        $obj = $this->objFromFixture(TestDataObject::class, 'obj1');

        $field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
        $this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));

        // set field items in other order
        $field->setValue($obj->Files()->sort('FileHash'));
        // Items should be returned in the correct order though.
        $this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));

        $field = SortableUploadField::create('OtherFiles', 'OtherFiles', $obj->OtherFiles())
            ->setRecord($obj)
            ->setSortColumn('Sort');

        $this->assertEquals(['FileC', 'FileB', 'FileA'], $field->getItems()->column('Title'));
    }

    public function testAddingFilesToNewRecord()
    {
        // Create a new DataObject which will have an unsaved relation
        $obj = TestDataObject::create();

        // The file IDs to add, Should result in D,B,A,C
        $data = ['Files' => ['4','2','1','3']];

        $field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
        $field->setSubmittedValue($data);
        $field->saveInto($obj);
        $obj->write();

        $this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $field->getItems()->column('Title'));

        // change the sort Order and remove an Item
        $field->setSubmittedValue(['Files' => ['1','2','3']]);
        $field->saveInto($obj);
        $obj->write();
        $this->assertEquals(['FileA', 'FileB', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileA', 'FileB', 'FileC'], $field->getItems()->column('Title'));

        // Test persistance of sort-order if the incoming array-list doesn't contain the sort column
        $field->setSubmittedValue(['Files' => ['3','1','2']]);
        // Set the value from an arraylist without any sort-column
        $field->setValue(ArrayList::create(
            File::get()->byIDs([1,2,3])->toArray()
        ));
        $field->saveInto($obj);
        $obj->write();
        $this->assertEquals(['FileC', 'FileA', 'FileB'], $obj->Files()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileC', 'FileA', 'FileB'], $field->getItems()->column('Title'));

        // Test with a newly added file
        $field->setSubmittedValue(['Files' => ['3','4','2','1']]);
        $field->saveInto($obj);
        $obj->write();

        $this->assertEquals(['FileC', 'FileD', 'FileB', 'FileA'], $obj->Files()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileC', 'FileD', 'FileB', 'FileA'], $field->getItems()->column('Title'));
    }

    public function testAddingFilesWithoutFormSubmission()
    {
        // Create a new DataObject which will have an unsaved relation
        $obj = TestDataObject::create();

        $field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
        // Set the value from a List without sort order
        $field->setValue(ArrayList::create(
            File::get()->byIDs([1,2,3])->toArray()
        ));
        $field->saveInto($obj);
        $obj->write();

        // Items should be ordered by ID now
        $this->assertEquals(['FileA', 'FileB', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileA', 'FileB', 'FileC'], $field->getItems()->column('Title'));
    }

    public function testExistingSortOrderForManyManyThroughList()
    {
        $obj = $this->objFromFixture(TestDataObject::class, 'obj2');

        $field = SortableUploadField::create('LinkedFiles', 'LinkedFiles', $obj->LinkedFiles())->setRecord($obj);
        $this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));

        // set field items in other order
        $field->setValue($obj->LinkedFiles()->sort('FileHash'));
        // Items should be returned in the correct order though.
        $this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));
    }

    public function testAddingFilesToNewRecordManyManyThroughList()
    {
        $obj = TestDataObject::create();

        // The file IDs to add, Should result in D,B,A,C
        $data = ['Files' => ['4','2','1','3']];

        $field = SortableUploadField::create('LinkedFiles', 'LinkedFiles', $obj->getLinkedFiles())->setRecord($obj);
        $field->setSubmittedValue($data);
        $field->saveInto($obj);
        $obj->write();

        $this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $obj->LinkedFiles()->sort('SortOrder')->column('Title'));
        $this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $field->getItems()->column('Title'));

        $linkObjs = FileLinkDataObject::get()->filter('OwnerID', $obj->ID);
        $this->assertEquals(4, $linkObjs->count());

        $titles = [];
        foreach ($linkObjs as $linkObj) {
            $titles[] = $linkObj->File()->Title;
        }

        $this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $titles);
    }
}


1			<?php
2
3			namespace Bummzack\SortableFile\Tests;
4
5			use Bummzack\SortableFile\Forms\SortableUploadField;
6			use Bummzack\SortableFile\Tests\Model\FileLinkDataObject;
7			use Bummzack\SortableFile\Tests\Model\TestDataObject;
8			use SilverStripe\Assets\Dev\TestAssetStore;
9			use SilverStripe\Assets\File;
10			use SilverStripe\Assets\Folder;
11			use SilverStripe\Control\Controller;
12			use SilverStripe\Dev\Debug;
13			use SilverStripe\Dev\SapphireTest;
14			use SilverStripe\Forms\FieldList;
15			use SilverStripe\Forms\Form;
16			use SilverStripe\Forms\FormAction;
17			use SilverStripe\ORM\ArrayList;
18			use SilverStripe\Versioned\Versioned;
19
20			class SortableUploadFieldTest extends SapphireTest
21			{
22			protected static $fixture_file = 'SortableUploadFieldTest.yml';
23
24			protected static $extra_dataobjects = [
25			TestDataObject::class
26			];
27
28			public function setUp()
29			{
30			parent::setUp();
31
32			Versioned::set_stage(Versioned::DRAFT);
33			$this->logInWithPermission('ADMIN');
34			TestAssetStore::activate(__DIR__ . '/assets');
35
36			// Copy test images for each of the fixture references
37			/** @var File $file */
38			$files = File::get()->exclude('ClassName', Folder::class);
39			foreach ($files as $file) {
40			$sourcePath = __DIR__ . '/assets/' . $file->Name;
41			$file->setFromLocalFile($sourcePath, $file->Filename);
42			}
43			}
44
45			public function tearDown()
46			{
47			TestAssetStore::reset();
48			parent::tearDown();
49			}
50
51			public function testSchemaDefaults()
52			{
53			$field = SortableUploadField::create('Files');
54
55			// Setup a dummy form, so that `getSchemaDataDefaults` doesn't error out
56			Controller::config()->set('url_segment', 'dummy');
57			Form::create(
58			Controller::curr(),
59			'TestForm',
60			FieldList::create($field),
61			FieldList::create(FormAction::create('test'))
62			);
63
64			$data = $field->getSchemaDataDefaults();
65
66			$this->assertArrayHasKey('sortable', $data);
67			$this->assertTrue($data['sortable']);
68			}
69
70			public function testSortColumn()
71			{
72			$field = SortableUploadField::create('Files');
73
74			$this->assertEquals('SortOrder', $field->getSortColumn(), 'Default value should be "SortOrder"');
75
76			$field->setSortColumn('Sort');
77
78			$this->assertEquals('Sort', $field->getSortColumn(), 'Changed value should be "Sort"');
79			}
80
81			public function testExistingSortOrder()
82			{
83			$obj = $this->objFromFixture(TestDataObject::class, 'obj1');
84
85			$field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
86			$this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));
87
88			// set field items in other order
89			$field->setValue($obj->Files()->sort('FileHash'));
90			// Items should be returned in the correct order though.
91			$this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));
92
93			$field = SortableUploadField::create('OtherFiles', 'OtherFiles', $obj->OtherFiles())
94			->setRecord($obj)
95			->setSortColumn('Sort');
96
97			$this->assertEquals(['FileC', 'FileB', 'FileA'], $field->getItems()->column('Title'));
98			}
99
100			public function testAddingFilesToNewRecord()
101			{
102			// Create a new DataObject which will have an unsaved relation
103			$obj = TestDataObject::create();
104
105			// The file IDs to add, Should result in D,B,A,C
106			$data = ['Files' => ['4','2','1','3']];
107
108			$field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
109			$field->setSubmittedValue($data);
110			$field->saveInto($obj);
111			$obj->write();
112
113			$this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
114			$this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $field->getItems()->column('Title'));
115
116			// change the sort Order and remove an Item
117			$field->setSubmittedValue(['Files' => ['1','2','3']]);
118			$field->saveInto($obj);
119			$obj->write();
120			$this->assertEquals(['FileA', 'FileB', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
121			$this->assertEquals(['FileA', 'FileB', 'FileC'], $field->getItems()->column('Title'));
122
123			// Test persistance of sort-order if the incoming array-list doesn't contain the sort column
124			$field->setSubmittedValue(['Files' => ['3','1','2']]);
125			// Set the value from an arraylist without any sort-column
126			$field->setValue(ArrayList::create(
127			File::get()->byIDs([1,2,3])->toArray()
128			));
129			$field->saveInto($obj);
130			$obj->write();
131			$this->assertEquals(['FileC', 'FileA', 'FileB'], $obj->Files()->sort('SortOrder')->column('Title'));
132			$this->assertEquals(['FileC', 'FileA', 'FileB'], $field->getItems()->column('Title'));
133
134			// Test with a newly added file
135			$field->setSubmittedValue(['Files' => ['3','4','2','1']]);
136			$field->saveInto($obj);
137			$obj->write();
138
139			$this->assertEquals(['FileC', 'FileD', 'FileB', 'FileA'], $obj->Files()->sort('SortOrder')->column('Title'));
140			$this->assertEquals(['FileC', 'FileD', 'FileB', 'FileA'], $field->getItems()->column('Title'));
141			}
142
143			public function testAddingFilesWithoutFormSubmission()
144			{
145			// Create a new DataObject which will have an unsaved relation
146			$obj = TestDataObject::create();
147
148			$field = SortableUploadField::create('Files', 'Files', $obj->Files())->setRecord($obj);
149			// Set the value from a List without sort order
150			$field->setValue(ArrayList::create(
151			File::get()->byIDs([1,2,3])->toArray()
152			));
153			$field->saveInto($obj);
154			$obj->write();
155
156			// Items should be ordered by ID now
157			$this->assertEquals(['FileA', 'FileB', 'FileC'], $obj->Files()->sort('SortOrder')->column('Title'));
158			$this->assertEquals(['FileA', 'FileB', 'FileC'], $field->getItems()->column('Title'));
159			}
160
161			public function testExistingSortOrderForManyManyThroughList()
162			{
163			$obj = $this->objFromFixture(TestDataObject::class, 'obj2');
164
165			$field = SortableUploadField::create('LinkedFiles', 'LinkedFiles', $obj->LinkedFiles())->setRecord($obj);
166			$this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));
167
168			// set field items in other order
169			$field->setValue($obj->LinkedFiles()->sort('FileHash'));
170			// Items should be returned in the correct order though.
171			$this->assertEquals(['FileA', 'FileB', 'FileC', 'FileD'], $field->getItems()->column('Title'));
172			}
173
174			public function testAddingFilesToNewRecordManyManyThroughList()
175			{
176			$obj = TestDataObject::create();
177
178			// The file IDs to add, Should result in D,B,A,C
179			$data = ['Files' => ['4','2','1','3']];
180
181			$field = SortableUploadField::create('LinkedFiles', 'LinkedFiles', $obj->getLinkedFiles())->setRecord($obj);
182			$field->setSubmittedValue($data);
183			$field->saveInto($obj);
184			$obj->write();
185
186			$this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $obj->LinkedFiles()->sort('SortOrder')->column('Title'));
187			$this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $field->getItems()->column('Title'));
188
189			$linkObjs = FileLinkDataObject::get()->filter('OwnerID', $obj->ID);
190			$this->assertEquals(4, $linkObjs->count());
191
192			$titles = [];
193			foreach ($linkObjs as $linkObj) {
194			$titles[] = $linkObj->File()->Title;
195			}
196
197			$this->assertEquals(['FileD', 'FileB', 'FileA', 'FileC'], $titles);
198			}
199			}
200

bummzack / sortablefile

Pull Request — master (#53)

testExistingSortOrderForManyManyThroughList() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like