jacobemerick / web

router/Router.class.inc.php

Spacing +12 added lines, -12 removed lines

@@ -18,10 +18,10 @@ 
 
 	private static function get_router_name()
 	{
-		if(Request::isAJAX())
+		if (Request::isAJAX())
 			return 'AJAXRouter';
 		
-		switch(URLDecode::getSite())
+		switch (URLDecode::getSite())
 		{
 			case 'ajax' :
 				return 'AjaxRouter';
@@ -65,14 +65,14 @@ 
 
 	final protected function check_for_redirect($redirect_uri)
 	{
-		foreach($this->get_redirect_array() as $check)
+		foreach ($this->get_redirect_array() as $check)
 		{
 			$redirect_uri = preg_replace($check->pattern, $check->replace, $redirect_uri);
 		}
 		
 		$redirect_uri = $this->check_for_special_redirect($redirect_uri);
 		
-		if($this->requires_trailing_slash() && substr($redirect_uri, -1) != '/')
+		if ($this->requires_trailing_slash() && substr($redirect_uri, -1) != '/')
 			$redirect_uri .= '/';
 		
         if (URLDecode::getHost() == 'waterfalls.jacobemerick.com') {
@@ -80,23 +80,23 @@ 
             $redirect_uri = $protocol . '://' . (!Loader::isLive() ? 'dev' : 'www') . '.waterfallsofthekeweenaw.com' . $redirect_uri;
         }
         
-		if($redirect_uri == URLDecode::getURI())
+		if ($redirect_uri == URLDecode::getURI())
 			return;
 		
 		$controller_check = $redirect_uri;
-		if(substr($redirect_uri, 0, 4) == 'http') {
+		if (substr($redirect_uri, 0, 4) == 'http') {
       $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
 			$controller_check = preg_replace('@^' . $protocol . '://([a-z\.]+)@', '', $redirect_uri);
 		
 		$controller = $this->get_controller($controller_check);
-		if($controller == '/Error404Controller')
+		if ($controller == '/Error404Controller')
 		{
 			Loader::loadNew('controller', '/Error404Controller')
 				->activate();
 			exit;
 		}
 
-		if(substr($redirect_uri, 0, 4) != 'http')
+		if (substr($redirect_uri, 0, 4) != 'http')
 		{
 			$redirect_uri = substr($redirect_uri, 1);
 			$redirect_uri = URLDecode::getBase() . $redirect_uri;
@@ -113,12 +113,12 @@ 
 
 	final private function get_controller($uri)
 	{
-		foreach($this->get_direct_array() as $check)
+		foreach ($this->get_direct_array() as $check)
 		{
-			if($uri == $check->match)
+			if ($uri == $check->match)
 				return "{$this->get_primary_folder()}/{$check->controller}";
 			
-			if(preg_match("@^{$check->match}$@", $uri))
+			if (preg_match("@^{$check->match}$@", $uri))
 				return "{$this->get_primary_folder()}/{$check->controller}";
 		}
 		
@@ -127,7 +127,7 @@ 
 
 	final private function get_primary_folder()
 	{
-		if(Request::isAjax())
+		if (Request::isAjax())
 			return 'ajax';
 		
 		return URLDecode::getSite();

Braces +18 added lines, -12 removed lines

@@ -18,8 +18,9 @@ 
 
 	private static function get_router_name()
 	{
-		if(Request::isAJAX())
-			return 'AJAXRouter';
+		if(Request::isAJAX()) {

+					return 'AJAXRouter';

+		}

 		
 		switch(URLDecode::getSite())
 		{
@@ -72,16 +73,18 @@ 
 		
 		$redirect_uri = $this->check_for_special_redirect($redirect_uri);
 		
-		if($this->requires_trailing_slash() && substr($redirect_uri, -1) != '/')
-			$redirect_uri .= '/';
+		if($this->requires_trailing_slash() && substr($redirect_uri, -1) != '/') {

+					$redirect_uri .= '/';

+		}

 		
         if (URLDecode::getHost() == 'waterfalls.jacobemerick.com') {
             $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
             $redirect_uri = $protocol . '://' . (!Loader::isLive() ? 'dev' : 'www') . '.waterfallsofthekeweenaw.com' . $redirect_uri;
         }
         
-		if($redirect_uri == URLDecode::getURI())
-			return;
+		if($redirect_uri == URLDecode::getURI()) {

+					return;

+		}

 		
 		$controller_check = $redirect_uri;
 		if(substr($redirect_uri, 0, 4) == 'http') {
@@ -115,11 +118,13 @@ 
 	{
 		foreach($this->get_direct_array() as $check)
 		{
-			if($uri == $check->match)
-				return "{$this->get_primary_folder()}/{$check->controller}";
+			if($uri == $check->match) {

+							return "{$this->get_primary_folder()}/{$check->controller}";

+			}

 			
-			if(preg_match("@^{$check->match}$@", $uri))
-				return "{$this->get_primary_folder()}/{$check->controller}";
+			if(preg_match("@^{$check->match}$@", $uri)) {

+							return "{$this->get_primary_folder()}/{$check->controller}";

+			}

 		}
 		
 		return '/Error404Controller';
@@ -127,8 +132,9 @@ 
 
 	final private function get_primary_folder()
 	{
-		if(Request::isAjax())
-			return 'ajax';
+		if(Request::isAjax()) {

+					return 'ajax';

+		}

 		
 		return URLDecode::getSite();
 	}

Indentation +7 added lines, -7 removed lines

@@ -75,19 +75,19 @@ 
 		if($this->requires_trailing_slash() && substr($redirect_uri, -1) != '/')
 			$redirect_uri .= '/';
 		
-        if (URLDecode::getHost() == 'waterfalls.jacobemerick.com') {
-            $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
-            $redirect_uri = $protocol . '://' . (!Loader::isLive() ? 'dev' : 'www') . '.waterfallsofthekeweenaw.com' . $redirect_uri;
-        }
+		if (URLDecode::getHost() == 'waterfalls.jacobemerick.com') {
+			$protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
+			$redirect_uri = $protocol . '://' . (!Loader::isLive() ? 'dev' : 'www') . '.waterfallsofthekeweenaw.com' . $redirect_uri;
+		}
         
 		if($redirect_uri == URLDecode::getURI())
 			return;
 		
 		$controller_check = $redirect_uri;
 		if(substr($redirect_uri, 0, 4) == 'http') {
-      $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
+	  $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
 			$controller_check = preg_replace('@^' . $protocol . '://([a-z\.]+)@', '', $redirect_uri);
-    }
+	}
 		
 		$controller = $this->get_controller($controller_check);
 		if($controller == '/Error404Controller')
@@ -138,7 +138,7 @@ 
 	{
 		return (
 			URLDecode::getExtension() != 'json' &&
-            strstr(URLDecode::getURI(), '#') === false);
+			strstr(URLDecode::getURI(), '#') === false);
 	}
 
 }

src/Domain/Stream/Activity/MysqlActivityRepository.php

Indentation +75 added lines, -75 removed lines

@@ -7,108 +7,108 @@
 class MysqlActivityRepository implements ActivityRepositoryInterface
 {
 
-    /** @var  ConnectionLocator */
-    protected $connections;
+	/** @var  ConnectionLocator */
+	protected $connections;
 
-    /**
-     * @param ConnectonLocator $connections
-     */
-    public function __construct(ConnectionLocator $connections)
-    {
-        $this->connections = $connections;
-    }
+	/**
+	 * @param ConnectonLocator $connections
+	 */
+	public function __construct(ConnectionLocator $connections)
+	{
+		$this->connections = $connections;
+	}
 
-    /**
-     * @param integer $id
-     *
-     * @return array|false
-     */
-    public function getActivityById($id)
-    {
-        $query = "
+	/**
+	 * @param integer $id
+	 *
+	 * @return array|false
+	 */
+	public function getActivityById($id)
+	{
+		$query = "
             SELECT *
             FROM `jpemeric_stream`.`activity`
             WHERE `id` = :id
             LIMIT 1";
-        $bindings = [
-            'id' => $id,
-        ];
+		$bindings = [
+			'id' => $id,
+		];
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchOne($query, $bindings);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchOne($query, $bindings);
+	}
 
-    /**
-     * @param integer $limit
-     * @param integer $offset
-     *
-     * @return array|false
-     */
-    public function getActivities($limit = null, $offset = 0)
-    {
-        $query = "
+	/**
+	 * @param integer $limit
+	 * @param integer $offset
+	 *
+	 * @return array|false
+	 */
+	public function getActivities($limit = null, $offset = 0)
+	{
+		$query = "
             SELECT *
             FROM `jpemeric_stream`.`activity`
             ORDER BY `datetime` DESC";
-        if (!is_null($limit)) {
-            $query .= "
+		if (!is_null($limit)) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
+		}
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query);
+	}
 
-    public function getActivitiesCount()
-    {
-        $query = "
+	public function getActivitiesCount()
+	{
+		$query = "
             SELECT COUNT(1) AS `count`
             FROM `jpemeric_stream`.`activity`";
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchValue($query);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchValue($query);
+	}
 
-    public function getActivitiesByType($type, $limit = null, $offset = 0)
-    {
-        $query = "
+	public function getActivitiesByType($type, $limit = null, $offset = 0)
+	{
+		$query = "
             SELECT *
             FROM `jpemeric_stream`.`activity`
             WHERE `type` = :type
             ORDER BY `datetime` DESC";
-        if (!is_null($limit)) {
-            $query .= "
+		if (!is_null($limit)) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
-        $bindings = [
-            'type' => $type,
-        ];
+		}
+		$bindings = [
+			'type' => $type,
+		];
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query, $bindings);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query, $bindings);
+	}
 
-    public function getActivitiesByTypeCount($type)
-    {
-        $query = "
+	public function getActivitiesByTypeCount($type)
+	{
+		$query = "
             SELECT COUNT(1) AS `count`
             FROM `jpemeric_stream`.`activity`
             WHERE `type` = :type";
-        $bindings = [
-            'type' => $type,
-        ];
+		$bindings = [
+			'type' => $type,
+		];
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchValue($query, $bindings);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchValue($query, $bindings);
+	}
 }

src/Domain/Stream/Changelog/MysqlChangelogRepository.php

Indentation +26 added lines, -26 removed lines

@@ -7,37 +7,37 @@
 class MysqlChangelogRepository implements ChangelogRepositoryInterface
 {
 
-    /** @var  ConnectionLocator */
-    protected $connections;
+	/** @var  ConnectionLocator */
+	protected $connections;
 
-    /**
-     * @param ConnectonLocator $connections
-     */
-    public function __construct(ConnectionLocator $connections)
-    {
-        $this->connections = $connections;
-    }
+	/**
+	 * @param ConnectonLocator $connections
+	 */
+	public function __construct(ConnectionLocator $connections)
+	{
+		$this->connections = $connections;
+	}
 
-    /**
-     * @param integer $limit
-     * @param integer $offset
-     *
-     * @return array|false
-     */
-    public function getChanges($limit = null, $offset = 0)
-    {
-        $query = "
+	/**
+	 * @param integer $limit
+	 * @param integer $offset
+	 *
+	 * @return array|false
+	 */
+	public function getChanges($limit = null, $offset = 0)
+	{
+		$query = "
             SELECT `message`, `message_short`, `datetime`, `commit_link`
             FROM `jpemeric_stream`.`changelog`
             ORDER BY `datetime` DESC";
-        if (!is_null($limit)) {
-            $query .= "
+		if (!is_null($limit)) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
+		}
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query);
+	}
 }

tests/unit/Domain/Stream/Activity/MysqlActivityRepositoryTest.php

Spacing +4 added lines, -4 removed lines

@@ -29,7 +29,7 @@ 
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }
@@ -249,7 +249,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['type'] == 'type one');
         });
         $testData = array_values($testData);
@@ -318,7 +318,7 @@ 
         $this->assertInternalType('array', $data);
         $this->assertCount(2, $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['type'] == 'type one');
         });
         $testData = array_values($testData);
@@ -384,7 +384,7 @@ 
         $repository = new MysqlActivityRepository(self::$connection);
         $data = $repository->getActivitiesByTypeCount('type one');
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['type'] == 'type one');
         });
 

Indentation +426 added lines, -426 removed lines

@@ -9,14 +9,14 @@ 
 class MysqlActivityRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_stream`.`activity` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `message` text NOT NULL,
@@ -28,428 +28,428 @@ 
                 `created_at` datetime,
                 `updated_at` datetime
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfActivityRepository()
-    {
-        $repository = new MysqlActivityRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Stream\Activity\MysqlActivityRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsActivityInterface()
-    {
-        $repository = new MysqlActivityRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Stream\Activity\ActivityRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlActivityRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testGetActivityById()
-    {
-        $testData = [
-            'id' => rand(1, 100),
-            'message' => 'test data',
-        ];
-
-        $this->insertData($testData);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivityById($testData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertArraySubset($testData, $data);
-    }
-
-    public function testGetActivityByIdFailure()
-    {
-        $testData = [
-            'id' => rand(1, 100),
-            'message' => 'test data',
-        ];
-
-        $this->insertData($testData);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivityById($testData['id'] + 1);
-
-        $this->assertFalse($data);
-    }
-
-    public function testGetActivities()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivities();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArraySubset($testRow, $data[$key]);
-        }
-    }
-
-    public function testGetActivitiesFailure()
-    {
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivities();
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivitiesRange()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivities(2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(2, $data);
-
-        $testData = array_slice($testData, 1, 2);
-
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArraySubset($testRow, $data[$key]);
-        }
-    }
-
-    public function testGetActivitiesRangeFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivities(1, 3);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivitiesCount()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesCount();
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivitiesCountEmpty()
-    {
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesCount();
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals('0', $data);
-    }
-
-    public function testGetActivitiesByType()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByType('type one');
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['type'] == 'type one');
-        });
-        $testData = array_values($testData);
-
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArraySubset($testRow, $data[$key]);
-        }
-    }
-
-    public function testGetActivitiesByTypeFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByType('type two');
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivitiesByTypeRange()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(301, 400),
-                'message' => 'test four',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByType('type one', 2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(2, $data);
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['type'] == 'type one');
-        });
-        $testData = array_values($testData);
-        $testData = array_slice($testData, 1, 2);
-
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArraySubset($testRow, $data[$key]);
-        }
-    }
-
-    public function testGetActivitiesByTypeRangeFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByType('type two', 2, 1);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivitiesByTypeCount()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByTypeCount('type one');
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['type'] == 'type one');
-        });
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivitiesByTypeCountEmpty()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-                'type' => 'type one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-                'type' => 'type one',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlActivityRepository(self::$connection);
-        $data = $repository->getActivitiesByTypeCount('type two');
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals('0', $data);
-    }
-
-    protected function insertData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'message' => '',
-            'message_long' => '',
-            'datetime' => '',
-            'metadata' => '',
-            'type' => '',
-            'type_id' => '',
-        ];
-
-        $data = array_merge($defaultData, $data);
-
-        return self::$connection->getDefault()->perform("
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfActivityRepository()
+	{
+		$repository = new MysqlActivityRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Stream\Activity\MysqlActivityRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsActivityInterface()
+	{
+		$repository = new MysqlActivityRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Stream\Activity\ActivityRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlActivityRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testGetActivityById()
+	{
+		$testData = [
+			'id' => rand(1, 100),
+			'message' => 'test data',
+		];
+
+		$this->insertData($testData);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivityById($testData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertArraySubset($testData, $data);
+	}
+
+	public function testGetActivityByIdFailure()
+	{
+		$testData = [
+			'id' => rand(1, 100),
+			'message' => 'test data',
+		];
+
+		$this->insertData($testData);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivityById($testData['id'] + 1);
+
+		$this->assertFalse($data);
+	}
+
+	public function testGetActivities()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivities();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArraySubset($testRow, $data[$key]);
+		}
+	}
+
+	public function testGetActivitiesFailure()
+	{
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivities();
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivitiesRange()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivities(2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(2, $data);
+
+		$testData = array_slice($testData, 1, 2);
+
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArraySubset($testRow, $data[$key]);
+		}
+	}
+
+	public function testGetActivitiesRangeFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivities(1, 3);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivitiesCount()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesCount();
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivitiesCountEmpty()
+	{
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesCount();
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals('0', $data);
+	}
+
+	public function testGetActivitiesByType()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type two',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByType('type one');
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['type'] == 'type one');
+		});
+		$testData = array_values($testData);
+
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArraySubset($testRow, $data[$key]);
+		}
+	}
+
+	public function testGetActivitiesByTypeFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByType('type two');
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivitiesByTypeRange()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type two',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(301, 400),
+				'message' => 'test four',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByType('type one', 2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(2, $data);
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['type'] == 'type one');
+		});
+		$testData = array_values($testData);
+		$testData = array_slice($testData, 1, 2);
+
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArraySubset($testRow, $data[$key]);
+		}
+	}
+
+	public function testGetActivitiesByTypeRangeFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByType('type two', 2, 1);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivitiesByTypeCount()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type two',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByTypeCount('type one');
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['type'] == 'type one');
+		});
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivitiesByTypeCountEmpty()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+				'type' => 'type one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+				'type' => 'type one',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlActivityRepository(self::$connection);
+		$data = $repository->getActivitiesByTypeCount('type two');
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals('0', $data);
+	}
+
+	protected function insertData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'message' => '',
+			'message_long' => '',
+			'datetime' => '',
+			'metadata' => '',
+			'type' => '',
+			'type_id' => '',
+		];
+
+		$data = array_merge($defaultData, $data);
+
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_stream`.`activity`
                 (id, message, message_long, datetime, metadata, type, type_id)
             VALUES
                 (:id, :message, :message_long, :datetime, :metadata, :type, :type_id)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`activity`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_stream.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`activity`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_stream.db');
+	}
 }

