Web Inspector: SyncTestSuite should complain if passed an async setup/test/teardown...
[WebKit-https.git] / LayoutTests / inspector / unit-tests / sync-test-suite.html
1 <!doctype html>
2 <html>
3 <head>
4 <script src="../../http/tests/inspector/resources/protocol-test.js"></script>
5 <script>
6 function test()
7 {
8     ProtocolTest.suppressStackTraces = true;
9
10     try {
11         let result = new SyncTestSuite(this);
12         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires name argument.");
13     } catch (e) {
14         ProtocolTest.log("PASS: instantiating SyncTestSuite requires name argument.");
15     }
16
17     try {
18         let result = new SyncTestSuite(this, {});
19         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires string name argument.");
20     } catch (e) {
21         ProtocolTest.log("PASS: instantiating SyncTestSuite requires string name argument.");
22     }
23
24     try {
25         let result = new SyncTestSuite(this, "      ");
26         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires non-whitespace name argument.");
27     } catch (e) {
28         ProtocolTest.log("PASS: instantiating SyncTestSuite requires non-whitespace name argument.");
29     }
30
31     try {
32         let result = new SyncTestSuite("something", {});
33         ProtocolTest.log("FAIL: instantiating SyncTestSuite requires test harness argument.");
34     } catch (e) {
35         ProtocolTest.log("PASS: instantiating SyncTestSuite requires test harness argument.");
36     }
37
38     let badArgsSuite = ProtocolTest.createSyncSuite("dummy");
39     try {
40         badArgsSuite.addTestCase();
41         ProtocolTest.log("FAIL: should not be able to add empty test case.");
42     } catch (e) {
43         ProtocolTest.log("PASS: should not be able to add empty test case.");
44     }
45     try {
46         badArgsSuite.addTestCase("string");
47         ProtocolTest.log("FAIL: should not be able to add non-object test case.");
48     } catch (e) {
49         ProtocolTest.log("PASS: should not be able to add non-object test case.");
50     }
51     try {
52         badArgsSuite.addTestCase({
53             name: {},
54             test: () => true,
55         });
56         ProtocolTest.log("FAIL: test case should require string name.");
57     } catch (e) {
58         ProtocolTest.log("PASS: test case should require string name.");
59     }
60     try {
61         badArgsSuite.addTestCase({
62             name: "        ",
63             test() {},
64         });
65         ProtocolTest.log("FAIL: test case should require non-whitespace name.");
66     } catch (e) {
67         ProtocolTest.log("PASS: test case should require non-whitespace name.");
68     }
69     try {
70         badArgsSuite.addTestCase({
71             name: "foo",
72             test: null,
73         });
74         ProtocolTest.log("FAIL: test case should require test function.");
75     } catch (e) {
76         ProtocolTest.log("PASS: test case should require test function.");
77     }
78     try {
79         badArgsSuite.addTestCase({
80             name: "foo",
81             test() {},
82             setup: "astd"
83         });
84         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
85     } catch (e) {
86         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
87     }
88     try {
89         badArgsSuite.addTestCase({
90             name: "foo",
91             test() {},
92             setup: 123
93         });
94         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
95     } catch (e) {
96         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
97     }
98     try {
99         badArgsSuite.addTestCase({
100             name: "foo",
101             test() {},
102             setup: Promise.resolve()
103         });
104         ProtocolTest.log("FAIL: should not be able to specify non-Function `setup` parameter.");
105     } catch (e) {
106         ProtocolTest.log("PASS: should not be able to specify non-Function `setup` parameter.");
107     }
108     try {
109         badArgsSuite.addTestCase({
110             name: "foo",
111             test() {},
112             teardown: "astd"
113         });
114         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
115     } catch (e) {
116         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
117     }
118     try {
119         badArgsSuite.addTestCase({
120             name: "foo",
121             test() {},
122             teardown: 123
123         });
124         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
125     } catch (e) {
126         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
127     }
128     try {
129         badArgsSuite.addTestCase({
130             name: "foo",
131             test() {},
132             teardown: Promise.resolve()
133         });
134         ProtocolTest.log("FAIL: should not be able to specify non-Function `teardown` parameter.");
135     } catch (e) {
136         ProtocolTest.log("PASS: should not be able to specify non-Function `teardown` parameter.");
137     }
138     try {
139         badArgsSuite.addTestCase({
140             name: "foo",
141             async test() {},
142         });
143         ProtocolTest.log("FAIL: should not be able to specify async `test` parameter.");
144     } catch (e) {
145         ProtocolTest.log("PASS: should not be able to specify async `test` parameter.");
146     }
147     try {
148         badArgsSuite.addTestCase({
149             name: "foo",
150             async setup() {},
151             test() {},
152         });
153         ProtocolTest.log("FAIL: should not be able to specify async `setup` parameter.");
154     } catch (e) {
155         ProtocolTest.log("PASS: should not be able to specify async `setup` parameter.");
156     }
157     try {
158         badArgsSuite.addTestCase({
159             name: "foo",
160             test() {},
161             async teardown() {},
162         });
163         ProtocolTest.log("FAIL: should not be able to specify async `teardown` parameter.");
164     } catch (e) {
165         ProtocolTest.log("PASS: should not be able to specify async `teardown` parameter.");
166     }
167
168     let runEmptySuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunEmptySuite");
169     try {
170         runEmptySuite.runTestCases();
171         ProtocolTest.log("FAIL: should not be able to run empty test suite.");
172     } catch (e) {
173         ProtocolTest.log("PASS: should not be able to run empty test suite.");
174     }
175
176     let runTwiceSuite = ProtocolTest.createSyncSuite("SyncTestSuite.RunTwiceSuite");
177     runTwiceSuite.addTestCase({
178         name: "DummyTest0",
179         description: "Check that a suite can't run more than once.",
180         test: () => true,
181     });
182
183     try {
184         let result = runTwiceSuite.runTestCases();
185         ProtocolTest.expectThat(result === true, "Return value of runTwiceSuite.runTestCases() should be true when all tests pass.");
186
187         runTwiceSuite.runTestCases(); // Try to trigger an error.
188         ProtocolTest.log("FAIL: should not be able to run a test suite twice.");
189     } catch (e) {
190         ProtocolTest.log("PASS: should not be able to run a test suite twice.");
191     }
192
193     let thrownError = new Error({"token": 666});
194
195     let sequentialExecutionSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SequentialExecution");
196     sequentialExecutionSuite.addTestCase({
197         name: "DummyTest1",
198         description: "Check test case execution order.",
199         test: () => true
200     });
201     sequentialExecutionSuite.addTestCase({
202         name: "DummyTest2",
203         description: "Check test case execution order.",
204         test: () => true
205     });
206     sequentialExecutionSuite.addTestCase({
207         name: "DummyTest3",
208         description: "Check test case execution order.",
209         test: () => true
210     });
211     sequentialExecutionSuite.addTestCase({
212         name: "FailingTest4",
213         description: "Check that test fails by throwing an Error instance.",
214         test() { throw thrownError; }
215     });
216
217     let result = sequentialExecutionSuite.runTestCases();
218     ProtocolTest.expectThat(result === false, "Return value of sequentialExecutionSuite.runTestCases() should be false when a test case fails.");
219     ProtocolTest.expectThat(sequentialExecutionSuite.runCount === 4, "sequentialExecutionSuite should have executed four tests.");
220     ProtocolTest.expectThat(sequentialExecutionSuite.passCount === 3, "sequentialExecutionSuite should have passed three tests.");
221     ProtocolTest.expectThat(sequentialExecutionSuite.failCount === 1, "sequentialExecutionSuite should have failed 1 test.");
222     ProtocolTest.expectThat(sequentialExecutionSuite.skipCount === 0, "sequentialExecutionSuite should have skipped zero tests.");
223
224     let abortOnFailureSuite = ProtocolTest.createSyncSuite("SyncTestSuite.AbortOnFailure");
225     abortOnFailureSuite.addTestCase({
226         name: "PassingTest5",
227         description: "This test is a dummy.",
228         test: () => true
229     });
230     abortOnFailureSuite.addTestCase({
231         name: "FailingTest6",
232         description: "This test should fail by explicitly returning `false`.",
233         test: () => false
234     });
235     abortOnFailureSuite.addTestCase({
236         name: "PassingTest7",
237         description: "This test should not executed when the preceding test fails.",
238         test: () => true
239     });
240
241     abortOnFailureSuite.runTestCases();
242     ProtocolTest.expectThat(result === false, "Return value of abortOnFailureSuite.runTestCases() should be false when a test case fails.");
243     ProtocolTest.expectThat(abortOnFailureSuite.runCount === 2, "abortOnFailureSuite should have executed two tests.");
244     ProtocolTest.expectThat(abortOnFailureSuite.passCount === 1, "abortOnFailureSuite should have passed one test.");
245     ProtocolTest.expectThat(abortOnFailureSuite.failCount === 1, "abortOnFailureSuite should have failed one test.");
246     ProtocolTest.expectThat(abortOnFailureSuite.skipCount === 1, "abortOnFailureSuite should have skipped one test.");
247
248     let setupAndTeardownSymbol = Symbol("sync-suite-setup-and-teardown-token");
249     window[setupAndTeardownSymbol] = 0;
250
251     let setupAndTeardownTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupAndTeardown");
252     setupAndTeardownTestSuite.addTestCase({
253         name: "TestWithSetupAndTeardown",
254         description: "Check execution order for setup and teardown actions.",
255         setup: () => {
256             window[setupAndTeardownSymbol] = 1;
257             return true;
258         },
259         test() {
260             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 1, "Test should see side effects of running setup() action.");
261             window[setupAndTeardownSymbol] = 2;
262             return true;
263         },
264         teardown: () => {
265             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 2, "Teardown should see side effects of running setup() action.");
266             window[setupAndTeardownSymbol] = 3;
267             return true;
268         }
269     });
270     setupAndTeardownTestSuite.addTestCase({
271         name: "TestRunningAfterTeardown",
272         description: "Check execution order for test after a teardown action.",
273         test() {
274             ProtocolTest.expectThat(window[setupAndTeardownSymbol] === 3, "Test should see side effects of previous test's teardown() action.");
275             return true;
276         },
277     });
278
279     setupAndTeardownTestSuite.runTestCases();
280
281     let setupExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupException");
282     setupExceptionTestSuite.addTestCase({
283         name: "TestWithExceptionDuringSetup",
284         description: "Check execution order for setup action that throws an exception.",
285         setup: () => { throw new Error() },
286         test() {
287             ProtocolTest.assert(false, "Test should not execute if its setup action threw an exception.");
288             return false;
289         },
290         teardown: () => {
291             ProtocolTest.assert(false, "Teardown action should not execute if its setup action threw an exception.");
292             return false;           
293         }
294     });
295     setupExceptionTestSuite.runTestCases();
296
297     let setupFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.SetupFailure");
298     setupFailureTestSuite.addTestCase({
299         name: "TestWithFailureDuringSetup",
300         description: "Check execution order for setup action that has failed.",
301         setup: () => false,
302         test() {
303             ProtocolTest.assert(false, "Test should not execute if its setup action returned false.")
304             return false;
305         },
306         teardown: () => {
307             ProtocolTest.assert(false, "Teardown action should not execute if its setup action returned false.")
308             return false;           
309         }
310     });
311     setupFailureTestSuite.runTestCases();
312
313     let teardownExceptionTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownException");
314     teardownExceptionTestSuite.addTestCase({
315         name: "TestWithExceptionDuringTeardown",
316         description: "Check execution order for teardown action that throws an exception.",
317         test: () => true,
318         teardown: () => { throw new Error() }
319     });
320     teardownExceptionTestSuite.addTestCase({
321         name: "TestAfterTeardownException",
322         descrption: "Check execution order for test after previous test's teardown throws an exception",
323         setup: () => {
324             ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action threw an exception.");
325             return false;
326         },
327         test() {
328             ProtocolTest.assert(false, "Test should not execute if previous test's teardown action threw an exception.");
329             return false;
330         }
331     });
332     teardownExceptionTestSuite.runTestCases();
333
334     let teardownFailureTestSuite = ProtocolTest.createSyncSuite("SyncTestSuite.TeardownFailure");
335     teardownFailureTestSuite.addTestCase({
336         name: "TestWithExceptionDuringTeardown",
337         description: "Check execution order for teardown action that has failed.",
338         test: () => true,
339         teardown: () => false,
340     });
341     teardownFailureTestSuite.addTestCase({
342         name: "TestAfterTeardownException",
343         descrption: "Check execution order for test after previous test's teardown throws an exception",
344         setup: () => {
345             ProtocolTest.assert(false, "Setup action should not execute if previous test's teardown action failed.");
346             return false;
347         },
348         test() {
349             ProtocolTest.assert(false, "Test should not execute if previous test's teardown action failed.");
350             return false;
351         }
352     });
353     teardownFailureTestSuite.runTestCases();
354
355     ProtocolTest.completeTest();
356 }
357 </script>
358 </head>
359 <body onLoad="runTest()">
360 </body>
361 </html>