abc-api/abcParser
1
0
Fork 0
Code Issues Pull Requests Releases Activity

initial commit

Browse Source
This commit is contained in:
richard
2016-04-15 21:38:56 -04:00
commit 1d3e8e3117
79 changed files with 16223 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

522
tests/unit/Laravel5/CollectionTest.php Normal file
View File

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