initial commit

tests/_bootstrap.php

@@ -0,0 +1,4 @@
+<?php
+// This is global bootstrap for autoloading
+
+include_once 'vendor/autoload.php';

tests/_data/abc/valid_abc_1.abc

@@ -0,0 +1,9 @@
+
+    //blank first line means this isn't a file header anymore!
+A: trad
+B: Traditional English tunes
+C: trad.
+X:3
+M:4/4
+K:C
+gaab babc :|

tests/_data/abc/valid_abc_2.abc

@@ -0,0 +1,28 @@
+
+X:40
+T:Abbotts Bromley Horn Dance
+A: trad
+C: trad.
+D: None
+G:lute
+H: Thousand year old tradition
+The Horns live in the church and are removed for the dance once a year
+R:Jig
+F:none.abc
+B: Traditional English tunes
+W:None
+Q:1/8=80
+L:1/8
+M:6/8
+N:Traditional English
+O:England
+Z:Andy Hornby
+%%TUNEURL: http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+%%ID:00000dab
+S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+P:ABC
+K:G
+e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]

tests/_data/abc/valid_abc_3.abc

@@ -0,0 +1,19 @@
+A: trad
+B: Traditional English tunes
+C: trad.
+D: None
+F:none.abc
+H: Thousand year old tradition
+The Horns live in the church and are removed for the dance once a year
+L:1/8
+M:6/8
+N:Traditional English
+O:England
+R:Jig
+S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+Z:Andy Hornby
+
+X:3
+M:4/4
+K:C
+gaab babc :|

tests/_data/dump.sql

@@ -0,0 +1 @@
+/* Replace this file with actual dump of your database */

tests/_support/AcceptanceTester.php

@@ -0,0 +1,26 @@
+<?php
+
+
+/**
+ * Inherited Methods
+ * @method void wantToTest($text)
+ * @method void wantTo($text)
+ * @method void execute($callable)
+ * @method void expectTo($prediction)
+ * @method void expect($prediction)
+ * @method void amGoingTo($argumentation)
+ * @method void am($role)
+ * @method void lookForwardTo($achieveValue)
+ * @method void comment($description)
+ * @method \Codeception\Lib\Friend haveFriend($name, $actorClass = NULL)
+ *
+ * @SuppressWarnings(PHPMD)
+*/
+class AcceptanceTester extends \Codeception\Actor
+{
+    use _generated\AcceptanceTesterActions;
+
+   /**
+    * Define custom actions here
+    */
+}

tests/_support/FunctionalTester.php

@@ -0,0 +1,26 @@
+<?php
+
+
+/**
+ * Inherited Methods
+ * @method void wantToTest($text)
+ * @method void wantTo($text)
+ * @method void execute($callable)
+ * @method void expectTo($prediction)
+ * @method void expect($prediction)
+ * @method void amGoingTo($argumentation)
+ * @method void am($role)
+ * @method void lookForwardTo($achieveValue)
+ * @method void comment($description)
+ * @method \Codeception\Lib\Friend haveFriend($name, $actorClass = NULL)
+ *
+ * @SuppressWarnings(PHPMD)
+*/
+class FunctionalTester extends \Codeception\Actor
+{
+    use _generated\FunctionalTesterActions;
+
+   /**
+    * Define custom actions here
+    */
+}

tests/_support/Helper/Acceptance.php

@@ -0,0 +1,10 @@
+<?php
+namespace Helper;
+
+// here you can define custom actions
+// all public methods declared in helper class will be available in $I
+
+class Acceptance extends \Codeception\Module
+{
+
+}

tests/_support/Helper/ExtraAsserts.php

@@ -0,0 +1,36 @@
+<?php
+namespace Helper;
+
+// here you can define custom actions
+// all public methods declared in helper class will be available in $I
+
+use Illuminate\Database\Eloquent\Model;
+
+class ExtraAsserts extends \Codeception\Module
+{
+
+    /**
+     * @param string $expected
+     * @param mixed $actual
+     * @param string $message
+     */
+    public function assertInstanceOf($expected, $actual, $message = '')
+    {
+        \PHPUnit_Framework_Assert::assertInstanceOf($expected, $actual, $message);
+    }
+
+    public function assertCanSave(Model $model)
+    {
+        \PHPUnit_Framework_Assert::assertTrue($model->save(), json_encode($model->getMessages()));
+    }
+
+    public function assertCanNotSave(Model $model, $message = '')
+    {
+        \PHPUnit_Framework_Assert::assertNotTrue($model->save(), $message);
+    }
+
+    public function haveNotFinishedTest()
+    {
+        \PHPUnit_Framework_Assert::markTestIncomplete();
+    }
+}

tests/_support/Helper/Functional.php

@@ -0,0 +1,10 @@
+<?php
+namespace Helper;
+
+// here you can define custom actions
+// all public methods declared in helper class will be available in $I
+
+class Functional extends \Codeception\Module
+{
+
+}

tests/_support/Helper/Unit.php

@@ -0,0 +1,10 @@
+<?php
+namespace Helper;
+
+// here you can define custom actions
+// all public methods declared in helper class will be available in $I
+
+class Unit extends \Codeception\Module
+{
+
+}

tests/_support/UnitTester.php

@@ -0,0 +1,26 @@
+<?php
+
+
+/**
+ * Inherited Methods
+ * @method void wantToTest($text)
+ * @method void wantTo($text)
+ * @method void execute($callable)
+ * @method void expectTo($prediction)
+ * @method void expect($prediction)
+ * @method void amGoingTo($argumentation)
+ * @method void am($role)
+ * @method void lookForwardTo($achieveValue)
+ * @method void comment($description)
+ * @method \Codeception\Lib\Friend haveFriend($name, $actorClass = NULL)
+ *
+ * @SuppressWarnings(PHPMD)
+*/
+class UnitTester extends \Codeception\Actor
+{
+    use _generated\UnitTesterActions;
+
+   /**
+    * Define custom actions here
+    */
+}

tests/_support/_generated/UnitTesterActions.php

@@ -0,0 +1,391 @@
+<?php  //[STAMP] e5fb1777708efe70c0e9573bd3d7b4f7
+namespace _generated;
+
+// This class was automatically generated by build task
+// You should not change it manually as it will be overwritten on next build
+// @codingStandardsIgnoreFile
+
+use Codeception\Module\Asserts;
+use Helper\ExtraAsserts;
+use Helper\Unit;
+
+trait UnitTesterActions
+{
+    /**
+     * @return \Codeception\Scenario
+     */
+    abstract protected function getScenario();
+
+    
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that two variables are equal.
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertEquals()
+     */
+    public function assertEquals($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertEquals', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that two variables are not equal
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotEquals()
+     */
+    public function assertNotEquals($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotEquals', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that two variables are same
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertSame()
+     */
+    public function assertSame($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertSame', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that two variables are not same
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotSame()
+     */
+    public function assertNotSame($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotSame', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that actual is greater than expected
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertGreaterThan()
+     */
+    public function assertGreaterThan($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertGreaterThan', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * @deprecated
+     * @see \Codeception\Module\Asserts::assertGreaterThen()
+     */
+    public function assertGreaterThen($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertGreaterThen', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that actual is greater or equal than expected
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertGreaterThanOrEqual()
+     */
+    public function assertGreaterThanOrEqual($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertGreaterThanOrEqual', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * @deprecated
+     * @see \Codeception\Module\Asserts::assertGreaterThenOrEqual()
+     */
+    public function assertGreaterThenOrEqual($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertGreaterThenOrEqual', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that actual is less than expected
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertLessThan()
+     */
+    public function assertLessThan($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertLessThan', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that actual is less or equal than expected
+     *
+     * @param        $expected
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertLessThanOrEqual()
+     */
+    public function assertLessThanOrEqual($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertLessThanOrEqual', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that haystack contains needle
+     *
+     * @param        $needle
+     * @param        $haystack
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertContains()
+     */
+    public function assertContains($needle, $haystack, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertContains', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that haystack doesn't contain needle.
+     *
+     * @param        $needle
+     * @param        $haystack
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotContains()
+     */
+    public function assertNotContains($needle, $haystack, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotContains', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that string match with pattern
+     *
+     * @param string $pattern
+     * @param string $string
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertRegExp()
+     */
+    public function assertRegExp($pattern, $string, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertRegExp', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that string not match with pattern
+     *
+     * @param string $pattern
+     * @param string $string
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotRegExp()
+     */
+    public function assertNotRegExp($pattern, $string, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotRegExp', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that variable is empty.
+     *
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertEmpty()
+     */
+    public function assertEmpty($actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertEmpty', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that variable is not empty.
+     *
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotEmpty()
+     */
+    public function assertNotEmpty($actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotEmpty', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that variable is NULL
+     *
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNull()
+     */
+    public function assertNull($actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNull', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that variable is not NULL
+     *
+     * @param        $actual
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertNotNull()
+     */
+    public function assertNotNull($actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertNotNull', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that condition is positive.
+     *
+     * @param        $condition
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertTrue()
+     */
+    public function assertTrue($condition, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertTrue', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks that condition is negative.
+     *
+     * @param        $condition
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertFalse()
+     */
+    public function assertFalse($condition, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertFalse', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks if file exists
+     *
+     * @param string $filename
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertFileExists()
+     */
+    public function assertFileExists($filename, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertFileExists', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Checks if file doesn't exist
+     *
+     * @param string $filename
+     * @param string $message
+     * @see \Codeception\Module\Asserts::assertFileNotExists()
+     */
+    public function assertFileNotExists($filename, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertFileNotExists', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * Fails the test with message.
+     *
+     * @param $message
+     * @see \Codeception\Module\Asserts::fail()
+     */
+    public function fail($message) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('fail', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     * @param string $expected
+     * @param mixed $actual
+     * @param string $message
+     * @see \Helper\ExtraAsserts::assertInstanceOf()
+     */
+    public function assertInstanceOf($expected, $actual, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertInstanceOf', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     *
+     * @see \Helper\ExtraAsserts::assertCanSave()
+     */
+    public function assertCanSave($model) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertCanSave', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     *
+     * @see \Helper\ExtraAsserts::assertCanNotSave()
+     */
+    public function assertCanNotSave($model, $message = null) {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('assertCanNotSave', func_get_args()));
+    }
+
+ 
+    /**
+     * [!] Method is generated. Documentation taken from corresponding module.
+     *
+     *
+     * @see \Helper\ExtraAsserts::haveNotFinishedTest()
+     */
+    public function haveNotFinishedTest() {
+        return $this->getScenario()->runStep(new \Codeception\Step\Action('haveNotFinishedTest', func_get_args()));
+    }
+}

tests/acceptance.suite.yml

@@ -0,0 +1,12 @@
+# Codeception Test Suite Configuration
+#
+# Suite for acceptance tests.
+# Perform tests in browser using the WebDriver or PhpBrowser.
+# If you need both WebDriver and PHPBrowser tests - create a separate suite.
+
+class_name: AcceptanceTester
+modules:
+    enabled:
+        - PhpBrowser:
+            url: http://localhost/myapp
+        - \Helper\Acceptance

tests/acceptance/_bootstrap.php

@@ -0,0 +1,2 @@
+<?php
+// Here you can initialize variables that will be available to your tests

tests/functional.suite.yml

@@ -0,0 +1,13 @@
+# Codeception Test Suite Configuration
+#
+# Suite for functional (integration) tests
+# Emulate web requests and make application process them
+# Include one of framework modules (Symfony2, Yii2, Laravel5) to use it
+
+class_name: FunctionalTester
+modules:
+    enabled:
+        # add framework module here
+        - \Helper\Functional
+        - Laravel5:
+          environment_file: .env.testing

tests/functional/_bootstrap.php

@@ -0,0 +1,2 @@
+<?php
+// Here you can initialize variables that will be available to your tests

tests/functional/laravel5/AbcParserCest.php

@@ -0,0 +1,160 @@
+<?php
+namespace laravel5;
+
+use \UnitTester;
+use \Codeception\Util\Stub;
+use XaiCorp\AbcParser\Models\Laravel5\Abc;
+use XaiCorp\AbcParser\Parser;
+use XaiCorp\AbcParser\Interfaces\Builder;
+//use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+
+
+class AbcParserCest
+{
+//    use TestHelperTrait;
+
+    /**
+     * @var string
+     */
+    protected $dataDir;
+
+    /**
+     * @var \XaiCorp\AbcParser\Interfaces\Builder
+     */
+    protected $builder;
+
+    /**
+     * @var Parser;
+     */
+    protected $parser;
+
+    public function __construct()
+    {
+        $this->dataDir = codecept_data_dir();
+    }
+
+    public function _before(UnitTester $I)
+    {
+        $this->builder = new Abc();
+    }
+
+    public function _after(UnitTester $I)
+    {
+        unset($builder);
+    }
+
+    // tests: trying to...
+    public function createParser(UnitTester $I)
+    {
+        $parser = new Parser($this->builder);
+        
+        $I->assertInstanceOf(Parser::class, $parser);
+    }
+
+    public function seeParseEmptyAbcWithoutErrors(UnitTester $I)
+    {
+        $abc = '';
+        $parser = new Parser($this->builder);
+
+        $result = $parser->parseABC($abc);
+        $I->assertEmpty($result);
+    }
+
+    public function seeParseABCExample1(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_1.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+
+    public function seeParseABCExample2(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_2.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '40',
+                'T' => ['Abbotts Bromley Horn Dance'],
+                'A' => ['trad'],
+                'C' => ['trad.'],
+                'D' => ['None'],
+                'G' => ['lute'],
+                'H' => [
+                    'Thousand year old tradition',
+                    'The Horns live in the church and are removed for the dance once a year'
+                ],
+                'R' => ['Jig'],
+                'F' => ['none.abc'],
+                'B' => ['Traditional English tunes'],
+                'W' => ['None'],
+                'Q' => '1/8=80',
+                'L' => '1/8',
+                'M' => '6/8',
+                'N' => ['Traditional English'],
+                'O' => ['England'],
+                'Z' => ['Andy Hornby'],
+                'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+                'P' => 'ABC',
+                'K' => 'G',
+                'music' => 'e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+
+
+    public function seeParseABCExample3(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_3.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+                'A' => ['trad'],
+                'C' => ['trad.'],
+                'D' => ['None'],
+                'H' => [
+                    'Thousand year old tradition',
+                    'The Horns live in the church and are removed for the dance once a year'
+                ],
+                'R' => ['Jig'],
+                'F' => ['none.abc'],
+                'B' => ['Traditional English tunes'],
+                'L' => '1/8',
+                'M' => '6/8',
+                'N' => ['Traditional English'],
+                'O' => ['England'],
+                'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+                'Z' => ['Andy Hornby'],
+
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ]
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+}

tests/functional/laravel5/CollectionCest.php

@@ -0,0 +1,20 @@
+<?php
+namespace laravel5;
+
+use \FunctionalTester;
+
+class CollectionCest
+{
+    public function _before(FunctionalTester $I)
+    {
+    }
+
+    public function _after(FunctionalTester $I)
+    {
+    }
+
+    // tests
+    public function tryToTest(FunctionalTester $I)
+    {
+    }
+}

tests/functional/laravel5/TuneAttributeCest.php

@@ -0,0 +1,28 @@
+<?php
+namespace laravel5;
+
+use \FunctionalTester;
+use XaiCorp\AbcParser\Models\Laravel5\TuneAttribute;
+
+class TuneAttributeCest
+{
+    public function _before(FunctionalTester $I)
+    {
+    }
+
+    public function _after(FunctionalTester $I)
+    {
+    }
+
+    // tests: trying to...
+    public function saveModel(FunctionalTester $I)
+    {
+        $model = new TuneAttribute();
+
+        $model->tune_id = 1;
+        $model->type = 'Title';
+        $model->string = 'a title';
+        $model->ordering = 1;
+        $I->assertCanSave($model);
+    }
+}

tests/unit.suite.yml

@@ -0,0 +1,10 @@
+# Codeception Test Suite Configuration
+#
+# Suite for unit (internal) tests.
+
+class_name: UnitTester
+modules:
+    enabled:
+        - Asserts
+        - \Helper\ExtraAsserts
+        - \Helper\Unit

tests/unit/AbcParserCest.php

@@ -0,0 +1,78 @@
+<?php
+
+use \Codeception\Util\Stub;
+use \XaiCorp\AbcParser\Parser;
+use \XaiCorp\AbcParser\Interfaces\Builder;
+
+class AbcParserCest
+{
+    /**
+     * @var \XaiCorp\AbcParser\Interfaces\Builder
+     */
+    protected $builder;
+
+    /**
+     * @var Parser;
+     */
+    protected $parser;
+
+    public function _before(UnitTester $I)
+    {
+
+    }
+
+    public function _after(UnitTester $I)
+    {
+        unset($builder);
+    }
+
+    // tests: trying to...
+    public function createParser(UnitTester $I)
+    {
+        $builder = \Mockery::mock(Builder::Class)
+            ->shouldReceive('newCollection')->once()
+            ->shouldreceive('getCollection')->once()->andreturn(true)
+            ->mock();
+
+        $parser = new Parser($builder);
+        
+        $I->assertInstanceOf(Parser::class, $parser);
+    }
+
+    public function seeParseABCCallNewCollection(UnitTester $I)
+    {
+        $abc = '';
+        $builder = \Mockery::mock(Builder::Class)
+            ->shouldReceive('newCollection')->once()
+            ->shouldreceive('getCollection')->once()->andreturn(true)
+            ->mock();
+
+        $parser = new Parser($builder);
+
+        $result = $parser->parseABC($abc);
+        $I->assertTrue($result);
+    }
+
+    public function seeParseABCExample1(UnitTester $I)
+    {
+        $abc = file_get_contents(__DIR__.'/../_data/abc/valid_abc_1.abc');
+        $builder = \Mockery::mock(Builder::Class)
+            ->shouldReceive('newCollection')->once()
+            ->shouldReceive('newPerson')->once()
+            ->shouldReceive('newTune')->once()
+            ->shouldReceive('newSetting')->once()
+            ->shouldReceive('appendToSetting')->once()
+            ->shouldReceive('storeTune')->once()
+            ->shouldreceive('getCollection')->once()->andreturn(true);
+        $builder->shouldReceive('setOnTune')
+            ->with('X', '3')
+            ->atMost()->times(4);
+        $builder = $builder->mock();
+
+
+        $parser = new Parser($builder);
+
+        $result = $parser->parseABC($abc);
+        $I->assertTrue($result);
+    }
+}

tests/unit/Laravel5/AbcParserCest.php

@@ -0,0 +1,156 @@
+<?php
+namespace arr;
+
+use \UnitTester;
+use XaiCorp\AbcParser\Models\Laravel5\Abc;
+use XaiCorp\AbcParser\Parser;
+
+class AbcParserCest
+{
+    /**
+     * @var string
+     */
+    protected $dataDir;
+
+    /**
+     * @var \XaiCorp\AbcParser\Interfaces\Builder
+     */
+    protected $builder;
+
+    /**
+     * @var Parser;
+     */
+    protected $parser;
+
+    public function __construct()
+    {
+        $this->dataDir = codecept_data_dir();
+    }
+
+    public function _before(UnitTester $I)
+    {
+        $this->builder = new Abc();
+    }
+
+    public function _after(UnitTester $I)
+    {
+        unset($builder);
+    }
+
+    // tests: trying to...
+    public function createParser(UnitTester $I)
+    {
+        $parser = new Parser($this->builder);
+
+        $I->assertInstanceOf(Parser::class, $parser);
+    }
+
+    public function seeParseEmptyAbcWithoutErrors(UnitTester $I)
+    {
+        $abc = '';
+        $parser = new Parser($this->builder);
+
+        $result = $parser->parseABC($abc);
+        $I->assertEmpty($result);
+    }
+
+    public function seeParseABCExample1(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_1.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $resultArray = $result->toArray();
+        $I->assertEquals($expected, $resultArray);
+    }
+
+    public function seeParseABCExample2(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_2.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '40',
+                'T' => ['Abbotts Bromley Horn Dance'],
+                'A' => ['trad'],
+                'C' => ['trad.'],
+                'D' => ['None'],
+                'G' => ['lute'],
+                'H' => [
+                    'Thousand year old tradition',
+                    'The Horns live in the church and are removed for the dance once a year'
+                ],
+                'R' => ['Jig'],
+                'F' => ['none.abc'],
+                'B' => ['Traditional English tunes'],
+                'W' => ['None'],
+                'Q' => '1/8=80',
+                'L' => '1/8',
+                'M' => '6/8',
+                'N' => ['Traditional English'],
+                'O' => ['England'],
+                'Z' => ['Andy Hornby'],
+                'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+                'P' => 'ABC',
+                'K' => 'G',
+                'music' => 'e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $resultArray = $result->toArray();
+        $I->assertEquals($expected, $resultArray);
+    }
+
+
+    public function seeParseABCExample3(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_3.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            'A' => ['trad'],
+            'C' => ['trad.'],
+            'D' => ['None'],
+            'H' => [
+                'Thousand year old tradition',
+                'The Horns live in the church and are removed for the dance once a year'
+            ],
+            'R' => ['Jig'],
+            'F' => ['none.abc'],
+            'B' => ['Traditional English tunes'],
+            'L' => '1/8',
+            'M' => '6/8',
+            'N' => ['Traditional English'],
+            'O' => ['England'],
+            'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+            'Z' => ['Andy Hornby'],
+
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ]
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result->toArray());
+
+        $I->assertEquals($expected, $result->toArray());
+    }
+}

tests/unit/Laravel5/CollectionAttributeTest.php

@@ -0,0 +1,155 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Collection;
+use XaiCorp\AbcParser\Models\Laravel5\CollectionAttribute;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+use XaiCorp\AbcParser\Models\Laravel5\Tune;
+use XaiCorp\AbcParser\Models\Laravel5\TuneAttribute;
+
+class CollectionAttributeTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'    => '',
+        ]);
+        $app->setBasePath(dirname(dirname(dirname(__DIR__))));
+        $Artisan = $app->make('Artisan');
+        $Artisan::call('migrate');
+
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $collection = factory(Collection::class)->create();
+        $type = 'Note';
+        $value = 'a title';
+        $ordering = 1;
+        $model = new CollectionAttribute();
+        $model->collection_id = $collection->id;
+        $model->type = $type;
+        $model->string = $value;
+        $model->ordering = $ordering;
+
+        $this->assertInstanceOf(CollectionAttribute::class, $model);
+        $this->assertEquals($collection->id, $model->collection_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($value, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testMassAssignable()
+    {
+        $collection = factory(Collection::class)->create();
+        $type = 'Note';
+        $value = 'a title';
+        $ordering = 1;
+        $model = CollectionAttribute::create([
+            'collection_id'   => $collection->id,
+            'type'      => $type,
+            'string'    => $value,
+            'ordering'  => $ordering
+        ]);
+
+        $this->assertInstanceOf(CollectionAttribute::class, $model);
+        $this->assertEquals($collection->id, $model->collection_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($value, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testFactory()
+    {
+        $model = factory(CollectionAttribute::class)->make([]);
+
+        $this->assertInstanceOf(CollectionAttribute::class, $model);
+        $this->assertNotNull($model->collection_id);
+        $this->assertNotNull($model->type);
+        $this->assertNotNull($model->string);
+        $this->assertNotNull($model->ordering);
+        $this->assertTrue($model->save(), json_encode($model->getMessages()));
+    }
+
+    public function testValidationAppliedOnSave()
+    {
+        $model = factory(CollectionAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->save());
+    }
+
+    public function testTypeValidation()
+    {
+        $model = factory(CollectionAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testTuneIdValidation()
+    {
+        $model = factory(CollectionAttribute::class)->make([]);
+        $model->collection_id += 1;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testStringValidation()
+    {
+        $longString = '';
+        for ($i=0; $i < 300; $i++) {
+            $longString .= 's';
+        }
+        $model = factory(CollectionAttribute::class)->make([]);
+        $model->string = $longString;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testOrderingValidation()
+    {
+        $model = factory(CollectionAttribute::class)->make([]);
+        $model->ordering = "fourth";
+
+        $this->assertFalse($model->validate());
+    }
+}

tests/unit/Laravel5/CollectionTest.php

@@ -0,0 +1,522 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Collection;
+use XaiCorp\AbcParser\Models\Laravel5\CollectionAttribute;
+
+class CollectionTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'    => '',
+        ]);
+        $app->setBasePath(dirname(dirname(dirname(__DIR__))));
+        $Artisan = $app->make('Artisan');
+        $Artisan::call('migrate');
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $name = "test1";
+        $model = new Collection();
+        $model->name = $name;
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEquals($name, $model->name);
+    }
+
+    public function testNameIsMassAssignable()
+    {
+        $name = "test1";
+        $model = Collection::create(['name'=>$name]);
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEquals($name, $model->name);
+    }
+
+    public function testFactorySetsName()
+    {
+        $model = factory(Collection::class)->make([]);
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertNotEmpty($model->name);
+    }
+
+    public function testAppendToCollection()
+    {
+        $setting = new \stdClass();
+
+        $model = factory(Collection::class)->make([]);
+
+        $result = $model->appendSetting($setting);
+
+        $this->assertInstanceOf(\Illuminate\Support\Collection::class, $result);
+        $this->assertContains($setting, $result);
+    }
+
+    public function testCanGetAuthorAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Author',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->A[0]);
+    }
+
+    public function testSetAuthorAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->A = $values;
+
+        $this->assertEquals($values[0], $model->A[0]);
+        $this->assertEquals($values[1], $model->A[1]);
+    }
+
+    public function testAuthorAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->A = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->A[0]);
+        $this->assertEquals($values[1], $model->A[1]);
+    }
+
+    public function testCanGetComposerAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Composer',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->C[0]);
+    }
+
+    public function testSetComposerAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->C = $values;
+
+        $this->assertEquals($values[0], $model->C[0]);
+        $this->assertEquals($values[1], $model->C[1]);
+    }
+
+    public function testComposerAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->C = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->C[0]);
+        $this->assertEquals($values[1], $model->C[1]);
+    }
+
+    public function testCanGetDiscographyAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Discography',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->D[0]);
+    }
+
+    public function testSetDiscographyAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->D = $values;
+
+        $this->assertEquals($values[0], $model->D[0]);
+        $this->assertEquals($values[1], $model->D[1]);
+    }
+
+    public function testDiscographyAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->D = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->D[0]);
+        $this->assertEquals($values[1], $model->D[1]);
+    }
+
+
+    public function testCanGetRhythmAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Rhythm',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->R[0]);
+    }
+
+    public function testSetRhythmAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->R = $values;
+
+        $this->assertEquals($values[0], $model->R[0]);
+        $this->assertEquals($values[1], $model->R[1]);
+    }
+
+    public function testRhythmAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->R = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->R[0]);
+        $this->assertEquals($values[1], $model->R[1]);
+    }
+
+
+    public function testCanGetHistoryAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'History',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->H[0]);
+    }
+
+    public function testSetHistoryAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->H = $values;
+
+        $this->assertEquals($values[0], $model->H[0]);
+        $this->assertEquals($values[1], $model->H[1]);
+    }
+
+    public function testHistoryAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->A = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->A[0]);
+        $this->assertEquals($values[1], $model->A[1]);
+    }
+
+
+    public function testCanGetFileAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'File',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->F[0]);
+    }
+
+    public function testSetFileAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->F = $values;
+
+        $this->assertEquals($values[0], $model->F[0]);
+        $this->assertEquals($values[1], $model->F[1]);
+    }
+
+    public function testFileAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->F = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->F[0]);
+        $this->assertEquals($values[1], $model->F[1]);
+    }
+
+
+    public function testCanGetBookAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Book',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->B[0]);
+    }
+
+    public function testSetBookAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->B = $values;
+
+        $this->assertEquals($values[0], $model->B[0]);
+        $this->assertEquals($values[1], $model->B[1]);
+    }
+
+    public function testBookAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->B = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->B[0]);
+        $this->assertEquals($values[1], $model->B[1]);
+    }
+
+
+    public function testCanGetNoteAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Note',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->N[0]);
+    }
+
+    public function testSetNoteAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->N = $values;
+
+        $this->assertEquals($values[0], $model->N[0]);
+        $this->assertEquals($values[1], $model->N[1]);
+    }
+
+    public function testNoteAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->N = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->N[0]);
+        $this->assertEquals($values[1], $model->N[1]);
+    }
+
+
+    public function testCanGetSourceAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Source',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->S[0]);
+    }
+
+    public function testSetSourceAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->S = $values;
+
+        $this->assertEquals($values[0], $model->S[0]);
+        $this->assertEquals($values[1], $model->S[1]);
+    }
+
+    public function testSourceAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->S = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->S[0]);
+        $this->assertEquals($values[1], $model->S[1]);
+    }
+
+
+    public function testCanGetTranscriberAttribute()
+    {
+        $string = 'Arthur';
+        $model = factory(Collection::class)->create([]);
+        $attr  = factory(CollectionAttribute::class)->create([
+            'collection_id' => $model->id,
+            'type'    => 'Transcriber',
+            'string'  => $string,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Collection::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($string, $model->Z[0]);
+    }
+
+    public function testSetTranscriberAttribute()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->Z = $values;
+
+        $this->assertEquals($values[0], $model->Z[0]);
+        $this->assertEquals($values[1], $model->Z[1]);
+    }
+
+    public function testTranscriberAttributeSaves()
+    {
+        $values = ['England', 'Scotland'];
+        $model = factory(Collection::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->Z = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->Z[0]);
+        $this->assertEquals($values[1], $model->Z[1]);
+    }
+}

tests/unit/Laravel5/PersonTest.php

@@ -0,0 +1,86 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+
+class PersonTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'mysql',
+            'host'     => 'localhost',
+            'database' => 'abc-api-testing',
+            'charset'   => 'utf8',
+            'collation' => 'utf8_unicode_ci',
+            'prefix'    => '',
+            'strict'    => false,
+            'username' => 'abc-api',
+            'password' => 'sio2nf0d'
+        ]);
+
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $name = "test1";
+        $model = new Person();
+        $model->name = $name;
+
+        $this->assertInstanceOf(Person::class, $model);
+        $this->assertEquals($name, $model->name);
+    }
+
+    public function testNameIsMassAssignable()
+    {
+        $name = "test1";
+        $model = Person::create(['name'=>$name]);
+
+        $this->assertInstanceOf(Person::class, $model);
+        $this->assertEquals($name, $model->name);
+    }
+
+    public function testFactorySetsName()
+    {
+        $model = factory(Person::class)->make([]);
+
+        $this->assertInstanceOf(Person::class, $model);
+        $this->assertNotEmpty($model->name);
+    }
+}

tests/unit/Laravel5/TuneAttributeTest.php

@@ -0,0 +1,156 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+use XaiCorp\AbcParser\Models\Laravel5\Tune;
+use XaiCorp\AbcParser\Models\Laravel5\TuneAttribute;
+
+class TuneAttributeTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'mysql',
+            'host'     => 'localhost',
+            'database' => 'abc-api-testing',
+            'charset'   => 'utf8',
+            'collation' => 'utf8_unicode_ci',
+            'prefix'    => '',
+            'strict'    => false,
+            'username' => 'abc-api',
+            'password' => 'sio2nf0d'
+        ]);
+
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $tune = factory(Tune::class)->create();
+        $type = 'Title';
+        $title = 'a title';
+        $ordering = 1;
+        $model = new TuneAttribute();
+        $model->tune_id = $tune->id;
+        $model->type = $type;
+        $model->string = $title;
+        $model->ordering = $ordering;
+
+        $this->assertInstanceOf(TuneAttribute::class, $model);
+        $this->assertEquals($tune->id, $model->tune_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($title, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testMassAssignable()
+    {
+        $tune = factory(Tune::class)->create();
+        $type = 'Title';
+        $title = 'a title';
+        $ordering = 1;
+        $model = TuneAttribute::create([
+            'tune_id'   => $tune->id,
+            'type'      => $type,
+            'string'    => $title,
+            'ordering'  => $ordering
+        ]);
+
+        $this->assertInstanceOf(TuneAttribute::class, $model);
+        $this->assertEquals($tune->id, $model->tune_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($title, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testFactory()
+    {
+        $model = factory(TuneAttribute::class)->make([]);
+
+        $this->assertInstanceOf(TuneAttribute::class, $model);
+        $this->assertNotNull($model->tune_id);
+        $this->assertNotNull($model->type);
+        $this->assertNotNull($model->string);
+        $this->assertNotNull($model->ordering);
+        $this->assertTrue($model->save(), json_encode($model->getMessages()));
+    }
+
+    public function testValidationAppliedOnSave()
+    {
+        $model = factory(TuneAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->save());
+    }
+
+    public function testTypeValidation()
+    {
+        $model = factory(TuneAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testTuneIdValidation()
+    {
+        $model = factory(TuneAttribute::class)->make([]);
+        $model->tune_id += 1;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testStringValidation()
+    {
+        $longString = '';
+        for ($i=0; $i < 300; $i++) {
+            $longString .= 's';
+        }
+        $model = factory(TuneAttribute::class)->make([]);
+        $model->string = $longString;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testOrderingValidation()
+    {
+        $model = factory(TuneAttribute::class)->make([]);
+        $model->ordering = "fourth";
+
+        $this->assertFalse($model->validate());
+    }
+}

tests/unit/Laravel5/TuneSettingAttributeTest.php

@@ -0,0 +1,156 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+use XaiCorp\AbcParser\Models\Laravel5\TuneSetting;
+use XaiCorp\AbcParser\Models\Laravel5\TuneSettingAttribute;
+
+class TuneSettingAttributeTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'mysql',
+            'host'     => 'localhost',
+            'database' => 'abc-api-testing',
+            'charset'   => 'utf8',
+            'collation' => 'utf8_unicode_ci',
+            'prefix'    => '',
+            'strict'    => false,
+            'username' => 'abc-api',
+            'password' => 'sio2nf0d'
+        ]);
+
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $tune = factory(TuneSetting::class)->create();
+        $type = 'Title';
+        $title = 'a title';
+        $ordering = 1;
+        $model = new TuneSettingAttribute();
+        $model->tune_id = $tune->id;
+        $model->type = $type;
+        $model->string = $title;
+        $model->ordering = $ordering;
+
+        $this->assertInstanceOf(TuneSettingAttribute::class, $model);
+        $this->assertEquals($tune->id, $model->tune_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($title, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testMassAssignable()
+    {
+        $setting = factory(TuneSetting::class)->create();
+        $type = 'Notes';
+        $value = 'a little note';
+        $ordering = 1;
+        $model = TuneSettingAttribute::create([
+            'setting_id'   => $setting->id,
+            'type'      => $type,
+            'string'    => $value,
+            'ordering'  => $ordering
+        ]);
+
+        $this->assertInstanceOf(TuneSettingAttribute::class, $model);
+        $this->assertEquals($setting->id, $model->setting_id);
+        $this->assertEquals($type, $model->type);
+        $this->assertEquals($value, $model->string);
+        $this->assertEquals($ordering, $model->ordering);
+    }
+
+    public function testFactory()
+    {
+        $model = factory(TuneSettingAttribute::class)->make([]);
+
+        $this->assertInstanceOf(TuneSettingAttribute::class, $model);
+        $this->assertNotNull($model->setting_id);
+        $this->assertNotNull($model->type);
+        $this->assertNotNull($model->string);
+        $this->assertNotNull($model->ordering);
+        $this->assertTrue($model->save(), json_encode($model->getMessages()));
+    }
+
+    public function testValidationAppliedOnSave()
+    {
+        $model = factory(TuneSettingAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->save());
+    }
+
+    public function testTypeValidation()
+    {
+        $model = factory(TuneSettingAttribute::class)->make([]);
+        $model->type = 'NotType';
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testTuneSettingIdValidation()
+    {
+        $model = factory(TuneSettingAttribute::class)->make([]);
+        $model->setting_id += 1;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testStringValidation()
+    {
+        $longString = '';
+        for ($i=0; $i < 300; $i++) {
+            $longString .= 's';
+        }
+        $model = factory(TuneSettingAttribute::class)->make([]);
+        $model->string = $longString;
+
+        $this->assertFalse($model->validate());
+    }
+
+    public function testOrderingValidation()
+    {
+        $model = factory(TuneSettingAttribute::class)->make([]);
+        $model->ordering = "fourth";
+
+        $this->assertFalse($model->validate());
+    }
+}

tests/unit/Laravel5/TuneSettingTest.php

@@ -0,0 +1,378 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+use XaiCorp\AbcParser\Models\Laravel5\Tune;
+use XaiCorp\AbcParser\Models\Laravel5\TuneAttribute;
+use XaiCorp\AbcParser\Models\Laravel5\TuneSetting;
+use XaiCorp\AbcParser\Models\Laravel5\TuneSettingAttribute;
+
+class TuneSettingTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+//        $app['config']->set('database.connections.testbench', [
+//            'driver'   => 'mysql',
+//            'host'     => 'localhost',
+//            'database' => 'abc-api-testing',
+//            'charset'   => 'utf8',
+//            'collation' => 'utf8_unicode_ci',
+//            'prefix'    => '',
+//            'strict'    => true,
+//            'username' => 'abc-api',
+//            'password' => 'sio2nf0d'
+//        ]);
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'    => '',
+        ]);
+        $app->setBasePath(dirname(dirname(dirname(__DIR__))));
+        $Artisan = $app->make('Artisan');
+        $Artisan::call('migrate');
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $model = new TuneSetting();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+    }
+
+    public function testMassAssignable()
+    {
+        $tune = factory(Tune::class)->create();
+        $data = [
+            'tune_id'   => $tune->id,
+            'meter'     => 'C',
+            'keysig'    => 'C',
+            'filename'  => 'filename',
+            'tempo'     => '1/8=200',
+            'L'         => '1/8',
+            'music'     => '',
+            'parts'     => 'abcbc'
+        ];
+        $model = TuneSetting::create($data);
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($data['meter'], $model->meter);
+        $this->assertEquals($data['keysig'], $model->keysig);
+        $this->assertEquals($data['filename'], $model->filename);
+        $this->assertEquals($data['tempo'], $model->tempo);
+        $this->assertEquals($data['L'], $model->L);
+        $this->assertEquals($data['music'], $model->music);
+        $this->assertEquals($data['parts'], $model->parts);
+    }
+
+
+    public function testFactory()
+    {
+        $model = factory(TuneSetting::class)->make([]);
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertNotNull($model->tune_id);
+        $this->assertNotNull($model->meter);
+        $this->assertNotNull($model->keysig);
+    }
+
+    public function testValidationAppliedOnSave()
+    {
+        $model = factory(TuneSetting::class)->make([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $model->meter = 'NotType';
+
+        $this->assertFalse($model->save());
+    }
+
+    public function testCanGetTranscriberAttribute()
+    {
+        $value = 'C';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Transcriber',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->Z[0]);
+    }
+
+    public function testSetTranscriberAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->Z = $values;
+
+        $this->assertEquals($values[0], $model->Z[0]);
+        $this->assertEquals($values[1], $model->Z[1]);
+    }
+
+    public function testTranscriberAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->Z = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->Z[0]);
+        $this->assertEquals($values[1], $model->Z[1]);
+    }
+
+    public function testCanGetNoteAttribute()
+    {
+        $value = 'A note';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Note',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->N[0]);
+    }
+
+    public function testSetNoteAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->N = $values;
+
+        $this->assertEquals($values[0], $model->N[0]);
+        $this->assertEquals($values[1], $model->N[1]);
+    }
+
+    public function testNoteAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->N = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->N[0]);
+        $this->assertEquals($values[1], $model->N[1]);
+    }
+
+    public function testCanGetDiscographyAttribute()
+    {
+        $value = 'A recording';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Discography',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->D[0]);
+    }
+
+    public function testSetDiscographyAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->D = $values;
+
+        $this->assertEquals($values[0], $model->D[0]);
+        $this->assertEquals($values[1], $model->D[1]);
+    }
+
+    public function testDiscographyAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->D = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->D[0]);
+        $this->assertEquals($values[1], $model->D[1]);
+    }
+
+    public function testCanGetSourceAttribute()
+    {
+        $value = 'A feel';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Source',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->S[0]);
+    }
+
+    public function testSetSourceAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->S = $values;
+
+        $this->assertEquals($values[0], $model->S[0]);
+        $this->assertEquals($values[1], $model->S[1]);
+    }
+
+    public function testSourceAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->S = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->S[0]);
+        $this->assertEquals($values[1], $model->S[1]);
+    }
+
+    public function testCanGetWordAttribute()
+    {
+        $value = 'A feel';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Word',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->W[0]);
+    }
+
+    public function testSetWordAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->W = $values;
+
+        $this->assertEquals($values[0], $model->W[0]);
+        $this->assertEquals($values[1], $model->W[1]);
+    }
+
+    public function testWordAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->W = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->W[0]);
+        $this->assertEquals($values[1], $model->W[1]);
+    }
+
+    public function testCanGetBookAttribute()
+    {
+        $value = 'A feel';
+        $model = factory(TuneSetting::class)->create([]);
+        $attr  = factory(TuneSettingAttribute::class)->create([
+            'setting_id' => $model->id,
+            'type'    => 'Book',
+            'string'  => $value,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(TuneSetting::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($value, $model->B[0]);
+    }
+
+    public function testSetBookAttribute()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->B = $values;
+
+        $this->assertEquals($values[0], $model->B[0]);
+        $this->assertEquals($values[1], $model->B[1]);
+    }
+
+    public function testBookAttributeSaves()
+    {
+        $values = ['Me', 'Womble2'];
+        $model = factory(TuneSetting::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->B = $values;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($values[0], $model->B[0]);
+        $this->assertEquals($values[1], $model->B[1]);
+    }
+
+}

tests/unit/Laravel5/TuneTest.php

@@ -0,0 +1,319 @@
+<?php
+namespace Laravel5;
+
+use Codeception\TestCase\Test;
+use Aedart\Testing\Laravel\Traits\TestHelperTrait;
+use XaiCorp\AbcParser\Models\Laravel5\Person;
+use XaiCorp\AbcParser\Models\Laravel5\Tune;
+use XaiCorp\AbcParser\Models\Laravel5\TuneAttribute;
+
+class TuneTest extends Test
+{
+    use TestHelperTrait;
+
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    /**
+     * Define environment setup.
+     *
+     * @param  \Illuminate\Foundation\Application  $app
+     * @return void
+     */
+    protected function getEnvironmentSetUp($app)
+    {
+        // Setup default database to use sqlite :memory:
+        $app['config']->set('database.default', 'testbench');
+//        $app['config']->set('database.connections.testbench', [
+//            'driver'   => 'mysql',
+//            'host'     => 'localhost',
+//            'database' => 'abc-api-testing',
+//            'charset'   => 'utf8',
+//            'collation' => 'utf8_unicode_ci',
+//            'prefix'    => '',
+//            'strict'    => true,
+//            'username' => 'abc-api',
+//            'password' => 'sio2nf0d'
+//        ]);
+        $app['config']->set('database.connections.testbench', [
+            'driver'   => 'sqlite',
+            'database' => ':memory:',
+            'prefix'    => '',
+        ]);
+        $app->setBasePath(dirname(dirname(dirname(__DIR__))));
+        $Artisan = $app->make('Artisan');
+        $Artisan::call('migrate');
+    }
+
+
+    protected function _before()
+    {
+        $this->startApplication();
+        $db = app()->make('db');
+        $db->beginTransaction();
+
+        $this->withFactories(__DIR__.'/factories');
+    }
+
+    protected function _after()
+    {
+        $db = app()->make('db');
+        $db->rollBack();
+        $this->stopApplication();
+    }
+
+    // tests: trying to...
+
+    public function testMakeModel()
+    {
+        $model = new Tune();
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+    }
+
+    public function testMassAssignable()
+    {
+        $xId = 44;
+        $model = Tune::create([
+            'x_id'   => $xId,
+        ]);
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($xId, $model->x_id);
+    }
+
+
+    public function testFactory()
+    {
+        $model = factory(Tune::class)->make([]);
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertNotNull($model->x_id);
+    }
+
+    public function testCanGetTitleAttribute()
+    {
+        $title = 'Wombles Forever';
+        $model = factory(Tune::class)->create([]);
+        $attr  = factory(TuneAttribute::class)->create([
+            'tune_id' => $model->id,
+            'type'    => 'Title',
+            'string'  => $title,
+        ]);
+
+        $model = $model->fresh();
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($title, $model->T[0]);
+    }
+
+    public function testSetTitleAttribute()
+    {
+        $titles = ['Title1', 'Womble2'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->T = $titles;
+
+        $this->assertEquals($titles[0], $model->T[0]);
+        $this->assertEquals($titles[1], $model->T[1]);
+    }
+
+    public function testTitleAttributeSaves()
+    {
+        $titles = ['Title1', 'Womble2'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->T = $titles;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($titles[0], $model->T[0]);
+        $this->assertEquals($titles[1], $model->T[1]);
+    }
+
+    public function testCanGetGroupAttribute()
+    {
+        $group = 'Flute';
+        $model = factory(Tune::class)->create([]);
+        $attr  = factory(TuneAttribute::class)->create([
+            'tune_id' => $model->id,
+            'type'    => 'Group',
+            'string'  => $group,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($group, $model->G[0]);
+    }
+
+    public function testSetGroupAttribute()
+    {
+        $groups = ['Flute', 'Oboe'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->G = $groups;
+
+        $this->assertEquals($groups[0], $model->G[0]);
+        $this->assertEquals($groups[1], $model->G[1]);
+    }
+
+    public function testGroupAttributeSaves()
+    {
+        $groups = ['Flute', 'Oboe'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->G = $groups;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($groups[0], $model->G[0]);
+        $this->assertEquals($groups[1], $model->G[1]);
+    }
+
+    public function testCanGetOriginAttribute()
+    {
+        $origin = 'England';
+        $model = factory(Tune::class)->create([]);
+        $attr  = factory(TuneAttribute::class)->create([
+            'tune_id' => $model->id,
+            'type'    => 'Origin',
+            'string'  => $origin,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($origin, $model->O[0]);
+    }
+
+    public function testSetOriginAttribute()
+    {
+        $origins = ['England', 'Scotland'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->O = $origins;
+
+        $this->assertEquals($origins[0], $model->O[0]);
+        $this->assertEquals($origins[1], $model->O[1]);
+    }
+
+    public function testOriginAttributeSaves()
+    {
+        $origins = ['England', 'Scotland'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->O = $origins;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($origins[0], $model->O[0]);
+        $this->assertEquals($origins[1], $model->O[1]);
+    }
+
+    public function testCanGetRhythmAttribute()
+    {
+        $rhythm = 'Reel';
+        $model = factory(Tune::class)->create([]);
+        $attr  = factory(TuneAttribute::class)->create([
+            'tune_id' => $model->id,
+            'type'    => 'Rhythm',
+            'string'  => $rhythm,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($rhythm, $model->R[0]);
+    }
+
+    public function testSetRhythmAttribute()
+    {
+        $rhythms = ['Reel', 'March'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->R = $rhythms;
+
+        $this->assertEquals($rhythms[0], $model->R[0]);
+        $this->assertEquals($rhythms[1], $model->R[1]);
+    }
+
+    public function testRhythmAttributeSaves()
+    {
+        $rhythms = ['England', 'Scotland'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->R = $rhythms;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($rhythms[0], $model->R[0]);
+        $this->assertEquals($rhythms[1], $model->R[1]);
+    }
+
+    public function testCanGetHistoryAttribute()
+    {
+        $history = 'England';
+        $model = factory(Tune::class)->create([]);
+        $attr  = factory(TuneAttribute::class)->create([
+            'tune_id' => $model->id,
+            'type'    => 'History',
+            'string'  => $history,
+        ]);
+        $model = $model->fresh();
+
+        $this->assertInstanceOf(Tune::class, $model);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $this->assertEquals($history, $model->H[0]);
+    }
+
+    public function testSetHistoryAttribute()
+    {
+        $history = ['some ', 'lines'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->H = $history;
+
+        $this->assertEquals($history[0], $model->H[0]);
+        $this->assertEquals($history[1], $model->H[1]);
+    }
+
+
+    public function testHistoryAttributeSaved()
+    {
+        $history = ['some ', 'lines'];
+        $model = factory(Tune::class)->create([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+
+        $model->H = $history;
+        $model->save();
+        $model = $model->fresh();
+
+        $this->assertEquals($history[0], $model->H[0]);
+        $this->assertEquals($history[1], $model->H[1]);
+    }
+
+    public function testValidationAppliedOnSave()
+    {
+        $model = factory(Tune::class)->make([]);
+        $this->assertEmpty($model->getMessages(), json_encode($model->getMessages()));
+        $model->x_id = 'NotType';
+
+        $this->assertFalse($model->save());
+    }
+
+}

tests/unit/Laravel5/factories/ModelFactory.php

@@ -0,0 +1,56 @@
+<?php
+
+/*
+|--------------------------------------------------------------------------
+| Model Factories
+|--------------------------------------------------------------------------
+|
+| Here you may define all of your model factories. Model factories give
+| you a convenient way to create models for testing and seeding your
+| database. Just tell the factory how a default model should look.
+|
+*/
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\Collection::class, function (Faker\Generator $faker) {
+    return [
+        'name' => $faker->name,
+    ];
+});
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\Tune::class, function (Faker\Generator $faker) {
+    return [
+        'x_id' => $faker->numberBetween(1, 10),
+    ];
+});
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\Person::class, function (Faker\Generator $faker) {
+    return [
+        'name' => $faker->name,
+        'email'=> $faker->safeEmail,
+    ];
+});
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\TuneAttribute::class, function (Faker\Generator $faker) {
+    $types = \XaiCorp\AbcParser\Models\Laravel5\TuneAttribute::getTypes();
+    return [
+        'tune_id' => function () {
+            return factory(\XaiCorp\AbcParser\Models\Laravel5\Tune::class)->create()->id;
+        },
+        'type' => $types[random_int(0, count($types)-1)],
+        'string' => $faker->words(3, true),
+        'ordering' => $faker->numberBetween(1, 5),
+    ];
+});
+
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\CollectionAttribute::class, function (Faker\Generator $faker) {
+    $types = \XaiCorp\AbcParser\Models\Laravel5\CollectionAttribute::getTypes();
+    return [
+        'collection_id' => function () {
+            return factory(\XaiCorp\AbcParser\Models\Laravel5\Collection::class)->create()->id;
+        },
+        'type' => $types[random_int(0, count($types)-1)],
+        'string' => $faker->words(3, true),
+        'ordering' => $faker->numberBetween(1, 5),
+    ];
+});

tests/unit/Laravel5/factories/TuneSettingFactory.php

@@ -0,0 +1,24 @@
+<?php
+
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\TuneSetting::class, function (Faker\Generator $faker) {
+    return [
+        'tune_id' => function () {
+            return factory(\XaiCorp\AbcParser\Models\Laravel5\Tune::class)->create()->id;
+        },
+        'meter' => 'C',
+        'keysig' => '6/8',
+    ];
+});
+
+$factory->define(\XaiCorp\AbcParser\Models\Laravel5\TuneSettingAttribute::class, function (Faker\Generator $faker) {
+    $types = \XaiCorp\AbcParser\Models\Laravel5\TuneSettingAttribute::getTypes();
+    return [
+        'setting_id' => function () {
+            return factory(\XaiCorp\AbcParser\Models\Laravel5\TuneSetting::class)->create()->id;
+        },
+        'type'      => $types[random_int(0, count($types)-1)],
+        'string'    => $faker->words(3, true),
+        'ordering'  => $faker->numberBetween(1, 5),
+    ];
+});

tests/unit/_bootstrap.php

@@ -0,0 +1,2 @@
+<?php
+// Here you can initialize variables that will be available to your tests

tests/unit/arr/AbcParserCest.php

@@ -0,0 +1,154 @@
+<?php
+namespace arr;
+
+use \UnitTester;
+use XaiCorp\AbcParser\Models\Arr\Abc;
+use XaiCorp\AbcParser\Parser;
+
+class AbcParserCest
+{
+    /**
+     * @var string
+     */
+    protected $dataDir;
+
+    /**
+     * @var \XaiCorp\AbcParser\Interfaces\Builder
+     */
+    protected $builder;
+
+    /**
+     * @var Parser;
+     */
+    protected $parser;
+
+    public function __construct()
+    {
+        $this->dataDir = codecept_data_dir();
+    }
+
+    public function _before(UnitTester $I)
+    {
+        $this->builder = new Abc();
+    }
+
+    public function _after(UnitTester $I)
+    {
+        unset($builder);
+    }
+
+    // tests: trying to...
+    public function createParser(UnitTester $I)
+    {
+        $parser = new Parser($this->builder);
+        
+        $I->assertInstanceOf(Parser::class, $parser);
+    }
+
+    public function seeParseEmptyAbcWithoutErrors(UnitTester $I)
+    {
+        $abc = '';
+        $parser = new Parser($this->builder);
+
+        $result = $parser->parseABC($abc);
+        $I->assertEmpty($result);
+    }
+
+    public function seeParseABCExample1(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_1.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+
+    public function seeParseABCExample2(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_2.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+            1 => [
+                'X' => '40',
+                'T' => ['Abbotts Bromley Horn Dance'],
+                'A' => ['trad'],
+                'C' => ['trad.'],
+                'D' => ['None'],
+                'G' => ['lute'],
+                'H' => [
+                    'Thousand year old tradition',
+                    'The Horns live in the church and are removed for the dance once a year'
+                ],
+                'R' => ['Jig'],
+                'F' => ['none.abc'],
+                'B' => ['Traditional English tunes'],
+                'W' => ['None'],
+                'Q' => '1/8=80',
+                'L' => '1/8',
+                'M' => '6/8',
+                'N' => ['Traditional English'],
+                'O' => ['England'],
+                'Z' => ['Andy Hornby'],
+                'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+                'P' => 'ABC',
+                'K' => 'G',
+                'music' => 'e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]'
+            ],
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+
+
+    public function seeParseABCExample3(UnitTester $I)
+    {
+        $abc = file_get_contents($this->dataDir.'/abc/valid_abc_3.abc');
+        $parser = new Parser($this->builder);
+        $expected = [
+                'A' => ['trad'],
+                'C' => ['trad.'],
+                'D' => ['None'],
+                'H' => [
+                    'Thousand year old tradition',
+                    'The Horns live in the church and are removed for the dance once a year'
+                ],
+                'R' => ['Jig'],
+                'F' => ['none.abc'],
+                'B' => ['Traditional English tunes'],
+                'L' => '1/8',
+                'M' => '6/8',
+                'N' => ['Traditional English'],
+                'O' => ['England'],
+                'S' => ['http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html'],
+                'Z' => ['Andy Hornby'],
+
+            1 => [
+                'X' => '3',
+                'M' => '4/4',
+                'K' => 'C',
+                'music' => 'gaab babc :|'
+            ]
+        ];
+
+        $result = $parser->parseABC($abc);
+        $I->assertNotEmpty($result);
+
+        $I->assertEquals($expected, $result);
+    }
+}

tests/unit/memory/AbcParserTest.php

@@ -0,0 +1,158 @@
+<?php
+
+/**
+ * @group Lib
+ * @group Unit
+ */
+
+use App\Libraries\abcParse\AbcParser;
+
+class AbcParserTest extends \Codeception\TestCase\Test
+{
+    private $_facade;
+
+    private $valid_abc_1 = "
+    //blank first line means this isn't a file header anymore!
+A: trad
+B: Traditional English tunes
+C: trad.
+X:3
+M:4/4
+K:C
+gaab babc :|
+    ";
+
+    private $valid_abc_2 = "
+X:40
+T:Abbotts Bromley Horn Dance
+A: trad
+C: trad.
+D: None
+G:lute
+H: Thousand year old tradition
+The Horns live in the church and are removed for the dance once a year
+R:Jig
+F:none.abc
+B: Traditional English tunes
+W:None
+Q:1/8=80
+L:1/8
+M:6/8
+N:Traditional English
+O:England
+Z:Andy Hornby
+%%TUNEURL: http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+%%ID:00000dab
+S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+P:ABC
+K:G
+e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]
+    ";
+
+    private $valid_abc_3 = "A: trad
+B: Traditional English tunes
+C: trad.
+D: None
+F:none.abc
+H: Thousand year old tradition
+The Horns live in the church and are removed for the dance once a year
+L:1/8
+M:6/8
+N:Traditional English
+O:England
+R:Jig
+S:http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html
+Z:Andy Hornby
+
+X:3
+M:4/4
+K:C
+gaab babc :|
+    ";
+
+
+    public function setUp()
+    {
+        parent::setup();
+        $this->_facade = new AbcParser();
+    }
+
+    public function test_not_header_data_no_crash()
+    {
+        $result = $this->_facade->parseABC($this->valid_abc_1);
+        $this->assertTrue(is_a($result, 'App\Libraries\abcParse\TuneCollection'));
+    }
+
+
+    public function test_all_parameters_for_tune()
+    {
+        $result = $this->_facade->parseABC($this->valid_abc_2);
+        $this->assertTrue(is_a($result, 'App\Libraries\abcParse\TuneCollection'));
+
+                // Tune details
+        $tune = $result[0];
+        // var_dump($tune); die();
+        $this->assertEquals('40', $result[0]->get('X'));
+        $this->assertEquals('Abbotts Bromley Horn Dance', array_shift($tune->get('T')) );
+        $this->assertEquals('England', array_shift($tune->get('O')) );
+        $this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad')), array_shift($tune->get('A')) );
+        $this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad.')), array_shift($tune->get('C')) );
+        $this->assertEquals('England', array_shift($tune->get('O')) );
+        $this->assertEquals('lute', array_shift($tune->get('G')) );
+        $history = $tune->get('H');
+        $this->assertEquals(2, count($history));
+        $this->assertEquals('Thousand year old tradition', $history[0] );
+        $this->assertEquals('The Horns live in the church and are removed for the dance once a year', $history[1] );
+        $this->assertEquals('Jig', array_shift($tune->get('R')) );
+
+        // setting details
+        $setting = $tune[0];
+        // var_dump($setting);die;
+        $this->assertEquals('Traditional English', array_shift($setting->get('N')) );
+        $this->assertEquals('1/8', $setting->get('L') );
+        $this->assertEquals('6/8', $setting->get('M') );
+        $this->assertEquals('G', $setting->get('K') );
+        $expectedMusic = "
+e|B2e G2e|B2e E2G|FGA GAB|1AGF G2:|2AGF E2|
+|e|c2e cde|A2c ABc|FGA GFE|_E=EF B,2g|
+e2g efg|c2e cde|dcB AGF|E3E2
+|:A|BcB e3|BcB f3|BcB AGF|1G2F G2:|2E3-E2|]
+        ";
+        $this->assertEquals(trim($expectedMusic), $setting->get('music'), "music strings should match" );
+
+        $Z = new App\Libraries\abcParse\Person(array('name'=>'Andy Hornby'));
+        $this->assertEquals($Z, array_shift($setting->get('Z')) );
+
+        $this->assertEquals('None', array_shift($setting->get('D')) );
+        $this->assertEquals('http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html', array_shift($setting->get('S')) );
+        $this->assertEquals('None', array_shift($setting->get('W')) );
+        $this->assertEquals('Traditional English tunes', array_shift($setting->get('B')) );
+        $this->assertEquals('none.abc', array_shift($setting->get('F')) );
+        $this->assertEquals('ABC', $setting->get('P') );
+        $this->assertEquals('1/8=80', $setting->get('Q') );
+    }
+
+
+    public function test_all_parameters_for_collection()
+    {
+        $collection = $this->_facade->parseABC($this->valid_abc_3);
+        $this->assertTrue(is_a($collection, 'App\Libraries\abcParse\TuneCollection'));
+
+        $this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad')), array_shift($collection->get('A')) );
+        $this->assertEquals('Traditional English tunes', array_shift($collection->get('B')) );
+        $this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'trad.')), array_shift($collection->get('C')) );
+        $this->assertEquals('None', array_shift($collection->get('D')) );
+        $this->assertEquals('none.abc', array_shift($collection->get('F')) );
+        $this->assertEquals('Thousand year old tradition', array_shift($collection->get('H')) );
+        $this->assertEquals('1/8', $collection->get('L') );
+        $this->assertEquals('6/8', $collection->get('M') );
+        $this->assertEquals('Traditional English', array_shift($collection->get('N')) );
+        $this->assertEquals('England', array_shift($collection->get('O')) );
+        $this->assertEquals('Jig', $collection->get('R') );
+        $this->assertEquals('http://www.leeds.ac.uk/music/Info/RRTuneBk/gettune/00000dab.html', array_shift($collection->get('S')) );
+        $this->assertEquals(new App\Libraries\abcParse\Person(array('name'=>'Andy Hornby')), array_shift($collection->get('Z')) );
+    }
+}

tests/unit/memory/PabcTest.php

@@ -0,0 +1,104 @@
+<?php
+
+/**
+ * @group Lib
+ * @group Unit
+ */
+
+use App\Libraries\abcParse\Pabc;
+use App\Models\abcParse\Tune;
+use App\Models\abcParse\TuneSetting as Setting;
+use App\Models\abcParse\Person;
+use App\Libraries\abcParse\TuneCollection;
+
+class PabcTest extends \Codeception\TestCase\Test
+{
+    private $_facade;
+
+    public function setUp()
+    {
+        $this->_facade = new Pabc();
+    }
+
+    private $valid_abc_1 = "
+X:1
+M:C
+K:C
+gaab babc :|
+    ";
+
+
+    /**
+     * test the parse_abc function
+     *
+     * This method receives abc in a string
+     * and converts it into a Tune object.
+     * If the string is not valid abc no Tune object is created
+     * and the method returns false.
+     *
+     * @dataProvider provider_parse_abc
+     */
+    public function test_parse_abc($string, $isValid)
+    {
+        $result = $this->_facade->parse_abc($string);
+        $this->assertEquals($isValid, is_a($result, TuneCollection::class));
+    }
+
+    public function provider_parse_abc()
+    {
+        return array(
+            array('not an abc', FALSE),
+            array($this->valid_abc_1, TRUE),
+        );
+    }
+
+
+    public function test_load_models()
+    {
+        $params = array(
+            'tuneModel'    => new Tune(),
+            'settingModel' => new Setting(),
+            'personModel'  => new Person(),
+        );
+
+        $this->_facade = new Pabc($params);
+
+        $this->assertInstanceOf(Tune::class, $this->_facade->tuneModel);
+        $this->assertInstanceOf(Setting::class, $this->_facade->settingModel);
+        $this->assertInstanceOf(Person::class, $this->_facade->personModel);
+    }
+
+
+    public function test_save_no_models()
+    {
+        $this->assertNull($this->_facade->tuneModel);
+
+        $result = $this->_facade->parse_abc($this->valid_abc_1);
+        $this->assertInstanceOf(TuneCollection::class, $result);
+
+        $this->assertFalse($result->get('change_hash'));
+        $saved = $this->_facade->save_collection($result);
+        $this->assertFalse($saved);
+        $this->assertFalse($result->get('change_hash'));
+    }
+
+    public function test_save()
+    {
+        $params = array(
+            'tuneModel'    => Mockery::mock(Tune::Class, ['store'=>true]),
+            'settingModel' => Mockery::mock(Setting::class, ['store'=>true]),
+            'personModel'  => Mockery::mock(Person::class, ['store'=>true]),
+        );
+
+        $this->_facade = new Pabc($params);
+
+        $result = $this->_facade->parse_abc($this->valid_abc_1);
+        $this->assertInstanceOf(TuneCollection::class, $result);
+
+        $this->assertFalse($result->get('change_hash'));
+        $saved = $this->_facade->save_collection($result);
+        $this->assertTrue($saved);
+        $this->assertNotNull($result->get('change_hash'));
+    }
+
+}

tests/unit/memory/PersonTest.php

@@ -0,0 +1,189 @@
+<?php
+
+/**
+ * @group Lib
+ * @group Unit
+ */
+
+use App\Libraries\abcParse\Person;
+use \Codeception\TestCase\Test;
+
+class PersonTest extends Test
+{
+    private $_person;
+
+    public function setUp()
+    {
+        $this->_person = new Person();
+    }
+
+    /**
+     * test the model contains the correct attributes
+     */
+    public function test_model_definition()
+    {
+        $this->assertClassHasAttribute('person_id', Person::class);
+        $this->assertClassHasAttribute('name', Person::class);
+        $this->assertClassHasAttribute('email', Person::class);
+    }
+
+    public function test_construct()
+    {
+        $params = array('person_id' => 5);
+        $this->_person = new Person($params);
+
+        $this->assertEquals(5, $this->_person->get('person_id'));
+    }
+
+
+    /**
+     * 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 provider_set
+     */
+    public function test_set($property, $value, $expected)
+    {
+        $success = $this->_person->set($property, $value);
+        $this->assertEquals($expected, $success);
+        if($success)
+        {
+            $this->assertEquals($value, $this->_person->get($property));
+        }
+    }
+
+    /**
+     *  @dataProvider provider_set
+     */
+    public function test_magic_set($property, $value, $expected)
+    {
+        $this->test_set($property, $value, $expected);
+    }
+
+    public function provider_set()
+    {
+        return array(
+            array('Y', 'anything', FALSE),
+            array('person_id', 'not', FALSE),
+            array('person_id', 11, TRUE),
+            array('person_id', '11', TRUE),
+            array('name', null, FALSE),
+            array('name', 1, FALSE),
+            array('name', 'anything', TRUE),
+            array('email', 'anything', FALSE),
+            array('email', 1, FALSE),
+            array('email', 'mail@example.com', TRUE),
+        );
+    }
+
+    /**
+     * @dataProvider provider_person_get
+     */
+    public function test_person_get($key, $expected)
+    {
+        $result = $this->_person->set($key, $expected);
+        $result = $this->_person->get($key);
+        $this->assertEquals($expected, $result);
+    }
+
+    public function provider_person_get()
+    {
+        return array(
+            array('', FALSE),
+            array('me', FALSE),
+            array(array('of','me'), FALSE),
+            array(new Person(), FALSE),
+            array('name', 'Richard Morgan'),
+            array('email', 'r_morgan@sympatico.ca'),
+            array('person_id', 0)
+        );
+    }
+
+    public function test_is_changed()
+    {
+        $person = new Person(array('name'=>'Richard Morgan'));
+
+        $this->assertInstanceOf(Person::class, $person);
+
+        $this->assertFalse($person->is_changed(), 'after load should be no changes');
+
+        $person->set('name','Richard Armitage');
+        $this->assertTrue($person->is_changed(), 'updating the name changes the data');
+    }
+
+    /**
+     * test the static function equals
+     * returns true if the data properties of 2 Person objects
+     * are identical
+     *
+     * @param (array) $params list of properties to set on the objects
+     * @param (boolean) $expected result of running equals
+     *
+     * @dataProvider provider_equals
+     */
+    public function test_equals($params)
+    {
+        // $this->markTestIncomplete();
+
+        $ob1 = new Person();
+        $ob2 = new Person();
+
+        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(Person::equals($ob1, $ob2));
+    }
+    /**
+     * test the static function equals
+     * returns true if the data properties of 2 Person objects
+     * are identical
+     *
+     * @param (array) $params list of properties to set on the objects
+     * @param (boolean) $expected result of running equals
+     *
+     * @dataProvider provider_equals
+     */
+    public function test_equals_fails($params)
+    {
+        $ob1 = new Person();
+        $ob2 = new Person();
+
+        foreach($params as $key => $val)
+        {
+            if(is_array($ob1->get($key)))
+            {
+                $ob1->append($key, $val);
+                $ob2->append($key, $val." hello");
+            }
+            else {
+                $ob1->set($key, $val);
+                $ob2->set($key, $val+1);
+            }
+        }
+        // print_r($ob1); print_r($ob2); die;
+        $this->assertFalse(Person::equals($ob1, $ob2));
+    }
+    public function provider_equals()
+    {
+        return array(
+            // array( array('person_id'=>'2') ),
+            array( array('name'=>'a title') ),
+            array( array('email'=>'mail@example.com') ),
+        );
+    }
+
+
+}

tests/unit/memory/SettingTest.php

@@ -0,0 +1,364 @@
+<?php
+
+use App\Libraries\abcParse\Setting;
+use App\Libraries\abcParse\Person;
+use \Codeception\TestCase\Test as TestCase;
+
+
+/**
+ * @group Lib
+ */
+class SettingTest extends TestCase
+{
+    private $_setting;
+    
+	public function setUp()
+	{
+        $this->_setting = new Setting();
+	}
+	
+    /**
+     * test the model contains the correct attributes
+     */
+    public function test_model_definition()
+	{
+        $this->assertClassHasAttribute('settingID', Setting::class);
+        $this->assertClassHasAttribute('tuneID', Setting::class);
+        
+        $this->assertClassHasAttribute('Z', Setting::class);
+        $this->assertClassHasAttribute('N', Setting::class);
+        $this->assertClassHasAttribute('D', Setting::class);
+        $this->assertClassHasAttribute('S', Setting::class);
+        $this->assertClassHasAttribute('W', Setting::class);
+        $this->assertClassHasAttribute('B', Setting::class);
+
+        $this->assertClassHasAttribute('F', Setting::class);
+        $this->assertClassHasAttribute('P', Setting::class);
+        $this->assertClassHasAttribute('Q', Setting::class);
+        $this->assertClassHasAttribute('L', Setting::class);
+        $this->assertClassHasAttribute('M', Setting::class);
+        $this->assertClassHasAttribute('K', Setting::class);
+        $this->assertClassHasAttribute('music', Setting::class);
+        // $this->assertClassHasAttribute('music_hash', Setting::class);
+
+        $this->assertClassHasAttribute('propertyNames', Setting::class);
+	}
+
+    /**
+     * test the set property method
+     * 
+     * also tests the validate_line protected 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 provider_set
+     */
+    public function test_set($property, $value, $expected_success, $expected_value = FALSE)
+    {
+        $success = $this->_setting->set($property, $value);
+        $this->assertEquals($expected_success, $success);
+        if($success)
+        {
+            if(! $expected_value ) { $expected_value = $value; }
+            $this->assertEquals($expected_value, $this->_setting->get($property));
+        }
+    }
+    /** 
+     * @dataProvider provider_set
+     */
+    public function test_magic_set($property, $value, $expected_success, $expected_value = FALSE)
+    {
+        $this->_setting->$property = $value;
+        if($expected_success)
+        {
+            $this->assertEquals($value, $this->_setting->get($property));
+        }
+    }
+    
+    public function provider_set()
+    {
+        return array(
+            array('Y', 'anything', FALSE),
+            array('settingID', 1, TRUE),
+            array('tuneID', array('alpha'), FALSE),
+            array('tuneID', 'alpha', FALSE),
+            array('tuneID', '1', TRUE),
+            array('tuneID', 1, TRUE),
+            array('f', 1, FALSE),
+            array('F', 1, FALSE),
+            array('F', '1',FALSE),
+            array('F', array('aplha'), TRUE),
+            array('P', array('string'), FALSE),
+            array('P', 10, FALSE),
+            array('P', 'string', TRUE),
+            array('Q', array('string'), FALSE),
+            array('Q', 10, FALSE),
+            array('Q', 'string', FALSE),
+            array('Q', '1/8=200', TRUE),
+            array('L', array('string'), FALSE),
+            array('L', 10, FALSE),
+            array('L', 'string', FALSE),
+            array('L', '1/8', TRUE),
+            array('M', array('string'), FALSE),
+            array('M', 10, FALSE),
+            array('M', 'string', FALSE),
+            array('M', '6/8', TRUE),
+            array('M', 'C', TRUE),
+            array('M', 'c', TRUE),
+            array('M', 'C|', TRUE),
+            array('K', array('string'), FALSE),
+            array('K', 10, FALSE),
+            array('K', 'C', TRUE),
+            array('K', 'Am', TRUE),
+            array('K', 'A minor', TRUE),
+            array('K', 'E dorian', TRUE),
+            array('music', 'GABc:|\\', TRUE),
+
+            array('Z', new Person(), FALSE),
+            array('Z', array(new Person(), 'not a person'), FALSE),
+            array('Z', array(new Person()), TRUE),
+            array('Z', 111, FALSE),
+            array('N', array('a string'), TRUE),
+            array('D', array('a string'), TRUE),
+            array('S', array('a string'), TRUE),
+            array('W', array('a string'), TRUE),
+            array('B', array('a string'), TRUE),
+        );
+    }
+    
+    /**
+     * the settingID can only be set if it's value is currently 0
+     * this ensures that we can't change a setting's id once it's set.
+     * the default, unset value for settingID is 0
+     */
+    public function test_set_settingID()
+    {
+        $success = $this->_setting->set('settingID', 1);
+        $this->assertTrue($success, 'first attempt should succeed');
+        
+        $success = $this->_setting->set('settingID', 2);
+        $this->assertFalse($success, 'second attempt should fail');
+    }
+    
+    
+    /**
+     * 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 provider_append
+     */
+    public function test_append($property, $value, $expected)
+    {
+        $success = $this->_setting->append($property, $value);
+        $this->assertEquals($expected, $success);
+        if($success)
+        {
+            $this->assertContains($value, $this->_setting->get($property));
+        }
+    }
+    
+    public function provider_append()
+    {
+        return array(
+            array('Y', 'anything', FALSE),
+            array('settingID', 1, FALSE),
+            array('tuneID', array('alpha'), FALSE),
+            array('tuneID', 'alpha', FALSE),
+            array('tuneID', '1', FALSE),
+            array('tuneID', 1, FALSE),
+            array('f', 1, FALSE),
+            array('F', 1, TRUE),
+            array('F', '1', TRUE),
+            array('F', array('aplha'), FALSE),
+            array('P', array('string'), FALSE),
+            array('P', 10, FALSE),
+            array('P', 'string', FALSE),
+            array('Q', array('string'), FALSE),
+            array('Q', 10, FALSE),
+            array('Q', 'string', FALSE),
+            array('Q', '1/8=200', FALSE),
+            array('L', array('string'), FALSE),
+            array('L', 10, FALSE),
+            array('L', 'string', FALSE),
+            array('L', '1/8', FALSE),
+            array('M', array('string'), FALSE),
+            array('M', 10, FALSE),
+            array('M', 'string', FALSE),
+            array('M', '6/8', FALSE),
+            array('M', 'C', FALSE),
+            array('M', 'c', FALSE),
+            array('M', 'C|', FALSE),
+            array('K', array('string'), FALSE),
+            array('K', 10, FALSE),
+            array('K', 'C', FALSE),
+            array('K', 'Am', FALSE),
+            array('K', 'A minor', FALSE),
+            array('K', 'E dorian', FALSE),
+            array('music', 'GABc:|\\', FALSE),
+
+            array('Z', new Person(), TRUE),
+            array('Z', array(new Person()), FALSE),
+            array('Z', 111, FALSE),
+            array('N', array('a string'), FALSE),
+            array('D', array('a string'), FALSE),
+            array('S', array('a string'), FALSE),
+            array('W', array('a string'), FALSE),
+            array('B', array('a string'), FALSE),
+            array('N', 'more notes', TRUE),
+            array('D', 'another record', TRUE),
+            array('S', 'another source', TRUE),
+            array('W', 'words', TRUE),
+            array('B', 'another book', TRUE),
+        );
+    }
+    
+    /**
+     * @dataProvider provider_get
+     */
+    public function test_get($key, $expected)
+    {
+        $result = $this->_setting->set($key, $expected);
+        $result = $this->_setting->get($key);
+        $this->assertEquals($expected, $result);
+    }
+
+    public function provider_get()
+    {
+        return array(
+            array('', FALSE),
+            array('me', FALSE),
+            array('settingID', 1),
+            array('tuneID', 2),
+            array('Q', '1/8=100'),
+            array('L', '1/8'),
+            array('M', '6/8'),
+            array('K', 'Am'),
+            array('music', 'GABc:|\\'),
+
+            array('Z', array(new Person())),
+            array('N', array('a string')),
+            array('D', array('a string')),
+            array('S', array('a string')),
+            array('W', array('a string')),
+            array('B', array('a string')),
+        );
+    } 
+    
+    /**
+     * test the static function equals
+     * returns true if the data properties of 2 Setting Objects
+     * are identical
+     * 
+     * @param (array) $params list of properties to set on the objects
+     * @param (boolean) $expected result of running equals
+     * 
+     * @dataProvider provider_equals
+     */
+    public function test_equals($params)
+    {
+        // $this->markTestIncomplete();
+        
+        $ob1 = new Setting();
+        $ob2 = new Setting();
+        
+        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(Setting::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 provider_equals
+     */
+    public function test_equals_fails($params)
+    {
+        $ob1 = new Setting();
+        $ob2 = new Setting();
+        
+        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+1);
+            }
+        }
+        $this->assertFalse(Setting::equals($ob1, $ob2));
+    }
+    public function provider_equals()
+    {
+        return array(
+            array( array('settingID'=>'2') ),
+            array( array('tuneID'=>'2') ),
+            array( array('Z'=> new Person()) ),
+            array( array('N'=>'an author') ),
+            array( array('D'=>'a composer') ),
+            array( array('S'=>'a group') ),
+            array( array('W'=>'some history') ),
+            array( array('B'=>'Plymouth') ),
+            array( array('F'=>'Jig') ),
+            array( array('P'=>'ABB') ),
+            array( array('Q'=>'1/8=100') ),
+            array( array('L'=>'1/4') ),
+            array( array('M'=>'2/4') ),
+            array( array('K'=>'G') ),
+            array( array('music'=>'a|cab|') ),
+        );
+    }
+    
+    public function test_isChanged()
+    {
+        $setting = new Setting();
+
+        $this->assertInstanceOf(Setting::class, $setting);
+        
+        $this->assertFalse($setting->is_changed(), 'after load should be no changes');
+        
+        $setting->set('K','G');
+        $this->assertTrue($setting->is_changed(), 'updating the name changes the data');
+    }
+    
+    
+    public function test_construct()
+    {
+        $params = array(
+            'settingID' => 3,
+            'Z'         => array(new Person()),
+            'P'         => 'ABC'
+        );
+        
+        $this->_setting = new Setting ($params);
+        
+        foreach($params as $key => $val)
+        {
+            $this->assertEquals($val, $this->_setting->get($key));
+        }
+    }
+
+}

tests/unit/memory/TuneCollectionTest.php

@@ -0,0 +1,210 @@
+<?php
+
+/**
+ * @group Lib
+ * @group Unit
+ */
+
+use App\Libraries\abcParse\Tune;
+//use App\Libraries\memory\Setting;
+use App\Libraries\abcParse\Person;
+use App\Libraries\abcParse\TuneCollection;
+use \Codeception\TestCase\Test as TestCase;
+
+class TuneCollectionTest extends TestCase
+{
+    private $_tunes;
+    
+    public function setUp()
+    {
+        $this->_tunes = new TuneCollection();
+    }
+    
+    
+    /**
+     * test the implementation of the Iterator interface
+     * 100% coverage! ;)
+     */
+    public function test_iterator()
+    {
+        $t = new Tune();
+        $this->assertEquals(0, count($this->_tunes));
+        $this->_tunes[] = $t;
+        $this->_tunes->push($t);
+        $this->assertEquals(2, count($this->_tunes));
+        
+        $this->assertInstanceOf(Tune::class, $this->_tunes[0], 'first tune');
+        $this->assertInstanceOf(Tune::class, $this->_tunes[1], 'second tune');
+        
+        foreach($this->_tunes as $key=>$val)
+        {
+            $this->assertInternalType('scalar', $key);
+            $this->assertInstanceOf(Tune::class, $val);
+            $this->assertTrue(isset($this->_tunes[$key]), 'key is set');
+            
+            unset($this->_tunes[$key]);
+            $this->assertFalse(isset($this->_tunes[$key]), 'key should have been unset');
+        }
+    }
+    
+    /**
+     * test the ability to remove the last tune from collection
+     * 
+     * tests the implementation of the Countable interface
+     */
+    public function test_pop()
+    {
+        $this->assertEquals(0, count($this->_tunes), 'no tunes in collection to begin with');
+        
+        $t = new Tune();
+        $this->_tunes->push($t);
+        
+        $this->assertEquals(1, count($this->_tunes), '1 tune added to collection');
+        
+        $result = $this->_tunes->pop();
+        $this->assertEquals(0, count($this->_tunes), 'no tunes left in collection');
+        $this->assertInstanceOf(Tune::class, $result);
+    }
+    
+    // public function test_construct()
+    // {
+        // $params = array(
+            // 'tc_id' => 5,
+            // 'cOwner' => 'me',
+            // 'B'     => array('my tune book'),
+            // 'R'     => 'reel'
+        // );
+//         
+        // $this->_tunes = new TuneCollection($params);
+//         
+        // foreach($params as $key => $val)
+        // {
+            // $this->assertEquals($val, $this->_tunes->get($key));
+        // }
+    // }
+    
+    /**
+     * 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 provider_set
+     */
+    public function test_set($property, $value, $expected)
+    {
+        $success = $this->_tunes->set($property, $value);
+        $this->assertEquals($expected, $success);
+        if($success)
+        {
+            $this->assertEquals($value, $this->_tunes->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 provider_set
+     */
+    public function test_magic_setter($property, $value, $expected)
+    {
+        $this->_tunes->$property = $value;
+        if($expected)
+        {
+            $this->assertEquals($value, $this->_tunes->get($property));
+        }
+    }
+    
+    public function provider_set()
+    {
+        return array(
+            array('Y', 'anything', FALSE),
+            array('A', 10, FALSE),
+            array('A', array('1','2'), FALSE),
+            array('A', array(new Person(),new Person()), TRUE),
+            array('C', 10, FALSE),
+            array('C', array('1','2'), FALSE),
+            array('C', array(new Person(),new Person()), TRUE),
+            array('H', 10, FALSE),
+            array('H', array('1','2'), TRUE),
+            array('O', 10, FALSE),
+            array('O', array('1','2'), TRUE),
+            array('R', 10, FALSE),
+            array('R', 'reel', TRUE),
+            array('collection', 10, FALSE),
+            array('collection', '10', FALSE),
+            array('collection', array(), FALSE),
+            array('collection', array('1','2'), FALSE),
+            array('collection', array(new Tune(), 'not a tune'), FALSE),
+            array('collection', array(new Tune()), TRUE),
+            array('tc_id', 'abc', FALSE),
+            array('tc_id', '11', TRUE),
+            array('tc_id', 15, TRUE),
+            array('cOwner', 'me', TRUE),
+        );
+    }
+    
+    public function test_set_tc_id()
+    {
+        //we should start with tc_id = 0
+        $this->assertEquals(0, $this->_tunes->get('tc_id'), 'should start at 0');
+        
+        //because tc_id == 0 we can change value
+        $this->_tunes->set('tc_id', 4);
+        $this->assertEquals(4, $this->_tunes->get('tc_id'), 'should have changed to 4');
+        
+        //tc_id is not 0 so we cannot change value
+        $this->_tunes->set('tc_id', 11);
+        $this->assertEquals(4, $this->_tunes->get('tc_id'), '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 provider_append
+     */
+    public function test_append($property, $value, $expected)
+    {
+        $success = $this->_tunes->append($property, $value);
+        $this->assertEquals($expected, $success);
+        if($success)
+        {
+            $this->assertContains($value, $this->_tunes->get($property));
+        }
+    }
+    
+    public function provider_append()
+    {
+        return array(
+            array('Y', 1, FALSE),
+            array('H', 'history', TRUE),
+            array('R', 'reel', TRUE),
+            array('r', 'reel', FALSE),
+            array('collection', 'setting', FALSE),
+            array('collection', new Tune(), TRUE),
+            array('collection', array(new Tune()), FALSE),
+        );
+    }
+    
+    
+    
+    public function test_get()
+    {
+        //R is a valid property so we should get it's value
+        $this->_tunes->set('R', 'reel');
+        $this->assertEquals('reel', $this->_tunes->get('R'));
+        
+        //X is not a property, so we should get FALSE
+        $this->assertFalse($this->_tunes->get('X'));
+    }
+    
+}

tests/unit/memory/TuneTest.php

@@ -0,0 +1,310 @@
+<?php
+
+use App\Libraries\abcParse\Tune;
+use App\Libraries\abcParse\Setting;
+use App\Libraries\abcParse\Person;
+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 test_model_definition()
+    {
+        //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 provider_set
+     */
+    public function test_set($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 provider_set
+     */
+    public function test_magic_setter($property, $value, $expected)
+    {
+        $this->_tune->$property = $value;
+        // $this->assertEquals($expected, $success);
+        if($expected)
+        {
+            $this->assertEquals($value, $this->_tune->get($property));
+        }
+    }
+        
+    /**
+     * @dataProvider provider_set
+     */
+    public function test_construct($property, $value, $expected)
+    {
+        $params = array($property => $value);
+        $this->_tune = new Tune($params);
+        
+        if($expected)
+        {
+            $this->assertEquals($value, $this->_tune->get($property));
+        }
+    } 
+    
+    public function provider_set()
+    {
+        return array(
+            array('Y', 'anything', FALSE),
+            array('x', 1, FALSE),
+            array('X', 1, TRUE),
+            array('X', 'aplha', FALSE),
+            array('X', '2', TRUE),
+            array('T', 'string', FALSE),
+            array('T', 10, FALSE),
+            array('T', array('1','2'), TRUE),
+            array('A', 10, FALSE),
+            array('A', array('1','2'), FALSE),
+            array('A', array(new Person(),new Person()), TRUE),
+            array('C', 10, FALSE),
+            array('C', array('1','2'), FALSE),
+            array('C', array(new Person(),new Person()), TRUE),
+            array('G', 10, FALSE),
+            array('G', array('1','2'), TRUE),
+            array('H', 10, FALSE),
+            array('H', array('1','2'), TRUE),
+            array('O', 10, FALSE),
+            array('O', array('1','2'), TRUE),
+            array('R', 10, FALSE),
+            array('R', array('1','2'), TRUE),
+            array('collection', 10, FALSE),
+            array('collection', '10', FALSE),
+            array('collection', array(), FALSE),
+            array('collection', array('1','2'), FALSE),
+            array('collection', array(new Setting()), TRUE),
+            array('tuneHash', 10, FALSE),
+            array('tuneHash', '10', FALSE),
+            array('tuneHash', array(), FALSE),
+            array('tuneHash', array('1','2'), FALSE),
+            array('tuneID', 'abc', FALSE),
+            array('tuneID', '11', TRUE),
+            array('tuneID', 15, TRUE),
+        );
+    }
+
+    public function test_set_tuneID()
+    {
+        //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 provider_append
+     */
+    public function test_append($property, $value, $expected)
+    {
+        $success = $this->_tune->append($property, $value);
+        $this->assertEquals($expected, $success);
+        if($success)
+        {
+            $this->assertContains($value, $this->_tune->get($property));
+        }
+    }
+    
+    public function provider_append()
+    {
+        return array(
+            array('Y', 1, FALSE),
+            array('X', 1, FALSE),
+            array('T','title', TRUE),
+            array('T', array('of','titles'), FALSE),
+            array('A', 'author', TRUE),
+            array('C', 'composer', TRUE),
+            array('G', 'Group', TRUE),
+            array('H', 'history', TRUE),
+            array('O', 'Origin', TRUE),
+            array('R', 'Rhythm', TRUE),
+            array('collection', 'setting', FALSE),
+            array('collection', new Setting(), TRUE),
+            array('collection', array(new Setting()), FALSE),
+            array('tuneHash', 'tuneHash', FALSE),
+            array('tuneHash', new Setting(), FALSE),
+            array('tuneHash', array(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 provider_equals
+     */
+    public function test_equals($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 provider_equals
+     */
+    public function test_equals_fails($params)
+    {
+        $ob1 = new Tune();
+        $ob2 = new Tune();
+        
+        foreach($params as $key => $val)
+        {
+            if($key === 'collection')
+            {
+                $ob1->set($key, $val);
+            }
+            else if(is_array($ob1->get($key)))
+            {
+                $ob1->append($key, $val);
+            }
+            else {
+                $ob1->set($key, $val);
+            }
+        }
+        $this->assertFalse(Tune::equals($ob1, $ob2));
+    }
+    public function provider_equals()
+    {
+        $setting1 = new Setting(array('settingID'=>5, 'tuneID'=>444));
+        $setting2 = new Setting(array('settingID'=>3, 'tuneID'=>2244));
+        return array(
+            array( array('X'=>'2') ),
+            array( array('T'=>'a title') ),
+            array( array('A'=>'an author') ),
+            array( array('C'=>'a composer') ),
+            array( array('G'=>'a group') ),
+            array( array('H'=>'some history') ),
+            array( array('O'=>'Plymouth') ),
+            array( array('R'=>'Jig') ),
+            array( array('collection' => array($setting1, $setting2) ))
+        );
+    }
+	
+    
+    public function test_isChanged()
+    {
+        $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 provider_get
+     */
+    public function test_get($key, $expected)
+    {
+        $result = $this->_tune->set($key, $expected);
+        $result = $this->_tune->get($key);
+        $this->assertEquals($expected, $result);
+    }
+
+    public function provider_get()
+    {
+        return array(
+            array('', FALSE),
+            array('me', FALSE),
+            array('tuneID', 2),
+            array('X', '2'),
+            array('T', array('1','2')),
+            array('A', array(new Person(),new Person())),
+            array('C', array(new Person(),new Person())),
+            array('G', array('1','2')),
+            array('H', array('1','2')),
+            array('O', array('1','2')),
+            array('R', array('1','2')),
+            array('collection', array(new Setting())),
+        );
+    }
+
+}