Skip to content

Commit 02ad805

Browse files
stevebaumanstevebauman
committed
Update tests
1 parent becc123 commit 02ad805

File tree

1 file changed

+83
-80
lines changed

1 file changed

+83
-80
lines changed

‎tests/Unit/Query/Filter/ParserTest.php‎

Lines changed: 83 additions & 80 deletions
Original file line numberDiff line numberDiff line change
@@ -2,8 +2,11 @@
22

33
namespace LdapRecord\Tests\Unit\Query\Filter;
44

5-
use LdapRecord\Query\Filter\ConditionNode;
6-
use LdapRecord\Query\Filter\GroupNode;
5+
use LdapRecord\Query\Filter\AndGroup;
6+
use LdapRecord\Query\Filter\ApproximatelyEquals;
7+
use LdapRecord\Query\Filter\Equals;
8+
use LdapRecord\Query\Filter\Not;
9+
use LdapRecord\Query\Filter\OrGroup;
710
use LdapRecord\Query\Filter\Parser;
811
use LdapRecord\Query\Filter\ParserException;
912
use LdapRecord\Tests\TestCase;
@@ -15,95 +18,95 @@ public function test_parsing_basic_filter()
1518
{
1619
$group = Parser::parse('(|(foo=bar)(:baz:~=zal))')[0];
1720

18-
$this->assertInstanceOf(GroupNode::class, $group);
21+
$this->assertInstanceOf(OrGroup::class, $group);
1922
$this->assertEquals('|', $group->getOperator());
2023

21-
$this->assertCount(2, $nodes = $group->getNodes());
24+
$this->assertCount(2, $filters = $group->getFilters());
2225

23-
$this->assertInstanceOf(ConditionNode::class, $nodes[0]);
24-
$this->assertEquals('foo', $nodes[0]->getAttribute());
25-
$this->assertEquals('=', $nodes[0]->getOperator());
26-
$this->assertEquals('bar', $nodes[0]->getValue());
26+
$this->assertInstanceOf(Equals::class, $filters[0]);
27+
$this->assertEquals('foo', $filters[0]->getAttribute());
28+
$this->assertEquals('=', $filters[0]->getOperator());
29+
$this->assertEquals('bar', $filters[0]->getValue());
2730

28-
$this->assertInstanceOf(ConditionNode::class, $nodes[1]);
29-
$this->assertEquals(':baz:', $nodes[1]->getAttribute());
30-
$this->assertEquals('~=', $nodes[1]->getOperator());
31-
$this->assertEquals('zal', $nodes[1]->getValue());
31+
$this->assertInstanceOf(ApproximatelyEquals::class, $filters[1]);
32+
$this->assertEquals(':baz:', $filters[1]->getAttribute());
33+
$this->assertEquals('~=', $filters[1]->getOperator());
34+
$this->assertEquals('zal', $filters[1]->getValue());
3235
}
3336

3437
public function test_parsing_badly_formatted_filter()
3538
{
36-
$nodes = Parser::parse('(foo=bar)_~@#-foobar-.~=(:baz:~=zal)');
39+
$filters = Parser::parse('(foo=bar)_~@#-foobar-.~=(:baz:~=zal)');
3740

38-
$this->assertCount(2, $nodes);
41+
$this->assertCount(2, $filters);
3942

40-
$this->assertInstanceOf(ConditionNode::class, $nodes[0]);
41-
$this->assertEquals('foo', $nodes[0]->getAttribute());
42-
$this->assertEquals('=', $nodes[0]->getOperator());
43-
$this->assertEquals('bar', $nodes[0]->getValue());
43+
$this->assertInstanceOf(Equals::class, $filters[0]);
44+
$this->assertEquals('foo', $filters[0]->getAttribute());
45+
$this->assertEquals('=', $filters[0]->getOperator());
46+
$this->assertEquals('bar', $filters[0]->getValue());
4447

45-
$this->assertInstanceOf(ConditionNode::class, $nodes[1]);
46-
$this->assertEquals(':baz:', $nodes[1]->getAttribute());
47-
$this->assertEquals('~=', $nodes[1]->getOperator());
48-
$this->assertEquals('zal', $nodes[1]->getValue());
48+
$this->assertInstanceOf(ApproximatelyEquals::class, $filters[1]);
49+
$this->assertEquals(':baz:', $filters[1]->getAttribute());
50+
$this->assertEquals('~=', $filters[1]->getOperator());
51+
$this->assertEquals('zal', $filters[1]->getValue());
4952
}
5053

