abcParser/tests/unit/Laravel5/TuneSettingTest.php

<?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]);
    }

}