Skip to content

Commit b42a0ea

Browse files
PhilDaiguillePhilDaiguille
committed
fix(lint): fix cs and phpstan
1 parent 26cf993 commit b42a0ea

2 files changed

Lines changed: 47 additions & 57 deletions

File tree

‎tests/Rules/Aria/RoleCatalogTest.php‎

Lines changed: 32 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,7 @@ public function testGetAllowedRolesReturnsNonEmptyArray(): void
1818
{
1919
$roles = RoleCatalog::getAllowedRoles();
2020

21-
self::assertIsArray($roles);
22-
self::assertNotEmpty($roles);
21+
$this->assertNotEmpty($roles);
2322
}
2423

2524
public function testGetAllowedRolesContainsKnownWaiAriaRoles(): void
@@ -40,90 +39,85 @@ public function testGetAllowedRolesContainsKnownWaiAriaRoles(): void
4039
];
4140

4241
foreach ($expected as $role) {
43-
self::assertContains($role, $roles, \sprintf('Expected role "%s" to be in the allowed roles list.', $role));
42+
$this->assertContains($role, $roles, \sprintf('Expected role "%s" to be in the allowed roles list.', $role));
4443
}
4544
}
4645

4746
public function testGetAllowedRolesContainsOnlyStrings(): void
4847
{
4948
foreach (RoleCatalog::getAllowedRoles() as $role) {
50-
self::assertIsString($role);
51-
self::assertNotEmpty($role);
49+
$this->assertNotEmpty($role);
5250
}
5351
}
5452

5553
public function testGetCatalogReturnsNonEmptyArray(): void
5654
{
5755
$catalog = RoleCatalog::getCatalog();
5856

59-
self::assertIsArray($catalog);
60-
self::assertNotEmpty($catalog);
57+
$this->assertNotEmpty($catalog);
6158
}
6259

6360
public function testGetCatalogEntriesHaveExpectedShape(): void
6461
{
6562
foreach (RoleCatalog::getCatalog() as $role => $entry) {
66-
self::assertIsString($role, 'Catalog key must be a string role name.');
67-
self::assertArrayHasKey('required_attrs', $entry, \sprintf('Role "%s" must have required_attrs.', $role));
68-
self::assertArrayHasKey('required_children', $entry, \sprintf('Role "%s" must have required_children.', $role));
69-
self::assertIsArray($entry['required_attrs']);
70-
self::assertIsArray($entry['required_children']);
63+
$this->assertArrayHasKey('required_attrs', $entry, \sprintf('Role "%s" must have required_attrs.', $role));
64+
$this->assertArrayHasKey('required_children', $entry, \sprintf('Role "%s" must have required_children.', $role));
7165
}
7266
}
7367

7468
public function testGetCatalogContainsCompositeWidgets(): void
7569
{
7670
$catalog = RoleCatalog::getCatalog();
7771

78-
self::assertArrayHasKey('table', $catalog);
79-
self::assertContains('row', $catalog['table']['required_children']);
72+
$this->assertArrayHasKey('table', $catalog);
73+
$this->assertContains('row', $catalog['table']['required_children']);
8074

81-
self::assertArrayHasKey('tablist', $catalog);
82-
self::assertContains('tab', $catalog['tablist']['required_children']);
75+
$this->assertArrayHasKey('tablist', $catalog);
76+
$this->assertContains('tab', $catalog['tablist']['required_children']);
8377

84-
self::assertArrayHasKey('list', $catalog);
85-
self::assertContains('listitem', $catalog['list']['required_children']);
78+
$this->assertArrayHasKey('list', $catalog);
79+
$this->assertContains('listitem', $catalog['list']['required_children']);
8680

87-
self::assertArrayHasKey('radiogroup', $catalog);
88-
self::assertContains('radio', $catalog['radiogroup']['required_children']);
81+
$this->assertArrayHasKey('radiogroup', $catalog);
82+
$this->assertContains('radio', $catalog['radiogroup']['required_children']);
8983

90-
self::assertArrayHasKey('tree', $catalog);
91-
self::assertContains('treeitem', $catalog['tree']['required_children']);
84+
$this->assertArrayHasKey('tree', $catalog);
85+
$this->assertContains('treeitem', $catalog['tree']['required_children']);
9286

93-
self::assertArrayHasKey('grid', $catalog);
94-
self::assertContains('row', $catalog['grid']['required_children']);
87+
$this->assertArrayHasKey('grid', $catalog);
88+
$this->assertContains('row', $catalog['grid']['required_children']);
9589

96-
self::assertArrayHasKey('listbox', $catalog);
97-
self::assertContains('option', $catalog['listbox']['required_children']);
90+
$this->assertArrayHasKey('listbox', $catalog);
91+
$this->assertContains('option', $catalog['listbox']['required_children']);
9892

99-
self::assertArrayHasKey('menu', $catalog);
100-
self::assertContains('menuitem', $catalog['menu']['required_children']);
93+
$this->assertArrayHasKey('menu', $catalog);
94+
$this->assertContains('menuitem', $catalog['menu']['required_children']);
10195

102-
self::assertArrayHasKey('menubar', $catalog);
103-
self::assertContains('menuitem', $catalog['menubar']['required_children']);
96+
$this->assertArrayHasKey('menubar', $catalog);
97+
$this->assertContains('menuitem', $catalog['menubar']['required_children']);
10498
}
10599

