/**
  * Tests whether we can grab an Episode that is due to be released within a
  * specified length of time from now.
  */
 public function testGetOneEpisodeReleasedWithinSeconds()
 {
     // Create Test Subreddit
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 1000));
     $subreddit->setDomain(rand(0, 1000));
     $subreddit->save();
     // Create Test Episode
     $episode = new Episode();
     $episode->setReleaseDate(date('Y-m-d H:i:s', time() + 100));
     $episode->setSubreddit($subreddit);
     $episode->save();
     $another_episode = new Episode();
     $another_episode->setReleaseDate(date('Y-m-d H:i:s', time() + 500));
     $another_episode->setSubreddit($subreddit);
     $another_episode->save();
     $seconds_within = 200;
     // Run table query to grab episode without ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within);
     $this->assertTrue($random_episode instanceof Episode);
     // Run table query to grab episode WITH ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within, $episode->getIncremented());
     $this->assertTrue($random_episode instanceof Episode);
     // Run table query to grab anotherepisode WITH ID
     $random_episode = EpisodeTable::getInstance()->getOneEpisodeReleasedWithinSeconds($seconds_within, $another_episode->getIncremented());
     $this->assertFalse($random_episode instanceof Episode);
     // Delete episodes
     $another_episode->delete();
     $episode->delete();
     // Delete subreddit.
     $subreddit->delete();
 }
 /**
  * Tests saving a sfGuardUserSubredditMembership that identifies a User as
  * "blocked" for a particular Subreddit.  When this occurs, all existing
  * future EpisodeAssignments should be deleted because blocked users cannot
  * participate with the Subreddit.
  */
 public function testSavingBlockedUser()
 {
     // Establish fake Subreddit
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 1000));
     $subreddit->setDomain(rand(0, 1000));
     $subreddit->save();
     // Establish User
     $user = new sfGuardUser();
     $user->setEmailAddress(rand(0, 100000));
     $user->setUsername(rand(0, 10000));
     $user->setIsValidated(1);
     $user->save();
     $user_id = $user->getIncremented();
     $this->assertNotEquals(0, $user_id);
     // Establish Episode for Subreddit
     $episode = new Episode();
     $episode->setSubreddit($subreddit);
     $episode->setReleaseDate(date('Y-m-d H:i:s', time() + 34000));
     $episode->save();
     $author_type = AuthorTypeTable::getInstance()->findOneBy('type', 'squid');
     $deadline = new Deadline();
     $deadline->setSubreddit($subreddit);
     $deadline->setAuthorType($author_type);
     $deadline->setSeconds(0);
     $deadline->save();
     $episode_assignment = new EpisodeAssignment();
     $episode_assignment->setSfGuardUser($user);
     $episode_assignment->setEpisode($episode);
     $episode_assignment->setAuthorType($author_type);
     $episode_assignment->save();
     $number_of_episodes = EpisodeAssignmentTable::getInstance()->createQuery()->select('COUNT(EpisodeAssignment.id)')->leftJoin('Episode')->where('subreddit_id = ?', $subreddit->getIncremented())->andWhere('EpisodeAssignment.sf_guard_user_id = ?', $user_id)->andWhere('Episode.release_date > NOW()')->groupBy('EpisodeAssignment.id')->count();
     $this->assertEquals(1, $number_of_episodes);
     // Establish User Membership as Blocked
     $blocked = MembershipTable::getInstance()->findOneBy('type', 'blocked');
     $user_membership = new sfGuardUserSubredditMembership();
     $user_membership->setSubreddit($subreddit);
     $user_membership->setSfGuardUser($user);
     $user_membership->setMembership($blocked);
     // Save Membership
     $user_membership->save();
     // Asert that User has zero Episodes
     $number_of_episodes = EpisodeAssignmentTable::getInstance()->createQuery()->select('COUNT(EpisodeAssignment.id)')->leftJoin('Episode')->where('subreddit_id = ?', $subreddit->getIncremented())->andWhere('EpisodeAssignment.sf_guard_user_id = ?', $user_id)->andWhere('Episode.release_date > NOW()')->groupBy('EpisodeAssignment.id');
     $sql = $number_of_episodes->getSqlQuery();
     $number_of_episodes = $number_of_episodes->count();
     $this->assertTrue(0 == $number_of_episodes, $sql . "\n" . $subreddit->getIncremented() . "\n" . $user_id);
     // Remove User Membership
     $user_membership->delete();
     // Delete User
     $user->delete();
     // Delete Episode
     $episode->delete();
     // Delete Deadline
     $deadline->delete();
     // Delete Subreddit
     $subreddit->delete();
 }
 function unsubscribe($subreddit)
 {
     $user = User::whereUsername(Auth::user()->username)->first();
     $sredit = Subreddit::whereTitle($subreddit)->first();
     $user->subscriptions()->detach([$sredit->id]);
     return Redirect::to('/r/' . $subreddit);
 }
