DBObjectTest::testIsset() - Code Metrics - Inspection of "test loaded" - suricate-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 8fa47c...77747e )

by Mathieu

created 2019-01-19 19:03 UTC

DBObjectTest::testIsset() A

↳ Parent: DBObjectTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	5
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	8
rs	10

<?php
class DBObjectTest extends \PHPUnit\Framework\TestCase
{
    protected $tableName = 'users';
    public function testContructor()
    {
        $classname = '\Suricate\DBObject';

        // Get mock, without the constructor being called
        $mock = $this->getMockBuilder($classname)
            ->disableOriginalConstructor()
            ->setMethods(array('setRelations'))
            ->getMockForAbstractClass();

        // set expectations for constructor calls
        $mock->expects($this->once())
            ->method('setRelations');

        // now call the constructor
        $reflectedClass = new ReflectionClass($classname);
        $constructor = $reflectedClass->getConstructor();
        $constructor->invoke($mock);
    }

    public function testGetTableName()
    {
        $testName = 'my_sql_table';

        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'tableName', $testName);
        $this->assertEquals($testName, $testDBO->getTableName());
    }

    public function testGetTableIndex()
    {
        $testIndex = 'id';

        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'tableIndex', $testIndex);
        $this->assertEquals($testIndex, $testDBO->getTableIndex());
    }

    public function testGetDBConfig()
    {
        $testConfigName = 'my_config';

        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'DBConfig', $testConfigName);
        $this->assertEquals($testConfigName, $testDBO->getDBConfig());
    }

    public function testUndefinedGet()
    {
        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'last_update']);
        $this->expectException(\InvalidArgumentException::class);
        
        $testDBO->undefinedVar;

    }

    public function testDBProperty()
    {
        $testDBO = new \Suricate\DBObject();
        $testDBO->regularProperty = 42;

        self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'not_loaded_var']);
        self::mockProperty($testDBO, 'dbValues', ['id' => 1, 'name' => 'test name']);
        $this->assertEquals($testDBO->id, 1);

        $this->assertNotEquals($testDBO->name, 'test name edited');

        $this->assertNull($testDBO->not_loaded_var);


        $this->assertTrue($testDBO->isDBVariable('id'));
        $this->assertFalse($testDBO->isDBVariable('regularProperty'));

        $this->assertTrue($testDBO->propertyExists('regularProperty'));
        $this->assertTrue($testDBO->propertyExists('id'));
        $this->assertFalse($testDBO->propertyExists('unknownProperty'));
    }

    public function testIsset()
    {
        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'not_loaded_var']);
        self::mockProperty($testDBO, 'dbValues', ['id' => 1, 'name' => 'test name']);

        $this->assertTrue(isset($testDBO->id));

        $this->assertFalse(isset($testDBO->undefVar));

    }

    public function testIsLoaded()
    {
        $testIndex = 'id';

        $testDBO = new \Suricate\DBObject();
        self::mockProperty($testDBO, 'tableIndex', $testIndex);
        self::mockProperty($testDBO, 'dbVariables', [$testIndex, 'name', 'not_loaded_var']);
        $this->assertFalse($testDBO->isLoaded());

        self::mockProperty($testDBO, 'dbValues', [$testIndex => 1, 'name' => 'test name']);
        $this->assertTrue($testDBO->isLoaded());
    }

    public function testHydrate()
    {
        $testDBO = new \Suricate\DBObject();
        $testDBO->realProperty = '';


        self::mockProperty($testDBO, 'dbVariables', ['id', 'name']);
        $testDBO->hydrate([
            'id' => 1,
            'name' => 'test record',
            'add_column' => 'test value',
            'realProperty' => 'my string',
        ]);

        $this->assertEquals($testDBO->realProperty, 'my string');


        $reflector = new ReflectionClass(get_class($testDBO));
        $property = $reflector->getProperty('dbValues');
        $property->setAccessible(true);
        $this->assertEquals([
            'id' => 1,
            'name' => 'test record',
        ], $property->getValue($testDBO));
    }

    public function testLoad()
    {
        // Prepare database
        $this->setupData();
        $dbLink = $this->getDatabase();

        // Inject database handler
        $testDBO = new \Suricate\DBObject();


        $reflector = new ReflectionClass(get_class($testDBO));
        $property = $reflector->getProperty('dbLink');
        $property->setAccessible(true);
        $property->setValue($testDBO, $dbLink);

        self::mockProperty($testDBO, 'tableName', $this->tableName);
        self::mockProperty($testDBO, 'tableIndex', 'id');
        self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'date_added']);

        $this->assertFalse($testDBO->isLoaded());
        $retVal = $testDBO->load(1);
        $this->assertTrue($testDBO->isLoaded());
        $this->assertEquals(1, $testDBO->id);

        $this->assertEquals('John', $testDBO->name);

        $this->assertInstanceOf('\Suricate\DBObject', $retVal);
    }
    

    public static function mockProperty($object, string $propertyName, $value)
    {
        $reflectionClass = new \ReflectionClass($object);

        $property = $reflectionClass->getProperty($propertyName);
        $property->setAccessible(true);
        $property->setValue($object, $value);
        $property->setAccessible(false);
    }

    protected function setupData()
    {
        $pdo = new PDO('sqlite:/tmp/test.db');
        $pdo->exec("DROP TABLE IF EXISTS `" . $this->tableName ."`");
        $pdo->exec("CREATE TABLE `" .$this->tableName. "` (`id` INTEGER PRIMARY KEY,`name` varchar(50) DEFAULT NULL,`date_added` datetime NOT NULL)");
        $stmt = $pdo->prepare("INSERT INTO `" . $this->tableName . "` (name, date_added) VALUES (:name, :date)");
        $values = [
            ['John', '2019-01-10 00:00:00'],
            ['Paul', '2019-01-11 00:00:00'],
            ['Robert', '2019-01-12 00:00:00']
        ];
        foreach ($values as $value) {
            $stmt->execute(['name' => $value[0], 'date' => $value[1]]);
        }
    }

    protected function getDatabase()
    {
        $database = new \Suricate\Database();
        $database->configure([
            'type' => 'sqlite',
            'file' => '/tmp/test.db',
        ]);

        return $database;
    }
}


