DataObjectSchemaTest::testClassNameForTable() - Code Metrics - Inspection of "Merge pull request #5646 from open-sausages/pulls/..." - silverstripe/silverstripe-framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 9e3f76...51d53f )

by Hamish

created 2016-06-14 03:06 UTC

DataObjectSchemaTest::testClassNameForTable() B

↳ Parent: DataObjectSchemaTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	43
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	27
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	43
rs	8.8571

<?php

/**
 * Tests schema inspection of DataObjects
 */
class DataObjectSchemaTest extends SapphireTest
{
	protected static $fixture_file = 'DataObjectSchemaTest.yml';

	protected $extraDataObjects = array(
		// Classes in base namespace
		'DataObjectSchemaTest_BaseClass',
		'DataObjectSchemaTest_BaseDataClass',
		'DataObjectSchemaTest_ChildClass',
		'DataObjectSchemaTest_GrandChildClass',
		'DataObjectSchemaTest_HasFields',
		'DataObjectSchemaTest_NoFields',
		'DataObjectSchemaTest_WithCustomTable',
		'DataObjectSchemaTest_WithRelation',
		// Classes in sub-namespace (See DataObjectSchemaTest_Namespacejd.php)
		'Namespaced\DOST\MyObject',
		'Namespaced\DOST\MyObject_CustomTable',
		'Namespaced\DOST\MyObject_NestedObject',
		'Namespaced\DOST\MyObject_NamespacedTable',
		'Namespaced\DOST\MyObject_Namespaced_Subclass',
		'Namespaced\DOST\MyObject_NoFields',
	);

	/**
	 * Test table name generation
	 */
	public function testTableName() {
		$schema = DataObject::getSchema();

		// Non-namespaced tables
		$this->assertEquals(
			'DataObjectSchemaTest_WithRelation',
			$schema->tableName('DataObjectSchemaTest_WithRelation')
		);
		$this->assertEquals(
			'DOSTWithCustomTable',
			$schema->tableName('DataObjectSchemaTest_WithCustomTable')
		);

		// Namespaced tables
		$this->assertEquals(
			'Namespaced\DOST\MyObject',
			$schema->tableName('Namespaced\DOST\MyObject')
		);
		$this->assertEquals(
			'CustomNamespacedTable',
			$schema->tableName('Namespaced\DOST\MyObject_CustomTable')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NestedObject',
			$schema->tableName('Namespaced\DOST\MyObject_NestedObject')
		);
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableName('Namespaced\DOST\MyObject_NamespacedTable')
		);
		$this->assertEquals(
			'Custom\SubclassedTable',
			$schema->tableName('Namespaced\DOST\MyObject_Namespaced_Subclass')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NoFields',
			$schema->tableName('Namespaced\DOST\MyObject_NoFields')
		);
	}

	/**
	 * Test that the class name is convertable from the table
	 */
	public function testClassNameForTable() {
		$schema = DataObject::getSchema();

		// Tables that aren't classes
		$this->assertNull($schema->tableClass('NotARealTable'));


		// Non-namespaced tables
		$this->assertEquals(
			'DataObjectSchemaTest_WithRelation',
			$schema->tableClass('DataObjectSchemaTest_WithRelation')
		);
		$this->assertEquals(
			'DataObjectSchemaTest_WithCustomTable',
			$schema->tableClass('DOSTWithCustomTable')
		);

		// Namespaced tables
		$this->assertEquals(
			'Namespaced\DOST\MyObject',
			$schema->tableClass('Namespaced\DOST\MyObject')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_CustomTable',
			$schema->tableClass('CustomNamespacedTable')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NestedObject',
			$schema->tableClass('Namespaced\DOST\MyObject_NestedObject')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NamespacedTable',
			$schema->tableClass('Custom\NamespacedTable')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_Namespaced_Subclass',
			$schema->tableClass('Custom\SubclassedTable')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NoFields',
			$schema->tableClass('Namespaced\DOST\MyObject_NoFields')
		);
	}

	/**
	 * Test non-namespaced tables
	 */
	public function testTableForObjectField() {
		$schema = DataObject::getSchema();
		$this->assertEquals(
			'DataObjectSchemaTest_WithRelation',
			$schema->tableForField('DataObjectSchemaTest_WithRelation', 'RelationID')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_WithRelation',
			$schema->tableForField('DataObjectSchemaTest_withrelation', 'RelationID')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_BaseDataClass', 'Title')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_HasFields', 'Title')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_NoFields', 'Title')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_nofields', 'Title')
		);

		$this->assertEquals(
			'DataObjectSchemaTest_HasFields',
			$schema->tableForField('DataObjectSchemaTest_HasFields', 'Description')
		);

		// Class and table differ for this model
		$this->assertEquals(
			'DOSTWithCustomTable',
			$schema->tableForField('DataObjectSchemaTest_WithCustomTable', 'Description')
		);
		$this->assertEquals(
			'DataObjectSchemaTest_WithCustomTable',
			$schema->classForField('DataObjectSchemaTest_WithCustomTable', 'Description')
		);
		$this->assertNull(
			$schema->tableForField('DataObjectSchemaTest_WithCustomTable', 'NotAField')
		);
		$this->assertNull(
			$schema->classForField('DataObjectSchemaTest_WithCustomTable', 'NotAField')
		);

		// Non-existant fields shouldn't match any table
		$this->assertNull(
			$schema->tableForField('DataObjectSchemaTest_BaseClass', 'Nonexist')
		);

		$this->assertNull(
			$schema->tableForField('Object', 'Title')
		);

		// Test fixed fields
		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_HasFields', 'ID')
		);
		$this->assertEquals(
			'DataObjectSchemaTest_BaseDataClass',
			$schema->tableForField('DataObjectSchemaTest_NoFields', 'Created')
		);
	}

	/**
	 * Check table for fields with namespaced objects can be found
	 */
	public function testTableForNamespacedObjectField() {
		$schema = DataObject::getSchema();

		// MyObject
		$this->assertEquals(
			'Namespaced\DOST\MyObject',
			$schema->tableForField('Namespaced\DOST\MyObject', 'Title')
		);

		// MyObject_CustomTable
		$this->assertEquals(
			'CustomNamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_CustomTable', 'Title')
		);

		// MyObject_NestedObject
		$this->assertEquals(
			'Namespaced\DOST\MyObject',
			$schema->tableForField('Namespaced\DOST\MyObject_NestedObject', 'Title')
		);
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NestedObject',
			$schema->tableForField('Namespaced\DOST\MyObject_NestedObject', 'Content')
		);

		// MyObject_NamespacedTable
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_NamespacedTable', 'Description')
		);
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_NamespacedTable', 'OwnerID')
		);

		// MyObject_Namespaced_Subclass
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'OwnerID')
		);
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'Title')
		);
		$this->assertEquals(
			'Custom\NamespacedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'ID')
		);
		$this->assertEquals(
			'Custom\SubclassedTable',
			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'Details')
		);

		// MyObject_NoFields
		$this->assertEquals(
			'Namespaced\DOST\MyObject_NoFields',
			$schema->tableForField('Namespaced\DOST\MyObject_NoFields', 'Created')
		);
	}

	/**
	 * Test that relations join on the correct columns
	 */
	public function testRelationsQuery() {
		$namespaced1 = $this->objFromFixture('Namespaced\DOST\MyObject_NamespacedTable', 'namespaced1');
		$nofields = $this->objFromFixture('Namespaced\DOST\MyObject_NoFields', 'nofields1');
		$subclass1 = $this->objFromFixture('Namespaced\DOST\MyObject_Namespaced_Subclass', 'subclass1');
		$customtable1 = $this->objFromFixture('Namespaced\DOST\MyObject_CustomTable', 'customtable1');
		$customtable3 = $this->objFromFixture('Namespaced\DOST\MyObject_CustomTable', 'customtable3');

		// Check has_one / has_many
		$this->assertEquals($nofields->ID, $namespaced1->Owner()->ID);
		$this->assertDOSEquals([
			['Title' => 'Namespaced 1'],
		], $nofields->Owns());

		// Check many_many / belongs_many_many
		$this->assertDOSEquals(
			[
				['Title' => 'Custom Table 1'],
				['Title' => 'Custom Table 2'],
			],
			$subclass1->Children()
		);
		$this->assertDOSEquals(
			[
				['Title' => 'Subclass 1', 'Details' => 'Oh, Hi!',]]
			,
			$customtable1->Parents()
		);
		$this->assertEmpty($customtable3->Parents()->count());

	}


	/**
	 * @covers DataObjectSchema::baseDataClass()
	 */
	public function testBaseDataClass() {
		$schema = DataObject::getSchema();

		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_BaseClass'));
		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_baseclass'));
		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_ChildClass'));
		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_CHILDCLASS'));
		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_GrandChildClass'));
		$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_GRANDChildClass'));

		$this->setExpectedException('InvalidArgumentException');
		$schema->baseDataClass('DataObject');
	}
}

