ActiveRecordAbstractTest::testBuild() - Code Metrics - Inspection of "CI-misc-43a1.37: CI-related changes" - supernova-ws/SuperNova - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — trunk (78000f)

by SuperNova.WS

created 2017-09-25 04:47 UTC

ActiveRecordAbstractTest::testBuild() B

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	38
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	22
nc	1
nop	0
dl	0
loc	38
rs	8.8571
c	0
b	0
f	0

<?php
/**
 * Created by Gorlum 12.07.2017 12:28
 */

namespace DBAL\Tests;

use Common\GlobalContainer;
use DBAL\ActiveRecordAbstract;
use DBAL\Tests\Fixtures\ActiveAbstractObjectDump;
use DBAL\Tests\Fixtures\RecordActiveAbstractObject;

/**
 * Class AccessLoggedTest
 * @coversDefaultClass \DBAL\ActiveRecordAbstract
 * @package classes
 */
class ActiveRecordAbstractTest extends \PHPUnit_Framework_TestCase {

  /**
   * Checking values setting
   *
   * @covers ::db
   * @covers ::setDb
   * @covers ::tableName
   * @covers ::calcTableName
   * @covers ::dbPrepareQuery
   */
  public function testDbData() {
    $this->assertEquals(\classSupernova::services()->db, RecordActiveAbstractObject::db());

    $db = new \db_mysql(new GlobalContainer());
    RecordActiveAbstractObject::setDb($db);
    $this->assertAttributeEquals($db, 'db', 'DBAL\Tests\Fixtures\RecordActiveAbstractObject');
    $this->assertEquals($db, RecordActiveAbstractObject::db());

    $this->assertEquals('active_abstract_object', RecordActiveAbstractObject::tableName());
    $this->assertEquals('active_abstract_object_dump', ActiveAbstractObjectDump::tableName());

    $dbq = invokeMethod(RecordActiveAbstractObject::class, 'dbPrepareQuery');
    $this->assertEquals("DBAL\\DbQuery", get_class($dbq));
    $this->assertAttributeEquals('active_abstract_object', 'table', $dbq);
  }

  /**
   * @covers ::haveTranslationToProperty
   */
  public function testHaveTranslationToProperty() {
    // Direct access field have NO translation
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['varchar']));
    // Translated field DO HAVE translation
    $this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['timestamp_current']));
    // Property name have NO translation
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['timestampCurrent']));
    // Not exists field have NO translation
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['notAField']));
  }

  /**
   * @covers ::haveField
   */
  public function testHaveField() {
    // Checking for fields and properties
    $this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['varchar']));
    $this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['timestamp_current']));
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['timestampCurrent']));
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['notAField']));
  }

  /**
   * @covers ::haveProperty
   */
  public function testHaveProperty() {
    $this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['varchar']));
    $this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['timestampCurrent']));
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['timestamp_current']));
    $this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['notAField']));
  }


  public function dataGetPropertyName() {
    return
      [
        ['varchar', 'varchar'],
        ['timestamp_current', 'timestampCurrent'],
        ['timestampCurrent', ''],
        ['notAField', ''],
      ];
  }

  /**
   * @covers ::getPropertyName
   * @dataProvider dataGetPropertyName
   */
  public function testGetPropertyName($param, $expected) {
    $this->assertEquals($expected, invokeMethod(RecordActiveAbstractObject::class, 'getPropertyName', [$param]));
  }


  /**
   * @return array
   */
  public function dataGetFieldName() {
    return
      [
        ['varchar', 'varchar'],
        ['timestampCurrent', 'timestamp_current'],
        ['timestamp_current', ''],
        ['notAField', ''],
      ];
  }

  /**
   * @covers ::getFieldName
   * @dataProvider dataGetFieldName
   */
  public function testGetFieldName($param, $expected) {
    $this->assertEquals($expected, invokeMethod(RecordActiveAbstractObject::class, 'getFieldName', [$param]));
  }

  /**
   * @covers ::translateNames
   */
  public function testTranslation() {
    // Fields to Properties
    $this->assertEquals(
      [
        'timestampCurrent' => TEST_VALUE_SQL_DATE,
        'varchar'          => 'varvalue',
        // TODO - add incorrect field
      ],
      invokeMethod(RecordActiveAbstractObject::class, 'translateNames', [
        [
          'timestamp_current' => TEST_VALUE_SQL_DATE,
          'varchar'           => 'varvalue',
          'notAField'         => 'test',
        ],
        ActiveRecordAbstract::FIELDS_TO_PROPERTIES
      ]));

    // Properties to Fields
    $this->assertEquals(
      [
        'timestamp_current' => TEST_VALUE_SQL_DATE,
        'varchar'           => 'varvalue',
      ],
      invokeMethod(RecordActiveAbstractObject::class, 'translateNames', [
        [
          'timestampCurrent' => TEST_VALUE_SQL_DATE,
          'varchar'          => 'varvalue',
          'notAProperty'     => 'test',
        ],
        ActiveRecordAbstract::PROPERTIES_TO_FIELDS
      ]));
  }

  /**
   * @covers ::__construct
   * @covers ::AcceptChanges
   */
  public function testConstructor() {
    $object = new RecordActiveAbstractObject();
    $this->assertAttributeEquals(\classSupernova::$gc, 'services', $object);
    $this->assertAttributeEquals(true, '_isNew', $object);
    $this->assertEquals(0, $object->id);

    $object->acceptChanges();
    $this->assertAttributeEquals(true, '_isNew', $object);
    $this->assertEquals(0, $object->id);

    $object->id = 5;
    $object->acceptChanges();
    $this->assertAttributeEquals(false, '_isNew', $object);
    $this->assertEquals(5, $object->id);

  }

  /**
   * @covers ::defaultValues
   * @covers ::fromProperties
   * @covers ::buildEvenEmpty
   * @covers ::build
   */
  public function testBuild() {
    // Testing empty buildEvenEmpty()
    $this->assertEquals(
      RecordActiveAbstractObject::class,
      get_class(invokeMethod(RecordActiveAbstractObject::class, 'buildEvenEmpty', [[]]))
    );

    // Testing empty build
    $this->assertFalse(RecordActiveAbstractObject::build([]));

    // Testing default values and overriding CURRENT_TIMESTAMP
    $object = RecordActiveAbstractObject::build([
      'timestampCurrent' => TEST_VALUE_SQL_DATE,
      'varchar'          => 'varvalue',
    ]);
    $this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
    $this->assertEquals('varvalue', $object->varchar);
    $this->assertNull($object->null);
    $this->assertNull($object->notAField);
    $this->assertEquals(
      [
        'timestampCurrent' => TEST_VALUE_SQL_DATE,
        'varchar'          => "varvalue",
        'null'             => null,
      ],
      $object->asArray()
    );


    // Testing CURRENT_TIMESTAMP and setting values to NULL-defaulted values
    $object = RecordActiveAbstractObject::build([
      'null' => 'nullvalue',
    ]);

    $this->assertEquals(date(FMT_DATE_TIME_SQL, SN_TIME_NOW), $object->timestampCurrent);
    $this->assertEquals('', $object->varchar);
    $this->assertEquals('nullvalue', $object->null);
  }

  /**
   * @covers ::fromFields
   */
  public function testFromFields() {
    $object = new RecordActiveAbstractObject();
    invokeMethod($object, 'fromFields', [[
      'timestamp_current' => TEST_VALUE_SQL_DATE,
      'notAField'         => 'test',
    ]]);

    $this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
    $this->assertEquals('', $object->varchar);
    $this->assertNull($object->notAField);
  }


  /**
   * @covers ::getDefault
   */
  public function testGetDefault() {
    $object = RecordActiveAbstractObject::buildEvenEmpty([]);

    $this->assertNull(invokeMethod($object, 'getDefault', ['timestamp_current']));
    $this->assertNull(invokeMethod($object, 'getDefault', ['NonExistingProperty']));
  }

  /**
   * @covers ::shieldName
   * @covers ::__set
   * expectedExceptionMessageRegExp /{{{ Свойство \s+ не существует в ActiveRecord \s+ }}}/
   * expectedExceptionMessage {{{ Свойство \s+ не существует в ActiveRecord \s+ }}}
   */
  public function test__set() {
    $object = RecordActiveAbstractObject::buildEvenEmpty([]);
    $this->assertEquals(SN_TIME_SQL, $object->timestampCurrent);
    $object->timestampCurrent = TEST_VALUE_SQL_DATE;
    $this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
    $this->expectExceptionMessage('{{{ Свойство \'q\' не существует в ActiveRecord \'' . RecordActiveAbstractObject::class . '\' }}}');
    $object->q = 5;
  }

  /**
   * @covers ::shieldName
   * @covers ::getDefault
   * @covers ::__get
   */
  public function test__get() {
    // Testing directly set values
    $object = RecordActiveAbstractObject::build([
      'timestampCurrent' => TEST_VALUE_SQL_DATE,
      'varchar'          => 'varvalue',
      'null'             => 'qwe',
    ]);
    $this->assertEquals(TEST_VALUE_SQL_DATE, $object->__get('timestampCurrent'));
    $this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);

    // Checking false-positive for field translated to property
    $this->assertNull($object->__get('timestamp_current'));
    $this->assertNull($object->timestamp_current);

    $this->assertEquals('varvalue', $object->varchar);
    $this->assertEquals('qwe', $object->null);
    $this->assertNull($object->notAProperty);

    // Testing CURRENT_TIMESTAMP and setting values to NULL-defaulted values
    $object = RecordActiveAbstractObject::buildEvenEmpty([]);

    $this->assertEquals(date(FMT_DATE_TIME_SQL, SN_TIME_NOW), $object->timestampCurrent);
    $this->assertEquals('', $object->varchar);
    $this->assertNull($object->null);
  }

  /**
   * @covers ::fromRecordList
   */
  public function testFromRecordList() {
    $this->assertEquals([], invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', ['']));
    $this->assertEquals([], invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [[]]));

    $testable = invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [[
      ['null' => null,],
      [],
      ['timestamp_current' => TEST_VALUE_SQL_DATE, 'null' => 'test',],
    ]]);
    $this->assertCount(2, $testable);
    $this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[0]));
    // Checking that indexes are maintained
    $this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[2]));
    $this->assertEquals(TEST_VALUE_SQL_DATE, $testable[2]->timestampCurrent);
    $this->assertEquals('test', $testable[2]->null);

    $testable = invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [
      [
        ['null' => null,],
        [],
        ['timestampCurrent' => TEST_VALUE_SQL_DATE, 'null' => 'test',],
      ],
      RecordActiveAbstractObject::PROPERTIES_TO_FIELDS
    ]);
    $this->assertCount(2, $testable);
    $this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[0]));
    $this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[2]));
    $this->assertEquals(TEST_VALUE_SQL_DATE, $testable[2]->timestampCurrent);
    $this->assertEquals('test', $testable[2]->null);
  }

}