5154
public function test_parsing_nested_filter_groups()
5255
{
5356
$group = Parser::parse('(&(objectCategory=person)(objectClass=contact)(|(sn=Smith)(sn=Johnson)))')[0];
5457

55-
$this->assertInstanceOf(GroupNode::class, $group);
58+
$this->assertInstanceOf(AndGroup::class, $group);
5659
$this->assertEquals('&', $group->getOperator());
5760

58-
$this->assertCount(3, $nodes = $group->getNodes());
61+
$this->assertCount(3, $filters = $group->getFilters());
5962

60-
$this->assertInstanceOf(ConditionNode::class, $nodes[0]);
61-
$this->assertEquals('objectCategory', $nodes[0]->getAttribute());
62-
$this->assertEquals('=', $nodes[0]->getOperator());
63-
$this->assertEquals('person', $nodes[0]->getValue());
63+
$this->assertInstanceOf(Equals::class, $filters[0]);
64+
$this->assertEquals('objectCategory', $filters[0]->getAttribute());
65+
$this->assertEquals('=', $filters[0]->getOperator());
66+
$this->assertEquals('person', $filters[0]->getValue());
6467

65-
$this->assertInstanceOf(ConditionNode::class, $nodes[1]);
66-
$this->assertEquals('objectClass', $nodes[1]->getAttribute());
67-
$this->assertEquals('=', $nodes[1]->getOperator());
68-
$this->assertEquals('contact', $nodes[1]->getValue());
68+
$this->assertInstanceOf(Equals::class, $filters[1]);
69+
$this->assertEquals('objectClass', $filters[1]->getAttribute());
70+
$this->assertEquals('=', $filters[1]->getOperator());
71+
$this->assertEquals('contact', $filters[1]->getValue());
6972

70-
$this->assertInstanceOf(GroupNode::class, $nodes[2]);
71-
$this->assertEquals('|', $nodes[2]->getOperator());
73+
$this->assertInstanceOf(OrGroup::class, $filters[2]);
74+
$this->assertEquals('|', $filters[2]->getOperator());
7275

73-
$this->assertCount(2, $nodes = $nodes[2]->getNodes());
76+
$this->assertCount(2, $nestedFilters = $filters[2]->getFilters());
7477

75-
$this->assertInstanceOf(ConditionNode::class, $nodes[0]);
76-
$this->assertEquals('sn', $nodes[0]->getAttribute());
77-
$this->assertEquals('=', $nodes[0]->getOperator());
78-
$this->assertEquals('Smith', $nodes[0]->getValue());
78+
$this->assertInstanceOf(Equals::class, $nestedFilters[0]);
79+
$this->assertEquals('sn', $nestedFilters[0]->getAttribute());
80+
$this->assertEquals('=', $nestedFilters[0]->getOperator());
81+
$this->assertEquals('Smith', $nestedFilters[0]->getValue());
7982

80-
$this->assertInstanceOf(ConditionNode::class, $nodes[1]);
81-
$this->assertEquals('sn', $nodes[1]->getAttribute());
82-
$this->assertEquals('=', $nodes[1]->getOperator());
83-
$this->assertEquals('Johnson', $nodes[1]->getValue());
83+
$this->assertInstanceOf(Equals::class, $nestedFilters[1]);
84+
$this->assertEquals('sn', $nestedFilters[1]->getAttribute());
85+
$this->assertEquals('=', $nestedFilters[1]->getOperator());
86+
$this->assertEquals('Johnson', $nestedFilters[1]->getValue());
8487

8588
$this->assertEquals('(&(objectCategory=person)(objectClass=contact)(|(sn=Smith)(sn=Johnson)))', Parser::assemble($group));
8689
}
8790

8891
public function test_parser_can_parse_value_with_equal_sign()
8992
{
90-
$nodes = Parser::parse('(&(objectClass=inetOrgPerson)(memberof=cn=foo,ou=Groups,dc=example,dc=org))');
93+
$filters = Parser::parse('(&(objectClass=inetOrgPerson)(memberof=cn=foo,ou=Groups,dc=example,dc=org))');
9194

92-
$this->assertCount(1, $nodes);
93-
$this->assertInstanceOf(GroupNode::class, $nodes[0]);
95+
$this->assertCount(1, $filters);
96+
$this->assertInstanceOf(AndGroup::class, $filters[0]);
9497

95-
$this->assertCount(2, $nodes[0]->getNodes());
98+
$this->assertCount(2, $filters[0]->getFilters());
9699

97-
$groupNodes = $nodes[0]->getNodes();
98-
$this->assertInstanceOf(ConditionNode::class, $groupNodes[0]);
99-
$this->assertEquals('objectClass', $groupNodes[0]->getAttribute());
100-
$this->assertEquals('=', $groupNodes[0]->getOperator());
101-
$this->assertEquals('inetOrgPerson', $groupNodes[0]->getValue());
100+
$groupFilters = $filters[0]->getFilters();
101+
$this->assertInstanceOf(Equals::class, $groupFilters[0]);
102+
$this->assertEquals('objectClass', $groupFilters[0]->getAttribute());
103+
$this->assertEquals('=', $groupFilters[0]->getOperator());
104+
$this->assertEquals('inetOrgPerson', $groupFilters[0]->getValue());
102105

103-
$this->assertInstanceOf(ConditionNode::class, $groupNodes[1]);
104-
$this->assertEquals('memberof', $groupNodes[1]->getAttribute());
105-
$this->assertEquals('=', $groupNodes[1]->getOperator());
106-
$this->assertEquals('cn=foo,ou=Groups,dc=example,dc=org', $groupNodes[1]->getValue());
106+
$this->assertInstanceOf(Equals::class, $groupFilters[1]);
107+
$this->assertEquals('memberof', $groupFilters[1]->getAttribute());
108+
$this->assertEquals('=', $groupFilters[1]->getOperator());
109+
$this->assertEquals('cn=foo,ou=Groups,dc=example,dc=org', $groupFilters[1]->getValue());
107110
}
108111

109112
public function test_parser_throws_exception_when_missing_open_parenthesis_is_detected()
@@ -132,63 +135,63 @@ public function test_parser_throws_exception_when_unclosed_nested_filter_is_dete
132135

133136
public function test_assemble_can_rebuild_parsed_filter()
134137
{
135-
$nodes = Parser::parse('(|(foo=bar)(:baz:~=zal))');
138+
$filters = Parser::parse('(|(foo=bar)(:baz:~=zal))');
136139

137-
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($nodes));
140+
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($filters));
138141
}
139142

140143
public function test_parser_removes_unneeded_parentheses()
141144
{
142-
$nodes = Parser::parse('(((|(foo=bar)(:baz:~=zal))))');
145+
$filters = Parser::parse('(((|(foo=bar)(:baz:~=zal))))');
143146

144-
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($nodes));
147+
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($filters));
145148
}
146149

147150
public function test_parser_removes_unneeded_spaces()
148151
{
149-
$nodes = Parser::parse(' ( |( foo=bar)( :baz:~=zal ) ) ');
152+
$filters = Parser::parse(' ( |( foo=bar)( :baz:~=zal ) ) ');
150153

151-
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($nodes));
154+
$this->assertEquals('(|(foo=bar)(:baz:~=zal))', Parser::assemble($filters));
152155
}
153156

154157
public function test_parser_preserves_value_spaces()
155158
{
156-
$nodes = Parser::parse('(|(foo=bar baz zal))');
159+
$filters = Parser::parse('(|(foo=bar baz zal))');
157160

158-
$this->assertEquals('(|(foo=bar baz zal))', Parser::assemble($nodes));
161+
$this->assertEquals('(|(foo=bar baz zal))', Parser::assemble($filters));
159162
}
160163

161-
public function test_parser_can_process_multiple_root_nodes()
164+
public function test_parser_can_process_multiple_root_filters()
162165
{
163-
$nodes = Parser::parse('(cn=Steve)(sn=Bauman)');
166+
$filters = Parser::parse('(cn=Steve)(sn=Bauman)');
164167

165-
$this->assertCount(2, $nodes);
168+
$this->assertCount(2, $filters);
166169

167-
$this->assertEquals('cn=Steve', $nodes[0]->getRaw());
168-
$this->assertEquals('sn=Bauman', $nodes[1]->getRaw());
170+
$this->assertEquals('cn=Steve', $filters[0]->getRaw());
171+
$this->assertEquals('sn=Bauman', $filters[1]->getRaw());
169172
}
170173

171-
public function test_parser_can_parse_multiple_root_group_nodes()
174+
public function test_parser_can_parse_multiple_root_group_filters()
172175
{
173-
$nodes = Parser::parse('(|(foo=bar))(|(&(cn=Steve)(sn=Bauman))([email protected]))');
176+
$filters = Parser::parse('(|(foo=bar))(|(&(cn=Steve)(sn=Bauman))([email protected]))');
174177

175-
$this->assertCount(2, $nodes);
178+
$this->assertCount(2, $filters);
176179

177-
$this->assertInstanceOf(GroupNode::class, $nodes[0]);
178-
$this->assertInstanceOf(GroupNode::class, $nodes[1]);
180+
$this->assertInstanceOf(OrGroup::class, $filters[0]);
181+
$this->assertInstanceOf(OrGroup::class, $filters[1]);
179182

180-
$this->assertEquals('|(foo=bar)', $nodes[0]->getRaw());
181-
$this->assertEquals('|(&(cn=Steve)(sn=Bauman))([email protected])', $nodes[1]->getRaw());
183+
$this->assertEquals('|(foo=bar)', $filters[0]->getRaw());
184+
$this->assertEquals('|(&(cn=Steve)(sn=Bauman))([email protected])', $filters[1]->getRaw());
182185
}
183186

184-
public function test_parser_can_process_single_node()
187+
public function test_parser_can_process_single_filter()
185188
{
186-
$node = Parser::parse('(foo=bar)')[0];
189+
$filter = Parser::parse('(foo=bar)')[0];
187190

188-
$this->assertEquals('(foo=bar)', Parser::assemble($node));
191+
$this->assertEquals('(foo=bar)', Parser::assemble($filter));
189192
}
190193

191-
public function test_parser_throws_exception_during_assemble_when_invalid_nodes_given()
194+
public function test_parser_throws_exception_during_assemble_when_invalid_filters_given()
192195
{
193196
$this->expectException(TypeError::class);
194197

0 commit comments

Comments
 (0)