QueryBuilderTest::testOffset() - Code Metrics - Benestar/asparagus - Measure and Improve Code Quality continuously with Scrutinizer

QueryBuilderTest::testOffset() A
last analyzed 2016-01-21 18:37 UTC

↳ Parent: QueryBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	7
rs	9.4285
cc	1
eloc	5
nc	1
nop	0

<?php

namespace Asparagus\Tests;

use Asparagus\QueryBuilder;

/**
 * @covers Asparagus\QueryBuilder
 *
 * @license GNU GPL v2+
 * @author Bene* < [email protected] >
 */
class QueryBuilderTest extends \PHPUnit_Framework_TestCase {

	public function testSelect() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->select( '?a', '?b' )
		);

		// use variables ?a and ?b
		$queryBuilder->where( '?a', '?b', '?c' );

		$this->assertEquals(
			'SELECT ?a ?b WHERE { ?a ?b ?c . }',
			$queryBuilder->getSPARQL()
		);
	}

	public function testSelect_invalidArgument() {
		$queryBuilder = new QueryBuilder();
		$this->setExpectedException( 'InvalidArgumentException' );

		$queryBuilder->select( '?a', false );
	}

	public function testSelectDistinct() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->selectDistinct( '?a', '?b' )
		);

		// use variables ?a and ?b
		$queryBuilder->where( '?a', '?b', '?c' );

		$this->assertEquals(
			'SELECT DISTINCT ?a ?b WHERE { ?a ?b ?c . }',
			$queryBuilder->getSPARQL()
		);
	}

	public function testSelectReduced() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->selectReduced( '?a', '?b' )
		);

		// use variables ?a and ?b
		$queryBuilder->where( '?a', '?b', '?c' );

		$this->assertEquals(
			'SELECT REDUCED ?a ?b WHERE { ?a ?b ?c . }',
			$queryBuilder->getSPARQL()
		);
	}

	public function testDescribe() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->describe( '?a', '?b', '<foo:bar>' )
		);

		// use variables ?a and ?b
		$queryBuilder->where( '?a', '?b', '?c' );

		$this->assertEquals(
			'DESCRIBE ?a ?b <foo:bar> WHERE { ?a ?b ?c . }',
			$queryBuilder->getSPARQL()
		);
	}

	public function testDescribe_undefinedPrefix() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->describe( 'foo:bar' )
		);

		// use variables ?a and ?b
		$queryBuilder->where( '?a', '?b', '?c' );

		$this->setExpectedException( 'RangeException' );
		$queryBuilder->getSPARQL();
	}

	public function testDescribe_queryFormAlreadySet() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->select( '?a', '?b' )
		);

		$this->setExpectedException( 'RuntimeException' );
		$queryBuilder->describe( 'foo:bar' );
	}

	public function testWhere() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->where( '?a', '?b', '?c' )
		);
	}

	public function testAlso() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->also( '?a', '?b', '?c' )
		);
	}

	public function testAlso_knownSubject() {
		$queryBuilder = new QueryBuilder();
		$queryBuilder->where( '?a', '?b', '?c' );
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->also( '?x', '?y' )
		);
	}

	public function testAlso_knownPredicate() {
		$queryBuilder = new QueryBuilder();
		$queryBuilder->where( '?a', '?b', '?c' );
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->also( '?z' )
		);
	}

	public function testFilter() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->filter( 'AVG (?x) > 9' )
		);
	}

	public function testFilterExists() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->filterExists( $queryBuilder->newSubgraph() )
		);
	}

	public function testFilterNotExists() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->filterNotExists( $queryBuilder->newSubgraph() )
		);
	}

	public function testOptional() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->optional( '?a', '?b', '?c' )
		);
	}

	public function testUnion() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->union( $queryBuilder->newSubgraph() )
		);
	}

	public function testSubquery() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->subquery( $queryBuilder->newSubquery() )
		);
	}

	public function testNewSubquery() {
		$queryBuilder = new QueryBuilder( array( 'a' => 'b' ) );
		$this->assertEquals(
			new QueryBuilder( array( 'a' => 'b' ) ),
			$queryBuilder->newSubquery()
		);
	}

	public function testNewSubgraph() {
		$queryBuilder = new QueryBuilder();
		$this->assertInstanceOf( 'Asparagus\GraphBuilder', $queryBuilder->newSubgraph() );
		$this->assertNotSame( $queryBuilder->newSubgraph(), $queryBuilder->newSubgraph() );
	}

	public function testGroupBy() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->groupBy( '?test' )
		);
	}

	public function testHaving() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->having( 'AVG(?size) > 10' )
		);
	}

	public function testOrderBy() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->orderBy( '?test' )
		);
	}

	public function testLimit() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->limit( 5 )
		);
	}

	public function testOffset() {
		$queryBuilder = new QueryBuilder();
		$this->assertSame(
			$queryBuilder,
			$queryBuilder->offset( 5 )
		);
	}

	public function testGetSPARQL() {
		$queryBuilder = new QueryBuilder();

		$this->assertEquals( 'SELECT * WHERE { }', $queryBuilder->getSPARQL() );
	}

	public function testGetSPARQL_withPrefixes() {
		$queryBuilder = new QueryBuilder( array( 'foo' => 'bar' ) );

		$this->assertEquals( 'PREFIX foo: <bar> SELECT * WHERE { }', $queryBuilder->getSPARQL() );
	}

	public function testGetSPARQL_noPrefixes() {
		$queryBuilder = new QueryBuilder( array( 'foo' => 'bar' ) );

		$this->assertEquals( 'SELECT * WHERE { }', $queryBuilder->getSPARQL( false ) );
	}

	public function testGetSPARQL_undefinedVariable() {
		$queryBuilder = new QueryBuilder();
		$this->setExpectedException( 'RangeException', '?x' );

		$queryBuilder->select( '?x' )->getSPARQL();
	}

	public function testGetSPARQL_undefinedPrefix() {
		$queryBuilder = new QueryBuilder();
		$this->setExpectedException( 'RangeException', 'foo, nyan' );

		$queryBuilder->where( '?x', 'foo:bar', 'nyan:data' )->getSPARQL();
	}

	public function testToString() {
		$queryBuilder = new QueryBuilder();

		$this->assertEquals( 'SELECT * WHERE { }', strval( $queryBuilder ) );
	}

	public function testFormat() {
		$queryBuilder = new QueryBuilder();

		$this->assertEquals( "SELECT * WHERE {\n}\n", $queryBuilder->format() );
	}

}