1			<?php
2			class DBObjectTest extends \PHPUnit\Framework\TestCase
3			{
4			protected $tableName = 'users';
5			public function testContructor()
6			{
7			$classname = '\Suricate\DBObject';
8
9			// Get mock, without the constructor being called
10			$mock = $this->getMockBuilder($classname)
11			->disableOriginalConstructor()
12			->setMethods(array('setRelations'))
13			->getMockForAbstractClass();
14
15			// set expectations for constructor calls
16			$mock->expects($this->once())
17			->method('setRelations');
18
19			// now call the constructor
20			$reflectedClass = new ReflectionClass($classname);
21			$constructor = $reflectedClass->getConstructor();
22			$constructor->invoke($mock);
23			}
24
25			public function testGetTableName()
26			{
27			$testName = 'my_sql_table';
28
29			$testDBO = new \Suricate\DBObject();
30			self::mockProperty($testDBO, 'tableName', $testName);
31			$this->assertEquals($testName, $testDBO->getTableName());
32			}
33
34			public function testGetTableIndex()
35			{
36			$testIndex = 'id';
37
38			$testDBO = new \Suricate\DBObject();
39			self::mockProperty($testDBO, 'tableIndex', $testIndex);
40			$this->assertEquals($testIndex, $testDBO->getTableIndex());
41			}
42
43			public function testGetDBConfig()
44			{
45			$testConfigName = 'my_config';
46
47			$testDBO = new \Suricate\DBObject();
48			self::mockProperty($testDBO, 'DBConfig', $testConfigName);
49			$this->assertEquals($testConfigName, $testDBO->getDBConfig());
50			}
51
52			public function testUndefinedGet()
53			{
54			$testDBO = new \Suricate\DBObject();
55			self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'last_update']);
56			$this->expectException(\InvalidArgumentException::class);
57
58			$testDBO->undefinedVar;
			0 ignored issues – show Bug Best Practice introduced 2019-01-15 20:52 UTC by Report Bug Copy Issue Report The property `undefinedVar` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
59			}
60
61			public function testDBProperty()
62			{
63			$testDBO = new \Suricate\DBObject();
64			$testDBO->regularProperty = 42;
			0 ignored issues – show Bug Best Practice introduced 2019-01-15 20:52 UTC by Report Bug Copy Issue Report The property `regularProperty` does not exist on `Suricate\DBObject`. Since you implemented `__set`, consider adding a @property annotation. Loading history...
65			self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'not_loaded_var']);
66			self::mockProperty($testDBO, 'dbValues', ['id' => 1, 'name' => 'test name']);
67			$this->assertEquals($testDBO->id, 1);
			0 ignored issues – show Bug Best Practice introduced 2019-01-15 20:52 UTC by Report Bug Copy Issue Report The property `id` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
68			$this->assertNotEquals($testDBO->name, 'test name edited');
			0 ignored issues – show Bug Best Practice introduced 2019-01-15 20:52 UTC by Report Bug Copy Issue Report The property `name` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
69			$this->assertNull($testDBO->not_loaded_var);
			0 ignored issues – show Bug Best Practice introduced 2019-01-15 20:52 UTC by Report Bug Copy Issue Report The property `not_loaded_var` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
70
71			$this->assertTrue($testDBO->isDBVariable('id'));
72			$this->assertFalse($testDBO->isDBVariable('regularProperty'));
73
74			$this->assertTrue($testDBO->propertyExists('regularProperty'));
75			$this->assertTrue($testDBO->propertyExists('id'));
76			$this->assertFalse($testDBO->propertyExists('unknownProperty'));
77			}
78
79			public function testIsset()
80			{
81			$testDBO = new \Suricate\DBObject();
82			self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'not_loaded_var']);
83			self::mockProperty($testDBO, 'dbValues', ['id' => 1, 'name' => 'test name']);
84
85			$this->assertTrue(isset($testDBO->id));
			0 ignored issues – show Bug Best Practice introduced 2019-01-16 22:06 UTC by Report Bug Copy Issue Report The property `id` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
86			$this->assertFalse(isset($testDBO->undefVar));
			0 ignored issues – show Bug Best Practice introduced 2019-01-16 22:06 UTC by Report Bug Copy Issue Report The property `undefVar` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
87			}
88
89			public function testIsLoaded()
90			{
91			$testIndex = 'id';
92
93			$testDBO = new \Suricate\DBObject();
94			self::mockProperty($testDBO, 'tableIndex', $testIndex);
95			self::mockProperty($testDBO, 'dbVariables', [$testIndex, 'name', 'not_loaded_var']);
96			$this->assertFalse($testDBO->isLoaded());
97
98			self::mockProperty($testDBO, 'dbValues', [$testIndex => 1, 'name' => 'test name']);
99			$this->assertTrue($testDBO->isLoaded());
100			}
101
102			public function testHydrate()
103			{
104			$testDBO = new \Suricate\DBObject();
105			$testDBO->realProperty = '';
			0 ignored issues – show Bug Best Practice introduced 2019-01-16 22:25 UTC by Report Bug Copy Issue Report The property `realProperty` does not exist on `Suricate\DBObject`. Since you implemented `__set`, consider adding a @property annotation. Loading history...
106
107			self::mockProperty($testDBO, 'dbVariables', ['id', 'name']);
108			$testDBO->hydrate([
109			'id' => 1,
110			'name' => 'test record',
111			'add_column' => 'test value',
112			'realProperty' => 'my string',
113			]);
114
115			$this->assertEquals($testDBO->realProperty, 'my string');
			0 ignored issues – show Bug Best Practice introduced 2019-01-16 22:25 UTC by Report Bug Copy Issue Report The property `realProperty` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
116
117			$reflector = new ReflectionClass(get_class($testDBO));
118			$property = $reflector->getProperty('dbValues');
119			$property->setAccessible(true);
120			$this->assertEquals([
121			'id' => 1,
122			'name' => 'test record',
123			], $property->getValue($testDBO));
124			}
125
126			public function testLoad()
127			{
128			// Prepare database
129			$this->setupData();
130			$dbLink = $this->getDatabase();
131
132			// Inject database handler
133			$testDBO = new \Suricate\DBObject();
134
135
136			$reflector = new ReflectionClass(get_class($testDBO));
137			$property = $reflector->getProperty('dbLink');
138			$property->setAccessible(true);
139			$property->setValue($testDBO, $dbLink);
140
141			self::mockProperty($testDBO, 'tableName', $this->tableName);
142			self::mockProperty($testDBO, 'tableIndex', 'id');
143			self::mockProperty($testDBO, 'dbVariables', ['id', 'name', 'date_added']);
144
145			$this->assertFalse($testDBO->isLoaded());
146			$retVal = $testDBO->load(1);
147			$this->assertTrue($testDBO->isLoaded());
148			$this->assertEquals(1, $testDBO->id);
			0 ignored issues – show Bug Best Practice introduced 2019-01-19 18:59 UTC by Report Bug Copy Issue Report The property `id` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
149			$this->assertEquals('John', $testDBO->name);
			0 ignored issues – show Bug Best Practice introduced 2019-01-19 19:04 UTC by Report Bug Copy Issue Report The property `name` does not exist on `Suricate\DBObject`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
150			$this->assertInstanceOf('\Suricate\DBObject', $retVal);
151			}
152
153
154			public static function mockProperty($object, string $propertyName, $value)
155			{
156			$reflectionClass = new \ReflectionClass($object);
157
158			$property = $reflectionClass->getProperty($propertyName);
159			$property->setAccessible(true);
160			$property->setValue($object, $value);
161			$property->setAccessible(false);
162			}
163
164			protected function setupData()
165			{
166			$pdo = new PDO('sqlite:/tmp/test.db');
167			$pdo->exec("DROP TABLE IF EXISTS `" . $this->tableName ."`");
168			$pdo->exec("CREATE TABLE `" .$this->tableName. "` (`id` INTEGER PRIMARY KEY,`name` varchar(50) DEFAULT NULL,`date_added` datetime NOT NULL)");
169			$stmt = $pdo->prepare("INSERT INTO `" . $this->tableName . "` (name, date_added) VALUES (:name, :date)");
170			$values = [
171			['John', '2019-01-10 00:00:00'],
172			['Paul', '2019-01-11 00:00:00'],
173			['Robert', '2019-01-12 00:00:00']
174			];
175			foreach ($values as $value) {
176			$stmt->execute(['name' => $value[0], 'date' => $value[1]]);
177			}
178			}
179
180			protected function getDatabase()
181			{
182			$database = new \Suricate\Database();
183			$database->configure([
184			'type' => 'sqlite',
185			'file' => '/tmp/test.db',
186			]);
187
188			return $database;
189			}
190			}
191

suricate-php / framework

Push — develop ( 8fa47c...77747e )

DBObjectTest::testIsset() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like