tests/unit/Domain/Stream/Changelog/MysqlChangelogRepositoryTest.php

Spacing +1 added lines, -1 removed lines

@@ -29,7 +29,7 @@
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }

Indentation +169 added lines, -169 removed lines

@@ -9,14 +9,14 @@ 
 class MysqlChangelogRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec("ATTACH DATABASE `jpemeric_stream.db` AS `jpemeric_stream`");
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_stream`.`changelog` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `hash` char(40) NOT NULL,
@@ -28,171 +28,171 @@ 
                 `created_at` datetime,
                 `updated_at` datetime
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfChangelogRepository()
-    {
-        $repository = new MysqlChangelogRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Stream\Changelog\MysqlChangelogRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsChangelogInterface()
-    {
-        $repository = new MysqlChangelogRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Stream\Changelog\ChangelogRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlChangelogRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testGetChanges()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlChangelogRepository(self::$connection);
-        $data = $repository->getChanges();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArraySubset($testRow, $data[$key]);
-            $this->assertArrayHasKey('id', $data[$key]);
-            $this->assertArrayHasKey('message', $data[$key]);
-            $this->assertArrayHasKey('message_short', $data[$key]);
-            $this->assertArrayHasKey('datetime', $data[$key]);
-            $this->assertArrayHasKey('commit_link', $data[$key]);
-        }
-    }
-
-    public function testGetChangesFailure()
-    {
-        $repository = new MysqlChangelogRepository(self::$connection);
-        $data = $repository->getChanges();
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetChangesRange()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'message' => 'test three',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlChangelogRepository(self::$connection);
-        $data = $repository->getChanges(2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(2, $data);
-
-        $testData = array_slice($testData, 1, 2);
-
-        foreach ($testData as $key => $testRow) {
-            $this->assertInternalType('array', $testRow);
-            $this->assertArraySubset($testRow, $data[$key]);
-        }
-    }
-
-    public function testGetChangesRangeFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'message' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'message' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlChangelogRepository(self::$connection);
-        $data = $repository->getChanges(1, 3);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    protected function insertData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'hash' => '',
-            'message' => null,
-            'message_short' => null,
-            'datetime' => '',
-            'author' => '',
-            'commit_link' => '',
-        ];
-
-        $data = array_merge($defaultData, $data);
-
-        return self::$connection->getDefault()->perform("
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfChangelogRepository()
+	{
+		$repository = new MysqlChangelogRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Stream\Changelog\MysqlChangelogRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsChangelogInterface()
+	{
+		$repository = new MysqlChangelogRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Stream\Changelog\ChangelogRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlChangelogRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testGetChanges()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlChangelogRepository(self::$connection);
+		$data = $repository->getChanges();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArraySubset($testRow, $data[$key]);
+			$this->assertArrayHasKey('id', $data[$key]);
+			$this->assertArrayHasKey('message', $data[$key]);
+			$this->assertArrayHasKey('message_short', $data[$key]);
+			$this->assertArrayHasKey('datetime', $data[$key]);
+			$this->assertArrayHasKey('commit_link', $data[$key]);
+		}
+	}
+
+	public function testGetChangesFailure()
+	{
+		$repository = new MysqlChangelogRepository(self::$connection);
+		$data = $repository->getChanges();
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetChangesRange()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+			[
+				'id' => rand(201, 300),
+				'message' => 'test three',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlChangelogRepository(self::$connection);
+		$data = $repository->getChanges(2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(2, $data);
+
+		$testData = array_slice($testData, 1, 2);
+
+		foreach ($testData as $key => $testRow) {
+			$this->assertInternalType('array', $testRow);
+			$this->assertArraySubset($testRow, $data[$key]);
+		}
+	}
+
+	public function testGetChangesRangeFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'message' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'message' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlChangelogRepository(self::$connection);
+		$data = $repository->getChanges(1, 3);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	protected function insertData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'hash' => '',
+			'message' => null,
+			'message_short' => null,
+			'datetime' => '',
+			'author' => '',
+			'commit_link' => '',
+		];
+
+		$data = array_merge($defaultData, $data);
+
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_stream`.`changelog`
                 (id, hash, message, message_short, datetime, author, commit_link)
             VALUES
                 (:id, :hash, :message, :message_short, :datetime, :author, :commit_link)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`changelog`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_stream.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_stream`.`changelog`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_stream.db');
+	}
 }

tests/unit/Domain/Blog/Series/MysqlSeriesRepositoryTest.php

Spacing +5 added lines, -5 removed lines

@@ -42,7 +42,7 @@ 
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }
@@ -180,11 +180,11 @@ 
         $repository = new MysqlSeriesRepository(self::$connection);
         $data = $repository->getSeriesForPost(reset($testPostData)['id']);
 
-        usort($testPostData, function ($rowA, $rowB) use ($testSeriesPostData) {
-            $seriesA = array_filter($testSeriesPostData, function ($row) use ($rowA) {
+        usort($testPostData, function($rowA, $rowB) use ($testSeriesPostData) {
+            $seriesA = array_filter($testSeriesPostData, function($row) use ($rowA) {
                 return ($rowA['id'] == $row['post']);
             });
-            $seriesB = array_filter($testSeriesPostData, function ($row) use ($rowB) {
+            $seriesB = array_filter($testSeriesPostData, function($row) use ($rowB) {
                 return ($rowB['id'] == $row['post']);
             });
 
@@ -308,7 +308,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });
         $testPosts = array_column($testPostData, 'id');

Indentation +352 added lines, -352 removed lines

@@ -9,14 +9,14 @@ 
 class MysqlSeriesRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`post` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `title` varchar(60) NOT NULL,
@@ -26,380 +26,380 @@ 
                 `body` text,
                 `display` integer(1) NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`series` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `title` text NOT NULL,
                 `description` text NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`series_post` (
                 `series` integer NOT NULL,
                 `post` integer NOT NULL,
                 `order` integer(1) NOT NULL
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfSeriesRepository()
-    {
-        $repository = new MysqlSeriesRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Series\MysqlSeriesRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsSeriesInterface()
-    {
-        $repository = new MysqlSeriesRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Series\SeriesRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlSeriesRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testGetSeriesForPost()
-    {
-        $testPostData = [
-            [
-                'id' => rand(1, 100),
-                'title' => 'test one',
-                'category' => 'test category',
-                'path' => 'test-one',
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'title' => 'test two',
-                'category' => 'test category',
-                'path' => 'test-two',
-                'display' => 1,
-            ],
-        ];
-
-        $testSeriesData = [
-            [
-                'id' => rand(1, 100),
-                'title' => 'test one',
-                'description' => 'test description',
-            ],
-        ];
-
-        $testSeriesPostData = [];
-        foreach ($testPostData as $testPostDataRow) {
-            array_push($testSeriesPostData, [
-                'series' => reset($testSeriesData)['id'],
-                'post' => $testPostDataRow['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testSeriesData, [$this, 'insertSeriesData']);
-        array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
-
-        $repository = new MysqlSeriesRepository(self::$connection);
-        $data = $repository->getSeriesForPost(reset($testPostData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        foreach ($testPostData as $key => $testPostRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArrayHasKey('series_title', $data[$key]);
-            $this->assertEquals(reset($testSeriesData)['title'], $data[$key]['series_title']);
-            $this->assertArrayHasKey('series_description', $data[$key]);
-            $this->assertEquals(reset($testSeriesData)['description'], $data[$key]['series_description']);
-            $this->assertArrayHasKey('post', $data[$key]);
-            $this->assertEquals($testPostRow['id'], $data[$key]['post']);
-            $this->assertArrayHasKey('title', $data[$key]);
-            $this->assertEquals($testPostRow['title'], $data[$key]['title']);
-            $this->assertArrayHasKey('category', $data[$key]);
-            $this->assertEquals($testPostRow['category'], $data[$key]['category']);
-            $this->assertArrayHasKey('path', $data[$key]);
-            $this->assertEquals($testPostRow['path'], $data[$key]['path']);
-        }
-    }
-
-    public function testGetSeriesForPostOrder()
-    {
-        $testPostData = [
-            [
-                'id' => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testSeriesData = [
-            [
-                'id' => rand(1, 100),
-            ],
-        ];
-
-        $order = [1, 2, 3];
-        shuffle($order);
-        $testSeriesPostData = [];
-        foreach ($testPostData as $key => $testPostDataRow) {
-            array_push($testSeriesPostData, [
-                'series' => reset($testSeriesData)['id'],
-                'post' => $testPostDataRow['id'],
-                'order' => $order[$key],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testSeriesData, [$this, 'insertSeriesData']);
-        array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
-
-        $repository = new MysqlSeriesRepository(self::$connection);
-        $data = $repository->getSeriesForPost(reset($testPostData)['id']);
-
-        usort($testPostData, function ($rowA, $rowB) use ($testSeriesPostData) {
-            $seriesA = array_filter($testSeriesPostData, function ($row) use ($rowA) {
-                return ($rowA['id'] == $row['post']);
-            });
-            $seriesB = array_filter($testSeriesPostData, function ($row) use ($rowB) {
-                return ($rowB['id'] == $row['post']);
-            });
-
-            return (reset($seriesA)['order'] > reset($seriesB)['order']);
-        });
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        foreach ($testPostData as $key => $testPostRow) {
-            $this->assertInternalType('array', $data[$key]);
-            $this->assertArrayHasKey('post', $data[$key]);
-            $this->assertEquals($testPostRow['id'], $data[$key]['post']);
-        }
-    }
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfSeriesRepository()
+	{
+		$repository = new MysqlSeriesRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Series\MysqlSeriesRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsSeriesInterface()
+	{
+		$repository = new MysqlSeriesRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Series\SeriesRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlSeriesRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testGetSeriesForPost()
+	{
+		$testPostData = [
+			[
+				'id' => rand(1, 100),
+				'title' => 'test one',
+				'category' => 'test category',
+				'path' => 'test-one',
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'title' => 'test two',
+				'category' => 'test category',
+				'path' => 'test-two',
+				'display' => 1,
+			],
+		];
+
+		$testSeriesData = [
+			[
+				'id' => rand(1, 100),
+				'title' => 'test one',
+				'description' => 'test description',
+			],
+		];
+
+		$testSeriesPostData = [];
+		foreach ($testPostData as $testPostDataRow) {
+			array_push($testSeriesPostData, [
+				'series' => reset($testSeriesData)['id'],
+				'post' => $testPostDataRow['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testSeriesData, [$this, 'insertSeriesData']);
+		array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
+
+		$repository = new MysqlSeriesRepository(self::$connection);
+		$data = $repository->getSeriesForPost(reset($testPostData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		foreach ($testPostData as $key => $testPostRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArrayHasKey('series_title', $data[$key]);
+			$this->assertEquals(reset($testSeriesData)['title'], $data[$key]['series_title']);
+			$this->assertArrayHasKey('series_description', $data[$key]);
+			$this->assertEquals(reset($testSeriesData)['description'], $data[$key]['series_description']);
+			$this->assertArrayHasKey('post', $data[$key]);
+			$this->assertEquals($testPostRow['id'], $data[$key]['post']);
+			$this->assertArrayHasKey('title', $data[$key]);
+			$this->assertEquals($testPostRow['title'], $data[$key]['title']);
+			$this->assertArrayHasKey('category', $data[$key]);
+			$this->assertEquals($testPostRow['category'], $data[$key]['category']);
+			$this->assertArrayHasKey('path', $data[$key]);
+			$this->assertEquals($testPostRow['path'], $data[$key]['path']);
+		}
+	}
+
+	public function testGetSeriesForPostOrder()
+	{
+		$testPostData = [
+			[
+				'id' => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id' => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testSeriesData = [
+			[
+				'id' => rand(1, 100),
+			],
+		];
+
+		$order = [1, 2, 3];
+		shuffle($order);
+		$testSeriesPostData = [];
+		foreach ($testPostData as $key => $testPostDataRow) {
+			array_push($testSeriesPostData, [
+				'series' => reset($testSeriesData)['id'],
+				'post' => $testPostDataRow['id'],
+				'order' => $order[$key],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testSeriesData, [$this, 'insertSeriesData']);
+		array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
+
+		$repository = new MysqlSeriesRepository(self::$connection);
+		$data = $repository->getSeriesForPost(reset($testPostData)['id']);
+
+		usort($testPostData, function ($rowA, $rowB) use ($testSeriesPostData) {
+			$seriesA = array_filter($testSeriesPostData, function ($row) use ($rowA) {
+				return ($rowA['id'] == $row['post']);
+			});
+			$seriesB = array_filter($testSeriesPostData, function ($row) use ($rowB) {
+				return ($rowB['id'] == $row['post']);
+			});
+
+			return (reset($seriesA)['order'] > reset($seriesB)['order']);
+		});
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		foreach ($testPostData as $key => $testPostRow) {
+			$this->assertInternalType('array', $data[$key]);
+			$this->assertArrayHasKey('post', $data[$key]);
+			$this->assertEquals($testPostRow['id'], $data[$key]['post']);
+		}
+	}
  
-    public function testGetSeriesForPostSeriesFilter()
-    {
-        $testPostAData = [
-            [
-                'id' => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'display' => 1,
-            ],
-        ];
-
-        $testPostBData = [
-            [
-                'id' => rand(501, 600),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(601, 700),
-                'display' => 1,
-            ],
-        ];
-
-        $testSeriesData = [
-            [
-                'id' => rand(1, 100),
-            ],
-            [
-                'id' => rand(101, 200),
-            ],
-        ];
-
-        $testSeriesPostData = [];
-        foreach ($testPostAData as $testPostDataRow) {
-            array_push($testSeriesPostData, [
-                'series' => $testSeriesData[0]['id'],
-                'post' => $testPostDataRow['id'],
-            ]);
-        }
-        foreach ($testPostBData as $testPostDataRow) {
-            array_push($testSeriesPostData, [
-                'series' => $testSeriesData[1]['id'],
-                'post' => $testPostDataRow['id'],
-            ]);
-        }
-
-        $testPostData = array_merge($testPostAData, $testPostBData);
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testSeriesData, [$this, 'insertSeriesData']);
-        array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
-
-        $repository = new MysqlSeriesRepository(self::$connection);
-        $data = $repository->getSeriesForPost(reset($testPostAData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPosts = array_column($testPostAData, 'id');
-        $dataPosts = array_column($data, 'post');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testPosts, $dataPosts),
-            array_diff($dataPosts, $testPosts)
-        ));
-    }
+	public function testGetSeriesForPostSeriesFilter()
+	{
+		$testPostAData = [
+			[
+				'id' => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'display' => 1,
+			],
+		];
+
+		$testPostBData = [
+			[
+				'id' => rand(501, 600),
+				'display' => 1,
+			],
+			[
+				'id' => rand(601, 700),
+				'display' => 1,
+			],
+		];
+
+		$testSeriesData = [
+			[
+				'id' => rand(1, 100),
+			],
+			[
+				'id' => rand(101, 200),
+			],
+		];
+
+		$testSeriesPostData = [];
+		foreach ($testPostAData as $testPostDataRow) {
+			array_push($testSeriesPostData, [
+				'series' => $testSeriesData[0]['id'],
+				'post' => $testPostDataRow['id'],
+			]);
+		}
+		foreach ($testPostBData as $testPostDataRow) {
+			array_push($testSeriesPostData, [
+				'series' => $testSeriesData[1]['id'],
+				'post' => $testPostDataRow['id'],
+			]);
+		}
+
+		$testPostData = array_merge($testPostAData, $testPostBData);
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testSeriesData, [$this, 'insertSeriesData']);
+		array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
+
+		$repository = new MysqlSeriesRepository(self::$connection);
+		$data = $repository->getSeriesForPost(reset($testPostAData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPosts = array_column($testPostAData, 'id');
+		$dataPosts = array_column($data, 'post');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testPosts, $dataPosts),
+			array_diff($dataPosts, $testPosts)
+		));
+	}
  
-    public function testGetSeriesForPostInactive()
-    {
-        $testPostData = [
-            [
-                'id' => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'display' => 0,
-            ],
-            [
-                'id' => rand(201, 300),
-                'display' => 0,
-            ],
-        ];
-
-        $testSeriesData = [
-            [
-                'id' => rand(1, 100),
-            ],
-        ];
-
-        $testSeriesPostData = [];
-        foreach ($testPostData as $testPostDataRow) {
-            array_push($testSeriesPostData, [
-                'series' => reset($testSeriesData)['id'],
-                'post' => $testPostDataRow['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testSeriesData, [$this, 'insertSeriesData']);
-        array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
-
-        $repository = new MysqlSeriesRepository(self::$connection);
-        $data = $repository->getSeriesForPost(reset($testPostData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPostData = array_filter($testPostData, function ($row) {
-            return ($row['display'] == 1);
-        });
-        $testPosts = array_column($testPostData, 'id');
-        $dataPosts = array_column($data, 'post');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testPosts, $dataPosts),
-            array_diff($dataPosts, $testPosts)
-        ));
-    }
-
-    public function testGetSeriesForPostFailure()
-    {
-        $repository = new MysqlSeriesRepository(self::$connection);
-        $data = $repository->getSeriesForPost(rand(1, 100));
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    protected function insertPostData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'title' => '',
-            'path' => '',
-            'category' => '',
-            'date' => '',
-            'body' => '',
-            'display' => 0,
-        ];
-
-        $data = array_merge($defaultData, $data);
-
-        return self::$connection->getDefault()->perform("
+	public function testGetSeriesForPostInactive()
+	{
+		$testPostData = [
+			[
+				'id' => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'display' => 0,
+			],
+			[
+				'id' => rand(201, 300),
+				'display' => 0,
+			],
+		];
+
+		$testSeriesData = [
+			[
+				'id' => rand(1, 100),
+			],
+		];
+
+		$testSeriesPostData = [];
+		foreach ($testPostData as $testPostDataRow) {
+			array_push($testSeriesPostData, [
+				'series' => reset($testSeriesData)['id'],
+				'post' => $testPostDataRow['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testSeriesData, [$this, 'insertSeriesData']);
+		array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
+
+		$repository = new MysqlSeriesRepository(self::$connection);
+		$data = $repository->getSeriesForPost(reset($testPostData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPostData = array_filter($testPostData, function ($row) {
+			return ($row['display'] == 1);
+		});
+		$testPosts = array_column($testPostData, 'id');
+		$dataPosts = array_column($data, 'post');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testPosts, $dataPosts),
+			array_diff($dataPosts, $testPosts)
+		));
+	}
+
+	public function testGetSeriesForPostFailure()
+	{
+		$repository = new MysqlSeriesRepository(self::$connection);
+		$data = $repository->getSeriesForPost(rand(1, 100));
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	protected function insertPostData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'title' => '',
+			'path' => '',
+			'category' => '',
+			'date' => '',
+			'body' => '',
+			'display' => 0,
+		];
+
+		$data = array_merge($defaultData, $data);
+
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`post`
                 (id, title, path, category, date, body, display)
             VALUES
                 (:id, :title, :path, :category, :date, :body, :display)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertSeriesData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'title' => '',
-            'description' => '',
-        ];
+	protected function insertSeriesData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'title' => '',
+			'description' => '',
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`series`
                 (id, title, description)
             VALUES
                 (:id, :title, :description)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertSeriesPostData(array $data)
-    {
-        $defaultData = [
-            'series' => '',
-            'post' => '',
-            'order' => 0,
-        ];
+	protected function insertSeriesPostData(array $data)
+	{
+		$defaultData = [
+			'series' => '',
+			'post' => '',
+			'order' => 0,
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`series_post`
                 (series, post, `order`)
             VALUES
                 (:series, :post, :order)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`series`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`series_post`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_blog.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`series`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`series_post`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_blog.db');
+	}
 }

tests/unit/Domain/Blog/Introduction/MysqlIntroductionRepositoryTest.php

Spacing +1 added lines, -1 removed lines

@@ -29,7 +29,7 @@
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }

Indentation +131 added lines, -131 removed lines

@@ -9,14 +9,14 @@ 
 class MysqlIntroductionRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`introduction` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `type` varchar(10) NOT NULL,
@@ -25,134 +25,134 @@ 
                 `content` text NOT NULL,
                 `image` image
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfIntroductionRepository()
-    {
-        $repository = new MysqlIntroductionRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Introduction\MysqlIntroductionRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsIntroductionInterface()
-    {
-        $repository = new MysqlIntroductionRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Introduction\IntroductionRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlIntroductionRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testFindByType()
-    {
-        $testData = [
-            'id' => rand(1, 100),
-            'type' => 'test',
-            'title' => 'test title',
-            'content' => 'test content',
-            'image' => rand(1, 100),
-        ];
-
-        $this->insertData($testData);
-
-        $repository = new MysqlIntroductionRepository(self::$connection);
-        $data = $repository->findByType('test');
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertArrayHasKey('title', $data);
-        $this->assertEquals($testData['title'], $data['title']);
-        $this->assertArrayHasKey('content', $data);
-        $this->assertEquals($testData['content'], $data['content']);
-        $this->assertArrayHasKey('image', $data);
-        $this->assertEquals($testData['image'], $data['image']);
-    }
-
-    public function testFindByTypeFilterValue()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'type' => 'test',
-                'title' => 'title a',
-                'value' => 'value a',
-            ],
-            [
-                'id' => rand(101, 200),
-                'type' => 'test',
-                'title' => 'title b',
-                'value' => 'value b',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertData']);
-
-        $repository = new MysqlIntroductionRepository(self::$connection);
-        $data = $repository->findByType('test', reset($testData)['value']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertEquals(reset($testData)['title'], $data['title']);
-    }
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfIntroductionRepository()
+	{
+		$repository = new MysqlIntroductionRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Introduction\MysqlIntroductionRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsIntroductionInterface()
+	{
+		$repository = new MysqlIntroductionRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Introduction\IntroductionRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlIntroductionRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testFindByType()
+	{
+		$testData = [
+			'id' => rand(1, 100),
+			'type' => 'test',
+			'title' => 'test title',
+			'content' => 'test content',
+			'image' => rand(1, 100),
+		];
+
+		$this->insertData($testData);
+
+		$repository = new MysqlIntroductionRepository(self::$connection);
+		$data = $repository->findByType('test');
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertArrayHasKey('title', $data);
+		$this->assertEquals($testData['title'], $data['title']);
+		$this->assertArrayHasKey('content', $data);
+		$this->assertEquals($testData['content'], $data['content']);
+		$this->assertArrayHasKey('image', $data);
+		$this->assertEquals($testData['image'], $data['image']);
+	}
+
+	public function testFindByTypeFilterValue()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'type' => 'test',
+				'title' => 'title a',
+				'value' => 'value a',
+			],
+			[
+				'id' => rand(101, 200),
+				'type' => 'test',
+				'title' => 'title b',
+				'value' => 'value b',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertData']);
+
+		$repository = new MysqlIntroductionRepository(self::$connection);
+		$data = $repository->findByType('test', reset($testData)['value']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertEquals(reset($testData)['title'], $data['title']);
+	}
  
-    public function testFindByTypeFailure()
-    {
-        $repository = new MysqlIntroductionRepository(self::$connection);
-        $data = $repository->findByType('empty type');
-
-        $this->assertFalse($data);
-    }
-
-    protected function insertData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'type' => '',
-            'value' => '',
-            'title' => '',
-            'content' => '',
-            'image' => null,
-        ];
-
-        $data = array_merge($defaultData, $data);
-
-        return self::$connection->getDefault()->perform("
+	public function testFindByTypeFailure()
+	{
+		$repository = new MysqlIntroductionRepository(self::$connection);
+		$data = $repository->findByType('empty type');
+
+		$this->assertFalse($data);
+	}
+
+	protected function insertData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'type' => '',
+			'value' => '',
+			'title' => '',
+			'content' => '',
+			'image' => null,
+		];
+
+		$data = array_merge($defaultData, $data);
+
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`introduction`
                 (id, type, value, title, content, image)
             VALUES
                 (:id, :type, :value, :title, :content, :image)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`introduction`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_blog.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`introduction`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_blog.db');
+	}
 }

tests/unit/Domain/Blog/Tag/MysqlTagRepositoryTest.php

Indentation +470 added lines, -470 removed lines

@@ -9,14 +9,14 @@ 
 class MysqlTagRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec("ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`");
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`post` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `title` varchar(60) NOT NULL,
@@ -26,497 +26,497 @@ 
                 `body` text,
                 `display` integer(1) NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`ptlink` (
                 `post_id` integer NOT NULL,
                 `tag_id` integer NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`tag` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `tag` varchar(25) NOT NULL
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfTagRepository()
-    {
-        $repository = new MysqlTagRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Tag\MysqlTagRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsTagInterface()
-    {
-        $repository = new MysqlTagRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Tag\TagRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlTagRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testFindTagByTitle()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertTagData']);
-
-        shuffle($testData);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->findTagByTitle(reset($testData)['tag']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertArrayHasKey('id', $data);
-        $this->assertEquals(reset($testData)['id'], $data['id']);
-        $this->assertArrayHasKey('tag', $data);
-        $this->assertEquals(reset($testData)['tag'], $data['tag']);
-    }
-
-    public function testFindTagByTitleFailure()
-    {
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->findTagByTitle('empty tag');
-
-        $this->assertFalse($data);
-    }
-
-    public function testGetAllTags()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getAllTags();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(count($testData), $data);
-        foreach ($testData as $key => $testDataRow) {
-            $this->assertArrayHasKey('id', $data[$key]);
-            $this->assertEquals($testDataRow['id'], $data[$key]['id']);
-            $this->assertArrayHasKey('tag', $data[$key]);
-            $this->assertEquals($testDataRow['tag'], $data[$key]['tag']);
-        }
-    }
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfTagRepository()
+	{
+		$repository = new MysqlTagRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Tag\MysqlTagRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsTagInterface()
+	{
+		$repository = new MysqlTagRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Tag\TagRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlTagRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testFindTagByTitle()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertTagData']);
+
+		shuffle($testData);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->findTagByTitle(reset($testData)['tag']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertArrayHasKey('id', $data);
+		$this->assertEquals(reset($testData)['id'], $data['id']);
+		$this->assertArrayHasKey('tag', $data);
+		$this->assertEquals(reset($testData)['tag'], $data['tag']);
+	}
+
+	public function testFindTagByTitleFailure()
+	{
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->findTagByTitle('empty tag');
+
+		$this->assertFalse($data);
+	}
+
+	public function testGetAllTags()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getAllTags();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(count($testData), $data);
+		foreach ($testData as $key => $testDataRow) {
+			$this->assertArrayHasKey('id', $data[$key]);
+			$this->assertEquals($testDataRow['id'], $data[$key]['id']);
+			$this->assertArrayHasKey('tag', $data[$key]);
+			$this->assertEquals($testDataRow['tag'], $data[$key]['tag']);
+		}
+	}
  
-    public function testGetAllTagsFailure()
-    {
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getAllTags();
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetTagCloud()
-    {
-        $testPostData = [
-            [
-                'id' => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'tag' => 'test three',
-            ],
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            $tempTagData = $testTagData;
-            shuffle($tempTagData);
-            for ($i = 0; $i < 2; $i++) {
-                array_push($testPTLinkData, [
-                    'post_id' => $testPostRow['id'],
-                    'tag_id' => $tempTagData[$i]['id'],
-                ]);
-            }
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        array_walk($testTagData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getTagCloud();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $tagCountData = array_map(function ($row) use ($testTagData) {
-            $tag = $row['tag_id'];
-            $tag = array_filter($testTagData, function ($row) use ($tag) {
-                return ($tag == $row['id']);
-            });
-            $tag = current($tag)['tag'];
-            return $tag;
-        }, $testPTLinkData);
-
-        $testCountData = [];
-        foreach ($tagCountData as $tagCountRow) {
-            $incremented = false;
-            foreach ($testCountData as $key => $testCountRow) {
-                if ($tagCountRow == $testCountRow['tag']) {
-                    $testCountData[$key]['count']++;
-                    $incremented = true;
-                    break;
-                }
-            }
-            if (!$incremented) {
-                array_push($testCountData, [
-                    'count' => 1,
-                    'tag' => $tagCountRow,
-                ]);
-            }
-        }
-
-        $this->assertCount(count($testCountData), $data);
-
-        usort($testCountData, function ($rowA, $rowB) {
-            return ($rowA['tag'] > $rowB['tag']);
-        });
-        usort($data, function ($rowA, $rowB) {
-            return ($rowA['tag'] > $rowB['tag']);
-        });
-
-        foreach ($testCountData as $key => $testCountRow) {
-            $this->assertArrayHasKey('count', $data[$key]);
-            $this->assertEquals($testCountRow['count'], $data[$key]['count']);
-            $this->assertArrayHasKey('tag', $data[$key]);
-            $this->assertEquals($testCountRow['tag'], $data[$key]['tag']);
-        }
-    }
-
-    public function testGetTagCloudInactive()
-    {
-        $testPostData = [
-            [
-                'id' => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id' => rand(201, 300),
-                'display' => 0,
-            ],
-        ];
-
-        $testTagData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'tag' => 'test three',
-            ],
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            $tempTagData = $testTagData;
-            shuffle($tempTagData);
-            for ($i = 0; $i < 2; $i++) {
-                array_push($testPTLinkData, [
-                    'post_id' => $testPostRow['id'],
-                    'tag_id' => $tempTagData[$i]['id'],
-                ]);
-            }
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        array_walk($testTagData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getTagCloud();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPTLinkData = array_filter($testPTLinkData, function ($row) use ($testPostData) {
-            $post = $row['post_id'];
-            $post = array_filter($testPostData, function ($row) use ($post) {
-                return ($post == $row['id']);
-            });
-            $post = current($post);
-            return ($post['display'] == 1);
-        });
-
-        $tagCountData = array_map(function ($row) use ($testTagData) {
-            $tag = $row['tag_id'];
-            $tag = array_filter($testTagData, function ($row) use ($tag) {
-                return ($tag == $row['id']);
-            });
-            $tag = current($tag)['tag'];
-            return $tag;
-        }, $testPTLinkData);
-
-        $testCountData = [];
-        foreach ($tagCountData as $tagCountRow) {
-            $incremented = false;
-            foreach ($testCountData as $key => $testCountRow) {
-                if ($tagCountRow == $testCountRow['tag']) {
-                    $testCountData[$key]['count']++;
-                    $incremented = true;
-                    break;
-                }
-            }
-            if (!$incremented) {
-                array_push($testCountData, [
-                    'count' => 1,
-                    'tag' => $tagCountRow,
-                ]);
-            }
-        }
-
-        $this->assertCount(count($testCountData), $data);
-
-        usort($testCountData, function ($rowA, $rowB) {
-            return ($rowA['tag'] > $rowB['tag']);
-        });
-        usort($data, function ($rowA, $rowB) {
-            return ($rowA['tag'] > $rowB['tag']);
-        });
-
-        foreach ($testCountData as $key => $testCountRow) {
-            $this->assertArrayHasKey('count', $data[$key]);
-            $this->assertEquals($testCountRow['count'], $data[$key]['count']);
-            $this->assertArrayHasKey('tag', $data[$key]);
-            $this->assertEquals($testCountRow['tag'], $data[$key]['tag']);
-        }
-    }
-
-    public function testGetTagCloudFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getTagCloud();
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
+	public function testGetAllTagsFailure()
+	{
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getAllTags();
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetTagCloud()
+	{
+		$testPostData = [
+			[
+				'id' => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+			[
+				'id' => rand(201, 300),
+				'tag' => 'test three',
+			],
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			$tempTagData = $testTagData;
+			shuffle($tempTagData);
+			for ($i = 0; $i < 2; $i++) {
+				array_push($testPTLinkData, [
+					'post_id' => $testPostRow['id'],
+					'tag_id' => $tempTagData[$i]['id'],
+				]);
+			}
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		array_walk($testTagData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getTagCloud();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$tagCountData = array_map(function ($row) use ($testTagData) {
+			$tag = $row['tag_id'];
+			$tag = array_filter($testTagData, function ($row) use ($tag) {
+				return ($tag == $row['id']);
+			});
+			$tag = current($tag)['tag'];
+			return $tag;
+		}, $testPTLinkData);
+
+		$testCountData = [];
+		foreach ($tagCountData as $tagCountRow) {
+			$incremented = false;
+			foreach ($testCountData as $key => $testCountRow) {
+				if ($tagCountRow == $testCountRow['tag']) {
+					$testCountData[$key]['count']++;
+					$incremented = true;
+					break;
+				}
+			}
+			if (!$incremented) {
+				array_push($testCountData, [
+					'count' => 1,
+					'tag' => $tagCountRow,
+				]);
+			}
+		}
+
+		$this->assertCount(count($testCountData), $data);
+
+		usort($testCountData, function ($rowA, $rowB) {
+			return ($rowA['tag'] > $rowB['tag']);
+		});
+		usort($data, function ($rowA, $rowB) {
+			return ($rowA['tag'] > $rowB['tag']);
+		});
+
+		foreach ($testCountData as $key => $testCountRow) {
+			$this->assertArrayHasKey('count', $data[$key]);
+			$this->assertEquals($testCountRow['count'], $data[$key]['count']);
+			$this->assertArrayHasKey('tag', $data[$key]);
+			$this->assertEquals($testCountRow['tag'], $data[$key]['tag']);
+		}
+	}
+
+	public function testGetTagCloudInactive()
+	{
+		$testPostData = [
+			[
+				'id' => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id' => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id' => rand(201, 300),
+				'display' => 0,
+			],
+		];
+
+		$testTagData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+			[
+				'id' => rand(201, 300),
+				'tag' => 'test three',
+			],
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			$tempTagData = $testTagData;
+			shuffle($tempTagData);
+			for ($i = 0; $i < 2; $i++) {
+				array_push($testPTLinkData, [
+					'post_id' => $testPostRow['id'],
+					'tag_id' => $tempTagData[$i]['id'],
+				]);
+			}
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		array_walk($testTagData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getTagCloud();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPTLinkData = array_filter($testPTLinkData, function ($row) use ($testPostData) {
+			$post = $row['post_id'];
+			$post = array_filter($testPostData, function ($row) use ($post) {
+				return ($post == $row['id']);
+			});
+			$post = current($post);
+			return ($post['display'] == 1);
+		});
+
+		$tagCountData = array_map(function ($row) use ($testTagData) {
+			$tag = $row['tag_id'];
+			$tag = array_filter($testTagData, function ($row) use ($tag) {
+				return ($tag == $row['id']);
+			});
+			$tag = current($tag)['tag'];
+			return $tag;
+		}, $testPTLinkData);
+
+		$testCountData = [];
+		foreach ($tagCountData as $tagCountRow) {
+			$incremented = false;
+			foreach ($testCountData as $key => $testCountRow) {
+				if ($tagCountRow == $testCountRow['tag']) {
+					$testCountData[$key]['count']++;
+					$incremented = true;
+					break;
+				}
+			}
+			if (!$incremented) {
+				array_push($testCountData, [
+					'count' => 1,
+					'tag' => $tagCountRow,
+				]);
+			}
+		}
+
+		$this->assertCount(count($testCountData), $data);
+
+		usort($testCountData, function ($rowA, $rowB) {
+			return ($rowA['tag'] > $rowB['tag']);
+		});
+		usort($data, function ($rowA, $rowB) {
+			return ($rowA['tag'] > $rowB['tag']);
+		});
+
+		foreach ($testCountData as $key => $testCountRow) {
+			$this->assertArrayHasKey('count', $data[$key]);
+			$this->assertEquals($testCountRow['count'], $data[$key]['count']);
+			$this->assertArrayHasKey('tag', $data[$key]);
+			$this->assertEquals($testCountRow['tag'], $data[$key]['tag']);
+		}
+	}
+
+	public function testGetTagCloudFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getTagCloud();
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
  
-    public function testGetTagsForPost()
-    {
-        $testPostData = [
-            'id' => rand(1, 100),
-            'display' => 1,
-        ];
-
-        $testTagData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-            [
-                'id' => rand(201, 300),
-                'tag' => 'test three',
-            ],
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testTagData as $testTagRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostData['id'],
-                'tag_id' => $testTagRow['id'],
-            ]);
-        }
-
-        $this->insertPostData($testPostData);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        array_walk($testTagData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getTagsForPost($testPostData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(count($testTagData), $data);
-
-        usort($testTagData, function ($rowA, $rowB) {
-            return ($rowA['tag'] > $rowB['tag']);
-        });
-
-        foreach ($testTagData as $key => $testTagRow) {
-            $this->assertArrayHasKey('id', $data[$key]);
-            $this->assertEquals($testTagRow['id'], $data[$key]['id']);
-            $this->assertArrayHasKey('tag', $data[$key]);
-            $this->assertEquals($testTagRow['tag'], $data[$key]['tag']);
-        }
-    }
+	public function testGetTagsForPost()
+	{
+		$testPostData = [
+			'id' => rand(1, 100),
+			'display' => 1,
+		];
+
+		$testTagData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+			[
+				'id' => rand(201, 300),
+				'tag' => 'test three',
+			],
+		];
+
+		$testPTLinkData = [];
+		foreach ($testTagData as $testTagRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostData['id'],
+				'tag_id' => $testTagRow['id'],
+			]);
+		}
+
+		$this->insertPostData($testPostData);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		array_walk($testTagData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getTagsForPost($testPostData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(count($testTagData), $data);
+
+		usort($testTagData, function ($rowA, $rowB) {
+			return ($rowA['tag'] > $rowB['tag']);
+		});
+
+		foreach ($testTagData as $key => $testTagRow) {
+			$this->assertArrayHasKey('id', $data[$key]);
+			$this->assertEquals($testTagRow['id'], $data[$key]['id']);
+			$this->assertArrayHasKey('tag', $data[$key]);
+			$this->assertEquals($testTagRow['tag'], $data[$key]['tag']);
+		}
+	}
  
-    public function testGetTagsForPostFailure()
-    {
-        $testData = [
-            [
-                'id' => rand(1, 100),
-                'tag' => 'test one',
-            ],
-            [
-                'id' => rand(101, 200),
-                'tag' => 'test two',
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertTagData']);
-
-        $repository = new MysqlTagRepository(self::$connection);
-        $data = $repository->getTagsForPost(rand(1, 10));
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    protected function insertPostData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'title' => '',
-            'path' => '',
-            'category' => '',
-            'date' => '',
-            'body' => '',
-            'display' => 0,
-        ];
-
-        $data = array_merge($defaultData, $data);
-
-        return self::$connection->getDefault()->perform("
+	public function testGetTagsForPostFailure()
+	{
+		$testData = [
+			[
+				'id' => rand(1, 100),
+				'tag' => 'test one',
+			],
+			[
+				'id' => rand(101, 200),
+				'tag' => 'test two',
+			],
+		];
+
+		array_walk($testData, [$this, 'insertTagData']);
+
+		$repository = new MysqlTagRepository(self::$connection);
+		$data = $repository->getTagsForPost(rand(1, 10));
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	protected function insertPostData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'title' => '',
+			'path' => '',
+			'category' => '',
+			'date' => '',
+			'body' => '',
+			'display' => 0,
+		];
+
+		$data = array_merge($defaultData, $data);
+
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`post`
                 (id, title, path, category, date, body, display)
             VALUES
                 (:id, :title, :path, :category, :date, :body, :display)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertPTLinkData(array $data)
-    {
-        $defaultData = [
-            'post' => null,
-            'tag' => null,
-        ];
+	protected function insertPTLinkData(array $data)
+	{
+		$defaultData = [
+			'post' => null,
+			'tag' => null,
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`ptlink`
                 (post_id, tag_id)
             VALUES
                 (:post_id, :tag_id)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertTagData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'tag' => '',
-        ];
+	protected function insertTagData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'tag' => '',
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`tag`
                 (id, tag)
             VALUES
                 (:id, :tag)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`ptlink`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`tag`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_blog.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`ptlink`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`tag`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_blog.db');
+	}
 }

Spacing +12 added lines, -12 removed lines

@@ -40,7 +40,7 @@ 
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }
@@ -200,9 +200,9 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $tagCountData = array_map(function ($row) use ($testTagData) {
+        $tagCountData = array_map(function($row) use ($testTagData) {
             $tag = $row['tag_id'];
-            $tag = array_filter($testTagData, function ($row) use ($tag) {
+            $tag = array_filter($testTagData, function($row) use ($tag) {
                 return ($tag == $row['id']);
             });
             $tag = current($tag)['tag'];
@@ -229,10 +229,10 @@ 
 
         $this->assertCount(count($testCountData), $data);
 
-        usort($testCountData, function ($rowA, $rowB) {
+        usort($testCountData, function($rowA, $rowB) {
             return ($rowA['tag'] > $rowB['tag']);
         });
-        usort($data, function ($rowA, $rowB) {
+        usort($data, function($rowA, $rowB) {
             return ($rowA['tag'] > $rowB['tag']);
         });
 
@@ -298,18 +298,18 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testPTLinkData = array_filter($testPTLinkData, function ($row) use ($testPostData) {
+        $testPTLinkData = array_filter($testPTLinkData, function($row) use ($testPostData) {
             $post = $row['post_id'];
-            $post = array_filter($testPostData, function ($row) use ($post) {
+            $post = array_filter($testPostData, function($row) use ($post) {
                 return ($post == $row['id']);
             });
             $post = current($post);
             return ($post['display'] == 1);
         });
 
-        $tagCountData = array_map(function ($row) use ($testTagData) {
+        $tagCountData = array_map(function($row) use ($testTagData) {
             $tag = $row['tag_id'];
-            $tag = array_filter($testTagData, function ($row) use ($tag) {
+            $tag = array_filter($testTagData, function($row) use ($tag) {
                 return ($tag == $row['id']);
             });
             $tag = current($tag)['tag'];
@@ -336,10 +336,10 @@ 
 
         $this->assertCount(count($testCountData), $data);
 
-        usort($testCountData, function ($rowA, $rowB) {
+        usort($testCountData, function($rowA, $rowB) {
             return ($rowA['tag'] > $rowB['tag']);
         });
-        usort($data, function ($rowA, $rowB) {
+        usort($data, function($rowA, $rowB) {
             return ($rowA['tag'] > $rowB['tag']);
         });
 
@@ -414,7 +414,7 @@ 
         $this->assertInternalType('array', $data);
         $this->assertCount(count($testTagData), $data);
 
-        usort($testTagData, function ($rowA, $rowB) {
+        usort($testTagData, function($rowA, $rowB) {
             return ($rowA['tag'] > $rowB['tag']);
         });
 

tests/unit/Domain/Blog/Post/MysqlPostRepositoryTest.php

Indentation +714 added lines, -714 removed lines

@@ -10,14 +10,14 @@ 
 class MysqlPostRepositoryTest extends PHPUnit_Framework_TestCase
 {
 
-    protected static $connection;
+	protected static $connection;
 
-    public static function setUpBeforeClass()
-    {
-        $extendedPdo = new ExtendedPdo('sqlite::memory:');
-        $extendedPdo->exec('ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`');
+	public static function setUpBeforeClass()
+	{
+		$extendedPdo = new ExtendedPdo('sqlite::memory:');
+		$extendedPdo->exec('ATTACH DATABASE `jpemeric_blog.db` AS `jpemeric_blog`');
 
-        $extendedPdo->exec("
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`post` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `title` varchar(60) NOT NULL,
@@ -27,761 +27,761 @@ 
                 `body` text,
                 `display` integer(1) NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`ptlink` (
                 `post_id` integer NOT NULL,
                 `tag_id` integer NOT NULL
             )"
-        );
-        $extendedPdo->exec("
+		);
+		$extendedPdo->exec("
             CREATE TABLE IF NOT EXISTS `jpemeric_blog`.`tag` (
                 `id` integer PRIMARY KEY AUTOINCREMENT,
                 `tag` varchar(25) NOT NULL
             )"
-        );
-
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
-            return $extendedPdo;
-        });
-    }
-
-    public function testIsInstanceOfPostRepository()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository',
-            $repository
-        );
-    }
-
-    public function testImplementsPostInterface()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-
-        $this->assertInstanceOf(
-            'Jacobemerick\Web\Domain\Blog\Post\PostRepositoryInterface',
-            $repository
-        );
-    }
-
-    public function testConstructSetsConnections()
-    {
-        $respository = new MysqlPostRepository(self::$connection);
-
-        $this->assertAttributeSame(
-            self::$connection,
-            'connections',
-            $respository
-        );
-    }
-
-    public function testFindPostByPath()
-    {
-        $testData = [
-            'id'       => rand(1, 100),
-            'title'    => 'test title',
-            'path'     => 'test-path',
-            'category' => 'test category',
-            'date'     => (new DateTime())->format('Y-m-d H:i:s'),
-            'body'     => 'test body',
-            'display'  => 1
-        ];
-
-        $this->insertPostData($testData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->findPostByPath($testData['category'], $testData['path']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertArrayHasKey('id', $data);
-        $this->assertEquals($testData['id'], $data['id']);
-        $this->assertArrayHasKey('title', $data);
-        $this->assertEquals($testData['title'], $data['title']);
-        $this->assertArrayHasKey('path', $data);
-        $this->assertEquals($testData['path'], $data['path']);
-        $this->assertArrayHasKey('date', $data);
-        $this->assertEquals($testData['date'], $data['date']);
-        $this->assertArrayHasKey('body', $data);
-        $this->assertEquals($testData['body'], $data['body']);
-        $this->assertArrayHasKey('category', $data);
-        $this->assertEquals($testData['category'], $data['category']);
-    }
-
-    public function testFindPostByPathInactive()
-    {
-        $testData = [
-            'id'       => rand(1, 100),
-            'path'     => 'test-path',
-            'category' => 'test category',
-            'display'  => 0
-        ];
-
-        $this->insertPostData($testData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->findPostByPath($testData['category'], $testData['path']);
-
-        $this->assertFalse($data);
-    }
-
-    public function testFindPostByPathFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->findPostByPath('', '');
-
-        $this->assertFalse($data);
-    }
-
-    public function testGetActivePosts()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'title'    => 'title one',
-                'path'     => 'path-one',
-                'category' => 'test category',
-                'date'     => (new DateTime('-1 day'))->format('Y-m-d H:i:s'),
-                'body'     => 'body one',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'title'    => 'title two',
-                'path'     => 'path-two',
-                'category' => 'test category',
-                'date'     => (new DateTime())->format('Y-m-d H:i:s'),
-                'body'     => 'body one',
-                'display'  => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePosts();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(count($testData), $data);
-
-        usort($testData, function ($rowA, $rowB) {
-            return ((new DateTime($rowA['date'])) < (new DateTime($rowB['date'])));
-        });
-
-        foreach ($testData as $key => $testRow) {
-            $this->assertArrayHasKey('id', $data[$key]);
-            $this->assertEquals($testRow['id'], $data[$key]['id']);
-            $this->assertArrayHasKey('title', $data[$key]);
-            $this->assertEquals($testRow['title'], $data[$key]['title']);
-            $this->assertArrayHasKey('path', $data[$key]);
-            $this->assertEquals($testRow['path'], $data[$key]['path']);
-            $this->assertArrayHasKey('date', $data[$key]);
-            $this->assertEquals($testRow['date'], $data[$key]['date']);
-            $this->assertArrayHasKey('body', $data[$key]);
-            $this->assertEquals($testRow['body'], $data[$key]['body']);
-            $this->assertArrayHasKey('category', $data[$key]);
-            $this->assertEquals($testRow['category'], $data[$key]['category']);
-        }
-    }
+		);
+
+		self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+			return $extendedPdo;
+		});
+	}
+
+	public function testIsInstanceOfPostRepository()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository',
+			$repository
+		);
+	}
+
+	public function testImplementsPostInterface()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+
+		$this->assertInstanceOf(
+			'Jacobemerick\Web\Domain\Blog\Post\PostRepositoryInterface',
+			$repository
+		);
+	}
+
+	public function testConstructSetsConnections()
+	{
+		$respository = new MysqlPostRepository(self::$connection);
+
+		$this->assertAttributeSame(
+			self::$connection,
+			'connections',
+			$respository
+		);
+	}
+
+	public function testFindPostByPath()
+	{
+		$testData = [
+			'id'       => rand(1, 100),
+			'title'    => 'test title',
+			'path'     => 'test-path',
+			'category' => 'test category',
+			'date'     => (new DateTime())->format('Y-m-d H:i:s'),
+			'body'     => 'test body',
+			'display'  => 1
+		];
+
+		$this->insertPostData($testData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->findPostByPath($testData['category'], $testData['path']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertArrayHasKey('id', $data);
+		$this->assertEquals($testData['id'], $data['id']);
+		$this->assertArrayHasKey('title', $data);
+		$this->assertEquals($testData['title'], $data['title']);
+		$this->assertArrayHasKey('path', $data);
+		$this->assertEquals($testData['path'], $data['path']);
+		$this->assertArrayHasKey('date', $data);
+		$this->assertEquals($testData['date'], $data['date']);
+		$this->assertArrayHasKey('body', $data);
+		$this->assertEquals($testData['body'], $data['body']);
+		$this->assertArrayHasKey('category', $data);
+		$this->assertEquals($testData['category'], $data['category']);
+	}
+
+	public function testFindPostByPathInactive()
+	{
+		$testData = [
+			'id'       => rand(1, 100),
+			'path'     => 'test-path',
+			'category' => 'test category',
+			'display'  => 0
+		];
+
+		$this->insertPostData($testData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->findPostByPath($testData['category'], $testData['path']);
+
+		$this->assertFalse($data);
+	}
+
+	public function testFindPostByPathFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->findPostByPath('', '');
+
+		$this->assertFalse($data);
+	}
+
+	public function testGetActivePosts()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'title'    => 'title one',
+				'path'     => 'path-one',
+				'category' => 'test category',
+				'date'     => (new DateTime('-1 day'))->format('Y-m-d H:i:s'),
+				'body'     => 'body one',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'title'    => 'title two',
+				'path'     => 'path-two',
+				'category' => 'test category',
+				'date'     => (new DateTime())->format('Y-m-d H:i:s'),
+				'body'     => 'body one',
+				'display'  => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePosts();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(count($testData), $data);
+
+		usort($testData, function ($rowA, $rowB) {
+			return ((new DateTime($rowA['date'])) < (new DateTime($rowB['date'])));
+		});
+
+		foreach ($testData as $key => $testRow) {
+			$this->assertArrayHasKey('id', $data[$key]);
+			$this->assertEquals($testRow['id'], $data[$key]['id']);
+			$this->assertArrayHasKey('title', $data[$key]);
+			$this->assertEquals($testRow['title'], $data[$key]['title']);
+			$this->assertArrayHasKey('path', $data[$key]);
+			$this->assertEquals($testRow['path'], $data[$key]['path']);
+			$this->assertArrayHasKey('date', $data[$key]);
+			$this->assertEquals($testRow['date'], $data[$key]['date']);
+			$this->assertArrayHasKey('body', $data[$key]);
+			$this->assertEquals($testRow['body'], $data[$key]['body']);
+			$this->assertArrayHasKey('category', $data[$key]);
+			$this->assertEquals($testRow['category'], $data[$key]['category']);
+		}
+	}
  
-    public function testGetActivePostsInactive()
-    {
-        $testData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 0,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePosts();
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['display'] == 1);
-        });
-
-        $this->assertCount(count($testData), $data);
-
-        $testIds = array_column($testData, 'ids');
-        $dataIds = array_column($data, 'ids');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testIds, $dataIds),
-            array_diff($dataIds, $testIds)
-        ));
-    }
+	public function testGetActivePostsInactive()
+	{
+		$testData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 0,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePosts();
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['display'] == 1);
+		});
+
+		$this->assertCount(count($testData), $data);
+
+		$testIds = array_column($testData, 'ids');
+		$dataIds = array_column($data, 'ids');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testIds, $dataIds),
+			array_diff($dataIds, $testIds)
+		));
+	}
  
-    public function testGetActivePostsFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePosts();
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsRange()
-    {
-        $testData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePosts(2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(2, $data);
-
-        $testData = array_slice($testData, 2, 1);
-
-        $testIds = array_column($testData, 'ids');
-        $dataIds = array_column($data, 'ids');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testIds, $dataIds),
-            array_diff($dataIds, $testIds)
-        ));
-    }
-
-    public function testGetActivePostsRangeFailure()
-    {
-        $testData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePosts(1, 3);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsCount()
-    {
-        $testData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCount();
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivePostsCountInactive()
-    {
-        $testData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 0,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCount();
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['display'] == 1);
-        });
-
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivePostsCountFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCount();
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals('0', $data);
-    }
-
-    public function testGetActivePostsByTag()
-    {
-        $testPostData = [
-            [
-                'id'       => rand(1, 100),
-                'title'    => 'title one',
-                'path'     => 'path-one',
-                'category' => 'test category',
-                'date'     => (new DateTime('-1 day'))->format('Y-m-d H:i:s'),
-                'body'     => 'body one',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'title'    => 'title two',
-                'path'     => 'path-two',
-                'category' => 'test category',
-                'date'     => (new DateTime())->format('Y-m-d H:i:s'),
-                'body'     => 'body one',
-                'display'  => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByTag($testTagData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-        $this->assertCount(count($testPostData), $data);
-        foreach ($testPostData as $key => $testPostRow) {
-            $this->assertArrayHasKey('id', $data[$key]);
-            $this->assertEquals($testPostRow['id'], $data[$key]['id']);
-            $this->assertArrayHasKey('title', $data[$key]);
-            $this->assertEquals($testPostRow['title'], $data[$key]['title']);
-            $this->assertArrayHasKey('path', $data[$key]);
-            $this->assertEquals($testPostRow['path'], $data[$key]['path']);
-            $this->assertArrayHasKey('date', $data[$key]);
-            $this->assertEquals($testPostRow['date'], $data[$key]['date']);
-            $this->assertArrayHasKey('body', $data[$key]);
-            $this->assertEquals($testPostRow['body'], $data[$key]['body']);
-            $this->assertArrayHasKey('category', $data[$key]);
-            $this->assertEquals($testPostRow['category'], $data[$key]['category']);
-       }
-    }
-
-    public function testGetActivePostsByTagInactive()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 0,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByTag($testTagData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPostData = array_filter($testPostData, function ($row) {
-            return ($row['display'] == 1);
-        });
-
-        $this->assertCount(count($testPostData), $data);
-
-        $testIds = array_column($testPostData, 'ids');
-        $dataIds = array_column($data, 'ids');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testIds, $dataIds),
-            array_diff($dataIds, $testIds)
-        ));
-    }
+	public function testGetActivePostsFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePosts();
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsRange()
+	{
+		$testData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePosts(2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(2, $data);
+
+		$testData = array_slice($testData, 2, 1);
+
+		$testIds = array_column($testData, 'ids');
+		$dataIds = array_column($data, 'ids');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testIds, $dataIds),
+			array_diff($dataIds, $testIds)
+		));
+	}
+
+	public function testGetActivePostsRangeFailure()
+	{
+		$testData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePosts(1, 3);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsCount()
+	{
+		$testData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCount();
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivePostsCountInactive()
+	{
+		$testData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 0,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCount();
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['display'] == 1);
+		});
+
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivePostsCountFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCount();
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals('0', $data);
+	}
+
+	public function testGetActivePostsByTag()
+	{
+		$testPostData = [
+			[
+				'id'       => rand(1, 100),
+				'title'    => 'title one',
+				'path'     => 'path-one',
+				'category' => 'test category',
+				'date'     => (new DateTime('-1 day'))->format('Y-m-d H:i:s'),
+				'body'     => 'body one',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'title'    => 'title two',
+				'path'     => 'path-two',
+				'category' => 'test category',
+				'date'     => (new DateTime())->format('Y-m-d H:i:s'),
+				'body'     => 'body one',
+				'display'  => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByTag($testTagData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+		$this->assertCount(count($testPostData), $data);
+		foreach ($testPostData as $key => $testPostRow) {
+			$this->assertArrayHasKey('id', $data[$key]);
+			$this->assertEquals($testPostRow['id'], $data[$key]['id']);
+			$this->assertArrayHasKey('title', $data[$key]);
+			$this->assertEquals($testPostRow['title'], $data[$key]['title']);
+			$this->assertArrayHasKey('path', $data[$key]);
+			$this->assertEquals($testPostRow['path'], $data[$key]['path']);
+			$this->assertArrayHasKey('date', $data[$key]);
+			$this->assertEquals($testPostRow['date'], $data[$key]['date']);
+			$this->assertArrayHasKey('body', $data[$key]);
+			$this->assertEquals($testPostRow['body'], $data[$key]['body']);
+			$this->assertArrayHasKey('category', $data[$key]);
+			$this->assertEquals($testPostRow['category'], $data[$key]['category']);
+	   }
+	}
+
+	public function testGetActivePostsByTagInactive()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 0,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByTag($testTagData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPostData = array_filter($testPostData, function ($row) {
+			return ($row['display'] == 1);
+		});
+
+		$this->assertCount(count($testPostData), $data);
+
+		$testIds = array_column($testPostData, 'ids');
+		$dataIds = array_column($data, 'ids');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testIds, $dataIds),
+			array_diff($dataIds, $testIds)
+		));
+	}
  
-    public function testGetActivePostsByTagFailure()
-    {
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByTag($testTagData['id']);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsByTagRange()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByTag($testTagData['id'], 2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPostData = array_slice($testPostData, 1, 2);
-
-        $this->assertCount(count($testPostData), $data);
-
-        $testIds = array_column($testPostData, 'ids');
-        $dataIds = array_column($data, 'ids');
-
-        $this->assertEmpty(array_merge(
-            array_diff($testIds, $dataIds),
-            array_diff($dataIds, $testIds)
-        ));
-    }
-
-    public function testGetActivePostsByTagRangeFailure()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByTag($testTagData['id'], 1, 3);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsCountByTag()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByTag($testTagData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals(count($testPostData), $data);
-    }
-
-    public function testGetActivePostsCountByTagInactive()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 0,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByTag($testTagData['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-
-        $testPostData = array_filter($testPostData, function ($row) {
-            return ($row['display'] == 1);
-        });
-
-        $this->assertEquals(count($testPostData), $data);
-    }
+	public function testGetActivePostsByTagFailure()
+	{
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByTag($testTagData['id']);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsByTagRange()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByTag($testTagData['id'], 2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPostData = array_slice($testPostData, 1, 2);
+
+		$this->assertCount(count($testPostData), $data);
+
+		$testIds = array_column($testPostData, 'ids');
+		$dataIds = array_column($data, 'ids');
+
+		$this->assertEmpty(array_merge(
+			array_diff($testIds, $dataIds),
+			array_diff($dataIds, $testIds)
+		));
+	}
+
+	public function testGetActivePostsByTagRangeFailure()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByTag($testTagData['id'], 1, 3);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsCountByTag()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByTag($testTagData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals(count($testPostData), $data);
+	}
+
+	public function testGetActivePostsCountByTagInactive()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 0,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByTag($testTagData['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+
+		$testPostData = array_filter($testPostData, function ($row) {
+			return ($row['display'] == 1);
+		});
+
+		$this->assertEquals(count($testPostData), $data);
+	}
  
-    public function testGetActivePostsCountByTagFailure()
-    {
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
+	public function testGetActivePostsCountByTagFailure()
+	{
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
 
-        $this->insertTagData($testTagData);
+		$this->insertTagData($testTagData);
 
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByTag($testTagData['id']);
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByTag($testTagData['id']);
 
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals('0', $data);
-    }
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals('0', $data);
+	}
  
-    public function testGetActivePostsByCategory() {}
+	public function testGetActivePostsByCategory() {}
 
-    public function testGetActivePostsByCategoryInactive() {}
+	public function testGetActivePostsByCategoryInactive() {}
 
-    public function testGetActivePostsByCategoryFailure() {}
+	public function testGetActivePostsByCategoryFailure() {}
 
-    public function testGetActivePostsByCategoryRange() {}
+	public function testGetActivePostsByCategoryRange() {}
 
-    public function testGetActivePostsByCategoryRangeFailure() {}
+	public function testGetActivePostsByCategoryRangeFailure() {}
 
-    public function testGetActivePostsCountByCategory() {}
+	public function testGetActivePostsCountByCategory() {}
 
-    public function testGetActivePostsCountByCategoryInactive() {}
+	public function testGetActivePostsCountByCategoryInactive() {}
 
-    public function testGetActivePostsCountByCategoryFailure() {}
+	public function testGetActivePostsCountByCategoryFailure() {}
 
-    public function testGetActivePostsByRelatedTags() {}
+	public function testGetActivePostsByRelatedTags() {}
 
-    public function testGetActivePostsByRelatedTagsLimit() {}
+	public function testGetActivePostsByRelatedTagsLimit() {}
 
-    public function testGetActivePostsByRelatedTagsInactive() {}
+	public function testGetActivePostsByRelatedTagsInactive() {}
 
-    public function testGetActivePostsByRelatedTagsExcludeSeries() {}
+	public function testGetActivePostsByRelatedTagsExcludeSeries() {}
 
-    public function testGetActivePostsByRelatedTagsFailure() {}
+	public function testGetActivePostsByRelatedTagsFailure() {}
 
-    protected function insertPostData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'title' => '',
-            'path' => '',
-            'category' => '',
-            'date' => '',
-            'body' => '',
-            'display' => 0,
-        ];
+	protected function insertPostData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'title' => '',
+			'path' => '',
+			'category' => '',
+			'date' => '',
+			'body' => '',
+			'display' => 0,
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`post`
                 (id, title, path, category, date, body, display)
             VALUES
                 (:id, :title, :path, :category, :date, :body, :display)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertPTLinkData(array $data)
-    {
-        $defaultData = [
-            'post' => null,
-            'tag' => null,
-        ];
+	protected function insertPTLinkData(array $data)
+	{
+		$defaultData = [
+			'post' => null,
+			'tag' => null,
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`ptlink`
                 (post_id, tag_id)
             VALUES
                 (:post_id, :tag_id)",
-            $data
-        );
-    }
+			$data
+		);
+	}
 
-    protected function insertTagData(array $data)
-    {
-        $defaultData = [
-            'id' => null,
-            'tag' => '',
-        ];
+	protected function insertTagData(array $data)
+	{
+		$defaultData = [
+			'id' => null,
+			'tag' => '',
+		];
 
-        $data = array_merge($defaultData, $data);
+		$data = array_merge($defaultData, $data);
 
-        return self::$connection->getDefault()->perform("
+		return self::$connection->getDefault()->perform("
             INSERT INTO `jpemeric_blog`.`tag`
                 (id, tag)
             VALUES
                 (:id, :tag)",
-            $data
-        );
-    }
-
-    protected function tearDown()
-    {
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`ptlink`");
-        self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`tag`");
-    }
-
-    public static function tearDownAfterClass()
-    {
-        self::$connection->getDefault()->disconnect();
-        unlink('jpemeric_blog.db');
-    }
+			$data
+		);
+	}
+
+	protected function tearDown()
+	{
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`post`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`ptlink`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`tag`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_blog.db');
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -41,7 +41,7 @@ 
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }
@@ -167,7 +167,7 @@ 
         $this->assertInternalType('array', $data);
         $this->assertCount(count($testData), $data);
 
-        usort($testData, function ($rowA, $rowB) {
+        usort($testData, function($rowA, $rowB) {
             return ((new DateTime($rowA['date'])) < (new DateTime($rowB['date'])));
         });
 
@@ -212,7 +212,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -347,7 +347,7 @@ 
         $this->assertNotFalse($data);
         $this->assertStringMatchesFormat('%d', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -464,7 +464,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -664,7 +664,7 @@ 
         $this->assertNotFalse($data);
         $this->assertStringMatchesFormat('%d', $data);
 
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });