Skip to content

Commit 59c1463

Browse files
marijnvanwezelmarijnvanwezel
committed
Merge branch '5.0.0-typing-and-consistency' of github.com:WikibaseSolutions/php-cypher-dsl into 5.0.0-typing-and-consistency
2 parents 16ba2d2 + d7a756c commit 59c1463

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

50 files changed

+234
-269
lines changed

‎tests/Unit/Clauses/CallClauseTest.php

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ public function testCallClauseWithEmptySubqueryIsEmpty(): void
2424

2525
$this->assertSame('', $clause->toQuery());
2626

27-
$clause->withVariables([Query::variable('x')]);
27+
$clause->withVariables(Query::variable('x'));
2828

2929
$this->assertSame('', $clause->toQuery());
3030
}
@@ -41,7 +41,7 @@ public function testCallClauseWithoutWithDoesNotHaveWithStatement(): void
4141

4242
public function testCallClauseFilled(): void
4343
{
44-
$query = Query::new()->match(Query::node('X')->setVariable('x'))->returning(Query::rawExpression('*'));
44+
$query = Query::new()->match(Query::node('X')->withVariable('x'))->returning(Query::rawExpression('*'));
4545

4646
$clause = new CallClause();
4747
$clause->withSubQuery($query);
@@ -51,11 +51,11 @@ public function testCallClauseFilled(): void
5151

5252
public function testCallClauseWithVariables(): void
5353
{
54-
$query = Query::new()->match(Query::node('X')->setVariable('x'))->returning(Query::rawExpression('*'));
54+
$query = Query::new()->match(Query::node('X')->withVariable('x'))->returning(Query::rawExpression('*'));
5555

5656
$clause = new CallClause();
5757
$clause->withSubQuery($query);
58-
$clause->withVariables([Query::variable('x')]);
58+
$clause->withVariables(Query::variable('x'));
5959

6060
$this->assertSame('CALL { WITH x MATCH (x:X) RETURN * }', $clause->toQuery());
6161
}
@@ -92,7 +92,7 @@ public function testGetWithVariables(): void
9292
$b = Query::variable('b');
9393
$c = Query::variable('c');
9494

95-
$clause->withVariables([$a]);
95+
$clause->withVariables($a);
9696
$clause->addVariable($b);
9797
$clause->addVariable($c);
9898

‎tests/Unit/Clauses/CreateClauseTest.php

Lines changed: 7 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -27,8 +27,6 @@
2727
use WikibaseSolutions\CypherDSL\Query;
2828
use WikibaseSolutions\CypherDSL\Tests\Unit\Expressions\TestHelper;
2929
use WikibaseSolutions\CypherDSL\Types\AnyType;
30-
use WikibaseSolutions\CypherDSL\Types\StructuralTypes\NodeType;
31-
use WikibaseSolutions\CypherDSL\Types\StructuralTypes\PathType;
3230

3331
/**
3432
* @covers \WikibaseSolutions\CypherDSL\Clauses\CreateClause
@@ -46,7 +44,7 @@ public function testEmptyClause(): void
4644
public function testSinglePattern(): void
4745
{
4846
$createClause = new CreateClause();
49-
$pattern = Query::node()->setVariable('a');
47+
$pattern = Query::node()->withVariable('a');
5048

5149
$createClause->addPattern($pattern);
5250

@@ -58,59 +56,24 @@ public function testMultiplePatterns(): void
5856
{
5957
$createClause = new CreateClause();
6058

61-
$patternA = Query::node()->setVariable('a');
62-
$patternB = Query::node()->setVariable('b')->relationshipTo(Query::node()->setVariable('c'));
59+
$patternA = Query::node()->withVariable('a');
60+
$patternB = Query::node()->withVariable('b')->relationshipTo(Query::node()->withVariable('c'), 'Foo');
6361

6462
$createClause->addPattern($patternA);
6563
$createClause->addPattern($patternB);
6664

67-
$this->assertSame("CREATE (a), (b)-->(c)", $createClause->toQuery());
65+
$this->assertSame("CREATE (a), (b)-[:Foo]->(c)", $createClause->toQuery());
6866
$this->assertEquals([$patternA, $patternB], $createClause->getPatterns());
6967
}
7068

71-
public function testAcceptsNodeType(): void
72-
{
73-
$createClause = new CreateClause();
74-
75-
$patternA = Query::node();
76-
77-
$createClause->addPattern($patternA);
78-
$createClause->toQuery();
79-
80-
$this->assertEquals([$patternA], $createClause->getPatterns());
81-
}
82-
83-
public function testAcceptsPathType(): void
84-
{
85-
$createClause = new CreateClause();
86-
87-
$patternA = Query::node()->relationshipTo(Query::node());
88-
89-
$createClause->addPattern($patternA);
90-
$createClause->toQuery();
91-
$this->assertEquals([$patternA], $createClause->getPatterns());
92-
}
93-
94-
public function testDoesNotAcceptAnyType(): void
95-
{
96-
$createClause = new CreateClause();
97-
98-
$patternA = Query::function()::date();
99-
100-
$this->expectException(TypeError::class);
101-
102-
$createClause->addPattern($patternA);
103-
$createClause->toQuery();
104-
}
105-
10669
public function testSetPatterns(): void
10770
{
10871
$createClause = new CreateClause();
10972

11073
$pathExpression = Query::node()->relationshipTo(Query::node());
11174
$createClause->addPattern($pathExpression);
11275

113-
$createClause->setPatterns([Query::node()->setVariable('a'), Query::node()->setVariable('b')]);
76+
$createClause->setPatterns([Query::node()->withVariable('a'), Query::node()->withVariable('b')]);
11477

11578
$this->assertSame("CREATE (a), (b)", $createClause->toQuery());
11679
}
@@ -119,8 +82,8 @@ public function testAddPattern(): void
11982
{
12083
$createClause = new CreateClause();
12184

122-
$createClause->addPattern(Query::node()->setVariable('a'));
123-
$createClause->addPattern(Query::node()->setVariable('b'));
85+
$createClause->addPattern(Query::node()->withVariable('a'));
86+
$createClause->addPattern(Query::node()->withVariable('b'));
12487

12588
$this->assertSame("CREATE (a), (b)", $createClause->toQuery());
12689
}

‎tests/Unit/Clauses/DeleteClauseTest.php

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -40,58 +40,58 @@ public function testEmptyClause(): void
4040
$delete = new DeleteClause();
4141

4242
$this->assertSame("", $delete->toQuery());
43-
$this->assertEquals([], $delete->getVariables());
43+
$this->assertEquals([], $delete->getStructures());
4444
$this->assertFalse($delete->detachesDeletion());
4545
}
4646

4747
public function testSingleVariable(): void
4848
{
4949
$delete = new DeleteClause();
50-
$variable = $this->getQueryConvertibleMock(Variable::class, "a");
50+
$variable = new Variable('a');
5151

52-
$delete->addVariable($variable);
52+
$delete->addStructure($variable);
5353

5454
$this->assertSame("DELETE a", $delete->toQuery());
55-
$this->assertEquals([$variable], $delete->getVariables());
55+
$this->assertEquals([$variable], $delete->getStructures());
5656
$this->assertFalse($delete->detachesDeletion());
5757
}
5858

5959
public function testMultipleVariables(): void
6060
{
6161
$delete = new DeleteClause();
6262

63-
$a = $this->getQueryConvertibleMock(Variable::class, "a");
64-
$b = $this->getQueryConvertibleMock(Variable::class, "b");
63+
$a = new Variable('a');
64+
$b = new Variable('b');
6565

66-
$delete->addVariable($a);
67-
$delete->addVariable($b);
66+
$delete->addStructure($a);
67+
$delete->addStructure($b);
6868

6969
$this->assertSame("DELETE a, b", $delete->toQuery());
70-
$this->assertEquals([$a, $b], $delete->getVariables());
70+
$this->assertEquals([$a, $b], $delete->getStructures());
7171
$this->assertFalse($delete->detachesDeletion());
7272
}
7373

7474
public function testDetachDelete(): void
7575
{
7676
$delete = new DeleteClause();
77-
$variable = $this->getQueryConvertibleMock(Variable::class, "a");
77+
$variable = new Variable('a');
7878

79-
$delete->addVariable($variable);
79+
$delete->addStructure($variable);
8080
$delete->setDetach(true);
8181

8282
$this->assertSame("DETACH DELETE a", $delete->toQuery());
83-
$this->assertEquals([$variable], $delete->getVariables());
83+
$this->assertEquals([$variable], $delete->getStructures());
8484
$this->assertTrue($delete->detachesDeletion());
8585
}
8686

8787
public function testAcceptsVariable(): void
8888
{
8989
$delete = new DeleteClause();
90-
$variable = $this->getQueryConvertibleMock(Variable::class, "a");
90+
$variable = new Variable('a');
9191

92-
$delete->addVariable($variable);
92+
$delete->addStructure($variable);
9393
$delete->toQuery();
94-
$this->assertEquals([$variable], $delete->getVariables());
94+
$this->assertEquals([$variable], $delete->getStructures());
9595
$this->assertFalse($delete->detachesDeletion());
9696
}
9797

@@ -102,50 +102,50 @@ public function testDoesNotAcceptAnyType(): void
102102

103103
$this->expectException(TypeError::class);
104104

105-
$delete->addVariable($variable);
105+
$delete->addStructure($variable);
106106
$delete->toQuery();
107107
}
108108

109109
public function testSetVariables(): void
110110
{
111111
$delete = new DeleteClause();
112112

113-
$variableA = $this->getQueryConvertibleMock(Variable::class, "a");
114-
$variableB = $this->getQueryConvertibleMock(Variable::class, "b");
113+
$variableA = new Variable('a');
114+
$variableB = new Variable('b');
115115

116116
$variables = [$variableA, $variableB];
117117

118-
$delete->setNodes($variables);
118+
$delete->setStructures($variables);
119119

120120
$this->assertSame("DELETE a, b", $delete->toQuery());
121-
$this->assertSame($variables, $delete->getVariables());
121+
$this->assertSame($variables, $delete->getStructures());
122122
}
123123

124124
public function testSetVariablesDoesNotAcceptAnyType(): void
125125
{
126126
$delete = new DeleteClause();
127127

128-
$variableA = $this->getQueryConvertibleMock(Variable::class, "a");
128+
$variableA = new Variable('a');
129129
$variableB = $this->getQueryConvertibleMock(AnyType::class, "b");
130130

131131
$variables = [$variableA, $variableB];
132132

133133
$this->expectException(TypeError::class);
134134

135-
$delete->setNodes($variables);
135+
$delete->setStructures($variables);
136136
$delete->toQuery();
137137
}
138138

139139
public function testGetVariables(): void
140140
{
141141
$delete = new DeleteClause();
142142

143-
$this->assertSame([], $delete->getVariables());
143+
$this->assertSame([], $delete->getStructures());
144144

145-
$variables = [$this->getQueryConvertibleMock(Variable::class, "a")];
146-
$delete->setNodes($variables);
145+
$variables = [new Variable('a')];
146+
$delete->setStructures($variables);
147147

148-
$this->assertSame($variables, $delete->getVariables());
148+
$this->assertSame($variables, $delete->getStructures());
149149
}
150150

151151
public function testDetachesDeletion(): void

‎tests/Unit/Clauses/MatchClauseTest.php

Lines changed: 13 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -22,13 +22,11 @@
2222
namespace WikibaseSolutions\CypherDSL\Tests\Unit\Clauses;
2323

2424
use PHPUnit\Framework\TestCase;
25-
use TypeError;
2625
use WikibaseSolutions\CypherDSL\Clauses\MatchClause;
2726
use WikibaseSolutions\CypherDSL\Tests\Unit\Expressions\TestHelper;
28-
use WikibaseSolutions\CypherDSL\Types\AnyType;
29-
use WikibaseSolutions\CypherDSL\Types\StructuralTypes\NodeType;
30-
use WikibaseSolutions\CypherDSL\Types\StructuralTypes\PathType;
31-
27+
use WikibaseSolutions\CypherDSL\Patterns\Node;
28+
use WikibaseSolutions\CypherDSL\Patterns\Path;
29+
use InvalidArgumentException;
3230
/**
3331
* @covers \WikibaseSolutions\CypherDSL\Clauses\MatchClause
3432
*/
@@ -47,7 +45,7 @@ public function testEmptyClause(): void
4745
public function testSinglePattern(): void
4846
{
4947
$match = new MatchClause();
50-
$pattern = $this->getQueryConvertibleMock(NodeType::class, "(a)");
48+
$pattern = (new Node())->withVariable('a');
5149
$match->addPattern($pattern);
5250

5351
$this->assertSame("MATCH (a)", $match->toQuery());
@@ -57,54 +55,22 @@ public function testSinglePattern(): void
5755
public function testMultiplePatterns(): void
5856
{
5957
$match = new MatchClause();
60-
$patternA = $this->getQueryConvertibleMock(NodeType::class, "(a)");
61-
$patternB = $this->getQueryConvertibleMock(PathType::class, "(b)-->(c)");
58+
$patternA = (new Node())->withVariable('a');
59+
$patternB = (new Node())->withVariable('b')->relationshipTo((new Node())->withVariable('c'), 'Foo');
6260

6361
$match->addPattern($patternA);
6462
$match->addPattern($patternB);
6563

66-
$this->assertSame("MATCH (a), (b)-->(c)", $match->toQuery());
64+
$this->assertSame("MATCH (a), (b)-[:Foo]->(c)", $match->toQuery());
6765
$this->assertEquals([$patternA, $patternB], $match->getPatterns());
6866
}
6967

70-
/**
71-
* @doesNotPerformAssertions
72-
*/
73-
public function testAcceptsNodeType(): void
74-
{
75-
$match = new MatchClause();
76-
$match->addPattern($this->getQueryConvertibleMock(NodeType::class, "(a)"));
77-
78-
$match->toQuery();
79-
}
80-
81-
/**
82-
* @doesNotPerformAssertions
83-
*/
84-
public function testAcceptsPathType(): void
85-
{
86-
$match = new MatchClause();
87-
$match->addPattern($this->getQueryConvertibleMock(PathType::class, "(a)"));
88-
89-
$match->toQuery();
90-
}
91-
92-
public function testDoesNotAcceptAnyType(): void
93-
{
94-
$this->expectException(TypeError::class);
95-
96-
$match = new MatchClause();
97-
$match->addPattern($this->getQueryConvertibleMock(AnyType::class, "(a)"));
98-
99-
$match->toQuery();
100-
}
101-
10268
public function testSetPatterns(): void
10369
{
10470
$match = new MatchClause();
105-
$match->addPattern($this->getQueryConvertibleMock(PathType::class, "(c)"));
71+
$match->addPattern((new Node())->withVariable('c'));
10672

107-
$patterns = [$this->getQueryConvertibleMock(PathType::class, "(a)"), $this->getQueryConvertibleMock(NodeType::class, "(b)")];
73+
$patterns = [(new Path([(new Node())->withVariable('a')])), new Path([(new Node())->withVariable('b')])];
10874

10975
$match->setPatterns($patterns);
11076

@@ -116,7 +82,7 @@ public function testSetPatternsDoesNotAcceptAnyType(): void
11682
{
11783
$match = new MatchClause();
11884

119-
$this->expectException(TypeError::class);
85+
$this->expectException(InvalidArgumentException::class);
12086

12187
$match->setPatterns([$this->getQueryConvertibleMock(AnyType::class, "(a)")]);
12288
$match->toQuery();
@@ -125,10 +91,10 @@ public function testSetPatternsDoesNotAcceptAnyType(): void
12591
/**
12692
* @doesNotPerformAssertions
12793
*/
128-
public function testSetPatternsAcceptsPathType(): void
94+
public function testSetPatternsAcceptsPath(): void
12995
{
13096
$match = new MatchClause();
131-
$match->setPatterns([$this->getQueryConvertibleMock(PathType::class, "(a)")]);
97+
$match->setPatterns([new Path([(new Node)->withVariable('a')])]);
13298

13399
$match->toQuery();
134100
}
@@ -137,7 +103,7 @@ public function testGetPatterns(): void
137103
{
138104
$match = new MatchClause();
139105

140-
$patterns = [$this->getQueryConvertibleMock(PathType::class, "(a)")];
106+
$patterns = [new Path([(new Node)->withVariable('a')])];
141107

142108
$match->setPatterns($patterns);
143109

0 commit comments

Comments
 (0)