public function testUserAdd()
 {
     $user = factory(User::class, 'valid-user')->make();
     $values = ['first_name' => $user->first_name, 'last_name' => $user->last_name, 'email' => $user->email, 'username' => $user->username, 'password' => $user->password];
     User::create($values);
     $this->tester->seeRecord('users', $values);
 }

 public function testAssetAdd()
 {
     $company = factory(Company::class, 'company')->make();
     $values = ['name' => $company->name];
     Company::create($values);
     $this->tester->seeRecord('companies', $values);
 }

 public function testAssetAdd()
 {
     $location = factory(Location::class, 'location')->make();
     $values = ['name' => $location->name];
     Location::create($values);
     $this->tester->seeRecord('locations', $values);
 }

 public function testLostStatuslabelAdd()
 {
     $statuslabel = factory(Statuslabel::class, 'lost')->make();
     $values = ['name' => $statuslabel->name];
     Statuslabel::create($values);
     $this->tester->seeRecord('status_labels', $values);
 }

 public function testLiking()
 {
     $idUser1 = 1;
     $idUser2 = 2;
     $idUser3 = 3;
     $idUser4 = 4;
     $photoidUser1 = 1;
     $photoidUser2 = 4;
     $photoidUser3 = 8;
     $photoidUser4 = 11;
     // User should be able to like photos they don't own
     list($result_code, $result) = User::likePhoto($idUser1, $photoidUser2);
     $this->assertEquals(200, $result_code);
     $this->assertTrue($result['success'] == true);
     $this->assertTrue($result['likes'] == true);
     $this->tester->seeInDatabase('UserPhotoLikes', ['userid' => $idUser1, 'photoid' => $photoidUser2]);
     // User should be able to unlike photos they don't own
     list($result_code, $result) = User::likePhoto($idUser1, $photoidUser2);
     $this->assertEquals(200, $result_code);
     $this->assertTrue($result['success'] == true);
     $this->assertTrue($result['likes'] == false);
     $this->tester->dontSeeInDatabase('UserPhotoLikes', ['userid' => $idUser1, 'photoid' => $photoidUser2]);
     // User should not be be able to like photos they own
     list($result_code, $result) = User::likePhoto($idUser1, $photoidUser1);
     $this->assertEquals(403, $result_code);
     $this->assertTrue($result['success'] == false);
     $this->tester->dontSeeInDatabase('UserPhotoLikes', ['userid' => $idUser1, 'photoid' => $photoidUser1]);
     // User should not be be able to like photos that don't exist
     list($result_code, $result) = User::likePhoto($idUser1, 0);
     $this->assertEquals(404, $result_code);
     $this->assertTrue($result['success'] == false);
     $this->tester->dontSeeInDatabase('UserPhotoLikes', ['userid' => $idUser1, 'photoid' => 0]);
 }

 public function testRoleCanBeDeleted()
 {
     $id = $this->tester->haveRecord('roles', ['role_name' => 'user']);
     $role = \ChopBox\Role::find($id);
     $role->delete();
     $this->tester->dontSeeRecord('roles', ['role_name' => 'user']);
 }

 public function testConsumableAdd()
 {
     $consumable = factory(Consumable::class, 'consumable')->make();
     $values = ['name' => $consumable->name, 'qty' => $consumable->qty, 'category_id' => $consumable->category_id, 'company_id' => $consumable->company_id];
     Consumable::create($values);
     $this->tester->seeRecord('consumables', $values);
 }

 public function testAccessoryCategoryAdd()
 {
     $category = factory(Category::class, 'accessory-category')->make();
     $values = ['name' => $category->name, 'category_type' => $category->category_type];
     Category::create($values);
     $this->tester->seeRecord('categories', $values);
 }

 public function testLostStatuslabelAdd()
 {
     $statuslabel = factory(Statuslabel::class, 'lost')->make();
     $values = ['name' => $statuslabel->name, 'deployable' => $statuslabel->deployable, 'pending' => $statuslabel->pending, 'archived' => $statuslabel->archived];
     Statuslabel::create($values);
     $this->tester->seeRecord('status_labels', $values);
 }

 public function testCreateWithoutFactory()
 {
     $factory = new \WebChemistry\Forms\Factory\Container();
     $this->tester->assertExceptionThrown('WebChemistry\\Forms\\FormException', function () use($factory) {
         $factory->create();
     });
 }

 public function testAssetModelAdd()
 {
     $assetmodel = factory(AssetModel::class, 'assetmodel')->make();
     $values = ['name' => $assetmodel->name, 'manufacturer_id' => $assetmodel->manufacturer_id, 'category_id' => $assetmodel->category_id, 'eol' => $assetmodel->eol];
     AssetModel::create($values);
     $this->tester->seeRecord('models', $values);
 }

 /**
  * @return mixed
  */
 public function createPlantWithColorForTest()
 {
     $plantID = $this->tester->haveRecord('plants', ['name' => 'test plant']);
     $colorArray = array("red" => "red", "yellow" => "yellow", "blue" => NULL, "green" => NULL, "brown" => NULL, "black" => NULL, "white" => NULL, "purple" => NULL, "orange" => NULL);
     $this->UUT->set($plantID, $colorArray);
     return $plantID;
 }

 public function testWrongTimestamps()
 {
     foreach ($this->bad_timestamps as $bad) {
         $this->modelWValidation->start_date = $bad;
         $this->tester->assertFalse($this->modelWValidation->save());
     }
 }

 public function testSetUnit()
 {
     $metric = new Metric();
     $this->tester->assertFalse($metric->setUnit('Invalid'), 'Metric::setUnit invalid unit set failed!');
     $metric->setUnit('Kilobits/Second');
     $this->tester->assertEquals('Kilobits/Second', $metric->getUnit(), 'Metric::setUnit failed!');
 }

 public function testSupplierAdd()
 {
     $supplier = factory(Supplier::class, 'supplier')->make();
     $values = ['name' => $supplier->name];
     Supplier::create($values);
     $this->tester->seeRecord('suppliers', $values);
 }

 public function testAccessoryAdd()
 {
     $accessory = factory(Accessory::class, 'accessory')->make();
     $values = ['name' => $accessory->name, 'category_id' => $accessory->category_id, 'qty' => $accessory->qty];
     Accessory::create($values);
     $this->tester->seeRecord('accessories', $values);
 }

 public function testManufacturerAdd()
 {
     $manufacturers = factory(Manufacturer::class, 'manufacturer')->make();
     $values = ['name' => $manufacturers->name];
     Manufacturer::create($values);
     $this->tester->seeRecord('manufacturers', $values);
 }

 public function testProcessProlog()
 {
     $I = $this->tester;
     $this->tester->wantToTest("processing the prolog and importing the file into the database");
     $this->import->setCsvReader($this->import->file);
     $this->import->processProlog();
     $prolog = $this->import->prolog;
     $this->assertEquals(14, count($prolog['columns']), "There are the correct number of columns");
     $this->assertEquals(6, count($prolog['prefix']), "There are the correct number of prefix entries");
     $this->assertEquals(10, count($prolog['meta']), "There are the correct number of meta entries");
     $this->import->getDataColumnIds();
     $this->import->processData();
     $results = $this->import->results['success'];
     verify(
       "There were 8 rows processed",
       count($results['rows'])
     )->equals(12);
     $this->import->processParents();
     $I->seeRecordCountInDatabaseTable("SchemaPropertyElement", 138);
     $I->seeRecordCountInDatabaseTable("SchemaProperty", 12);
     //prolog namespace entries are readable
     //prolog headers are actually in row 1
     //prolog headers not in row 1 produce fatal error (logged)
     //prolog entries can be matched to database (column uri matched to profile id)
     //prolog entries that can't be matched produce fatal error (logged)
 } //

 public function testWrongDates()
 {
     foreach ($this->bad_dates as $bad) {
         $this->modelWValidation->date_birth = $bad;
         $this->tester->assertFalse($this->modelWValidation->save());
     }
 }

 public function testAssetAdd()
 {
     $asset = factory(Asset::class, 'asset')->make();
     $values = ['name' => $asset->name, 'model_id' => $asset->model_id, 'status_id' => $asset->status_id, 'asset_tag' => $asset->asset_tag];
     Asset::create($values);
     $this->tester->seeRecord('assets', $values);
 }