1			<?php
2
3			namespace Asparagus\Tests;
4
5			use Asparagus\QueryBuilder;
6
7			/**
8			* @covers Asparagus\QueryBuilder
9			*
10			* @license GNU GPL v2+
11			* @author Bene* < [email protected] >
12			*/
13			class QueryBuilderTest extends \PHPUnit_Framework_TestCase {
14
15			public function testSelect() {
16			$queryBuilder = new QueryBuilder();
17			$this->assertSame(
18			$queryBuilder,
19			$queryBuilder->select( '?a', '?b' )
20			);
21
22			// use variables ?a and ?b
23			$queryBuilder->where( '?a', '?b', '?c' );
24
25			$this->assertEquals(
26			'SELECT ?a ?b WHERE { ?a ?b ?c . }',
27			$queryBuilder->getSPARQL()
28			);
29			}
30
31			public function testSelect_invalidArgument() {
32			$queryBuilder = new QueryBuilder();
33			$this->setExpectedException( 'InvalidArgumentException' );
34
35			$queryBuilder->select( '?a', false );
36			}
37
38			public function testSelectDistinct() {
39			$queryBuilder = new QueryBuilder();
40			$this->assertSame(
41			$queryBuilder,
42			$queryBuilder->selectDistinct( '?a', '?b' )
43			);
44
45			// use variables ?a and ?b
46			$queryBuilder->where( '?a', '?b', '?c' );
47
48			$this->assertEquals(
49			'SELECT DISTINCT ?a ?b WHERE { ?a ?b ?c . }',
50			$queryBuilder->getSPARQL()
51			);
52			}
53
54			public function testSelectReduced() {
55			$queryBuilder = new QueryBuilder();
56			$this->assertSame(
57			$queryBuilder,
58			$queryBuilder->selectReduced( '?a', '?b' )
59			);
60
61			// use variables ?a and ?b
62			$queryBuilder->where( '?a', '?b', '?c' );
63
64			$this->assertEquals(
65			'SELECT REDUCED ?a ?b WHERE { ?a ?b ?c . }',
66			$queryBuilder->getSPARQL()
67			);
68			}
69
70			public function testDescribe() {
71			$queryBuilder = new QueryBuilder();
72			$this->assertSame(
73			$queryBuilder,
74			$queryBuilder->describe( '?a', '?b', '<foo:bar>' )
75			);
76
77			// use variables ?a and ?b
78			$queryBuilder->where( '?a', '?b', '?c' );
79
80			$this->assertEquals(
81			'DESCRIBE ?a ?b <foo:bar> WHERE { ?a ?b ?c . }',
82			$queryBuilder->getSPARQL()
83			);
84			}
85
86			public function testDescribe_undefinedPrefix() {
87			$queryBuilder = new QueryBuilder();
88			$this->assertSame(
89			$queryBuilder,
90			$queryBuilder->describe( 'foo:bar' )
91			);
92
93			// use variables ?a and ?b
94			$queryBuilder->where( '?a', '?b', '?c' );
95
96			$this->setExpectedException( 'RangeException' );
97			$queryBuilder->getSPARQL();
98			}
99
100			public function testDescribe_queryFormAlreadySet() {
101			$queryBuilder = new QueryBuilder();
102			$this->assertSame(
103			$queryBuilder,
104			$queryBuilder->select( '?a', '?b' )
105			);
106
107			$this->setExpectedException( 'RuntimeException' );
108			$queryBuilder->describe( 'foo:bar' );
109			}
110
111			public function testWhere() {
112			$queryBuilder = new QueryBuilder();
113			$this->assertSame(
114			$queryBuilder,
115			$queryBuilder->where( '?a', '?b', '?c' )
116			);
117			}
118
119			public function testAlso() {
120			$queryBuilder = new QueryBuilder();
121			$this->assertSame(
122			$queryBuilder,
123			$queryBuilder->also( '?a', '?b', '?c' )
124			);
125			}
126
127			public function testAlso_knownSubject() {
128			$queryBuilder = new QueryBuilder();
129			$queryBuilder->where( '?a', '?b', '?c' );
130			$this->assertSame(
131			$queryBuilder,
132			$queryBuilder->also( '?x', '?y' )
133			);
134			}
135
136			public function testAlso_knownPredicate() {
137			$queryBuilder = new QueryBuilder();
138			$queryBuilder->where( '?a', '?b', '?c' );
139			$this->assertSame(
140			$queryBuilder,
141			$queryBuilder->also( '?z' )
142			);
143			}
144
145			public function testFilter() {
146			$queryBuilder = new QueryBuilder();
147			$this->assertSame(
148			$queryBuilder,
149			$queryBuilder->filter( 'AVG (?x) > 9' )
150			);
151			}
152
153			public function testFilterExists() {
154			$queryBuilder = new QueryBuilder();
155			$this->assertSame(
156			$queryBuilder,
157			$queryBuilder->filterExists( $queryBuilder->newSubgraph() )
158			);
159			}
160
161			public function testFilterNotExists() {
162			$queryBuilder = new QueryBuilder();
163			$this->assertSame(
164			$queryBuilder,
165			$queryBuilder->filterNotExists( $queryBuilder->newSubgraph() )
166			);
167			}
168
169			public function testOptional() {
170			$queryBuilder = new QueryBuilder();
171			$this->assertSame(
172			$queryBuilder,
173			$queryBuilder->optional( '?a', '?b', '?c' )
174			);
175			}
176
177			public function testUnion() {
178			$queryBuilder = new QueryBuilder();
179			$this->assertSame(
180			$queryBuilder,
181			$queryBuilder->union( $queryBuilder->newSubgraph() )
182			);
183			}
184
185			public function testSubquery() {
186			$queryBuilder = new QueryBuilder();
187			$this->assertSame(
188			$queryBuilder,
189			$queryBuilder->subquery( $queryBuilder->newSubquery() )
190			);
191			}
192
193			public function testNewSubquery() {
194			$queryBuilder = new QueryBuilder( array( 'a' => 'b' ) );
195			$this->assertEquals(
196			new QueryBuilder( array( 'a' => 'b' ) ),
197			$queryBuilder->newSubquery()
198			);
199			}
200
201			public function testNewSubgraph() {
202			$queryBuilder = new QueryBuilder();
203			$this->assertInstanceOf( 'Asparagus\GraphBuilder', $queryBuilder->newSubgraph() );
204			$this->assertNotSame( $queryBuilder->newSubgraph(), $queryBuilder->newSubgraph() );
205			}
206
207			public function testGroupBy() {
208			$queryBuilder = new QueryBuilder();
209			$this->assertSame(
210			$queryBuilder,
211			$queryBuilder->groupBy( '?test' )
212			);
213			}
214
215			public function testHaving() {
216			$queryBuilder = new QueryBuilder();
217			$this->assertSame(
218			$queryBuilder,
219			$queryBuilder->having( 'AVG(?size) > 10' )
220			);
221			}
222
223			public function testOrderBy() {
224			$queryBuilder = new QueryBuilder();
225			$this->assertSame(
226			$queryBuilder,
227			$queryBuilder->orderBy( '?test' )
228			);
229			}
230
231			public function testLimit() {
232			$queryBuilder = new QueryBuilder();
233			$this->assertSame(
234			$queryBuilder,
235			$queryBuilder->limit( 5 )
236			);
237			}
238
239			public function testOffset() {
240			$queryBuilder = new QueryBuilder();
241			$this->assertSame(
242			$queryBuilder,
243			$queryBuilder->offset( 5 )
244			);
245			}
246
247			public function testGetSPARQL() {
248			$queryBuilder = new QueryBuilder();
249
250			$this->assertEquals( 'SELECT * WHERE { }', $queryBuilder->getSPARQL() );
251			}
252
253			public function testGetSPARQL_withPrefixes() {
254			$queryBuilder = new QueryBuilder( array( 'foo' => 'bar' ) );
255
256			$this->assertEquals( 'PREFIX foo: <bar> SELECT * WHERE { }', $queryBuilder->getSPARQL() );
257			}
258
259			public function testGetSPARQL_noPrefixes() {
260			$queryBuilder = new QueryBuilder( array( 'foo' => 'bar' ) );
261
262			$this->assertEquals( 'SELECT * WHERE { }', $queryBuilder->getSPARQL( false ) );
263			}
264
265			public function testGetSPARQL_undefinedVariable() {
266			$queryBuilder = new QueryBuilder();
267			$this->setExpectedException( 'RangeException', '?x' );
268
269			$queryBuilder->select( '?x' )->getSPARQL();
270			}
271
272			public function testGetSPARQL_undefinedPrefix() {
273			$queryBuilder = new QueryBuilder();
274			$this->setExpectedException( 'RangeException', 'foo, nyan' );
275
276			$queryBuilder->where( '?x', 'foo:bar', 'nyan:data' )->getSPARQL();
277			}
278
279			public function testToString() {
280			$queryBuilder = new QueryBuilder();
281
282			$this->assertEquals( 'SELECT * WHERE { }', strval( $queryBuilder ) );
283			}
284
285			public function testFormat() {
286			$queryBuilder = new QueryBuilder();
287
288			$this->assertEquals( "SELECT * WHERE {\n}\n", $queryBuilder->format() );
289			}
290
291			}
292

Benestar / asparagus

QueryBuilderTest::testOffset() A last analyzed 2016-01-21 18:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

QueryBuilderTest::testOffset() A
last analyzed 2016-01-21 18:37 UTC