Пример #4
0
 function display($subreddit, $post)
 {
     $post = Post::whererand($post)->first();
     $subreddit = Subreddit::whereTitle($subreddit)->first();
     $comments = $post->comments;
     return View::make('post.view', ['post' => $post, 'subreddit' => $subreddit, 'comments' => $comments]);
 }
 /**
  * Similar to the testGetSubredditsNotNeedingEpisodeGeneration() test above,
  * this tests whether we can grab the inevrse: all of the Subreddits that
  * *don't* have future Episodes beyond one interval of the creation
  * interval.
  */
 public function testGetSubredditsNeedingEpisodeGeneration()
 {
     // Create Test Subreddit
     $subreddit = new Subreddit();
     $subreddit->setName('test2');
     $subreddit->setDomain('test2');
     $subreddit->setCreateNewEpisodesCronFormatted('0 0 1 * *');
     $subreddit->setEpisodeScheduleCronFormatted('0 0 1 * *');
     $subreddit->setCreationInterval('0');
     $subreddit->save();
     // Test against all Subreddits
     $subreddits = SubredditTable::getInstance()->getSubredditsNeedingEpisodeGeneration();
     $this->assertTrue(!empty($subreddits));
     $this->assertTrue($subreddits[0] instanceof Subreddit);
     // Test against Test Subreddit
     $subreddits = SubredditTable::getInstance()->getSubredditsNeedingEpisodeGeneration($subreddit->getName());
     $this->assertTrue(!empty($subreddits));
     $this->assertTrue($subreddits[0] instanceof Subreddit);
     $this->assertTrue($subreddits[0] == $subreddit);
     $subreddit->delete();
 }
 /**
  * Since a User can only have one membership in a Subreddit, this tests that
  * the first returned sfGuardUserSubredditMembership is the exact same as
  * the only one made.  The limitation on sfGuardUserSubredditMemberships is
  * in place using Unique indexes in the database, so we depend upon that to
  * prevent multiple Subreddit Memberships.
  */
 public function testGetFirstByUserSubredditAndMemberships()
 {
     $user = new sfGuardUser();
     $user->setEmailAddress(rand(0, 1000));
     $user->setUsername(rand(0, 1000));
     $user->setIsValidated(1);
     $user->save();
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 1000));
     $subreddit->setDomain(rand(0, 1000));
     $subreddit->save();
     $membership = MembershipTable::getInstance()->findOneByType('user');
     $second_membership = MembershipTable::getInstance()->findOneByType('admin');
     $user_subreddit_membership = new sfGuardUserSubredditMembership();
     $user_subreddit_membership->setSfGuardUserId($user->getIncremented());
     $user_subreddit_membership->setSubredditId($subreddit->getIncremented());
     $user_subreddit_membership->setMembership($membership);
     $user_subreddit_membership->save();
     $second_user_subreddit_membership = new sfGuardUserSubredditMembership();
     $second_user_subreddit_membership->setSfGuardUserId($user->getIncremented());
     $second_user_subreddit_membership->setSubredditId($subreddit->getIncremented());
     $second_user_subreddit_membership->setMembership($second_membership);
     $exception_thrown = false;
     try {
         $second_user_subreddit_membership->save();
     } catch (Exception $exception) {
         unset($exception);
         $exception_thrown = true;
     }
     $retrieved_object = sfGuardUserSubredditMembershipTable::getInstance()->getFirstByUserSubredditAndMemberships($user->getIncremented(), $subreddit->getIncremented(), array($membership->getType()));
     $this->assertEquals($retrieved_object->getIncremented(), $user_subreddit_membership->getIncremented());
     $user_subreddit_membership->delete();
     $subreddit->delete();
     $user->delete();
     $this->assertTrue($exception_thrown);
 }
 /**
  * We've combined the process for preventing saving with a specific call for
  * deletion to aid in handling errors and dealing with unsaved objects.
  * This tests whether the exception is thrown
  */
 public function testdeleteWithException()
 {
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 10000));
     $subreddit->setDomain(rand(0, 10000));
     $subreddit->save();
     $user = new sfGuardUser();
     $user->setUsername(rand(0, 10000));
     $user->setEmailAddress(rand(0, 10000));
     $user->setIsValidated(1);
     $user->save();
     $first = AuthorTypeTable::getInstance()->findOneByType('squid');
     $episode = new Episode();
     $episode->setReleaseDate(date('Y-m-d H:i:s', time() + 100000));
     $episode->setSubreddit($subreddit);
     $episode->save();
     $deadline = new Deadline();
     $deadline->setSubreddit($subreddit);
     $deadline->setAuthorType($first);
     $deadline->setSeconds(0);
     $deadline->save();
     $assignment = new EpisodeAssignment();
     $assignment->setSfGuardUser($user);
     $assignment->setEpisode($episode);
     $assignment->setAuthorType($first);
     $assignment->save();
     // Delete with exception
     $exception_thrown = false;
     $exception_code = 987654321;
     try {
         $assignment->deleteWithException("Test exception", $exception_code);
     } catch (sfException $exception) {
         $this->assertEquals($exception_code, $exception->getCode());
         unset($exception);
         $exception_thrown = true;
     }
     $this->assertTrue($exception_thrown);
     // Delete the rest of the objects
     $episode->delete();
     $user->delete();
     $subreddit->delete();
 }