106100
public function testGetCatalogRolesWithRequiredAttrs(): void
107101
{
108102
$catalog = RoleCatalog::getCatalog();
109103

110-
self::assertArrayHasKey('tab', $catalog);
111-
self::assertContains('aria-selected', $catalog['tab']['required_attrs']);
104+
$this->assertArrayHasKey('tab', $catalog);
105+
$this->assertContains('aria-selected', $catalog['tab']['required_attrs']);
112106

113-
self::assertArrayHasKey('checkbox', $catalog);
114-
self::assertContains('aria-checked', $catalog['checkbox']['required_attrs']);
107+
$this->assertArrayHasKey('checkbox', $catalog);
108+
$this->assertContains('aria-checked', $catalog['checkbox']['required_attrs']);
115109

116-
self::assertArrayHasKey('radio', $catalog);
117-
self::assertContains('aria-checked', $catalog['radio']['required_attrs']);
110+
$this->assertArrayHasKey('radio', $catalog);
111+
$this->assertContains('aria-checked', $catalog['radio']['required_attrs']);
118112
}
119113

120114
public function testGetCatalogRolesWithNoRequiredAttrs(): void
121115
{
122116
$catalog = RoleCatalog::getCatalog();
123117

124118
foreach (['button', 'table', 'list', 'menu', 'menubar', 'row'] as $role) {
125-
self::assertArrayHasKey($role, $catalog);
126-
self::assertSame([], $catalog[$role]['required_attrs'], \sprintf('Role "%s" should have no required_attrs.', $role));
119+
$this->assertArrayHasKey($role, $catalog);
120+
$this->assertSame([], $catalog[$role]['required_attrs'], \sprintf('Role "%s" should have no required_attrs.', $role));
127121
}
128122
}
129123
}

‎tests/Standard/StandardRuleSetsTest.php‎

Lines changed: 15 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -24,15 +24,15 @@ public function testBasicReturnsRuleInterfaceInstances(): void
2424
{
2525
$rules = StandardRuleSets::basic();
2626

27-
self::assertNotEmpty($rules);
28-
self::assertContainsOnlyInstancesOf(RuleInterface::class, $rules);
27+
$this->assertNotEmpty($rules);
28+
$this->assertCount(5, $rules);
2929
}
3030

