PotatoConnectorTest

Complexity

Total Complexity

18

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	20
Bugs	7	Features	8

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	21	1
A	testGetAdaptar()	0	5	1
A	testGetHost()	0	5	1
A	testSqliteConnect()	0	5	1
A	testSqliteConnectForNoPath()	0	5	1
A	testConnectDriverForSQLite()	0	5	1
A	testConnectDriverForMySql()	0	12	1
A	testConnectDriverforException()	0	4	1
A	testGetUsername()	0	5	1
A	testGetDBName()	0	5	1
A	testGetPassWord()	0	5	1
A	testGetConfigurationsIfGivenFilePath()	0	19	2
A	testGetConFilePath()	0	5	1
A	testSetConnectionFunction()	0	5	1
A	testSetConnectionFunctionThrowsException()	0	4	1
A	testSetConnection()	0	5	1
A	tearDown()	0	4	1

<?php

use Elchroy\PotatoORM\PotatoConnector;
use Mockery as m;
use org\bovigo\vfs\vfsStream;

class PotatoConnectorTest extends PHPUnit_Framework_TestCase
{
    private $root;
    private $connector;
    private $mockConnection;

The property $mockConnection is not used and could be removed.

    private $configFile;
    private $expectedconfig;
    private $adaptar;
    private $host;
    private $dbname;
    private $username;
    private $password;

    public function setUp()
    {
        $this->expectedconfig = [
                'host'        => 'myhost',
                'username'    => 'myusername',
                'password'    => '',
                'dbname'      => 'mydb',
                'adaptar'     => 'sqlite',
                'sqlite_file' => 'sample.db',
            ];
        $this->adaptar = $this->expectedconfig['adaptar'];
        $this->host = $this->expectedconfig['host'];
        $this->dbname = $this->expectedconfig['dbname'];
        $this->username = $this->expectedconfig['username'];
        $this->password = $this->expectedconfig['password'];

        $this->root = vfsStream::setup('home');
        $this->configFile = vfsStream::url('home/config.ini');

        $this->connector = new PotatoConnector($this->expectedconfig);
    }

    public function testGetAdaptar()
    {
        $adaptar = $this->connector->getAdaptar();
        $this->assertEquals('sqlite', $adaptar);
    }

    public function testGetHost()
    {
        $host = $this->connector->getHost();
        $this->assertEquals('myhost', $host);
    }

    public function testSqliteConnect()
    {
        $result = $this->connector->sqliteConnect('sqlite', 'sample.db');
        $this->assertInstanceOf('PDO', $result);
    }

    public function testSqliteConnectForNoPath()
    {
        $result = $this->connector->sqliteConnect('sqlite');
        $this->assertInstanceOf('PDO', $result);
    }

    public function testConnectDriverForSQLite()
    {
        $result = $this->connector->connectDriver('sqlite');
        $this->assertInstanceOf('PDO', $result);
    }

    public function testConnectDriverForMySql()
    {
        $conn = mysqli_connect('127.0.0.1', 'root', '');
        mysqli_query($conn, 'CREATE DATABASE IF NOT EXISTS elchroy');
        $this->connector->configuration['host'] = '127.0.0.1';
        $this->connector->configuration['dbname'] = 'elchroy';
        $this->connector->configuration['username'] = 'root';
        $this->connector->configuration['password'] = '';
        $result = $this->connector->connectDriver('mysql');
        $this->assertInstanceOf('PDO', $result);
        mysqli_query($conn, 'DROP DATABASE elchroy'); //Destroy the database;
    }

    /**
     * @expectedException Elchroy\PotatoORMExceptions\InvalidAdaptarException
     *
     * @expectedExceptionMessage Invalid Adapter wrongAdaptar : Please provide a driver for the connection to the database.
     */
    public function testConnectDriverforException()
    {
        $result = $this->connector->connectDriver('wrongAdaptar');

$result is not used, you could remove the assignment.

    }

    public function testGetUsername()
    {
        $username = $this->connector->getUsername();
        $this->assertEquals('myusername', $username);
    }

    public function testGetDBName()
    {
        $dbname = $this->connector->getDBName();
        $this->assertEquals('mydb', $dbname);
    }

    public function testGetPassWord()
    {
        $password = $this->connector->getPassword();
        $this->assertEquals('', $password);
    }

    public function testGetConfigurationsIfGivenFilePath()
    {
        $file = fopen($this->configFile, 'a');
        $configData = [
                    '[database]',
                    'host = myhost',
                    'username = myusername',
                    'password = ',
                    'dbname = mydb',
                    'adaptar = sqlite',
                    'sqlite_file = sample.db',
            ];
        foreach ($configData as $cfg) {
            fwrite($file, $cfg."\n");
        }
        fclose($file);
        $result = $this->connector->getConfigurations($this->configFile);
        $this->assertEquals($this->expectedconfig, $result);
    }

    public function testGetConFilePath()
    {
        $path = $this->connector->getConfigFilePath($this->configFile);
        $this->assertEquals('vfs://home/config.ini', $path);
    }

    public function testSetConnectionFunction()
    {
        $connection = $this->connector->connect($this->adaptar, $this->host, $this->dbname, $this->username, $this->password);

The call to PotatoConnector::connect() has too many arguments starting with $this->host.

        $this->assertInstanceOf('PDO', $connection);
    }

    /**
     * @expectedException Elchroy\PotatoORMExceptions\FaultyConnectionException
     *
     * @expectedExceptionMessage Please provide a driver for the connection to the database.
     */
    public function testSetConnectionFunctionThrowsException()
    {
        $connection = $this->connector->connect('wrongAdaptar', 'wrongHostname', 'wrongDbName', 'wrongUsername', 'wrongPassword');

The call to PotatoConnector::connect() has too many arguments starting with 'wrongHostname'.

$connection is not used, you could remove the assignment.

    }

    public function testSetConnection()
    {
        $connection = $this->connector->setConnection();
        $this->assertInstanceOf('PDO', $connection);
    }

    public function tearDown()
    {
        m::close();
    }
}