Web Inspector: add protocol test for existing error handling performed by the backend
[WebKit-https.git] / LayoutTests / inspector / protocol / backend-dispatcher-malformed-message-errors.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     let suite = ProtocolTest.createAsyncSuite("Protocol.MalformedMessageErrors");
9
10     let errorCodes = {
11         ParseError: -32700,
12         InvalidRequest: -32600,
13         MethodNotFound: -32601,
14         InvalidParams: -32602,
15         InternalError: -32603,
16         ServerError: -32000,
17     };
18
19     function addErrorResponseTestCase(args)
20     {
21         let {name, description, message, expectedError} = args;
22
23         suite.addTestCase({
24             name,
25             description,
26             test: (resolve, reject) => {
27                 let stringifiedMessage = (typeof message !== "string") ? JSON.stringify(message) : message;
28                 ProtocolTest.log("Sending message: " + stringifiedMessage);
29                 InspectorProtocol.awaitMessage(message)
30                 .then(function resolved(response) {
31                     ProtocolTest.log("FAIL: the backend should send a protocol error when receiving for an invalid message.");
32                     reject();
33                 }, function rejected(response) {
34                     ProtocolTest.log("PASS: the backend should send a protocol error when receiving for an invalid message.");
35                     ProtocolTest.expectThat(response.code === errorCodes[expectedError], `the reported error should be "${expectedError}" (${errorCodes[expectedError]})`);
36                     ProtocolTest.log("Actual error code: " + response.code);
37                     ProtocolTest.log("Actual error message: " + response.message);
38                     resolve();
39                 })
40                 .catch(reject);
41             }
42         });
43     }
44
45     addErrorResponseTestCase({
46         name: "UnparseableStringMessage",
47         description: "The backend should return an error if a message is not valid JSON.",
48         message: "not-a-json-object",
49         expectedError: "ParseError"
50     });
51
52     addErrorResponseTestCase({
53         name: "JSONObjectWithSyntaxError",
54         description: "The backend should return an error if a message is not valid JSON.",
55         message: "{name: 123,}",
56         expectedError: "ParseError"
57     });
58
59     addErrorResponseTestCase({
60         name: "EmptyJSONObject",
61         description: "The backend should return an error if a message lacks an 'id' field.",
62         message: {},
63         expectedError: "InvalidRequest"
64     });
65
66     addErrorResponseTestCase({
67         name: "MissingIdField",
68         description: "The backend should return an error if a message lacks an 'id' field.",
69         message: {lucky: 123},
70         expectedError: "InvalidRequest"
71     });
72
73     addErrorResponseTestCase({
74         name: "IdFieldWithArrayType",
75         description: "The backend should return an error if a message has a non-numeric 'id' field.",
76         message: {id: []},
77         expectedError: "InvalidRequest"
78     });
79
80     addErrorResponseTestCase({
81         name: "IdFieldWithStringType",
82         description: "The backend should return an error if a message has a non-numeric 'id' field.",
83         message: {id: "123"},
84         expectedError: "InvalidRequest"
85     });
86
87     addErrorResponseTestCase({
88         name: "MissingMethodField",
89         description: "The backend should return an error if a message lacks a 'method' field.",
90         message: {id: 123},
91         expectedError: "InvalidRequest"
92     });
93
94     addErrorResponseTestCase({
95         name: "MethodFieldWithArrayType",
96         description: "The backend should return an error if a message has a non-string 'method' field.",
97         message: {id: 123, method: []},
98         expectedError: "InvalidRequest"
99     });
100
101     addErrorResponseTestCase({
102         name: "MethodFieldWithNumberType",
103         description: "The backend should return an error if a message has a non-string 'method' field.",
104         message: {id: 123, method: 123},
105         expectedError: "InvalidRequest"
106     });
107
108     addErrorResponseTestCase({
109         name: "MethodFieldWithBadFormatting",
110         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
111         message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod"},
112         expectedError: "InvalidRequest"
113     });
114
115     addErrorResponseTestCase({
116         name: "MethodFieldWithBadFormatting2",
117         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
118         message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod."},
119         expectedError: "InvalidRequest"
120     });
121
122     addErrorResponseTestCase({
123         name: "MethodFieldWithBadFormatting3",
124         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
125         message: {id: 123, method: ".ThisIsDefinitelyNotADomainAndMethod"},
126         expectedError: "InvalidRequest"
127     });
128
129     addErrorResponseTestCase({
130         name: "MethodFieldWithBadFormatting4",
131         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
132         message: {id: 123, method: "."},
133         expectedError: "InvalidRequest"
134     });
135
136     addErrorResponseTestCase({
137         name: "MethodFieldWithBadFormatting5",
138         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
139         message: {id: 123, method: ".FooBar."},
140         expectedError: "InvalidRequest"
141     });
142
143     addErrorResponseTestCase({
144         name: "MethodFieldWithBadFormatting6",
145         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
146         message: {id: 123, method: "Foo.Bar.Baz"},
147         expectedError: "InvalidRequest"
148     });
149
150     addErrorResponseTestCase({
151         name: "MethodFieldWithFakeDomain",
152         description: "The backend should return an error if a message specifies a domain that doesn't exist.",
153         message: {id: 123, method: "DummyDomain.DummyMethod"},
154         expectedError: "MethodNotFound"
155     });
156
157     addErrorResponseTestCase({
158         name: "MethodFieldWithFakeMethod",
159         description: "The backend should return an error if a message specifies a method that doesn't exist.",
160         message: {id: 123, method: "Inspector.DummyMethod"},
161         expectedError: "MethodNotFound"
162     });
163
164
165     suite.runTestCasesAndFinish();
166 }
167 </script>
168 </head>
169 <body onload="runTest()">
170     <p>Testing the inspector backend's error handling when sending invalid messages.</p>
171 </body>
172 </html>