public function testSampleNewsDelete()
 {
     $mapper = test_spot_mapper();
     $post = $mapper->first('Entity_Post', array('title' => "Test Post Modified"));
     $result = $mapper->delete($post);
     $this->assertTrue($result);
 }

 public function testGetCustomEntityMapper()
 {
     $mapper = test_spot_mapper('SpotTest\\Entity\\Event');
     $this->assertInstanceOf(Entity\Event::mapper(), $mapper);
     $query = $mapper->testQuery();
     $this->assertInstanceOf('Spot\\Query', $query);
 }

 public function testLength()
 {
     $mapper = test_spot_mapper();
     $entity = new Entity_Author(array('email' => 't@t', 'password' => 'test'));
     $mapper->save($entity);
     $this->assertTrue($entity->hasErrors());
     $this->assertContains("Email must be longer than 4", $entity->errors('email'));
 }

 public function testPostHasManyPolymorphicComments()
 {
     $mapper = test_spot_mapper('SpotTest\\Entity\\Post');
     $post = $mapper->first();
     $this->assertInstanceOf('SpotTest\\Entity\\Post', $post);
     $query = $post->polymorphic_comments->query();
     $this->assertEquals(3, count($post->polymorphic_comments));
 }

 public function testLength()
 {
     $mapper = test_spot_mapper('SpotTest\\Entity\\Author');
     $entity = new SpotTest\Entity\Author(['email' => 't@t', 'password' => 'test']);
     $mapper->save($entity);
     $this->assertTrue($entity->hasErrors());
     $this->assertContains("Email must be longer than 4", $entity->errors('email'));
 }

 public function testInsertPostArray()
 {
     $mapper = test_spot_mapper();
     $post = array('title' => "Test Post", 'body' => "<p>This is a really awesome super-duper post.</p><p>It's really quite lovely.</p>", 'date_created' => $mapper->connection('\\Spot\\Entity\\Post')->dateTime());
     $result = $mapper->insert('\\Spot\\Entity\\Post', $post);
     // returns inserted id
     $this->assertTrue($result !== false);
 }

 public function testEntitySetDataConstruct()
 {
     $mapper = test_spot_mapper();
     $post = new Entity_Post(array('title' => 'My Awesome Post', 'body' => '<p>Body</p>'));
     $data = $post->data();
     ksort($data);
     $testData = array('id' => null, 'title' => 'My Awesome Post', 'body' => '<p>Body</p>', 'status' => 0, 'date_created' => null);
     ksort($testData);
     $this->assertEquals($testData, $data);
 }

 public function testUniqueCompoundIndexNoValidationErrorWhenDataDifferent()
 {
     $zipMapper = test_spot_mapper('\\SpotTest\\Entity\\Zip');
     $data = ['code' => '23456', 'city' => 'Testville', 'state' => 'NY', 'lat' => 1, 'lng' => 2];
     $zip1 = $zipMapper->create($data);
     // Make data slightly different on unique compound index
     $data2 = array_merge($data, ['city' => 'Testville2']);
     $zip2 = $zipMapper->create($data2);
     $this->assertEmpty($zip1->errors());
     $this->assertEmpty($zip2->errors());
 }

 public function testEntityRelations()
 {
     $mapper = test_spot_mapper();
     $post = new Entity_Post();
     $relations = $mapper->relations('Entity_Post');
     $sortedRelations = array_keys($relations);
     sort($sortedRelations);
     // Assert $relations are correct
     $testRelations = array('comments', 'tags', 'author');
     sort($testRelations);
     $this->assertEquals($sortedRelations, $testRelations);
 }

 public function testEntitySetPropertiesData()
 {
     $mapper = test_spot_mapper();
     $post = new Entity_Post();
     // Set data
     $post->title = "My Awesome Post";
     $post->body = "<p>Body</p>";
     $data = $mapper->data($post);
     ksort($data);
     $testData = array('id' => null, 'title' => 'My Awesome Post', 'body' => '<p>Body</p>', 'status' => null, 'date_created' => null);
     ksort($testData);
     $this->assertEquals($testData, $data);
 }

 public static function events(EventEmitter $eventEmitter)
 {
     $eventEmitter->on('beforeInsert', function ($entity, $mapper) {
         $entity->token = uniqid();
     });
     $eventEmitter->on('afterInsert', function ($entity, $mapper) {
         $mapper = test_spot_mapper('SpotTest\\Entity\\Event\\Search');
         $result = $mapper->create(['event_id' => $entity->id, 'body' => $entity->title . ' ' . $entity->description]);
         if (!$result) {
             throw new \Spot\Exception("Event search index entity failed to save!");
         }
     });
 }

 public function testUniqueFieldCreatesValidationError()
 {
     $mapper = test_spot_mapper();
     // Setup new user
     $user1 = new \Spot\Entity\User(array('email' => '[email protected]', 'password' => 'test', 'is_admin' => true));
     $mapper->save($user1);
     // Setup new user (identical, expecting a validation error)
     $user2 = new \Spot\Entity\User(array('email' => '[email protected]', 'password' => 'test', 'is_admin' => false));
     $mapper->save($user2);
     $this->assertFalse($user1->hasErrors());
     $this->assertTrue($user2->hasErrors());
     $this->assertEquals($user2->errors('email'), array("Email '[email protected]' is already taken."));
 }

 public function testEventSearchIndex()
 {
     $mapper = test_spot_mapper();
     if (!$mapper->config()->connection() instanceof \Spot\Adapter\Mysql) {
         $this->markTestSkipped('Only supported in MySQL - requires FULLTEXT search');
     }
     $event = new Entity_Event(array('title' => 'Test Event 1', 'description' => 'Test Description', 'type' => 'free', 'date_start' => strtotime('+1 day')));
     $mapper->save($event);
     // Ensure Event_Search record was inserted with 'afterSave' hook
     $eventSearchEntity = $mapper->first('Entity_Event_Search', array('event_id' => $event->id));
     $this->assertInstanceOf('Entity_Event_Search', $eventSearchEntity);
     $events = $mapper->all('Entity_Event_Search')->search('body', 'Test', array('boolean' => true))->execute();
     $this->assertGreaterThan(0, count($events));
 }

 public function testRelationConditions()
 {
     $mapper = test_spot_mapper();
     for ($i = 1; $i <= 10; $i++) {
         $id = $mapper->insert('Entity_Post', array('title' => ($i % 2 ? 'odd' : 'even') . '_title', 'author_id' => 1, 'body' => '<p>' . $i . '_body</p>', 'status' => $i, 'date_created' => $mapper->connection('Entity_Post')->dateTime()));
         for ($j = 1; $j <= 2; $j++) {
             $mapper->insert('Entity_Post_Comment', array('post_id' => $id, 'name' => ($j % 2 ? 'odd' : 'even') . '_title', 'email' => '[email protected]', 'body' => ($j % 2 ? 'odd' : 'even') . '_comment_body'));
         }
     }
     $post = $mapper->all('Entity_Post')->first();
     $relation = $mapper->loadRelation($post, 'comments');
     $this->assertEquals($relation->conditions(), array('post_id' => 1));
     $posts = $mapper->all('Entity_Post')->execute();
     $relation = $mapper->loadRelation($posts, 'comments');
     $this->assertEquals($relation->conditions(), array('post_id' => array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)));
 }

 public function testInsertWithTransactionRollbackOnReturnFalse()
 {
     $post = new \Spot\Entity\Post();
     $mapper = test_spot_mapper();
     $post->title = "Rolledback";
     $post->body = "<p>This is a really awesome super-duper post -- in a TRANSACTION!.</p>";
     $post->date_created = $mapper->connection('\\Spot\\Entity\\Post')->dateTime();
     // Save in transation
     $phpunit = $this;
     $mapper->transaction(function ($mapper) use($post, $phpunit) {
         $result = $mapper->insert($post);
         // Return false AFTER save to trigger rollback
         return false;
     });
     // Ensure record was NOT saved
     $this->assertFalse($mapper->first('\\Spot\\Entity\\Post', array('title' => $post->title)));
 }

 public function testCustomTypeRegistration()
 {
     $mapper = test_spot_mapper();
     $cfg = $mapper->config();
     // Register JSON type, add json field type, and migrate
     $cfg->typeHandler('json_oneway', 'Test\\Type\\Json');
     Entity_Type::$_fields['json_oneway'] = array('type' => 'json_oneway');
     $mapper->entityManager()->resetFields();
     // Have to resetFields b/c field definitions are cached
     $this->assertArrayHasKey('json_oneway', $mapper->fields('Entity_Type'));
     $mapper->migrate('Entity_Type');
     // Save array data with JSON type
     $data = array('json_oneway' => array('a' => 'b', 'foo' => 'bar'));
     $result = $mapper->create('Entity_Type', $data);
     $this->assertTrue($result !== false);
     // Select entity from db to ensure it is saved correctly
     $entity = $mapper->get('Entity_Type', $result->id);
     $this->assertSame(json_encode($data['json_oneway']), $entity->json_oneway);
     $mapper->dropDatasource('Entity_Type');
 }

 /**
  * @depends testEventInsert
  */
 public function testEventSearchBelongsToEvent($eventId)
 {
     $mapper = test_spot_mapper('SpotTest\\Entity\\Event\\Search');
     $eventSearch = $mapper->first(['event_id' => $eventId]);
     $this->assertInstanceOf('SpotTest\\Entity\\Event', $eventSearch->event->execute());
 }

 public function testSerialized()
 {
     $data = array('title' => 'A Post', 'body' => 'A Body', 'status' => 0, 'author_id' => 1, 'data' => array('posts' => 'are cool', 'another field' => 'to serialize'));
     $post = new Entity_Post($data);
     $this->assertEquals($post->data, array('posts' => 'are cool', 'another field' => 'to serialize'));
     $mapper = test_spot_mapper();
     $mapper->save($post);
     $post = $mapper->all('Entity_Post')->first();
     $this->assertEquals($post->data, array('posts' => 'are cool', 'another field' => 'to serialize'));
     $post->data = 'asdf';
     $this->assertEquals($post->data, 'asdf');
     $mapper->save($post);
     $post = $mapper->all('Entity_Post')->first();
     $this->assertEquals($post->data, 'asdf');
 }

 public function testInsertEventRunsTypeOptionsValidation()
 {
     $mapper = test_spot_mapper('\\SpotTest\\Entity\\Event');
     $event = new \SpotTest\Entity\Event(['title' => 'Test Event 1', 'description' => 'Test Description', 'type' => 'invalid_value', 'date_start' => new \DateTime('+1 day')]);
     $result = $mapper->insert($event);
     $this->assertFalse($result);
     $this->assertEquals(['Type contains invalid value'], $event->errors('type'));
 }

 /**
  * @expectedException InvalidArgumentException
  */
 public function testInvalidRelationClass()
 {
     $mapper = test_spot_mapper('SpotTest\\Entity\\Post');
     $entity = $mapper->first();
     $entity->fake = $mapper->hasOne($entity, 'Nonexistent\\Entity', 'fake_field');
     $entity->fake->something;
 }