302 lines
8.7 KiB
PHP
302 lines
8.7 KiB
PHP
<?php
|
|
|
|
namespace Tests\Unit\Memory;
|
|
|
|
use XaiCorp\AbcParser\Models\Memory\Person;
|
|
use XaiCorp\AbcParser\Models\Memory\Setting;
|
|
use XaiCorp\AbcParser\Models\Memory\Tune;
|
|
use Codeception\TestCase\Test as TestCase;
|
|
|
|
/**
|
|
* @group Lib
|
|
* @group Unit
|
|
*/
|
|
class TuneTest extends TestCase
|
|
{
|
|
private $tune;
|
|
|
|
public function setUp()
|
|
{
|
|
$this->tune = new Tune();
|
|
}
|
|
|
|
/**
|
|
* test the model contains the correct attributes
|
|
*/
|
|
public function testModelDefinition()
|
|
{
|
|
//Private attributes, probably shouldn't be tested
|
|
$this->assertClassHasAttribute('tuneID', Tune::class);
|
|
$this->assertClassHasAttribute('A', Tune::class);
|
|
$this->assertClassHasAttribute('C', Tune::class);
|
|
$this->assertClassHasAttribute('T', Tune::class);
|
|
$this->assertClassHasAttribute('G', Tune::class);
|
|
$this->assertClassHasAttribute('O', Tune::class);
|
|
$this->assertClassHasAttribute('R', Tune::class);
|
|
$this->assertClassHasAttribute('H', Tune::class);
|
|
$this->assertClassHasAttribute('X', Tune::class);
|
|
$this->assertClassHasAttribute('propertyNames', Tune::class);
|
|
}
|
|
|
|
|
|
/**
|
|
* test the set property method
|
|
*
|
|
* @param (string) $property, the name of the property to set
|
|
* @param (mixed) value to set
|
|
* @param (Boolean) expected value for return value of set method
|
|
*
|
|
* @dataProvider providerSet
|
|
*/
|
|
public function testSet($property, $value, $expected)
|
|
{
|
|
$success = $this->tune->set($property, $value);
|
|
$this->assertEquals($expected, $success);
|
|
if ($success) {
|
|
$this->assertEquals($value, $this->tune->get($property));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* test the set property method
|
|
*
|
|
* @param (string) $property, the name of the property to set
|
|
* @param (mixed) value to set
|
|
* @param (Boolean) expected value for return value of set method
|
|
*
|
|
* @dataProvider providerSet
|
|
*/
|
|
public function testMagicSetter($property, $value, $expected)
|
|
{
|
|
$this->tune->$property = $value;
|
|
// $this->assertEquals($expected, $success);
|
|
if ($expected) {
|
|
$this->assertEquals($value, $this->tune->get($property));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dataProvider providerSet
|
|
*/
|
|
public function testConstruct($property, $value, $expected)
|
|
{
|
|
$params = [$property => $value];
|
|
$this->tune = new Tune($params);
|
|
|
|
if ($expected) {
|
|
$this->assertEquals($value, $this->tune->get($property));
|
|
}
|
|
}
|
|
|
|
public function providerSet()
|
|
{
|
|
return [
|
|
['Y', 'anything', false],
|
|
['x', 1, false],
|
|
['X', 1, true],
|
|
['X', 'aplha', false],
|
|
['X', '2', true],
|
|
['T', 'string', false],
|
|
['T', 10, false],
|
|
['T', ['1', '2'], true],
|
|
['A', 10, false],
|
|
['A', ['1', '2'], false],
|
|
['A', [new Person(), new Person()], true],
|
|
['C', 10, false],
|
|
['C', ['1', '2'], false],
|
|
['C', [new Person(), new Person()], true],
|
|
['G', 10, false],
|
|
['G', ['1', '2'], true],
|
|
['H', 10, false],
|
|
['H', ['1', '2'], true],
|
|
['O', 10, false],
|
|
['O', ['1', '2'], true],
|
|
['R', 10, false],
|
|
['R', ['1', '2'], true],
|
|
['collection', 10, false],
|
|
['collection', '10', false],
|
|
['collection', [], false],
|
|
['collection', ['1', '2'], false],
|
|
['collection', [new Setting()], true],
|
|
['tuneHash', 10, false],
|
|
['tuneHash', '10', false],
|
|
['tuneHash', [], false],
|
|
['tuneHash', ['1', '2'], false],
|
|
['tuneID', 'abc', false],
|
|
['tuneID', '11', true],
|
|
['tuneID', 15, true],
|
|
];
|
|
}
|
|
|
|
public function testSetTuneID()
|
|
{
|
|
//we should start with tuneID = 0
|
|
$this->assertEquals(0, $this->tune->get('tuneID'), 'should start at 0');
|
|
|
|
//because tuneID == 0 we can change value
|
|
$this->tune->set('tuneID', 4);
|
|
$this->assertEquals(4, $this->tune->get('tuneID'), 'should have changed to 4');
|
|
|
|
//tuneID is not 0 so we cannot change value
|
|
$this->tune->set('tuneID', 11);
|
|
$this->assertEquals(4, $this->tune->get('tuneID'), 'should not have changed from 4');
|
|
}
|
|
|
|
|
|
/**
|
|
* test the append value method
|
|
*
|
|
* @param (string) $property, the name of the property to set
|
|
* @param (mixed) value to append
|
|
* @param (Boolean) expected value for return value of append method
|
|
*
|
|
* @dataProvider providerAppend
|
|
*/
|
|
public function testAppend($property, $value, $expected)
|
|
{
|
|
$success = $this->tune->append($property, $value);
|
|
$this->assertEquals($expected, $success);
|
|
if ($success) {
|
|
$this->assertContains($value, $this->tune->get($property));
|
|
}
|
|
}
|
|
|
|
public function providerAppend()
|
|
{
|
|
return [
|
|
['Y', 1, false],
|
|
['X', 1, false],
|
|
['T', 'title', true],
|
|
['T', ['of', 'titles'], false],
|
|
['A', 'author', true],
|
|
['C', 'composer', true],
|
|
['G', 'Group', true],
|
|
['H', 'history', true],
|
|
['O', 'Origin', true],
|
|
['R', 'Rhythm', true],
|
|
['collection', 'setting', false],
|
|
['collection', new Setting(), true],
|
|
['collection', [new Setting()], false],
|
|
['tuneHash', 'tuneHash', false],
|
|
['tuneHash', new Setting(), false],
|
|
['tuneHash', [new Setting()], false],
|
|
];
|
|
}
|
|
|
|
|
|
/**
|
|
* test the static function equals
|
|
* returns true if the data properties of 2 Abc_Tunes
|
|
* are identical
|
|
*
|
|
* @param (array) $params list of properties to set on the objects
|
|
* @param (boolean) $expected result of running equals
|
|
*
|
|
* @dataProvider providerEquals
|
|
*/
|
|
public function testEquals($params)
|
|
{
|
|
// $this->markTestIncomplete();
|
|
|
|
$ob1 = new Tune();
|
|
$ob2 = new Tune();
|
|
|
|
foreach ($params as $key => $val) {
|
|
if (is_array($ob1->get($key))) {
|
|
$ob1->append($key, $val);
|
|
$ob2->append($key, $val);
|
|
} else {
|
|
$ob1->set($key, $val);
|
|
$ob2->set($key, $val);
|
|
}
|
|
}
|
|
|
|
$this->assertTrue(Tune::equals($ob1, $ob2));
|
|
}
|
|
|
|
/**
|
|
* test the static function equals
|
|
* returns true if the data properties of 2 Abc_Tunes
|
|
* are identical
|
|
*
|
|
* @param (array) $params list of properties to set on the objects
|
|
* @param (boolean) $expected result of running equals
|
|
*
|
|
* @dataProvider providerEquals
|
|
*/
|
|
public function testEqualsFails($params)
|
|
{
|
|
$ob1 = new Tune();
|
|
$ob2 = new Tune();
|
|
|
|
foreach ($params as $key => $val) {
|
|
if ($key === 'collection') {
|
|
$ob1->set($key, $val);
|
|
} elseif (is_array($ob1->get($key))) {
|
|
$ob1->append($key, $val);
|
|
} else {
|
|
$ob1->set($key, $val);
|
|
}
|
|
}
|
|
$this->assertFalse(Tune::equals($ob1, $ob2));
|
|
}
|
|
|
|
public function providerEquals()
|
|
{
|
|
$setting1 = new Setting(['settingID' => 5, 'tuneID' => 444]);
|
|
$setting2 = new Setting(['settingID' => 3, 'tuneID' => 2244]);
|
|
return [
|
|
[['X' => '2']],
|
|
[['T' => 'a title']],
|
|
[['A' => 'an author']],
|
|
[['C' => 'a composer']],
|
|
[['G' => 'a group']],
|
|
[['H' => 'some history']],
|
|
[['O' => 'Plymouth']],
|
|
[['R' => 'Jig']],
|
|
[['collection' => [$setting1, $setting2]]],
|
|
];
|
|
}
|
|
|
|
|
|
public function testIsChanged()
|
|
{
|
|
$tune = new Tune();
|
|
|
|
$this->assertInstanceOf(Tune::class, $tune);
|
|
|
|
$this->assertFalse($tune->is_changed(), 'after load should be no changes');
|
|
|
|
$tune->set('X', '5');
|
|
$this->assertTrue($tune->is_changed(), 'updating the name changes the data');
|
|
}
|
|
|
|
/**
|
|
* @dataProvider providerGet
|
|
*/
|
|
public function testGet($key, $expected)
|
|
{
|
|
$result = $this->tune->set($key, $expected);
|
|
$result = $this->tune->get($key);
|
|
$this->assertEquals($expected, $result);
|
|
}
|
|
|
|
public function providerGet()
|
|
{
|
|
return [
|
|
['', false],
|
|
['me', false],
|
|
['tuneID', 2],
|
|
['X', '2'],
|
|
['T', ['1', '2']],
|
|
['A', [new Person(), new Person()]],
|
|
['C', [new Person(), new Person()]],
|
|
['G', ['1', '2']],
|
|
['H', ['1', '2']],
|
|
['O', ['1', '2']],
|
|
['R', ['1', '2']],
|
|
['collection', [new Setting()]],
|
|
];
|
|
}
|
|
}
|