-
Notifications
You must be signed in to change notification settings - Fork 5
/
TableContext.php
408 lines (382 loc) · 13.2 KB
/
TableContext.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
<?php
declare(strict_types = 1);
namespace LoversOfBehat\TableExtension\Context;
use Behat\Gherkin\Node\TableNode;
use LoversOfBehat\TableExtension\AssertArraySubset;
use LoversOfBehat\TableExtension\Exception\NoArraySubsetException;
use LoversOfBehat\TableExtension\Exception\TableNotFoundException;
class TableContext extends RawTableContext
{
/**
* Checks that there is at least 1 table on the page.
*
* @Then I should see a table
*/
public function assertTable(): void
{
if ($this->getTableCount()) {
return;
}
throw new \RuntimeException('There are no tables present on the page.');
}
/**
* Checks that there are no tables on the page.
*
* @Then I should not see a table
*/
public function assertNoTable(): void
{
$count = $this->getTableCount();
if ($count === 0) {
return;
}
throw new \RuntimeException("There are $count tables on the page, but none should be present.");
}
/**
* Checks that the given table is present on the page.
*
* @Then I should see the :name table
*/
public function assertNamedTable(string $name): void
{
$this->getTable($name);
}
/**
* Checks that the given table is not present on the page.
*
* @Then I should not see the :name table
*/
public function assertNoNamedTable(string $name): void
{
try {
$this->getTable($name);
} catch (TableNotFoundException $e) {
return;
}
throw new \RuntimeException("The $name table was found in the page but it was not expected to be.");
}
/**
* Checks that the expected number of tables is present in the page.
*
* @Then /^I should see (\d+) (?:table|tables)$/
*/
public function assertTables(int $count): void
{
$actual = $this->getTableCount();
if ($count === $actual) {
return;
}
throw new \RuntimeException("There are $actual tables on the page instead of the expected $count.");
}
/**
* Checks that a table exists in the page with the given number of columns.
*
* @param int $count
* The expected number of columns.
*
* @Then I should see a table with :count column(s)
*/
public function assertTableWithColumnCountExists(int $count): void
{
$this->assertTable();
foreach ($this->getTables() as $table) {
if ($table->getColumnCount() === $count) {
return;
}
}
throw new TableNotFoundException("No table with $count columns is present on the page.");
}
/**
* Checks that a table exists in the page with the given number of rows.
*
* @param int $count
* The expected number of rows.
*
* @Then I should see a table with :count row(s)
*/
public function assertTableWithRowCountExists(int $count): void
{
$this->assertTable();
foreach ($this->getTables() as $table) {
if ($table->getRowCount() === $count) {
return;
}
}
throw new \RuntimeException("No table with $count rows is present on the page.");
}
/**
* Checks that the given table has the given number of columns.
*
* @param string $name
* The human readable name for the table.
* @param int $count
* The expected number of columns.
*
* @Then the :name table should have :count column(s)
*/
public function assertTableColumnCount(string $name, int $count): void
{
$table = $this->getTable($name);
$actual = $table->getColumnCount();
if ($actual === $count) {
return;
}
throw new \RuntimeException("The $name table should have $count columns but it has $actual columns.");
}
/**
* Checks that the given table does not have the given number of columns.
*
* @param string $name
* The human readable name for the table.
* @param int $count
* The unexpected number of columns.
*
* @Then the :name table should not have :count column(s)
*/
public function assertNoTableColumnCount(string $name, int $count): void
{
$table = $this->getTable($name);
$actual = $table->getColumnCount();
if ($actual === $count) {
throw new \RuntimeException("The $name table should not have $count columns.");
}
}
/**
* Checks that the given table has the given number of rows.
*
* @param string $name
* The human readable name for the table.
* @param int $count
* The expected number of rows.
*
* @Then the :name table should have :count row(s)
*/
public function assertTableRowCount(string $name, int $count): void
{
$table = $this->getTable($name);
$actual = $table->getRowCount();
if ($actual === $count) {
return;
}
throw new \RuntimeException("The $name table should have $count rows but it has $actual rows.");
}
/**
* Checks that the given table does not have the given number of rows.
*
* @param string $name
* The human readable name for the table.
* @param int $count
* The unexpected number of rows.
*
* @Then the :name table should not have :count row(s)
*/
public function assertNoTableRowCount(string $name, int $count): void
{
$table = $this->getTable($name);
$actual = $table->getRowCount();
if ($actual === $count) {
throw new \RuntimeException("The $name table should not have $count rows.");
}
}
/**
* Checks that the given table contains the given data.
*
* This checks that the data is present in the table, ignoring row and column ordering.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that is expected to be present in the table.
*
* @Then the :name table should contain:
*/
public function assertTableData(string $name, TableNode $data): void
{
$table = $this->getTable($name);
$this->assertArraySubset($data->getRows(), $table->getData());
}
/**
* Checks that the given table does not contain the given data.
*
* This checks that the data is not present in the table, ignoring row and column ordering.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that is expected to be present in the table.
*
* @Then the :name table should not contain:
*/
public function assertNoTableData(string $name, TableNode $data): void
{
try {
$this->assertTableData($name, $data);
throw new \RuntimeException("A table with the given data is present on the page, but should not be.");
} catch (NoArraySubsetException $e) {
}
}
/**
* Checks that the given table matches the given structure and data.
*
* @param string $name
* The human readable name for the table.
* @param \Behat\Gherkin\Node\TableNode $data
* The expected structure and data of the table.
*
* @Then the :name table should be:
*/
public function assertExactTableData(string $name, TableNode $data): void
{
$table = $this->getTable($name);
if ($table->getData() !== $data->getRows()) {
throw new \RuntimeException("The table $name doesn't match the expected data.");
}
}
/**
* Checks that the given table contains the given non-consecutive columns, identified by headers.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that is expected to be present in the table, with the first row identifying the columns to match.
*
* @Then the :name table should contain the following column(s):
*/
public function assertTableColumnData(string $name, TableNode $data): void
{
$table = $this->getTable($name);
$this->assertArraySubset($data->getColumnsHash(), array_values($table->getColumnData($data->getRow(0))));
}
/**
* Checks that the given table contains any column with the given data
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that is expected to be present in the table.
*
* @Then the :name table should contain a column with the following data:
*/
public function assertTableAnyColumnData(string $name, TableNode $data): void
{
$table = $this->getTable($name);
$rows = $table->getData();
// Convert rows of columns to columns of rows.
$columns = array_map(null, ...$rows);
foreach ($columns as $column) {
if (!empty($column) && !is_array($column)) {
// The array_map() above will convert a single column of data to
// a single value, so we need to convert it back to an array.
$column = [$column];
}
try {
if ($data->getColumn(0) === $column) {
return;
}
} catch (NoArraySubsetException $e) {
}
}
throw new \RuntimeException("No column was found with the exact row data given.");
}
/**
* Checks that the given table does not contain the given non-consecutive columns, identified by headers.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that should not be present in the table, with the first row identifying the columns to match.
*
* @Then the :name table should not contain the following column(s):
*/
public function assertNoTableColumnData(string $name, TableNode $data): void
{
try {
$this->assertTableColumnData($name, $data);
throw new \RuntimeException("A table with the given column data is present on the page, but should not be.");
} catch (NoArraySubsetException $e) {
}
}
/**
* Checks that the given table contains the given non-consecutive rows, identified by headers.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that is expected to be present in the table, with the first column identifying the rows to match.
*
* @Then the :name table should contain the following row(s):
*/
public function assertTableRowData(string $name, TableNode $data): void
{
$table = $this->getTable($name);
$this->assertArraySubset($data->getRowsHash(), $table->getRowData($data->getColumn(0)));
}
/**
* Checks that the given table does not contain the given non-consecutive rows, identified by headers.
*
* @param string $name
* The human readable name for the table.
* @param TableNode $data
* The data that should not be present in the table, with the first column identifying the rows to match.
*
* @Then the :name table should not contain the following row(s):
*/
public function assertNoTableRowData(string $name, TableNode $data): void
{
try {
$this->assertTableRowData($name, $data);
} catch (NoArraySubsetException $e) {
return;
}
throw new \RuntimeException("A table with the given row data is present in the page but it was not expected to be.");
}
/**
* Checks that a table with the given number of columns does not exist in the page.
*
* @param int $count
* The number of columns.
*
* @Then I should not see a table with :count column(s)
*/
public function assertNoColumnCount(int $count): void
{
foreach ($this->getTables() as $table) {
if ($table->getColumnCount() === $count) {
throw new \RuntimeException("A table with $count columns is present on the page, but should not be.");
}
}
}
/**
* Checks that a table with the given number of rows does not exist in the page.
*
* @param int $count
* The number of rows.
*
* @Then I should not see a table with :count row(s)
*/
public function assertNoRowCount(int $count): void
{
foreach ($this->getTables() as $table) {
if ($table->getRowCount() === $count) {
throw new \RuntimeException("A table with $count rows is present on the page, but should not be.");
}
}
}
/**
* Checks that the given array contains the given subset.
*
* @param array $subset
* The subset that is expected to exist in the array.
* @param array $array
* The array.
* @param bool $strict
* Whether to perform strict data type checking when comparing the two arrays.
*
* @throws NoArraySubsetException
*/
protected function assertArraySubset(array $subset, array $array, bool $strict = false): void
{
$assert = new AssertArraySubset($subset, $strict);
$assert->evaluate($array);
}
}