class DataObjectSchemaTest_BaseClass extends DataObject implements TestOnly {

}

class DataObjectSchemaTest_ChildClass extends DataObjectSchemaTest_BaseClass {

}

class DataObjectSchemaTest_GrandChildClass extends DataObjectSchemaTest_ChildClass {

}

class DataObjectSchemaTest_BaseDataClass extends DataObject implements TestOnly {

	private static $db = array(
		'Title' => 'Varchar'
	);
}


class DataObjectSchemaTest_NoFields extends DataObjectSchemaTest_BaseDataClass {

}

class DataObjectSchemaTest_HasFields extends DataObjectSchemaTest_NoFields {

	private static $db = array(
		'Description' => 'Varchar'
	);
}

class DataObjectSchemaTest_WithCustomTable extends DataObjectSchemaTest_NoFields {
	private static $table_name = 'DOSTWithCustomTable';
	private static $db = array(
		'Description' => 'Text'
	);
}

class DataObjectSchemaTest_WithRelation extends DataObjectSchemaTest_NoFields {

	private static $has_one = array(
		'Relation' => 'DataObjectSchemaTest_HasFields'
	);
}


1			<?php
2
3			/**
4			* Tests schema inspection of DataObjects
5			*/
6			class DataObjectSchemaTest extends SapphireTest
7			{
8			protected static $fixture_file = 'DataObjectSchemaTest.yml';
9
10			protected $extraDataObjects = array(
11			// Classes in base namespace
12			'DataObjectSchemaTest_BaseClass',
13			'DataObjectSchemaTest_BaseDataClass',
14			'DataObjectSchemaTest_ChildClass',
15			'DataObjectSchemaTest_GrandChildClass',
16			'DataObjectSchemaTest_HasFields',
17			'DataObjectSchemaTest_NoFields',
18			'DataObjectSchemaTest_WithCustomTable',
19			'DataObjectSchemaTest_WithRelation',
20			// Classes in sub-namespace (See DataObjectSchemaTest_Namespacejd.php)
21			'Namespaced\DOST\MyObject',
22			'Namespaced\DOST\MyObject_CustomTable',
23			'Namespaced\DOST\MyObject_NestedObject',
24			'Namespaced\DOST\MyObject_NamespacedTable',
25			'Namespaced\DOST\MyObject_Namespaced_Subclass',
26			'Namespaced\DOST\MyObject_NoFields',
27			);
28
29			/**
30			* Test table name generation
31			*/
32			public function testTableName() {
33			$schema = DataObject::getSchema();
34
35			// Non-namespaced tables
36			$this->assertEquals(
37			'DataObjectSchemaTest_WithRelation',
38			$schema->tableName('DataObjectSchemaTest_WithRelation')
39			);
40			$this->assertEquals(
41			'DOSTWithCustomTable',
42			$schema->tableName('DataObjectSchemaTest_WithCustomTable')
43			);
44
45			// Namespaced tables
46			$this->assertEquals(
47			'Namespaced\DOST\MyObject',
48			$schema->tableName('Namespaced\DOST\MyObject')
49			);
50			$this->assertEquals(
51			'CustomNamespacedTable',
52			$schema->tableName('Namespaced\DOST\MyObject_CustomTable')
53			);
54			$this->assertEquals(
55			'Namespaced\DOST\MyObject_NestedObject',
56			$schema->tableName('Namespaced\DOST\MyObject_NestedObject')
57			);
58			$this->assertEquals(
59			'Custom\NamespacedTable',
60			$schema->tableName('Namespaced\DOST\MyObject_NamespacedTable')
61			);
62			$this->assertEquals(
63			'Custom\SubclassedTable',
64			$schema->tableName('Namespaced\DOST\MyObject_Namespaced_Subclass')
65			);
66			$this->assertEquals(
67			'Namespaced\DOST\MyObject_NoFields',
68			$schema->tableName('Namespaced\DOST\MyObject_NoFields')
69			);
70			}
71
72			/**
73			* Test that the class name is convertable from the table
74			*/
75			public function testClassNameForTable() {
76			$schema = DataObject::getSchema();
77
78			// Tables that aren't classes
79			$this->assertNull($schema->tableClass('NotARealTable'));
80
81
82			// Non-namespaced tables
83			$this->assertEquals(
84			'DataObjectSchemaTest_WithRelation',
85			$schema->tableClass('DataObjectSchemaTest_WithRelation')
86			);
87			$this->assertEquals(
88			'DataObjectSchemaTest_WithCustomTable',
89			$schema->tableClass('DOSTWithCustomTable')
90			);
91
92			// Namespaced tables
93			$this->assertEquals(
94			'Namespaced\DOST\MyObject',
95			$schema->tableClass('Namespaced\DOST\MyObject')
96			);
97			$this->assertEquals(
98			'Namespaced\DOST\MyObject_CustomTable',
99			$schema->tableClass('CustomNamespacedTable')
100			);
101			$this->assertEquals(
102			'Namespaced\DOST\MyObject_NestedObject',
103			$schema->tableClass('Namespaced\DOST\MyObject_NestedObject')
104			);
105			$this->assertEquals(
106			'Namespaced\DOST\MyObject_NamespacedTable',
107			$schema->tableClass('Custom\NamespacedTable')
108			);
109			$this->assertEquals(
110			'Namespaced\DOST\MyObject_Namespaced_Subclass',
111			$schema->tableClass('Custom\SubclassedTable')
112			);
113			$this->assertEquals(
114			'Namespaced\DOST\MyObject_NoFields',
115			$schema->tableClass('Namespaced\DOST\MyObject_NoFields')
116			);
117			}
118
119			/**
120			* Test non-namespaced tables
121			*/
122			public function testTableForObjectField() {
123			$schema = DataObject::getSchema();
124			$this->assertEquals(
125			'DataObjectSchemaTest_WithRelation',
126			$schema->tableForField('DataObjectSchemaTest_WithRelation', 'RelationID')
127			);
128
129			$this->assertEquals(
130			'DataObjectSchemaTest_WithRelation',
131			$schema->tableForField('DataObjectSchemaTest_withrelation', 'RelationID')
132			);
133
134			$this->assertEquals(
135			'DataObjectSchemaTest_BaseDataClass',
136			$schema->tableForField('DataObjectSchemaTest_BaseDataClass', 'Title')
137			);
138
139			$this->assertEquals(
140			'DataObjectSchemaTest_BaseDataClass',
141			$schema->tableForField('DataObjectSchemaTest_HasFields', 'Title')
142			);
143
144			$this->assertEquals(
145			'DataObjectSchemaTest_BaseDataClass',
146			$schema->tableForField('DataObjectSchemaTest_NoFields', 'Title')
147			);
148
149			$this->assertEquals(
150			'DataObjectSchemaTest_BaseDataClass',
151			$schema->tableForField('DataObjectSchemaTest_nofields', 'Title')
152			);
153
154			$this->assertEquals(
155			'DataObjectSchemaTest_HasFields',
156			$schema->tableForField('DataObjectSchemaTest_HasFields', 'Description')
157			);
158
159			// Class and table differ for this model
160			$this->assertEquals(
161			'DOSTWithCustomTable',
162			$schema->tableForField('DataObjectSchemaTest_WithCustomTable', 'Description')
163			);
164			$this->assertEquals(
165			'DataObjectSchemaTest_WithCustomTable',
166			$schema->classForField('DataObjectSchemaTest_WithCustomTable', 'Description')
167			);
168			$this->assertNull(
169			$schema->tableForField('DataObjectSchemaTest_WithCustomTable', 'NotAField')
170			);
171			$this->assertNull(
172			$schema->classForField('DataObjectSchemaTest_WithCustomTable', 'NotAField')
173			);
174
175			// Non-existant fields shouldn't match any table
176			$this->assertNull(
177			$schema->tableForField('DataObjectSchemaTest_BaseClass', 'Nonexist')
178			);
179
180			$this->assertNull(
181			$schema->tableForField('Object', 'Title')
182			);
183
184			// Test fixed fields
185			$this->assertEquals(
186			'DataObjectSchemaTest_BaseDataClass',
187			$schema->tableForField('DataObjectSchemaTest_HasFields', 'ID')
188			);
189			$this->assertEquals(
190			'DataObjectSchemaTest_BaseDataClass',
191			$schema->tableForField('DataObjectSchemaTest_NoFields', 'Created')
192			);
193			}
194
195			/**
196			* Check table for fields with namespaced objects can be found
197			*/
198			public function testTableForNamespacedObjectField() {
199			$schema = DataObject::getSchema();
200
201			// MyObject
202			$this->assertEquals(
203			'Namespaced\DOST\MyObject',
204			$schema->tableForField('Namespaced\DOST\MyObject', 'Title')
205			);
206
207			// MyObject_CustomTable
208			$this->assertEquals(
209			'CustomNamespacedTable',
210			$schema->tableForField('Namespaced\DOST\MyObject_CustomTable', 'Title')
211			);
212
213			// MyObject_NestedObject
214			$this->assertEquals(
215			'Namespaced\DOST\MyObject',
216			$schema->tableForField('Namespaced\DOST\MyObject_NestedObject', 'Title')
217			);
218			$this->assertEquals(
219			'Namespaced\DOST\MyObject_NestedObject',
220			$schema->tableForField('Namespaced\DOST\MyObject_NestedObject', 'Content')
221			);
222
223			// MyObject_NamespacedTable
224			$this->assertEquals(
225			'Custom\NamespacedTable',
226			$schema->tableForField('Namespaced\DOST\MyObject_NamespacedTable', 'Description')
227			);
228			$this->assertEquals(
229			'Custom\NamespacedTable',
230			$schema->tableForField('Namespaced\DOST\MyObject_NamespacedTable', 'OwnerID')
231			);
232
233			// MyObject_Namespaced_Subclass
234			$this->assertEquals(
235			'Custom\NamespacedTable',
236			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'OwnerID')
237			);
238			$this->assertEquals(
239			'Custom\NamespacedTable',
240			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'Title')
241			);
242			$this->assertEquals(
243			'Custom\NamespacedTable',
244			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'ID')
245			);
246			$this->assertEquals(
247			'Custom\SubclassedTable',
248			$schema->tableForField('Namespaced\DOST\MyObject_Namespaced_Subclass', 'Details')
249			);
250
251			// MyObject_NoFields
252			$this->assertEquals(
253			'Namespaced\DOST\MyObject_NoFields',
254			$schema->tableForField('Namespaced\DOST\MyObject_NoFields', 'Created')
255			);
256			}
257
258			/**
259			* Test that relations join on the correct columns
260			*/
261			public function testRelationsQuery() {
262			$namespaced1 = $this->objFromFixture('Namespaced\DOST\MyObject_NamespacedTable', 'namespaced1');
263			$nofields = $this->objFromFixture('Namespaced\DOST\MyObject_NoFields', 'nofields1');
264			$subclass1 = $this->objFromFixture('Namespaced\DOST\MyObject_Namespaced_Subclass', 'subclass1');
265			$customtable1 = $this->objFromFixture('Namespaced\DOST\MyObject_CustomTable', 'customtable1');
266			$customtable3 = $this->objFromFixture('Namespaced\DOST\MyObject_CustomTable', 'customtable3');
267
268			// Check has_one / has_many
269			$this->assertEquals($nofields->ID, $namespaced1->Owner()->ID);
270			$this->assertDOSEquals([
271			['Title' => 'Namespaced 1'],
272			], $nofields->Owns());
273
274			// Check many_many / belongs_many_many
275			$this->assertDOSEquals(
276			[
277			['Title' => 'Custom Table 1'],
278			['Title' => 'Custom Table 2'],
279			],
280			$subclass1->Children()
281			);
282			$this->assertDOSEquals(
283			[
284			['Title' => 'Subclass 1', 'Details' => 'Oh, Hi!',]]
285			,
286			$customtable1->Parents()
287			);
288			$this->assertEmpty($customtable3->Parents()->count());
289
290			}
291
292
293			/**
294			* @covers DataObjectSchema::baseDataClass()
295			*/
296			public function testBaseDataClass() {
297			$schema = DataObject::getSchema();
298
299			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_BaseClass'));
300			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_baseclass'));
301			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_ChildClass'));
302			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_CHILDCLASS'));
303			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_GrandChildClass'));
304			$this->assertEquals('DataObjectSchemaTest_BaseClass', $schema->baseDataClass('DataObjectSchemaTest_GRANDChildClass'));
305
306			$this->setExpectedException('InvalidArgumentException');
307			$schema->baseDataClass('DataObject');
308			}
309			}
310
311			class DataObjectSchemaTest_BaseClass extends DataObject implements TestOnly {
312
313			}
314
315			class DataObjectSchemaTest_ChildClass extends DataObjectSchemaTest_BaseClass {
316
317			}
318
319			class DataObjectSchemaTest_GrandChildClass extends DataObjectSchemaTest_ChildClass {
320
321			}
322
323			class DataObjectSchemaTest_BaseDataClass extends DataObject implements TestOnly {
324
325			private static $db = array(
326			'Title' => 'Varchar'
327			);
328			}
329
330
331			class DataObjectSchemaTest_NoFields extends DataObjectSchemaTest_BaseDataClass {
332
333			}
334
335			class DataObjectSchemaTest_HasFields extends DataObjectSchemaTest_NoFields {
336
337			private static $db = array(
338			'Description' => 'Varchar'
339			);
340			}
341
342			class DataObjectSchemaTest_WithCustomTable extends DataObjectSchemaTest_NoFields {
343			private static $table_name = 'DOSTWithCustomTable';
344			private static $db = array(
345			'Description' => 'Text'
346			);
347			}
348
349			class DataObjectSchemaTest_WithRelation extends DataObjectSchemaTest_NoFields {
350
351			private static $has_one = array(
352			'Relation' => 'DataObjectSchemaTest_HasFields'
353			);
354			}
355

silverstripe / silverstripe-framework

Push — master ( 9e3f76...51d53f )

DataObjectSchemaTest::testClassNameForTable() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like