| <!DOCTYPE html> |
| <html> |
| <head> |
| <script src="../../http/tests/inspector/resources/inspector-test.js"></script> |
| <script> |
| function test() |
| { |
| let suite = InspectorTest.createAsyncSuite("Protocol.BackendInvocationReturnValues"); |
| let dummyCallback = () => {}; |
| |
| // Test behavior for promise-based callbacks. |
| |
| suite.addTestCase({ |
| name: "ResolveCommandPromiseOnSuccess.call", |
| description: "Backend command's returned promise should be resolved if the command is successful.", |
| test(resolve, reject) { |
| let returnValue = RuntimeAgent.evaluate("42"); |
| |
| InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(returnValue instanceof Promise)) |
| reject(); |
| |
| returnValue.then(function resolved(result) { |
| InspectorTest.log("PASS: A successful command invocation's promise should be resolved."); |
| resolve(); |
| }, function rejected(result) { |
| InspectorTest.log("FAIL: A successful command invocation's promise should be resolved."); |
| reject(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "ResolveCommandPromiseOnSuccess.invoke", |
| description: "Backend command's returned promise should be resolved if the command is successful.", |
| test(resolve, reject) { |
| let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"}); |
| |
| InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(returnValue instanceof Promise)) |
| reject(); |
| |
| returnValue.then(function resolved(result) { |
| InspectorTest.log("PASS: A successful command invocation's promise should be resolved."); |
| resolve(); |
| }, function rejected(result) { |
| InspectorTest.log("FAIL: A successful command invocation's promise should be resolved."); |
| reject(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithInvalidArguments.call", |
| description: "Backend command's returned promise should be rejected if the command has invalid arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate(42); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithInvalidArguments.invoke", |
| description: "Backend command's returned promise should be rejected if the command has invalid arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate.invoke({expression: 42}); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithMissingArguments.call", |
| description: "Backend command's returned promise should be rejected if the command lacks required arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate(); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithMissingArguments.invoke.MissingObject", |
| description: "Backend command's returned promise should be rejected if the command lacks required arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate.invoke(); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithMissingArguments.invoke.NonObject", |
| description: "Backend command's returned promise should be rejected if the command lacks required arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate.invoke("test"); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithMissingArguments.invoke.EmptyObject", |
| description: "Backend command's returned promise should be rejected if the command lacks required arguments.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.evaluate.invoke({}); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "RejectCommandPromiseWithExtraArgumentThatIsNotCallback.call", |
| description: "Backend command's returned promise should be rejected if the command has an extra argument that is not a callback.", |
| test(resolve, reject) { |
| let result = RuntimeAgent.enable(1); |
| |
| InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback."); |
| // If a promise wasn't returned, we can't test the rest so just die. |
| if (!(result instanceof Promise)) |
| reject(); |
| |
| result.then(function resolved(result) { |
| InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected."); |
| reject(); |
| }, function rejected(result) { |
| InspectorTest.log("PASS: An invalid command invocation's promise should be rejected."); |
| resolve(); |
| }); |
| } |
| }); |
| |
| // Test behavior for function-based callbacks. |
| |
| suite.addTestCase({ |
| name: "ReturnNothingIfCallback.call", |
| description: "Backend commands should not return anything if a callback is supplied.", |
| test(resolve, reject) { |
| let returnValue = RuntimeAgent.evaluate("41", dummyCallback); |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback."); |
| resolve(); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "ReturnNothingIfCallback.invoke", |
| description: "Backend commands should not return anything if a callback is supplied.", |
| test(resolve, reject) { |
| let returnValue = RuntimeAgent.evaluate.invoke({expression: "41"}, dummyCallback); |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback."); |
| resolve(); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithResultOnSuccess.call", |
| description: "Backend command callback should be invoked with a result if the command is successful.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate("42", function(error, result) { |
| InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter."); |
| InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters."); |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithResultOnSuccess.invoke", |
| description: "Backend command callback should be invoked with a result if the command is successful.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"}, function(error, result) { |
| InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter."); |
| InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters."); |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForInvalidArguments.call", |
| description: "Backend command callback should be invoked with an error if the command has invalid arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate(42, function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForInvalidArguments.invoke", |
| description: "Backend command callback should be invoked with an error if the command has invalid arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate.invoke({expression: 42}, function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForMissingArguments.call", |
| description: "Backend command callback should be invoked with an error if the command lacks required arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate(function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForMissingArguments.invoke.MissingObject", |
| description: "Backend command callback should be invoked with an error if the command lacks required arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate.invoke(undefined, function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForMissingArguments.invoke.NonObject", |
| description: "Backend command callback should be invoked with an error if the command lacks required arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate.invoke("test", function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "InvokeCallbackWithErrorForMissingArguments.invoke.EmptyObject", |
| description: "Backend command callback should be invoked with an error if the command lacks required arguments.", |
| test(resolve, reject) { |
| let initialState = 1; |
| let returnValue = RuntimeAgent.evaluate.invoke({}, function callback(error) { |
| InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter."); |
| InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter."); |
| |
| initialState++; |
| resolve(); |
| }); |
| |
| InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback."); |
| InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously."); |
| } |
| }); |
| |
| suite.runTestCasesAndFinish(); |
| } |
| </script> |
| </head> |
| <body onload="runTest()"> |
| <p>Testing the inspector backend's return values when invoking a protocol command in various ways.</p> |
| </body> |
| </html> |