3131
public function testBasicContainsExpectedClasses(): void
3232
{
3333
$classes = array_map(static fn (RuleInterface $r): string => $r::class, StandardRuleSets::basic());
3434

35-
self::assertSame([
35+
$this->assertSame([
3636
ImgAltRule::class,
3737
BannedTagsRule::class,
3838
ButtonContentRule::class,
@@ -45,8 +45,8 @@ public function testRecommendedReturnsRuleInterfaceInstances(): void
4545
{
4646
$rules = StandardRuleSets::recommended();
4747

48-
self::assertNotEmpty($rules);
49-
self::assertContainsOnlyInstancesOf(RuleInterface::class, $rules);
48+
$this->assertNotEmpty($rules);
49+
$this->assertCount(15, $rules);
5050
}
5151

5252
public function testRecommendedIsSupersetOfBasic(): void
@@ -55,16 +55,16 @@ public function testRecommendedIsSupersetOfBasic(): void
5555
$recommendedClasses = array_map(static fn (RuleInterface $r): string => $r::class, StandardRuleSets::recommended());
5656

5757
foreach ($basicClasses as $class) {
58-
self::assertContains($class, $recommendedClasses, \sprintf('Recommended should include basic rule "%s".', $class));
58+
$this->assertContains($class, $recommendedClasses, \sprintf('Recommended should include basic rule "%s".', $class));
5959
}
6060
}
6161

6262
public function testStandardReturnsRuleInterfaceInstances(): void
6363
{
6464
$rules = StandardRuleSets::standard();
6565

66-
self::assertNotEmpty($rules);
67-
self::assertContainsOnlyInstancesOf(RuleInterface::class, $rules);
66+
$this->assertNotEmpty($rules);
67+
$this->assertCount(26, $rules);
6868
}
6969

7070
public function testStandardIsSupersetOfRecommended(): void
@@ -73,16 +73,16 @@ public function testStandardIsSupersetOfRecommended(): void
7373
$standardClasses = array_map(static fn (RuleInterface $r): string => $r::class, StandardRuleSets::standard());
7474

7575
foreach ($recommendedClasses as $class) {
76-
self::assertContains($class, $standardClasses, \sprintf('Standard should include recommended rule "%s".', $class));
76+
$this->assertContains($class, $standardClasses, \sprintf('Standard should include recommended rule "%s".', $class));
7777
}
7878
}
7979

8080
public function testStrictReturnsRuleInterfaceInstances(): void
8181
{
8282
$rules = StandardRuleSets::strict();
8383

84-
self::assertNotEmpty($rules);
85-
self::assertContainsOnlyInstancesOf(RuleInterface::class, $rules);
84+
$this->assertNotEmpty($rules);
85+
$this->assertGreaterThan(26, \count($rules));
8686
}
8787

8888
public function testStrictIsSupersetOfStandard(): void
@@ -91,7 +91,7 @@ public function testStrictIsSupersetOfStandard(): void
9191
$strictClasses = array_map(static fn (RuleInterface $r): string => $r::class, StandardRuleSets::strict());
9292

9393
foreach ($standardClasses as $class) {
94-
self::assertContains($class, $strictClasses, \sprintf('Strict should include standard rule "%s".', $class));
94+
$this->assertContains($class, $strictClasses, \sprintf('Strict should include standard rule "%s".', $class));
9595
}
9696
}
9797

@@ -104,11 +104,7 @@ public function testEachRuleSetContainsUniqueClasses(): void
104104
'strict' => StandardRuleSets::strict(),
105105
] as $level => $rules) {
106106
$classes = array_map(static fn (RuleInterface $r): string => $r::class, $rules);
107-
self::assertSame(
108-
array_unique($classes),
109-
$classes,
110-
\sprintf('Rule set "%s" should not contain duplicate rule classes.', $level)
111-
);
107+
$this->assertSame(array_unique($classes), $classes, \sprintf('Rule set "%s" should not contain duplicate rule classes.', $level));
112108
}
113109
}
114110

@@ -117,10 +113,10 @@ public function testInstantiateProducesNewInstancesEachCall(): void
117113
$rulesA = StandardRuleSets::basic();
118114
$rulesB = StandardRuleSets::basic();
119115

120-
self::assertCount(\count($rulesA), $rulesB);
116+
$this->assertCount(\count($rulesA), $rulesB);
121117

122118
foreach ($rulesA as $i => $ruleA) {
123-
self::assertNotSame($ruleA, $rulesB[$i], 'Each call to basic() should return fresh instances.');
119+
$this->assertNotSame($ruleA, $rulesB[$i], 'Each call to basic() should return fresh instances.');
124120
}
125121
}
126122
}

0 commit comments

Comments
 (0)