<?php

include dirname(__FILE__) . '/../../bootstrap/functional.php';
/**
 * This is an example class of sfTestFunctional
 * It may require some attention to work with the default values (line 40).
 */
$browser = new sfBrowser();
$test_browser = new sfTestFunctional($browser);
$test_browser->setTester('json.response', 'sfTesterJsonResponse');
$test_browser->get('/subreddit')->with('request')->begin()->isParameter('module', 'subreddit')->isParameter('action', 'index')->end()->with('response')->begin()->isStatusCode(200)->end()->with('json.response')->begin()->isJson()->end();
/**
 * Test the creation
 */
$entity = new Subreddit();
$entity_array = $entity->exportTo('array');
$identifier = $entity->getTable()->getIdentifier();
/**
 * Please build a valid $entity_array here
 */
unset($entity_array[$identifier]);
//$entity_array['name'] = "pony";
//$entity_array['created_at'] = date('Y-m-d H:i:s');
//$entity_array['updated_at'] = date('Y-m-d H:i:s');
$test_browser->call('/subreddit', 'post', array('content' => json_encode($entity_array)))->with('request')->begin()->isParameter('module', 'subreddit')->isParameter('action', 'create')->end()->with('response')->begin()->isStatusCode(200)->end();
/**
 * If the new entity has been created
 */
