silverstripe-framework/tests/php/ORM/ArrayListTest.php
Sam Minnee 4740346ed8 FIX: Make ArrayList::limit() consistent with DataList::limit()
This makes it easier to swap one fo the other without code breaking.
Since it’s strictly a removed API, I’ve opted to throw a deprecation
note in SS4 rather than throwing an InvalidArgumentException.

Fixes #2949
2018-10-11 21:05:20 +13:00

1228 lines
38 KiB
PHP

<?php
namespace SilverStripe\ORM\Tests;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\Filterable;
use SilverStripe\Dev\SapphireTest;
use SilverStripe\View\ArrayData;
use SilverStripe\Dev\Deprecation;
use stdClass;
class ArrayListTest extends SapphireTest
{
public function testPushOperator()
{
$list = new ArrayList(
array(
array('Num' => 1)
)
);
$list[] = array('Num' => 2);
$this->assertEquals(2, count($list));
$this->assertEquals(array('Num' => 2), $list->last());
$list[] = array('Num' => 3);
$this->assertEquals(3, count($list));
$this->assertEquals(array('Num' => 3), $list->last());
}
public function testArrayAccessExists()
{
$list = new ArrayList(
array(
$one = new DataObject(array('Title' => 'one')),
$two = new DataObject(array('Title' => 'two')),
$three = new DataObject(array('Title' => 'three'))
)
);
$this->assertEquals(count($list), 3);
$this->assertTrue(isset($list[0]), 'First item in the set is set');
$this->assertEquals($one, $list[0], 'First item in the set is accessible by array notation');
}
public function testArrayAccessUnset()
{
$list = new ArrayList(
array(
$one = new DataObject(array('Title' => 'one')),
$two = new DataObject(array('Title' => 'two')),
$three = new DataObject(array('Title' => 'three'))
)
);
unset($list[0]);
$this->assertEquals(count($list), 2);
}
public function testArrayAccessSet()
{
$list = new ArrayList();
$this->assertEquals(0, count($list));
$list['testing!'] = $test = new DataObject(array('Title' => 'I\'m testing!'));
$this->assertEquals($test, $list['testing!'], 'Set item is accessible by the key we set it as');
}
public function testCount()
{
$list = new ArrayList();
$this->assertEquals(0, $list->count());
$list = new ArrayList(array(1, 2, 3));
$this->assertEquals(3, $list->count());
}
public function testExists()
{
$list = new ArrayList();
$this->assertFalse($list->exists());
$list = new ArrayList(array(1, 2, 3));
$this->assertTrue($list->exists());
}
public function testToNestedArray()
{
$list = new ArrayList(
array(
array('First' => 'FirstFirst', 'Second' => 'FirstSecond'),
(object) array('First' => 'SecondFirst', 'Second' => 'SecondSecond'),
new ArrayListTest\TestObject('ThirdFirst', 'ThirdSecond')
)
);
$this->assertEquals(
$list->toNestedArray(),
array(
array('First' => 'FirstFirst', 'Second' => 'FirstSecond'),
array('First' => 'SecondFirst', 'Second' => 'SecondSecond'),
array('First' => 'ThirdFirst', 'Second' => 'ThirdSecond')
)
);
}
public function testEach()
{
$list = new ArrayList(array(1, 2, 3));
$count = 0;
$test = $this;
$list->each(
function ($item) use (&$count, $test) {
$count++;
$test->assertTrue(is_int($item));
}
);
$this->assertEquals($list->Count(), $count);
}
public function testLimit()
{
$list = new ArrayList(
array(
array('Key' => 1), array('Key' => 2), array('Key' => 3)
)
);
$this->assertEquals(
$list->limit(2, 1)->toArray(),
array(
array('Key' => 2), array('Key' => 3)
)
);
}
/**
* @expectedException PHPUnit_Framework_Error
*/
public function testZeroLimit()
{
Deprecation::notification_version('4.3.0');
$list = new ArrayList([
['Key' => 1],
['Key' => 2],
]);
$list->limit(0);
}
public function testAddRemove()
{
$list = new ArrayList(
array(
array('Key' => 1), array('Key' => 2)
)
);
$list->add(array('Key' => 3));
$this->assertEquals(
$list->toArray(),
array(
array('Key' => 1), array('Key' => 2), array('Key' => 3)
)
);
$list->remove(array('Key' => 2));
$this->assertEquals(
array_values($list->toArray()),
array(
array('Key' => 1), array('Key' => 3)
)
);
}
public function testReplace()
{
$list = new ArrayList(
array(
array('Key' => 1),
$two = (object) array('Key' => 2),
(object) array('Key' => 3)
)
);
$this->assertEquals(array('Key' => 1), $list[0]);
$list->replace(array('Key' => 1), array('Replaced' => 1));
$this->assertEquals(3, count($list));
$this->assertEquals(array('Replaced' => 1), $list[0]);
$this->assertEquals($two, $list[1]);
$list->replace($two, array('Replaced' => 2));
$this->assertEquals(3, count($list));
$this->assertEquals(array('Replaced' => 2), $list[1]);
}
public function testMerge()
{
$list = new ArrayList(
array(
array('Num' => 1), array('Num' => 2)
)
);
$list->merge(
array(
array('Num' => 3), array('Num' => 4)
)
);
$this->assertEquals(4, count($list));
$this->assertEquals(
$list->toArray(),
array(
array('Num' => 1), array('Num' => 2), array('Num' => 3), array('Num' => 4)
)
);
}
public function testRemoveDuplicates()
{
$list = new ArrayList(
array(
array('ID' => 1, 'Field' => 1),
array('ID' => 2, 'Field' => 2),
array('ID' => 3, 'Field' => 3),
array('ID' => 4, 'Field' => 1),
(object) array('ID' => 5, 'Field' => 2)
)
);
$this->assertEquals(5, count($list));
$list->removeDuplicates();
$this->assertEquals(5, count($list));
$list->removeDuplicates('Field');
$this->assertEquals(3, count($list));
$this->assertEquals(array(1, 2, 3), $list->column('Field'));
$this->assertEquals(array(1, 2, 3), $list->column('ID'));
}
public function testPushPop()
{
$list = new ArrayList(array('Num' => 1));
$this->assertEquals(1, count($list));
$list->push(array('Num' => 2));
$this->assertEquals(2, count($list));
$this->assertEquals(array('Num' => 2), $list->last());
$list->push(array('Num' => 3));
$this->assertEquals(3, count($list));
$this->assertEquals(array('Num' => 3), $list->last());
$this->assertEquals(array('Num' => 3), $list->pop());
$this->assertEquals(2, count($list));
$this->assertEquals(array('Num' => 2), $list->last());
}
public function testShiftUnshift()
{
$list = new ArrayList(array('Num' => 1));
$this->assertEquals(1, count($list));
$list->unshift(array('Num' => 2));
$this->assertEquals(2, count($list));
$this->assertEquals(array('Num' => 2), $list->first());
$list->unshift(array('Num' => 3));
$this->assertEquals(3, count($list));
$this->assertEquals(array('Num' => 3), $list->first());
$this->assertEquals(array('Num' => 3), $list->shift());
$this->assertEquals(2, count($list));
$this->assertEquals(array('Num' => 2), $list->first());
}
public function testFirstLast()
{
$list = new ArrayList(
array(
array('Key' => 1), array('Key' => 2), array('Key' => 3)
)
);
$this->assertEquals($list->first(), array('Key' => 1));
$this->assertEquals($list->last(), array('Key' => 3));
}
public function testMap()
{
$list = new ArrayList(
array(
array('ID' => 1, 'Name' => 'Steve',),
(object) array('ID' => 3, 'Name' => 'Bob'),
array('ID' => 5, 'Name' => 'John')
)
);
$map = $list->map('ID', 'Name');
// Items added after calling map should not be included retroactively
$list->add(array('ID' => 7, 'Name' => 'Andrew'));
$this->assertInstanceOf('SilverStripe\\ORM\\Map', $map);
$this->assertEquals(
array(
1 => 'Steve',
3 => 'Bob',
5 => 'John'
),
$map->toArray()
);
}
public function testFind()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$this->assertEquals(
$list->find('Name', 'Bob'),
(object) array(
'Name' => 'Bob'
)
);
}
public function testColumn()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$this->assertEquals(
$list->column('Name'),
array(
'Steve', 'Bob', 'John'
)
);
}
public function testSortSimpleDefaultIsSortedASC()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'bonny'),
)
);
// Unquoted name
$list1 = $list->sort('Name');
$this->assertEquals(
array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'John'),
array('Name' => 'Steve'),
),
$list1->toArray()
);
// Quoted name name
$list2 = $list->sort('"Name"');
$this->assertEquals(
array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'John'),
array('Name' => 'Steve'),
),
$list2->toArray()
);
// Array (non-associative)
$list3 = $list->sort(array('"Name"'));
$this->assertEquals(
array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'John'),
array('Name' => 'Steve'),
),
$list3->toArray()
);
// Quoted name name with table
$list4 = $list->sort('"Record"."Name"');
$this->assertEquals(
array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'John'),
array('Name' => 'Steve')
),
$list4->toArray()
);
// Quoted name name with table (desc)
$list5 = $list->sort('"Record"."Name" DESC');
$this->assertEquals(
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
array('Name' => 'bonny'),
(object) array('Name' => 'Bob')
),
$list5->toArray()
);
// Table without quotes
$list6 = $list->sort('Record.Name');
$this->assertEquals(
array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'John'),
array('Name' => 'Steve')
),
$list6->toArray()
);
// Check original list isn't altered
$this->assertEquals(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'bonny'),
),
$list->toArray()
);
}
public function testMixedCaseSort()
{
// Note: Natural sorting is not expected, so if 'bonny10' were included
// below we would expect it to appear between bonny1 and bonny2. That's
// undesirable though so we're not enforcing it in tests.
$original = array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'bonny'),
array('Name' => 'bonny1'),
//array('Name' => 'bonny10'),
array('Name' => 'bonny2'),
);
$list = new ArrayList($original);
$expected = array(
(object) array('Name' => 'Bob'),
array('Name' => 'bonny'),
array('Name' => 'bonny1'),
//array('Name' => 'bonny10'),
array('Name' => 'bonny2'),
array('Name' => 'John'),
array('Name' => 'Steve'),
);
// Unquoted name
$list1 = $list->sort('Name');
$this->assertEquals($expected, $list1->toArray());
// Quoted name name
$list2 = $list->sort('"Name"');
$this->assertEquals($expected, $list2->toArray());
// Array (non-associative)
$list3 = $list->sort(array('"Name"'));
$this->assertEquals($expected, $list3->toArray());
// Check original list isn't altered
$this->assertEquals($original, $list->toArray());
}
public function testSortSimpleASCOrder()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
// Sort two arguments
$list1 = $list->sort('Name', 'ASC');
$this->assertEquals(
$list1->toArray(),
array(
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'Steve')
)
);
// Sort single string
$list2 = $list->sort('Name asc');
$this->assertEquals(
$list2->toArray(),
array(
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'Steve')
)
);
// Sort quoted string
$list3 = $list->sort('"Name" ASCENDING');
$this->assertEquals(
$list3->toArray(),
array(
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'Steve')
)
);
// Sort array specifier
$list4 = $list->sort(array('Name' => 'ascending'));
$this->assertEquals(
$list4->toArray(),
array(
(object) array('Name' => 'Bob'),
array('Name' => 'John'),
array('Name' => 'Steve')
)
);
// Check original list isn't altered
$this->assertEquals(
$list->toArray(),
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
}
public function testSortSimpleDESCOrder()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
// Sort two arguments
$list1 = $list->sort('Name', 'DESC');
$this->assertEquals(
$list1->toArray(),
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
(object) array('Name' => 'Bob')
)
);
// Sort single string
$list2 = $list->sort('Name desc');
$this->assertEquals(
$list2->toArray(),
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
(object) array('Name' => 'Bob')
)
);
// Sort quoted string
$list3 = $list->sort('"Name" DESCENDING');
$this->assertEquals(
$list3->toArray(),
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
(object) array('Name' => 'Bob')
)
);
// Sort array specifier
$list4 = $list->sort(array('Name' => 'descending'));
$this->assertEquals(
$list4->toArray(),
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
(object) array('Name' => 'Bob')
)
);
// Check original list isn't altered
$this->assertEquals(
$list->toArray(),
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
}
public function testSortNumeric()
{
$list = new ArrayList(
array(
array('Sort' => 0),
array('Sort' => -1),
array('Sort' => 1),
array('Sort' => -2),
array('Sort' => 2),
array('Sort' => -10),
array('Sort' => 10)
)
);
// Sort descending
$list1 = $list->sort('Sort', 'DESC');
$this->assertEquals(
array(
array('Sort' => 10),
array('Sort' => 2),
array('Sort' => 1),
array('Sort' => 0),
array('Sort' => -1),
array('Sort' => -2),
array('Sort' => -10)
),
$list1->toArray()
);
// Sort ascending
$list1 = $list->sort('Sort', 'ASC');
$this->assertEquals(
array(
array('Sort' => -10),
array('Sort' => -2),
array('Sort' => -1),
array('Sort' => 0),
array('Sort' => 1),
array('Sort' => 2),
array('Sort' => 10)
),
$list1->toArray()
);
}
public function testReverse()
{
$list = new ArrayList(
array(
array('Name' => 'John'),
array('Name' => 'Bob'),
array('Name' => 'Steve')
)
);
$list = $list->sort('Name', 'ASC');
$list = $list->reverse();
$this->assertEquals(
$list->toArray(),
array(
array('Name' => 'Steve'),
array('Name' => 'John'),
array('Name' => 'Bob')
)
);
}
public function testSimpleMultiSort()
{
$list = new ArrayList(
array(
(object) array('Name'=>'Object1', 'F1'=>1, 'F2'=>2, 'F3'=>3),
(object) array('Name'=>'Object2', 'F1'=>2, 'F2'=>1, 'F3'=>4),
(object) array('Name'=>'Object3', 'F1'=>5, 'F2'=>2, 'F3'=>2),
)
);
$list = $list->sort('F3', 'ASC');
$this->assertEquals($list->first()->Name, 'Object3', 'Object3 should be first in the list');
$this->assertEquals($list->last()->Name, 'Object2', 'Object2 should be last in the list');
$list = $list->sort('F3', 'DESC');
$this->assertEquals($list->first()->Name, 'Object2', 'Object2 should be first in the list');
$this->assertEquals($list->last()->Name, 'Object3', 'Object3 should be last in the list');
}
public function testMultiSort()
{
$list = new ArrayList(
array(
(object) array('ID'=>3, 'Name'=>'Bert', 'Importance'=>1),
(object) array('ID'=>1, 'Name'=>'Aron', 'Importance'=>2),
(object) array('ID'=>2, 'Name'=>'Aron', 'Importance'=>1),
)
);
$list = $list->sort(array('Name'=>'ASC', 'Importance'=>'ASC'));
$this->assertEquals($list->first()->ID, 2, 'Aron.2 should be first in the list');
$this->assertEquals($list->last()->ID, 3, 'Bert.3 should be last in the list');
$list = $list->sort(array('Name'=>'ASC', 'Importance'=>'DESC'));
$this->assertEquals($list->first()->ID, 1, 'Aron.2 should be first in the list');
$this->assertEquals($list->last()->ID, 3, 'Bert.3 should be last in the list');
}
/**
* Check that we don't cause recursion errors with array_multisort() and circular dependencies
*/
public function testSortWithCircularDependencies()
{
$itemA = new stdClass;
$childA = new stdClass;
$itemA->child = $childA;
$childA->parent = $itemA;
$itemA->Sort = 1;
$itemB = new stdClass;
$childB = new stdClass;
$itemB->child = $childB;
$childB->parent = $itemB;
$itemB->Sort = 1;
$items = new ArrayList;
$items->add($itemA);
$items->add($itemB);
// This call will trigger a fatal error if there are issues with circular dependencies
$items->sort('Sort');
}
/**
* $list->filter('Name', 'bob'); // only bob in the list
*/
public function testSimpleFilter()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$list = $list->filter('Name', 'Bob');
$this->assertEquals(array((object)array('Name'=>'Bob')), $list->toArray(), 'List should only contain Bob');
}
/**
* $list->filter('Name', array('Steve', 'John'); // Steve and John in list
*/
public function testSimpleFilterWithMultiple()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
(object) array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$expected = array(
array('Name' => 'Steve'),
array('Name' => 'John')
);
$list = $list->filter('Name', array('Steve','John'));
$this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and John');
}
/**
* $list->filter('Name', array('Steve', 'John'); // negative version
*/
public function testSimpleFilterWithMultipleNoMatch()
{
$list = new ArrayList(
array(
array('Name' => 'Steve', 'ID' => 1),
(object) array('Name' => 'Steve', 'ID' => 2),
array('Name' => 'John', 'ID' => 2)
)
);
$list = $list->filter(array('Name'=>'Clair'));
$this->assertEquals(array(), $list->toArray(), 'List should be empty');
}
/**
* $list->filter(array('Name'=>'bob, 'Age'=>21)); // bob with the Age 21 in list
*/
public function testMultipleFilter()
{
$list = new ArrayList(
array(
array('Name' => 'Steve', 'ID' => 1),
(object) array('Name' => 'Steve', 'ID' => 2),
array('Name' => 'John', 'ID' => 2)
)
);
$list = $list->filter(array('Name'=>'Steve', 'ID'=>2));
$this->assertEquals(
array((object)array('Name'=>'Steve', 'ID'=>2)),
$list->toArray(),
'List should only contain object Steve'
);
}
/**
* $list->filter(array('Name'=>'bob, 'Age'=>21)); // negative version
*/
public function testMultipleFilterNoMatch()
{
$list = new ArrayList(
array(
array('Name' => 'Steve', 'ID' => 1),
(object) array('Name' => 'Steve', 'ID' => 2),
array('Name' => 'John', 'ID' => 2)
)
);
$list = $list->filter(array('Name'=>'Steve', 'ID'=>4));
$this->assertEquals(array(), $list->toArray(), 'List should be empty');
}
/**
* $list->filter(array('Name'=>'Steve', 'Age'=>array(21, 43))); // Steve with the Age 21 or 43
*/
public function testMultipleWithArrayFilter()
{
$list = new ArrayList(
array(
array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
array('Name' => 'Steve', 'ID' => 2, 'Age'=>18),
array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
)
);
$list = $list->filter(array('Name'=>'Steve','Age'=>array(21, 43)));
$expected = array(
array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
);
$this->assertEquals(2, $list->count());
$this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and Steve');
}
/**
* $list->filter(array('Name'=>array('aziz','bob'), 'Age'=>array(21, 43)));
*/
public function testMultipleWithArrayFilterAdvanced()
{
$list = new ArrayList(
array(
array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
array('Name' => 'Steve', 'ID' => 2, 'Age'=>18),
array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
array('Name' => 'Clair', 'ID' => 2, 'Age'=>52),
array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
)
);
$list = $list->filter(array('Name'=>array('Steve','Clair'),'Age'=>array(21, 43)));
$expected = array(
array('Name' => 'Steve', 'ID' => 1, 'Age'=>21),
array('Name' => 'Clair', 'ID' => 2, 'Age'=>21),
array('Name' => 'Steve', 'ID' => 3, 'Age'=>43)
);
$this->assertEquals(3, $list->count());
$this->assertEquals($expected, $list->toArray(), 'List should only contain Steve and Steve and Clair');
}
public function testFilterAny()
{
$list = new ArrayList(
array(
$steve = array('Name' => 'Steve', 'ID' => 1, 'Age' => 21),
$bob = array('Name' => 'Bob', 'ID' => 2, 'Age' => 18),
$clair = array('Name' => 'Clair', 'ID' => 3, 'Age' => 21),
$phil = array('Name' => 'Phil', 'ID' => 4, 'Age' => 21),
$oscar = array('Name' => 'Oscar', 'ID' => 5, 'Age' => 52),
$mike = array('Name' => 'Mike', 'ID' => 6, 'Age' => 43),
)
);
// only bob in the list
//$list = $list->filterAny('Name', 'bob');
$filteredList = $list->filterAny('Name', 'Bob')->toArray();
$this->assertCount(1, $filteredList);
$this->assertContains($bob, $filteredList);
// azis or bob in the list
//$list = $list->filterAny('Name', array('aziz', 'bob');
$filteredList = $list->filterAny('Name', array('Aziz', 'Bob'))->toArray();
$this->assertCount(1, $filteredList);
$this->assertContains($bob, $filteredList);
$filteredList = $list->filterAny('Name', array('Steve', 'Bob'))->toArray();
$this->assertCount(2, $filteredList);
$this->assertContains($steve, $filteredList);
$this->assertContains($bob, $filteredList);
// bob or anyone aged 21 in the list
//$list = $list->filterAny(array('Name'=>'bob, 'Age'=>21));
$filteredList = $list->filterAny(array('Name' => 'Bob', 'Age' => 21))->toArray();
$this->assertCount(4, $filteredList);
$this->assertContains($bob, $filteredList);
$this->assertContains($steve, $filteredList);
$this->assertContains($clair, $filteredList);
$this->assertContains($phil, $filteredList);
// bob or anyone aged 21 or 43 in the list
// $list = $list->filterAny(array('Name'=>'bob, 'Age'=>array(21, 43)));
$filteredList = $list->filterAny(array('Name' => 'Bob', 'Age' => array(21, 43)))->toArray();
$this->assertCount(5, $filteredList);
$this->assertContains($bob, $filteredList);
$this->assertContains($steve, $filteredList);
$this->assertContains($clair, $filteredList);
$this->assertContains($mike, $filteredList);
$this->assertContains($phil, $filteredList);
// all bobs, phils or anyone aged 21 or 43 in the list
//$list = $list->filterAny(array('Name'=>array('bob','phil'), 'Age'=>array(21, 43)));
$filteredList = $list->filterAny(array('Name' => array('Bob', 'Phil'), 'Age' => array(21, 43)))->toArray();
$this->assertCount(5, $filteredList);
$this->assertContains($bob, $filteredList);
$this->assertContains($steve, $filteredList);
$this->assertContains($clair, $filteredList);
$this->assertContains($mike, $filteredList);
$this->assertContains($phil, $filteredList);
$filteredList = $list->filterAny(array('Name' => array('Bob', 'Nobody'), 'Age' => array(21, 43)))->toArray();
$this->assertCount(5, $filteredList);
$this->assertContains($bob, $filteredList);
$this->assertContains($steve, $filteredList);
$this->assertContains($clair, $filteredList);
$this->assertContains($mike, $filteredList);
$this->assertContains($phil, $filteredList);
}
/**
* $list = $list->filterByCallback(function($item, $list) { return $item->Age == 21; })
*/
public function testFilterByCallback()
{
$list = new ArrayList(
array(
$steve = array('Name' => 'Steve', 'ID' => 1, 'Age' => 21),
array('Name' => 'Bob', 'ID' => 2, 'Age' => 18),
$clair = array('Name' => 'Clair', 'ID' => 2, 'Age' => 21),
array('Name' => 'Oscar', 'ID' => 2, 'Age' => 52),
array('Name' => 'Mike', 'ID' => 3, 'Age' => 43)
)
);
$list = $list->filterByCallback(
function ($item, $list) {
return $item->Age == 21;
}
);
$this->assertEquals(2, $list->count());
$this->assertEquals($steve, $list[0]->toMap(), 'List should only contain Steve and Clair');
$this->assertEquals($clair, $list[1]->toMap(), 'List should only contain Steve and Clair');
$this->assertTrue($list instanceof Filterable, 'The List should be of type SS_Filterable');
}
/**
* $list->exclude('Name', 'bob'); // exclude bob from list
*/
public function testSimpleExclude()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$list = $list->exclude('Name', 'Bob');
$expected = array(
array('Name' => 'Steve'),
array('Name' => 'John')
);
$this->assertEquals(2, $list->count());
$this->assertEquals($expected, $list->toArray(), 'List should not contain Bob');
}
/**
* $list->exclude('Name', 'bob'); // No exclusion version
*/
public function testSimpleExcludeNoMatch()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$list = $list->exclude('Name', 'Clair');
$expected = array(
array('Name' => 'Steve'),
array('Name' => 'Bob'),
array('Name' => 'John')
);
$this->assertEquals($expected, $list->toArray(), 'List should be unchanged');
}
/**
* $list->exclude('Name', array('Steve','John'));
*/
public function testSimpleExcludeWithArray()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$list = $list->exclude('Name', array('Steve','John'));
$expected = array(array('Name' => 'Bob'));
$this->assertEquals(1, $list->count());
$this->assertEquals($expected, $list->toArray(), 'List should only contain Bob');
}
/**
* $list->exclude(array('Name'=>'bob, 'Age'=>21)); // exclude all Bob that has Age 21
*/
public function testExcludeWithTwoArrays()
{
$list = new ArrayList(
array(
array('Name' => 'Bob' , 'Age' => 21),
array('Name' => 'Bob' , 'Age' => 32),
array('Name' => 'John', 'Age' => 21)
)
);
$list = $list->exclude(array('Name' => 'Bob', 'Age' => 21));
$expected = array(
array('Name' => 'Bob', 'Age' => 32),
array('Name' => 'John', 'Age' => 21)
);
$this->assertEquals(2, $list->count());
$this->assertEquals($expected, $list->toArray(), 'List should only contain John and Bob');
}
/**
* $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16)));
*/
public function testMultipleExclude()
{
$list = new ArrayList(
array(
array('Name' => 'bob', 'Age' => 10),
array('Name' => 'phil', 'Age' => 11),
array('Name' => 'bob', 'Age' => 12),
array('Name' => 'phil', 'Age' => 12),
array('Name' => 'bob', 'Age' => 14),
array('Name' => 'phil', 'Age' => 14),
array('Name' => 'bob', 'Age' => 16),
array('Name' => 'phil', 'Age' => 16)
)
);
$list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16)));
$expected = array(
array('Name' => 'phil', 'Age' => 11),
array('Name' => 'bob', 'Age' => 12),
array('Name' => 'phil', 'Age' => 12),
array('Name' => 'bob', 'Age' => 14),
array('Name' => 'phil', 'Age' => 14),
);
$this->assertEquals($expected, $list->toArray());
}
/**
* $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16), 'Bananas'=>true));
*/
public function testMultipleExcludeNoMatch()
{
$list = new ArrayList(
array(
array('Name' => 'bob', 'Age' => 10),
array('Name' => 'phil', 'Age' => 11),
array('Name' => 'bob', 'Age' => 12),
array('Name' => 'phil', 'Age' => 12),
array('Name' => 'bob', 'Age' => 14),
array('Name' => 'phil', 'Age' => 14),
array('Name' => 'bob', 'Age' => 16),
array('Name' => 'phil', 'Age' => 16)
)
);
$list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16),'Bananas'=>true));
$expected = array(
array('Name' => 'bob', 'Age' => 10),
array('Name' => 'phil', 'Age' => 11),
array('Name' => 'bob', 'Age' => 12),
array('Name' => 'phil', 'Age' => 12),
array('Name' => 'bob', 'Age' => 14),
array('Name' => 'phil', 'Age' => 14),
array('Name' => 'bob', 'Age' => 16),
array('Name' => 'phil', 'Age' => 16)
);
$this->assertEquals($expected, $list->toArray());
}
/**
* $list->exclude(array('Name'=>array('bob','phil'), 'Age'=>array(10, 16), 'HasBananas'=>true));
*/
public function testMultipleExcludeThreeArguments()
{
$list = new ArrayList(
array(
array('Name' => 'bob', 'Age' => 10, 'HasBananas'=>false),
array('Name' => 'phil','Age' => 11, 'HasBananas'=>true),
array('Name' => 'bob', 'Age' => 12, 'HasBananas'=>true),
array('Name' => 'phil','Age' => 12, 'HasBananas'=>true),
array('Name' => 'bob', 'Age' => 14, 'HasBananas'=>false),
array('Name' => 'ann', 'Age' => 14, 'HasBananas'=>true),
array('Name' => 'phil','Age' => 14, 'HasBananas'=>false),
array('Name' => 'bob', 'Age' => 16, 'HasBananas'=>false),
array('Name' => 'phil','Age' => 16, 'HasBananas'=>true),
array('Name' => 'clair','Age' => 16, 'HasBananas'=>true)
)
);
$list = $list->exclude(array('Name'=>array('bob','phil'),'Age'=>array(10, 16),'HasBananas'=>true));
$expected = array(
array('Name' => 'bob', 'Age' => 10, 'HasBananas'=>false),
array('Name' => 'phil','Age' => 11, 'HasBananas'=>true),
array('Name' => 'bob', 'Age' => 12, 'HasBananas'=>true),
array('Name' => 'phil','Age' => 12, 'HasBananas'=>true),
array('Name' => 'bob', 'Age' => 14, 'HasBananas'=>false),
array('Name' => 'ann', 'Age' => 14, 'HasBananas'=>true),
array('Name' => 'phil','Age' => 14, 'HasBananas'=>false),
array('Name' => 'bob', 'Age' => 16, 'HasBananas'=>false),
array('Name' => 'clair','Age' => 16, 'HasBananas'=>true)
);
$this->assertEquals($expected, $list->toArray());
}
public function testCanFilterBy()
{
$list = new ArrayList(
array(
array('Name' => 'Steve'),
array('Name' => 'Bob'),
array('Name' => 'John')
)
);
$this->assertTrue($list->canFilterBy('Name'));
$this->assertFalse($list->canFilterBy('Age'));
}
public function testCanFilterByEmpty()
{
$list = new ArrayList();
$this->assertFalse($list->canFilterBy('Name'));
$this->assertFalse($list->canFilterBy('Age'));
}
public function testByID()
{
$list = new ArrayList(
array(
array('ID' => 1, 'Name' => 'Steve'),
array('ID' => 2, 'Name' => 'Bob'),
array('ID' => 3, 'Name' => 'John')
)
);
$element = $list->byID(1);
$this->assertEquals($element['Name'], 'Steve');
$element = $list->byID(2);
$this->assertEquals($element['Name'], 'Bob');
$element = $list->byID(4);
$this->assertNull($element);
}
public function testByIDs()
{
$list = new ArrayList(
array(
array('ID' => 1, 'Name' => 'Steve'),
array('ID' => 2, 'Name' => 'Bob'),
array('ID' => 3, 'Name' => 'John')
)
);
$knownIDs = $list->column('ID');
$removedID = array_pop($knownIDs);
$filteredItems = $list->byIDs($knownIDs);
foreach ($filteredItems as $item) {
$this->assertContains($item->ID, $knownIDs);
$this->assertNotEquals($removedID, $item->ID);
}
}
public function testByIDEmpty()
{
$list = new ArrayList();
$element = $list->byID(1);
$this->assertNull($element);
}
}