jacobemerick / web

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

Spacing +10 added lines, -10 removed lines

@@ -48,7 +48,7 @@ 
             )"
         );
 
-        self::$connection = new ConnectionLocator(function () use ($extendedPdo) {
+        self::$connection = new ConnectionLocator(function() use ($extendedPdo) {
             return $extendedPdo;
         });
     }
@@ -174,7 +174,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'])));
         });
 
@@ -219,7 +219,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -354,7 +354,7 @@ 
         $this->assertNotFalse($data);
         $this->assertStringMatchesFormat('%d', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -471,7 +471,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -671,7 +671,7 @@ 
         $this->assertNotFalse($data);
         $this->assertStringMatchesFormat('%d', $data);
 
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -769,7 +769,7 @@ 
         $this->assertNotFalse($data);
         $this->assertInternalType('array', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -921,7 +921,7 @@ 
         $this->assertNotFalse($data);
         $this->assertStringMatchesFormat('%d', $data);
 
-        $testData = array_filter($testData, function ($row) {
+        $testData = array_filter($testData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -1109,7 +1109,7 @@ 
         $this->assertInternalType('array', $data);
 
         array_shift($testPostData);
-        $testPostData = array_filter($testPostData, function ($row) {
+        $testPostData = array_filter($testPostData, function($row) {
             return ($row['display'] == 1);
         });
 
@@ -1181,7 +1181,7 @@ 
         $this->assertInternalType('array', $data);
 
         array_shift($testPostData);
-        $testPostData = array_filter($testPostData, function ($row) use ($testSeriesPostData) {
+        $testPostData = array_filter($testPostData, function($row) use ($testSeriesPostData) {
             return (!in_array($row['id'], array_column($testSeriesPostData, 'post')));
         });
 

Indentation +1225 added lines, -1225 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,1272 +27,1272 @@ 
                 `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`.`series_post` (
                 `series` integer NOT NULL,
                 `post` integer NOT NULL,
                 `order` integer(1) 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['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',
-            'display'  => 0
-        ];
-
-        $this->insertPostData($testData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->findPostByPath($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['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',
+			'display'  => 0
+		];
+
+		$this->insertPostData($testData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->findPostByPath($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()
-    {
-        $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->getActivePostsByCategory(reset($testData)['category']);
-
-        $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('title', $data[$key]);
-            $this->assertEquals($testDataRow['title'], $data[$key]['title']);
-            $this->assertArrayHasKey('path', $data[$key]);
-            $this->assertEquals($testDataRow['path'], $data[$key]['path']);
-            $this->assertArrayHasKey('date', $data[$key]);
-            $this->assertEquals($testDataRow['date'], $data[$key]['date']);
-            $this->assertArrayHasKey('body', $data[$key]);
-            $this->assertEquals($testDataRow['body'], $data[$key]['body']);
-            $this->assertArrayHasKey('category', $data[$key]);
-            $this->assertEquals($testDataRow['category'], $data[$key]['category']);
-        }
-    }
-
-    public function testGetActivePostsByCategoryInactive()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'category' => 'test category',
-                'display'  => 0,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByCategory(reset($testData)['category']);
-
-        $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 testGetActivePostsByCategory()
+	{
+		$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->getActivePostsByCategory(reset($testData)['category']);
+
+		$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('title', $data[$key]);
+			$this->assertEquals($testDataRow['title'], $data[$key]['title']);
+			$this->assertArrayHasKey('path', $data[$key]);
+			$this->assertEquals($testDataRow['path'], $data[$key]['path']);
+			$this->assertArrayHasKey('date', $data[$key]);
+			$this->assertEquals($testDataRow['date'], $data[$key]['date']);
+			$this->assertArrayHasKey('body', $data[$key]);
+			$this->assertEquals($testDataRow['body'], $data[$key]['body']);
+			$this->assertArrayHasKey('category', $data[$key]);
+			$this->assertEquals($testDataRow['category'], $data[$key]['category']);
+		}
+	}
+
+	public function testGetActivePostsByCategoryInactive()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'category' => 'test category',
+				'display'  => 0,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByCategory(reset($testData)['category']);
+
+		$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 testGetActivePostsByCategoryFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByCategory('');
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsByCategoryRange()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByCategory(reset($testData)['category'], 2, 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testData = array_slice($testData, 1, 2);
-
-        $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 testGetActivePostsByCategoryRangeFailure()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByCategory(reset($testData)['category'], 1, 3);
-
-        $this->assertEmpty($data);
-        $this->assertInternalType('array', $data);
-    }
-
-    public function testGetActivePostsCountByCategory()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByCategory(reset($testData)['category']);
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivePostsCountByCategoryInactive()
-    {
-        $testData = [
-            [
-                'id'       => rand(1, 100),
-                'category' => 'test category',
-                'display'  => 0,
-            ],
-            [
-                'id'       => rand(101, 200),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'category' => 'test category',
-                'display'  => 1,
-            ],
-        ];
-
-        array_walk($testData, [$this, 'insertPostData']);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByCategory(reset($testData)['category']);
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-
-        $testData = array_filter($testData, function ($row) {
-            return ($row['display'] == 1);
-        });
-
-        $this->assertEquals(count($testData), $data);
-    }
-
-    public function testGetActivePostsCountByCategoryFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsCountByCategory('');
-
-        $this->assertNotFalse($data);
-        $this->assertStringMatchesFormat('%d', $data);
-        $this->assertEquals('0', $data);
-    }
-
-    public function testGetActivePostsByRelatedTags()
-    {
-        $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('-2 days'))->format('Y-m-d H:i:s'),
-                'body'     => 'body two',
-                'display'  => 1,
-            ],
-            [
-                'id'       => rand(201, 300),
-                'title'    => 'title three',
-                'path'     => 'path-three',
-                'category' => 'test category',
-                'date'     => (new DateTime('-3 days'))->format('Y-m-d H:i:s'),
-                'body'     => 'body three',
-                '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->getActivePostsByRelatedTags(reset($testPostData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        array_shift($testPostData);
-
-        $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']);
-            $this->assertArrayHasKey('count', $data[$key]);
-            $this->assertEquals(count($testTagData), $data[$key]['count']);
-        }
-    }
-
-    public function testGetActivePostsByRelatedTagsLimit()
-    {
-        $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->getActivePostsByRelatedTags(reset($testPostData)['id'], 1);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        $testPostData = array_slice($testPostData, 1, 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 testGetActivePostsByCategoryFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByCategory('');
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsByCategoryRange()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByCategory(reset($testData)['category'], 2, 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testData = array_slice($testData, 1, 2);
+
+		$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 testGetActivePostsByCategoryRangeFailure()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByCategory(reset($testData)['category'], 1, 3);
+
+		$this->assertEmpty($data);
+		$this->assertInternalType('array', $data);
+	}
+
+	public function testGetActivePostsCountByCategory()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(101, 200),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByCategory(reset($testData)['category']);
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivePostsCountByCategoryInactive()
+	{
+		$testData = [
+			[
+				'id'       => rand(1, 100),
+				'category' => 'test category',
+				'display'  => 0,
+			],
+			[
+				'id'       => rand(101, 200),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'category' => 'test category',
+				'display'  => 1,
+			],
+		];
+
+		array_walk($testData, [$this, 'insertPostData']);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByCategory(reset($testData)['category']);
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+
+		$testData = array_filter($testData, function ($row) {
+			return ($row['display'] == 1);
+		});
+
+		$this->assertEquals(count($testData), $data);
+	}
+
+	public function testGetActivePostsCountByCategoryFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsCountByCategory('');
+
+		$this->assertNotFalse($data);
+		$this->assertStringMatchesFormat('%d', $data);
+		$this->assertEquals('0', $data);
+	}
+
+	public function testGetActivePostsByRelatedTags()
+	{
+		$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('-2 days'))->format('Y-m-d H:i:s'),
+				'body'     => 'body two',
+				'display'  => 1,
+			],
+			[
+				'id'       => rand(201, 300),
+				'title'    => 'title three',
+				'path'     => 'path-three',
+				'category' => 'test category',
+				'date'     => (new DateTime('-3 days'))->format('Y-m-d H:i:s'),
+				'body'     => 'body three',
+				'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->getActivePostsByRelatedTags(reset($testPostData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		array_shift($testPostData);
+
+		$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']);
+			$this->assertArrayHasKey('count', $data[$key]);
+			$this->assertEquals(count($testTagData), $data[$key]['count']);
+		}
+	}
+
+	public function testGetActivePostsByRelatedTagsLimit()
+	{
+		$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->getActivePostsByRelatedTags(reset($testPostData)['id'], 1);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		$testPostData = array_slice($testPostData, 1, 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 testGetActivePostsByRelatedTagsInactive()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 0,
-            ],
-            [
-                'id'      => rand(301, 400),
-                '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->getActivePostsByRelatedTags(reset($testPostData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        array_shift($testPostData);
-        $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 testGetActivePostsByRelatedTagsInactive()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 0,
+			],
+			[
+				'id'      => rand(301, 400),
+				'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->getActivePostsByRelatedTags(reset($testPostData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		array_shift($testPostData);
+		$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 testGetActivePostsByRelatedTagsExcludeSeries()
-    {
-        $testPostData = [
-            [
-                'id'      => rand(1, 100),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(101, 200),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(201, 300),
-                'display' => 1,
-            ],
-            [
-                'id'      => rand(301, 400),
-                'display' => 1,
-            ],
-        ];
-
-        $testTagData = [
-            'id' => rand(1, 100),
-        ];
-
-        $testPTLinkData = [];
-        foreach ($testPostData as $testPostRow) {
-            array_push($testPTLinkData, [
-                'post_id' => $testPostRow['id'],
-                'tag_id' => $testTagData['id'],
-            ]);
-        }
-
-        $seriesPostKey = rand(1, 3);
-        $testSeriesPostData = [
-            [
-                'series' => 1,
-                'post' => reset($testPostData)['id'],
-            ],
-            [
-                'series' => 1,
-                'post' => $testPostData[$seriesPostKey]['id'],
-            ],
-        ];
-
-        array_walk($testPostData, [$this, 'insertPostData']);
-        array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
-        array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
-        $this->insertTagData($testTagData);
-
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByRelatedTags(reset($testPostData)['id']);
-
-        $this->assertNotFalse($data);
-        $this->assertInternalType('array', $data);
-
-        array_shift($testPostData);
-        $testPostData = array_filter($testPostData, function ($row) use ($testSeriesPostData) {
-            return (!in_array($row['id'], array_column($testSeriesPostData, 'post')));
-        });
-
-        $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 testGetActivePostsByRelatedTagsFailure()
-    {
-        $repository = new MysqlPostRepository(self::$connection);
-        $data = $repository->getActivePostsByRelatedTags('');
-
-        $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 testGetActivePostsByRelatedTagsExcludeSeries()
+	{
+		$testPostData = [
+			[
+				'id'      => rand(1, 100),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(101, 200),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(201, 300),
+				'display' => 1,
+			],
+			[
+				'id'      => rand(301, 400),
+				'display' => 1,
+			],
+		];
+
+		$testTagData = [
+			'id' => rand(1, 100),
+		];
+
+		$testPTLinkData = [];
+		foreach ($testPostData as $testPostRow) {
+			array_push($testPTLinkData, [
+				'post_id' => $testPostRow['id'],
+				'tag_id' => $testTagData['id'],
+			]);
+		}
+
+		$seriesPostKey = rand(1, 3);
+		$testSeriesPostData = [
+			[
+				'series' => 1,
+				'post' => reset($testPostData)['id'],
+			],
+			[
+				'series' => 1,
+				'post' => $testPostData[$seriesPostKey]['id'],
+			],
+		];
+
+		array_walk($testPostData, [$this, 'insertPostData']);
+		array_walk($testPTLinkData, [$this, 'insertPTLinkData']);
+		array_walk($testSeriesPostData, [$this, 'insertSeriesPostData']);
+		$this->insertTagData($testTagData);
+
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByRelatedTags(reset($testPostData)['id']);
+
+		$this->assertNotFalse($data);
+		$this->assertInternalType('array', $data);
+
+		array_shift($testPostData);
+		$testPostData = array_filter($testPostData, function ($row) use ($testSeriesPostData) {
+			return (!in_array($row['id'], array_column($testSeriesPostData, 'post')));
+		});
+
+		$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 testGetActivePostsByRelatedTagsFailure()
+	{
+		$repository = new MysqlPostRepository(self::$connection);
+		$data = $repository->getActivePostsByRelatedTags('');
+
+		$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 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
-        );
-    }
+			$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`.`series_post`");
-        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`.`series_post`");
+		self::$connection->getDefault()->perform("DELETE FROM `jpemeric_blog`.`tag`");
+	}
+
+	public static function tearDownAfterClass()
+	{
+		self::$connection->getDefault()->disconnect();
+		unlink('jpemeric_blog.db');
+	}
 }

controller/blog/PostController.class.inc.php

Braces +9 added lines, -7 removed lines

@@ -26,8 +26,9 @@ 
 		parent::__construct();
 		
 		$this->post = PostCollector::getPostByURI(URLDecode::getPiece(2));
-		if($this->post == null)
-			$this->eject();
+		if($this->post == null) {

+					$this->eject();

+		}

 		
 		$this->handle_comment_submit(
 			self::$BLOG_SITE_ID,
@@ -106,8 +107,9 @@ 
 	private function get_series_posts()
 	{
 		$series_posts = $this->fetch_series_posts();
-		if(count($series_posts) < 1)
-			return array();
+		if(count($series_posts) < 1) {

+					return array();

+		}

 		
 		$previous_post = new stdclass();
 		$next_post = new stdclass();
@@ -141,9 +143,9 @@ 
 
 			$post->url = Loader::getRootUrl('blog') . "{$post_row['category']}/{$post_row['path']}/";
 			
-			if(!$found_current_post)
-				$previous_post = $post;
-			else
+			if(!$found_current_post) {

+							$previous_post = $post;

+			} else
 			{
 				$next_post = $post;
 				break;

Spacing +10 added lines, -10 removed lines

@@ -27,7 +27,7 @@ 
         $repository = new Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository($container['db_connection_locator']);
         $this->post = $repository->findPostByPath(URLDecode::getPiece(2));
 
-		if($this->post == null)
+		if ($this->post == null)
 			$this->eject();
 		
 		$this->handle_comment_submit(
@@ -95,7 +95,7 @@ 
 		$keyword_array = array();
 		$keywords = $this->tags;
 		
-		foreach($keywords as $keyword)
+		foreach ($keywords as $keyword)
 		{
 			$keyword_array[] = $keyword['tag'];
 		}
@@ -109,16 +109,16 @@ 
 	private function get_series_posts()
 	{
 		$series_posts = $this->fetch_series_posts();
-		if(count($series_posts) < 1)
+		if (count($series_posts) < 1)
 			return array();
 		
 		$previous_post = new stdclass();
 		$next_post = new stdclass();
 		
 		$found_current_post = false;
-		foreach($series_posts as $post_row)
+		foreach ($series_posts as $post_row)
 		{
-			if($post_row['post'] == $this->post['id'])
+			if ($post_row['post'] == $this->post['id'])
 			{
 				$found_current_post = true;
 				continue;
@@ -144,7 +144,7 @@ 
 
 			$post->url = Loader::getRootUrl('blog') . "{$post_row['category']}/{$post_row['path']}/";
 			
-			if(!$found_current_post)
+			if (!$found_current_post)
 				$previous_post = $post;
 			else
 			{
@@ -163,7 +163,7 @@ 
 	private $series_posts;
 	private function fetch_series_posts()
 	{
-      if(!isset($this->series_posts)) {
+      if (!isset($this->series_posts)) {
           global $container;
           $repository = new Jacobemerick\Web\Domain\Blog\Series\MysqlSeriesRepository($container['db_connection_locator']);
           $this->series_posts = $repository->getSeriesForPost($this->post['id']);
@@ -174,14 +174,14 @@ 
 	private function get_related_posts()
 	{
 		$tag_array = array();
-		foreach($this->tags as $tag)
+		foreach ($this->tags as $tag)
 		{
 			$tag_array[] = $tag['id'];
 		}
 		
 		$series_posts = $this->fetch_series_posts();
 		$exclude_post_array = array();
-		foreach($series_posts as $series_post)
+		foreach ($series_posts as $series_post)
 		{
 			$exclude_post_array[] = $series_post['post'];
 		}
@@ -192,7 +192,7 @@ 
 
         $post_array = array();
 		
-		foreach($post_result as $post_row)
+		foreach ($post_result as $post_row)
 		{
 			$post = new stdclass();
 			$post->title = $post_row['title'];

Indentation +29 added lines, -29 removed lines

@@ -23,9 +23,9 @@ 
 	{
 		parent::__construct();
 		
-        global $container;
-        $repository = new Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository($container['db_connection_locator']);
-        $this->post = $repository->findPostByPath(URLDecode::getPiece(2));
+		global $container;
+		$repository = new Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository($container['db_connection_locator']);
+		$this->post = $repository->findPostByPath(URLDecode::getPiece(2));
 
 		if($this->post == null)
 			$this->eject();
@@ -36,9 +36,9 @@ 
 			Loader::getRootUrl('blog') . $this->post['category'] . '/' . $this->post['path'] . '/',
 			$this->post['title']);
 
-        global $container;
-        $repository = new Jacobemerick\Web\Domain\Blog\Tag\MysqlTagRepository($container['db_connection_locator']);
-        $this->tags = $repository->getTagsForPost($this->post['id']);
+		global $container;
+		$repository = new Jacobemerick\Web\Domain\Blog\Tag\MysqlTagRepository($container['db_connection_locator']);
+		$this->tags = $repository->getTagsForPost($this->post['id']);
 	}
 
 	protected function set_head_data()
@@ -50,9 +50,9 @@ 
 		$this->set_keywords($this->get_post_keywords());
 		$this->set_author(self::$AUTHOR);
 
-    $photo = Content::instance('FetchFirstPhoto', $this->post['body'])->activate(true);
-    $photo = preg_match('/^<img src="([a-z-:\.\/]+)" [^>]+>$/', $photo, $matches);
-    $this->set_head('thumbnail', $matches[1]);
+	$photo = Content::instance('FetchFirstPhoto', $this->post['body'])->activate(true);
+	$photo = preg_match('/^<img src="([a-z-:\.\/]+)" [^>]+>$/', $photo, $matches);
+	$this->set_head('thumbnail', $matches[1]);
 
 		if (array_key_exists($this->post['id'], self::$DEPRECATED_BLOGS)) {
 			$log_id = self::$DEPRECATED_BLOGS[$this->post['id']];
@@ -126,16 +126,16 @@ 
 			
 			$post = new stdclass();
 
-      if (
-        strpos($post_row['title'], 'Rainy Supe Loop') === 0 ||
-        strpos($post_row['title'], 'Malapais Loop') === 0
-      ) {
-        $title = $post_row['title'];
-        $title = explode(':', $title);
-        $title = array_pop($title);
-        $title = trim($title);
-        $post->title = $title;
-      } else if (strpos($post_row['title'], 'Isle Royale') === 0) {
+	  if (
+		strpos($post_row['title'], 'Rainy Supe Loop') === 0 ||
+		strpos($post_row['title'], 'Malapais Loop') === 0
+	  ) {
+		$title = $post_row['title'];
+		$title = explode(':', $title);
+		$title = array_pop($title);
+		$title = trim($title);
+		$post->title = $title;
+	  } else if (strpos($post_row['title'], 'Isle Royale') === 0) {
 				$title = $post_row['title'];
 				$title = explode(',', $title);
 				$title = array_pop($title);
@@ -166,12 +166,12 @@ 
 	private $series_posts;
 	private function fetch_series_posts()
 	{
-      if(!isset($this->series_posts)) {
-          global $container;
-          $repository = new Jacobemerick\Web\Domain\Blog\Series\MysqlSeriesRepository($container['db_connection_locator']);
-          $this->series_posts = $repository->getSeriesForPost($this->post['id']);
-      }
-      return $this->series_posts;
+	  if(!isset($this->series_posts)) {
+		  global $container;
+		  $repository = new Jacobemerick\Web\Domain\Blog\Series\MysqlSeriesRepository($container['db_connection_locator']);
+		  $this->series_posts = $repository->getSeriesForPost($this->post['id']);
+	  }
+	  return $this->series_posts;
 	}
 
 	private function get_related_posts()
@@ -189,11 +189,11 @@ 
 			$exclude_post_array[] = $series_post['post'];
 		}
 
-        global $container;
-        $repository = new Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository($container['db_connection_locator']);
-        $post_result = $repository->getActivePostsByRelatedTags($this->post['id']);
+		global $container;
+		$repository = new Jacobemerick\Web\Domain\Blog\Post\MysqlPostRepository($container['db_connection_locator']);
+		$post_result = $repository->getActivePostsByRelatedTags($this->post['id']);
 
-        $post_array = array();
+		$post_array = array();
 		
 		foreach($post_result as $post_row)
 		{

src/Domain/Blog/Post/MysqlPostRepository.php

Doc Comments +10 added lines, -1 removed lines

@@ -11,7 +11,7 @@ 
     protected $connections;
 
     /**
-     * @param Aura\Sql\ConnectionLocator $connections
+     * @param ConnectionLocator $connections
      */
     public function __construct(ConnectionLocator $connections)
     {
@@ -41,6 +41,9 @@ 
             ->fetchOne($query, $bindings);
     }
 
+    /**
+     * @param integer $limit
+     */
     public function getActivePosts($limit = null, $offset = 0)
     {
         $query = "
@@ -79,6 +82,9 @@ 
             ->fetchValue($query, $bindings);
     }
 
+    /**
+     * @param integer $limit
+     */
     public function getActivePostsByTag($tag, $limit = null, $offset = 0)
     {
         $query = "
@@ -122,6 +128,9 @@ 
             ->fetchValue($query, $bindings);
     }
 
+    /**
+     * @param integer $limit
+     */
     public function getActivePostsByCategory($category, $limit = null, $offset = 0)
     {
         $query = "

Indentation +134 added lines, -134 removed lines

@@ -7,163 +7,163 @@ 
 class MysqlPostRepository implements PostRepositoryInterface
 {
 
-    /** @var  Aura\Sql\ConnectionLocator */
-    protected $connections;
-
-    /**
-     * @param Aura\Sql\ConnectionLocator $connections
-     */
-    public function __construct(ConnectionLocator $connections)
-    {
-        $this->connections = $connections;
-    }
-
-    /**
-     * @param string $path
-     *
-     * @return array|false
-     */
-    public function findPostByPath($path)
-    {
-        $query = "
+	/** @var  Aura\Sql\ConnectionLocator */
+	protected $connections;
+
+	/**
+	 * @param Aura\Sql\ConnectionLocator $connections
+	 */
+	public function __construct(ConnectionLocator $connections)
+	{
+		$this->connections = $connections;
+	}
+
+	/**
+	 * @param string $path
+	 *
+	 * @return array|false
+	 */
+	public function findPostByPath($path)
+	{
+		$query = "
             SELECT `id`, `title`, `path`, `date`, `body`, `category`
             FROM `jpemeric_blog`.`post`
             WHERE `path` = :path AND `display` = :is_active
             LIMIT 1";
-        $bindings = [
-            'path'      => $path,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchOne($query, $bindings);
-    }
-
-    public function getActivePosts($limit = null, $offset = 0)
-    {
-        $query = "
+		$bindings = [
+			'path'      => $path,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchOne($query, $bindings);
+	}
+
+	public function getActivePosts($limit = null, $offset = 0)
+	{
+		$query = "
             SELECT `id`, `title`, `path`, `date`, `body`, `category`
             FROM `jpemeric_blog`.`post`
             WHERE `display` = :is_active
             ORDER BY `date` DESC";
-        if ($limit != null) {
-            $query .= "
+		if ($limit != null) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
+		}
 
-        $bindings = [
-            'is_active' => 1,
-        ];
+		$bindings = [
+			'is_active' => 1,
+		];
 
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query, $bindings);
-    }
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query, $bindings);
+	}
 
-    public function getActivePostsCount()
-    {
-        $query = "
+	public function getActivePostsCount()
+	{
+		$query = "
             SELECT COUNT(1) AS `count`
             FROM `jpemeric_blog`.`post`
             WHERE `display` = :is_active";
-        $bindings = [
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchValue($query, $bindings);
-    }
-
-    public function getActivePostsByTag($tag, $limit = null, $offset = 0)
-    {
-        $query = "
+		$bindings = [
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchValue($query, $bindings);
+	}
+
+	public function getActivePostsByTag($tag, $limit = null, $offset = 0)
+	{
+		$query = "
             SELECT `id`, `title`, `path`, `date`, `body`, `category`
             FROM `jpemeric_blog`.`post`
             INNER JOIN `jpemeric_blog`.`ptlink` ON `ptlink`.`post_id` = `post`.`id` AND
                                                    `ptlink`.`tag_id` = :tag_id
             WHERE `display` = :is_active";
-        if ($limit != null) {
-            $query .= "
+		if ($limit != null) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
-
-        $bindings = [
-            'tag_id'    => $tag,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query, $bindings);
-    }
-
-    public function getActivePostsCountByTag($tag)
-    {
-        $query = "
+		}
+
+		$bindings = [
+			'tag_id'    => $tag,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query, $bindings);
+	}
+
+	public function getActivePostsCountByTag($tag)
+	{
+		$query = "
             SELECT COUNT(1) AS `count`
             FROM `jpemeric_blog`.`post`
             INNER JOIN `jpemeric_blog`.`ptlink` ON `ptlink`.`post_id` = `post`.`id` AND
                                                    `ptlink`.`tag_id` = :tag_id
             WHERE `display` = :is_active";
-        $bindings = [
-            'tag_id'    => $tag,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchValue($query, $bindings);
-    }
-
-    public function getActivePostsByCategory($category, $limit = null, $offset = 0)
-    {
-        $query = "
+		$bindings = [
+			'tag_id'    => $tag,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchValue($query, $bindings);
+	}
+
+	public function getActivePostsByCategory($category, $limit = null, $offset = 0)
+	{
+		$query = "
             SELECT `id`, `title`, `path`, `date`, `body`, `category`
             FROM `jpemeric_blog`.`post`
             WHERE `category` = :category AND `display` = :is_active";
-        if ($limit != null) {
-            $query .= "
+		if ($limit != null) {
+			$query .= "
             LIMIT {$offset}, {$limit}";
-        }
-
-        $bindings = [
-            'category'  => $category,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query, $bindings);
-    }
-
-    public function getActivePostsCountByCategory($category)
-    {
-        $query = "
+		}
+
+		$bindings = [
+			'category'  => $category,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query, $bindings);
+	}
+
+	public function getActivePostsCountByCategory($category)
+	{
+		$query = "
             SELECT COUNT(1) AS `count`
             FROM `jpemeric_blog`.`post`
             WHERE `category` = :category AND `display` = :is_active";
-        $bindings = [
-            'category'  => $category,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchValue($query, $bindings);
-    }
-
-    public function getActivePostsByRelatedTags($post, $limit = 4)
-    {
-        $query = "
+		$bindings = [
+			'category'  => $category,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchValue($query, $bindings);
+	}
+
+	public function getActivePostsByRelatedTags($post, $limit = 4)
+	{
+		$query = "
             SELECT `id`, `title`, `path`, `date`, `body`, `category`, COUNT(1) AS `count`
             FROM `jpemeric_blog`.`post`
             INNER JOIN `jpemeric_blog`.`ptlink` ON `ptlink`.`post_id` = `post`.`id` AND
@@ -183,14 +183,14 @@ 
             GROUP BY `id`
             ORDER BY `count` DESC
             LIMIT {$limit}";
-        $bindings = [
-            'post'      => $post,
-            'is_active' => 1,
-        ];
-
-        return $this
-            ->connections
-            ->getRead()
-            ->fetchAll($query, $bindings);
-    }
+		$bindings = [
+			'post'      => $post,
+			'is_active' => 1,
+		];
+
+		return $this
+			->connections
+			->getRead()
+			->fetchAll($query, $bindings);
+	}
 }