$location = $browser->getResponse()->getHttpHeader('Location');
if ($location) {
    // Get ?
 /**
  * This tests whether the
  * EpisodeAssignmentTable::getFirstByUserAuthorTypeAndSubreddit() function
  * retrieves the correct EpisodeAssignment for a particular User in a
  * Subreddit based on the AuthorType used in the EpisodeAssignment.  Users
  * can sign up for one Episode per AuthorType in each Subreddit, which means
  * future Episodes (sicne we don't want the existence of past episode to
  * disqualify Users from ever signing up again).
  */
 public function testGetFirstByUserAuthorTypeAndSubreddit()
 {
     // Create two episode assignments: one for a past Episode, one for a future
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 10000));
     $subreddit->setDomain(rand(0, 10000));
     $subreddit->save();
     $user = new sfGuardUser();
     $user->setUsername(rand(0, 10000));
     $user->setEmailAddress(rand(0, 10000));
     $user->setisValidated(1);
     $user->save();
     $first = AuthorTypeTable::getInstance()->findOneBy('type', 'squid');
     $understudy = AuthorTypeTable::getInstance()->findOneBy('type', 'shark');
     $this->assertTrue($first instanceof AuthorType);
     $this->assertNotEquals(null, $first->getIncremented());
     $this->assertTrue($understudy instanceof AuthorType);
     $this->assertNotEquals(null, $understudy->getIncremented());
     $deadline_one = new Deadline();
     $deadline_one->setSeconds(100);
     $deadline_one->setAuthorType($first);
     $deadline_one->setSubreddit($subreddit);
     $deadline_one->save();
     $deadline_two = new Deadline();
     $deadline_two->setSeconds(0);
     $deadline_two->setAuthorType($understudy);
     $deadline_two->setSubreddit($subreddit);
     $deadline_two->save();
     $episode_one = new Episode();
     $episode_one->setReleaseDate(date('Y-m-d H:i:s', time() + 200000));
     $episode_one->setSubreddit($subreddit);
     $episode_one->save();
     $episode_two = new Episode();
     $episode_two->setReleaseDate(date('Y-m-d H:i:s', time() + 100000));
     $episode_two->setSubreddit($subreddit);
     $episode_two->save();
     $episode_three = new Episode();
     $episode_three->setReleaseDate(date('Y-m-d H:i:s', time() + 300000));
     $episode_three->setSubreddit($subreddit);
     $episode_three->save();
     $assignment_one = new EpisodeAssignment();
     $assignment_one->setEpisode($episode_one);
     $assignment_one->setSfGuardUser($user);
     $assignment_one->setAuthorType($first);
     $assignment_one->save();
     $assignment_two = new EpisodeAssignment();
     $assignment_two->setEpisode($episode_two);
     $assignment_two->setSfGuardUser($user);
     $assignment_two->setAuthorType($understudy);
     $assignment_two->save();
     /* There should only be one Episode Assignment for future episodes per 
      * authortype per subreddit, so saving the third assignment should fail
      * --- this is covered more in EpisodeAssignmentTest.phop
      */
     $exception_thrown = false;
     $assignment_three = new EpisodeAssignment();
     $assignment_three->setEpisode($episode_three);
     $assignment_three->setSfGuardUser($user);
     $assignment_three->setAuthorType($first);
     try {
         $assignment_three->save();
     } catch (Exception $exception) {
         $exception_thrown = true;
         $this->assertEquals(102, $exception->getCode());
         unset($exception);
     }
     $this->assertTrue($exception_thrown);
     /* Since we can trust that only one assignment per authortype per user
      * per subreddit exists for future episodes (based on the failure to
      * save $assignment_three), we check now to ensure that the
      * getFirstByUserAuthorTypeAndSubreddit() function returns a valid
      * EpisodeAssignment.
      */
     $test_one = EpisodeAssignmentTable::getInstance()->getFirstByUserAuthorTypeAndSubreddit($assignment_one->getAuthorTypeId(), $assignment_one->getSfGuardUserId(), $assignment_one->getEpisode()->getSubredditId());
     $test_two = EpisodeAssignmentTable::getInstance()->getFirstByUserAuthorTypeAndSubreddit($assignment_two->getAuthorTypeId(), $assignment_two->getSfGuardUserId(), $assignment_two->getEpisode()->getSubredditId());
     $this->assertEquals($test_one->getIncremented(), $assignment_one->getIncremented());
     $this->assertEquals($test_two->getIncremented(), $assignment_two->getIncremented());
     $assignment_one->delete();
     $assignment_two->delete();
     $episode_one->delete();
     $episode_two->delete();
     $episode_three->delete();
     $deadline_one->delete();
     $deadline_two->delete();
     $user->delete();
     $subreddit->delete();
 }
Пример #10
0
 /**
  * Fetches and returns an array of the subreddits to which the logged-in user
  * is subscribed
  *
  * @access public
  * @return array
  */
 public function getMySubreddits()
 {
     if (!$this->isLoggedIn()) {
         $message = 'No user is logged in to list subreddit subscriptions';
         $code = RedditException::LOGIN_REQUIRED;
         throw new RedditException($message, $code);
     }
     $verb = 'GET';
     $url = 'http://www.reddit.com/reddits/mine.json';
     $response = $this->sendRequest($verb, $url);
     $subreddits = array();
     foreach ($response['data']['children'] as $child) {
         $subreddit = new Subreddit($this);
         $subreddit->setData($child['data']);
         $subreddits[] = $subreddit;
     }
     return $subreddits;
 }
Пример #11
0
 /**
  * Tests whether we can generate a collection of Episodes to be saved.
  * These Episodes are produced using the creation and episode schedules of
  * the Subreddit.
  */
 public function testCollectGeneratedEpisodes()
 {
     /* @todo: Test iteration lengths, not just creation of episodes. */
     $subreddit = new Subreddit();
     $subreddit->setName(rand(0, 1000));
     $subreddit->setDomain(rand(0, 1000));
     $subreddit->setEpisodeScheduleCronFormatted('0 0 * * *');
     $subreddit->setCreateNewEpisodesCronFormatted('0 0 1 * *');
     $subreddit->save();
     $episodes = $subreddit->collectGeneratedEpisodes();
     $this->assertTrue(!empty($episodes));
     $this->assertTrue($episodes[0] instanceof Episode);
     $subreddit->delete();
 }