LayoutTests/inspector/protocol/backend-dispatcher-malformed-message-errors.html - WebKit - Git at Google

 <!doctype html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/protocol-test.js"></script>
 <script>
 function test()
 {
     let suite = ProtocolTest.createAsyncSuite("Protocol.MalformedMessageErrors");

     let errorCodes = {
         ParseError: -32700,
         InvalidRequest: -32600,
         MethodNotFound: -32601,
         InvalidParams: -32602,
         InternalError: -32603,
         ServerError: -32000,
     };

     function addErrorResponseTestCase(args)
     {
         let {name, description, message, expectedError} = args;

         suite.addTestCase({
             name,
             description,
             test(resolve, reject) {
                 let stringifiedMessage = (typeof message !== "string") ? JSON.stringify(message) : message;
                 ProtocolTest.log("Sending message: " + stringifiedMessage);
                 InspectorProtocol.awaitMessage(message)
                 .then(function resolved(response) {
                     ProtocolTest.log("FAIL: the backend should send a protocol error when receiving for an invalid message.");
                     reject();
                 }, function rejected(response) {
                     ProtocolTest.log("PASS: the backend should send a protocol error when receiving for an invalid message.");
                     ProtocolTest.expectThat(response.code === errorCodes[expectedError], `the reported error should be "${expectedError}" (${errorCodes[expectedError]})`);
                     ProtocolTest.log("Actual error code: " + response.code);
                     ProtocolTest.log("Actual error message: " + response.message);
                     resolve();
                 })
                 .catch(reject);
             }
         });
     }

     addErrorResponseTestCase({
         name: "UnparseableStringMessage",
         description: "The backend should return an error if a message is not valid JSON.",
         message: "not-a-json-object",
         expectedError: "ParseError"
     });

     addErrorResponseTestCase({
         name: "JSONObjectWithSyntaxError",
         description: "The backend should return an error if a message is not valid JSON.",
         message: "{name: 123,}",
         expectedError: "ParseError"
     });

     addErrorResponseTestCase({
         name: "EmptyJSONObject",
         description: "The backend should return an error if a message lacks an 'id' field.",
         message: {},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MissingIdField",
         description: "The backend should return an error if a message lacks an 'id' field.",
         message: {lucky: 123},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "IdFieldWithArrayType",
         description: "The backend should return an error if a message has a non-numeric 'id' field.",
         message: {id: []},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "IdFieldWithStringType",
         description: "The backend should return an error if a message has a non-numeric 'id' field.",
         message: {id: "123"},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MissingMethodField",
         description: "The backend should return an error if a message lacks a 'method' field.",
         message: {id: 123},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithArrayType",
         description: "The backend should return an error if a message has a non-string 'method' field.",
         message: {id: 123, method: []},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithNumberType",
         description: "The backend should return an error if a message has a non-string 'method' field.",
         message: {id: 123, method: 123},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod"},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting2",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod."},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting3",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: ".ThisIsDefinitelyNotADomainAndMethod"},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting4",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: "."},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting5",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: ".FooBar."},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithBadFormatting6",
         description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
         message: {id: 123, method: "Foo.Bar.Baz"},
         expectedError: "InvalidRequest"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithFakeDomain",
         description: "The backend should return an error if a message specifies a domain that doesn't exist.",
         message: {id: 123, method: "DummyDomain.DummyMethod"},
         expectedError: "MethodNotFound"
     });

     addErrorResponseTestCase({
         name: "MethodFieldWithFakeMethod",
         description: "The backend should return an error if a message specifies a method that doesn't exist.",
         message: {id: 123, method: "Inspector.DummyMethod"},
         expectedError: "MethodNotFound"
     });


     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
     <p>Testing the inspector backend's error handling when sending invalid messages.</p>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/protocol-test.js"></script>
	<script>
	function test()
	{
	let suite = ProtocolTest.createAsyncSuite("Protocol.MalformedMessageErrors");

	let errorCodes = {
	ParseError: -32700,
	InvalidRequest: -32600,
	MethodNotFound: -32601,
	InvalidParams: -32602,
	InternalError: -32603,
	ServerError: -32000,
	};

	function addErrorResponseTestCase(args)
	{
	let {name, description, message, expectedError} = args;

	suite.addTestCase({
	name,
	description,
	test(resolve, reject) {
	let stringifiedMessage = (typeof message !== "string") ? JSON.stringify(message) : message;
	ProtocolTest.log("Sending message: " + stringifiedMessage);
	InspectorProtocol.awaitMessage(message)
	.then(function resolved(response) {
	ProtocolTest.log("FAIL: the backend should send a protocol error when receiving for an invalid message.");
	reject();
	}, function rejected(response) {
	ProtocolTest.log("PASS: the backend should send a protocol error when receiving for an invalid message.");
	ProtocolTest.expectThat(response.code === errorCodes[expectedError], `the reported error should be "${expectedError}" (${errorCodes[expectedError]})`);
	ProtocolTest.log("Actual error code: " + response.code);
	ProtocolTest.log("Actual error message: " + response.message);
	resolve();
	})
	.catch(reject);
	}
	});
	}

	addErrorResponseTestCase({
	name: "UnparseableStringMessage",
	description: "The backend should return an error if a message is not valid JSON.",
	message: "not-a-json-object",
	expectedError: "ParseError"
	});

	addErrorResponseTestCase({
	name: "JSONObjectWithSyntaxError",
	description: "The backend should return an error if a message is not valid JSON.",
	message: "{name: 123,}",
	expectedError: "ParseError"
	});

	addErrorResponseTestCase({
	name: "EmptyJSONObject",
	description: "The backend should return an error if a message lacks an 'id' field.",
	message: {},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MissingIdField",
	description: "The backend should return an error if a message lacks an 'id' field.",
	message: {lucky: 123},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "IdFieldWithArrayType",
	description: "The backend should return an error if a message has a non-numeric 'id' field.",
	message: {id: []},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "IdFieldWithStringType",
	description: "The backend should return an error if a message has a non-numeric 'id' field.",
	message: {id: "123"},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MissingMethodField",
	description: "The backend should return an error if a message lacks a 'method' field.",
	message: {id: 123},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithArrayType",
	description: "The backend should return an error if a message has a non-string 'method' field.",
	message: {id: 123, method: []},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithNumberType",
	description: "The backend should return an error if a message has a non-string 'method' field.",
	message: {id: 123, method: 123},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod"},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting2",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: "ThisIsDefinitelyNotADomainAndMethod."},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting3",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: ".ThisIsDefinitelyNotADomainAndMethod"},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting4",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: "."},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting5",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: ".FooBar."},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithBadFormatting6",
	description: "The backend should return an error if a message has a 'method' field not formatted as 'Domain.Methodname'.",
	message: {id: 123, method: "Foo.Bar.Baz"},
	expectedError: "InvalidRequest"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithFakeDomain",
	description: "The backend should return an error if a message specifies a domain that doesn't exist.",
	message: {id: 123, method: "DummyDomain.DummyMethod"},
	expectedError: "MethodNotFound"
	});

	addErrorResponseTestCase({
	name: "MethodFieldWithFakeMethod",
	description: "The backend should return an error if a message specifies a method that doesn't exist.",
	message: {id: 123, method: "Inspector.DummyMethod"},
	expectedError: "MethodNotFound"
	});


	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Testing the inspector backend's error handling when sending invalid messages.</p>
	</body>
	</html>