1			<?php
2			/**
3			* Created by Gorlum 12.07.2017 12:28
4			*/
5
6			namespace DBAL\Tests;
7
8			use Common\GlobalContainer;
9			use DBAL\ActiveRecordAbstract;
10			use DBAL\Tests\Fixtures\ActiveAbstractObjectDump;
11			use DBAL\Tests\Fixtures\RecordActiveAbstractObject;
12
13			/**
14			* Class AccessLoggedTest
15			* @coversDefaultClass \DBAL\ActiveRecordAbstract
16			* @package classes
17			*/
18			class ActiveRecordAbstractTest extends \PHPUnit_Framework_TestCase {
19
20			/**
21			* Checking values setting
22			*
23			* @covers ::db
24			* @covers ::setDb
25			* @covers ::tableName
26			* @covers ::calcTableName
27			* @covers ::dbPrepareQuery
28			*/
29			public function testDbData() {
30			$this->assertEquals(\classSupernova::services()->db, RecordActiveAbstractObject::db());
31
32			$db = new \db_mysql(new GlobalContainer());
33			RecordActiveAbstractObject::setDb($db);
34			$this->assertAttributeEquals($db, 'db', 'DBAL\Tests\Fixtures\RecordActiveAbstractObject');
35			$this->assertEquals($db, RecordActiveAbstractObject::db());
36
37			$this->assertEquals('active_abstract_object', RecordActiveAbstractObject::tableName());
38			$this->assertEquals('active_abstract_object_dump', ActiveAbstractObjectDump::tableName());
39
40			$dbq = invokeMethod(RecordActiveAbstractObject::class, 'dbPrepareQuery');
41			$this->assertEquals("DBAL\\DbQuery", get_class($dbq));
42			$this->assertAttributeEquals('active_abstract_object', 'table', $dbq);
43			}
44
45			/**
46			* @covers ::haveTranslationToProperty
47			*/
48			public function testHaveTranslationToProperty() {
49			// Direct access field have NO translation
50			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['varchar']));
51			// Translated field DO HAVE translation
52			$this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['timestamp_current']));
53			// Property name have NO translation
54			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['timestampCurrent']));
55			// Not exists field have NO translation
56			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveTranslationToProperty', ['notAField']));
57			}
58
59			/**
60			* @covers ::haveField
61			*/
62			public function testHaveField() {
63			// Checking for fields and properties
64			$this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['varchar']));
65			$this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['timestamp_current']));
66			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['timestampCurrent']));
67			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveField', ['notAField']));
68			}
69
70			/**
71			* @covers ::haveProperty
72			*/
73			public function testHaveProperty() {
74			$this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['varchar']));
75			$this->assertTrue(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['timestampCurrent']));
76			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['timestamp_current']));
77			$this->assertFalse(invokeMethod(RecordActiveAbstractObject::class, 'haveProperty', ['notAField']));
78			}
79
80
81			public function dataGetPropertyName() {
82			return
83			[
84			['varchar', 'varchar'],
85			['timestamp_current', 'timestampCurrent'],
86			['timestampCurrent', ''],
87			['notAField', ''],
88			];
89			}
90
91			/**
92			* @covers ::getPropertyName
93			* @dataProvider dataGetPropertyName
94			*/
95			public function testGetPropertyName($param, $expected) {
96			$this->assertEquals($expected, invokeMethod(RecordActiveAbstractObject::class, 'getPropertyName', [$param]));
97			}
98
99
100			/**
101			* @return array
102			*/
103			public function dataGetFieldName() {
104			return
105			[
106			['varchar', 'varchar'],
107			['timestampCurrent', 'timestamp_current'],
108			['timestamp_current', ''],
109			['notAField', ''],
110			];
111			}
112
113			/**
114			* @covers ::getFieldName
115			* @dataProvider dataGetFieldName
116			*/
117			public function testGetFieldName($param, $expected) {
118			$this->assertEquals($expected, invokeMethod(RecordActiveAbstractObject::class, 'getFieldName', [$param]));
119			}
120
121			/**
122			* @covers ::translateNames
123			*/
124			public function testTranslation() {
125			// Fields to Properties
126			$this->assertEquals(
127			[
128			'timestampCurrent' => TEST_VALUE_SQL_DATE,
129			'varchar' => 'varvalue',
130			// TODO - add incorrect field
131			],
132			invokeMethod(RecordActiveAbstractObject::class, 'translateNames', [
133			[
134			'timestamp_current' => TEST_VALUE_SQL_DATE,
135			'varchar' => 'varvalue',
136			'notAField' => 'test',
137			],
138			ActiveRecordAbstract::FIELDS_TO_PROPERTIES
139			]));
140
141			// Properties to Fields
142			$this->assertEquals(
143			[
144			'timestamp_current' => TEST_VALUE_SQL_DATE,
145			'varchar' => 'varvalue',
146			],
147			invokeMethod(RecordActiveAbstractObject::class, 'translateNames', [
148			[
149			'timestampCurrent' => TEST_VALUE_SQL_DATE,
150			'varchar' => 'varvalue',
151			'notAProperty' => 'test',
152			],
153			ActiveRecordAbstract::PROPERTIES_TO_FIELDS
154			]));
155			}
156
157			/**
158			* @covers ::__construct
159			* @covers ::AcceptChanges
160			*/
161			public function testConstructor() {
162			$object = new RecordActiveAbstractObject();
163			$this->assertAttributeEquals(\classSupernova::$gc, 'services', $object);
164			$this->assertAttributeEquals(true, '_isNew', $object);
165			$this->assertEquals(0, $object->id);
166
167			$object->acceptChanges();
168			$this->assertAttributeEquals(true, '_isNew', $object);
169			$this->assertEquals(0, $object->id);
170
171			$object->id = 5;
172			$object->acceptChanges();
173			$this->assertAttributeEquals(false, '_isNew', $object);
174			$this->assertEquals(5, $object->id);
175
176			}
177
178			/**
179			* @covers ::defaultValues
180			* @covers ::fromProperties
181			* @covers ::buildEvenEmpty
182			* @covers ::build
183			*/
184			public function testBuild() {
185			// Testing empty buildEvenEmpty()
186			$this->assertEquals(
187			RecordActiveAbstractObject::class,
188			get_class(invokeMethod(RecordActiveAbstractObject::class, 'buildEvenEmpty', [[]]))
189			);
190
191			// Testing empty build
192			$this->assertFalse(RecordActiveAbstractObject::build([]));
193
194			// Testing default values and overriding CURRENT_TIMESTAMP
195			$object = RecordActiveAbstractObject::build([
196			'timestampCurrent' => TEST_VALUE_SQL_DATE,
197			'varchar' => 'varvalue',
198			]);
199			$this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
200			$this->assertEquals('varvalue', $object->varchar);
201			$this->assertNull($object->null);
202			$this->assertNull($object->notAField);
203			$this->assertEquals(
204			[
205			'timestampCurrent' => TEST_VALUE_SQL_DATE,
206			'varchar' => "varvalue",
207			'null' => null,
208			],
209			$object->asArray()
210			);
211
212
213			// Testing CURRENT_TIMESTAMP and setting values to NULL-defaulted values
214			$object = RecordActiveAbstractObject::build([
215			'null' => 'nullvalue',
216			]);
217
218			$this->assertEquals(date(FMT_DATE_TIME_SQL, SN_TIME_NOW), $object->timestampCurrent);
219			$this->assertEquals('', $object->varchar);
220			$this->assertEquals('nullvalue', $object->null);
221			}
222
223			/**
224			* @covers ::fromFields
225			*/
226			public function testFromFields() {
227			$object = new RecordActiveAbstractObject();
228			invokeMethod($object, 'fromFields', [[
229			'timestamp_current' => TEST_VALUE_SQL_DATE,
230			'notAField' => 'test',
231			]]);
232
233			$this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
234			$this->assertEquals('', $object->varchar);
235			$this->assertNull($object->notAField);
236			}
237
238
239			/**
240			* @covers ::getDefault
241			*/
242			public function testGetDefault() {
243			$object = RecordActiveAbstractObject::buildEvenEmpty([]);
244
245			$this->assertNull(invokeMethod($object, 'getDefault', ['timestamp_current']));
246			$this->assertNull(invokeMethod($object, 'getDefault', ['NonExistingProperty']));
247			}
248
249			/**
250			* @covers ::shieldName
251			* @covers ::__set
252			* expectedExceptionMessageRegExp /{{{ Свойство \s+ не существует в ActiveRecord \s+ }}}/
253			* expectedExceptionMessage {{{ Свойство \s+ не существует в ActiveRecord \s+ }}}
254			*/
255			public function test__set() {
256			$object = RecordActiveAbstractObject::buildEvenEmpty([]);
257			$this->assertEquals(SN_TIME_SQL, $object->timestampCurrent);
258			$object->timestampCurrent = TEST_VALUE_SQL_DATE;
259			$this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
260			$this->expectExceptionMessage('{{{ Свойство \'q\' не существует в ActiveRecord \'' . RecordActiveAbstractObject::class . '\' }}}');
261			$object->q = 5;
262			}
263
264			/**
265			* @covers ::shieldName
266			* @covers ::getDefault
267			* @covers ::__get
268			*/
269			public function test__get() {
270			// Testing directly set values
271			$object = RecordActiveAbstractObject::build([
272			'timestampCurrent' => TEST_VALUE_SQL_DATE,
273			'varchar' => 'varvalue',
274			'null' => 'qwe',
275			]);
276			$this->assertEquals(TEST_VALUE_SQL_DATE, $object->__get('timestampCurrent'));
277			$this->assertEquals(TEST_VALUE_SQL_DATE, $object->timestampCurrent);
278
279			// Checking false-positive for field translated to property
280			$this->assertNull($object->__get('timestamp_current'));
281			$this->assertNull($object->timestamp_current);
282
283			$this->assertEquals('varvalue', $object->varchar);
284			$this->assertEquals('qwe', $object->null);
285			$this->assertNull($object->notAProperty);
286
287			// Testing CURRENT_TIMESTAMP and setting values to NULL-defaulted values
288			$object = RecordActiveAbstractObject::buildEvenEmpty([]);
289
290			$this->assertEquals(date(FMT_DATE_TIME_SQL, SN_TIME_NOW), $object->timestampCurrent);
291			$this->assertEquals('', $object->varchar);
292			$this->assertNull($object->null);
293			}
294
295			/**
296			* @covers ::fromRecordList
297			*/
298			public function testFromRecordList() {
299			$this->assertEquals([], invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', ['']));
300			$this->assertEquals([], invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [[]]));
301
302			$testable = invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [[
303			['null' => null,],
304			[],
305			['timestamp_current' => TEST_VALUE_SQL_DATE, 'null' => 'test',],
306			]]);
307			$this->assertCount(2, $testable);
308			$this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[0]));
309			// Checking that indexes are maintained
310			$this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[2]));
311			$this->assertEquals(TEST_VALUE_SQL_DATE, $testable[2]->timestampCurrent);
312			$this->assertEquals('test', $testable[2]->null);
313
314			$testable = invokeMethod(RecordActiveAbstractObject::class, 'fromRecordList', [
315			[
316			['null' => null,],
317			[],
318			['timestampCurrent' => TEST_VALUE_SQL_DATE, 'null' => 'test',],
319			],
320			RecordActiveAbstractObject::PROPERTIES_TO_FIELDS
321			]);
322			$this->assertCount(2, $testable);
323			$this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[0]));
324			$this->assertEquals(RecordActiveAbstractObject::class, get_class($testable[2]));
325			$this->assertEquals(TEST_VALUE_SQL_DATE, $testable[2]->timestampCurrent);
326			$this->assertEquals('test', $testable[2]->null);
327			}
328
329			}
330

supernova-ws / SuperNova

Branch — trunk (78000f)

ActiveRecordAbstractTest::testBuild() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like