Mojo JS validation unit test should check Connection et al

Replaced the test for validation of requests and responses
with one that relies on the Connection et al classes to set
up the validators and deliver messages.

BUG=413303

Review URL: https://codereview.chromium.org/551293004

Cr-Commit-Position: refs/heads/master@{#294924}

mojo/mojo_public_tests.gypi

@@ -218,9 +218,11 @@
       'dependencies': [
         '../gin/gin.gyp:gin_test',
         'mojo_common_test_support',
+        'mojo_environment_standalone',
         'mojo_js_bindings_lib',
         'mojo_public_test_interfaces',
         'mojo_run_all_unittests',
+        'mojo_utility',
       ],
       'sources': [
         'public/js/bindings/tests/run_js_tests.cc',

mojo/public/js/bindings/connection.js

@@ -3,11 +3,15 @@
 // found in the LICENSE file.
 
 define("mojo/public/js/bindings/connection", [
+  "mojo/public/js/bindings/connector",
   "mojo/public/js/bindings/router",
-], function(router) {
+], function(connector, router) {
 
-  function Connection(handle, localFactory, remoteFactory) {
-    this.router_ = new router.Router(handle);
+  function Connection(
+      handle, localFactory, remoteFactory, routerFactory, connectorFactory) {
+    if (routerFactory === undefined)
+      routerFactory = router.Router;
+    this.router_ = new routerFactory(handle, connectorFactory);
     this.remote = new remoteFactory(this.router_);
     this.local = new localFactory(this.remote);
     this.router_.setIncomingReceiver(this.local);
@@ -33,7 +37,21 @@ define("mojo/public/js/bindings/connection", [
     return this.router_.encounteredError();
   };
 
+  // The TestConnection subclass is only intended to be used in unit tests.
+
+  function TestConnection(handle, localFactory, remoteFactory) {
+    Connection.call(this,
+                    handle,
+                    localFactory,
+                    remoteFactory,
+                    router.TestRouter,
+                    connector.TestConnector);
+  }
+
+  TestConnection.prototype = Object.create(Connection.prototype);
+
   var exports = {};
   exports.Connection = Connection;
+  exports.TestConnection = TestConnection;
   return exports;
 });

mojo/public/js/bindings/connector.js

@@ -104,7 +104,24 @@ define("mojo/public/js/bindings/connector", [
     }
   };
 
+  // The TestConnector subclass is only intended to be used in unit tests. It
+  // enables delivering a message to the pipe's handle without an async wait.
+
+  function TestConnector(handle) {
+    Connector.call(this, handle);
+  }
+
+  TestConnector.prototype = Object.create(Connector.prototype);
+
+  TestConnector.prototype.waitToReadMore_ = function() {
+  };
+
+  TestConnector.prototype.deliverMessage = function() {
+    this.readMore_(core.RESULT_OK);
+  }
+
   var exports = {};
   exports.Connector = Connector;
+  exports.TestConnector = TestConnector;
   return exports;
 });

mojo/public/js/bindings/router.js

@@ -8,8 +8,10 @@ define("mojo/public/js/bindings/router", [
   "mojo/public/js/bindings/validator",
 ], function(codec, connector, validator) {
 
-  function Router(handle) {
-    this.connector_ = new connector.Connector(handle);
+  function Router(handle, connectorFactory) {
+    if (connectorFactory === undefined)
+      connectorFactory = connector.Connector;
+    this.connector_ = new connectorFactory(handle);
     this.incomingReceiver_ = null;
     this.nextRequestID_ = 0;
     this.responders_ = {};
@@ -71,9 +73,14 @@ define("mojo/public/js/bindings/router", [
     var err = messageValidator.validateMessageHeader();
     for (var i = 0; err === noError && i < this.payloadValidators_.length; ++i)
       err = this.payloadValidators_[i](messageValidator);
-    if (err !== noError)
-      this.close();
 
+    if (err == noError)
+      this.handleValidIncomingMessage_(message);
+    else
+      this.handleInvalidIncomingMessage_(message, err);
+  };
+
+  Router.prototype.handleValidIncomingMessage_ = function(message) {
     if (message.expectsResponse()) {
       if (this.incomingReceiver_) {
         this.incomingReceiver_.acceptWithResponder(message, this);
@@ -92,7 +99,11 @@ define("mojo/public/js/bindings/router", [
       if (this.incomingReceiver_)
         this.incomingReceiver_.accept(message);
     }
-  };
+  }
+
+  Router.prototype.handleInvalidIncomingMessage_ = function(message, error) {
+    this.close();
+  }
 
   Router.prototype.handleConnectionError_ = function(result) {
     for (var each in this.responders_)
@@ -100,7 +111,25 @@ define("mojo/public/js/bindings/router", [
     this.close();
   };
 
+  // The TestRouter subclass is only intended to be used in unit tests.
+  // It defeats valid message handling and delgates invalid message handling.
+
+  function TestRouter(handle, connectorFactory) {
+    Router.call(this, handle, connectorFactory);
+  }
+
+  TestRouter.prototype = Object.create(Router.prototype);
+
+  TestRouter.prototype.handleValidIncomingMessage_ = function() {
+  };
+
+  TestRouter.prototype.handleInvalidIncomingMessage_ =
+      function(message, error) {
+        this.validationErrorHandler(error);
+      };
+
   var exports = {};
   exports.Router = Router;
+  exports.TestRouter = TestRouter;
   return exports;
 });

mojo/public/js/bindings/tests/BUILD.gn

@@ -6,11 +6,12 @@
 test("mojo_js_unittests") {
   deps = [
     "//gin:gin_test",
-    "//mojo/common/test:run_all_unittests",
     "//mojo/common/test:test_support",
-    "//mojo/environment:chromium",
-    "//mojo/public/interfaces/bindings/tests:test_interfaces",
+    "//mojo/public/cpp/environment:standalone",
     "//mojo/bindings/js",
+    "//mojo/public/interfaces/bindings/tests:test_interfaces",
+    "//mojo/common/test:run_all_unittests",
+    "//mojo/public/cpp/utility",
   ]
 
   sources = [ "run_js_tests.cc" ]

mojo/public/js/bindings/tests/DEPS

@@ -3,4 +3,5 @@ include_rules = [
   "+gin",
   "+v8",
   "+mojo/bindings/js/core.h",
+  "+mojo/bindings/js/support.h",
 ]

mojo/public/js/bindings/tests/run_js_tests.cc

@@ -10,6 +10,8 @@
 #include "gin/test/file_runner.h"
 #include "gin/test/gtest.h"
 #include "mojo/bindings/js/core.h"
+#include "mojo/bindings/js/support.h"
+#include "mojo/public/cpp/environment/environment.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
@@ -21,6 +23,7 @@ class TestRunnerDelegate : public gin::FileRunnerDelegate {
   TestRunnerDelegate() {
     AddBuiltinModule(gin::Console::kModuleName, gin::Console::GetModule);
     AddBuiltinModule(Core::kModuleName, Core::GetModule);
+    AddBuiltinModule(Support::kModuleName, Support::GetModule);
   }
 
  private:
@@ -28,6 +31,7 @@ class TestRunnerDelegate : public gin::FileRunnerDelegate {
 };
 
 void RunTest(std::string test, bool run_until_idle) {
+  Environment env;
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.AppendASCII("mojo")

mojo/public/js/bindings/validation_unittests.js

@@ -9,10 +9,26 @@ define([
     "mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom",
     "mojo/public/js/bindings/buffer",
     "mojo/public/js/bindings/codec",
+    "mojo/public/js/bindings/connection",
+    "mojo/public/js/bindings/connector",
+    "mojo/public/js/bindings/core",
     "mojo/public/js/bindings/tests/validation_test_input_parser",
+    "mojo/public/js/bindings/router",
     "mojo/public/js/bindings/validator",
-  ], function(
-    console, file, expect, testInterface, buffer, codec, parser, validator) {
+], function(console,
+            file,
+            expect,
+            testInterface,
+            buffer,
+            codec,
+            connection,
+            connector,
+            core,
+            parser,
+            router,
+            validator) {
+
+  var noError = validator.validationError.NONE;
 
   function checkTestMessageParser() {
     function TestMessageParserFailure(message, input) {
@@ -196,11 +212,18 @@ define([
     return contents.trim();
   }
 
+  function checkValidationResult(testFile, err) {
+    var actualResult = (err === noError) ? "PASS" : err;
+    var expectedResult = readTestExpected(testFile);
+    if (actualResult != expectedResult)
+      console.log("[Test message validation failed: " + testFile + " ]");
+    expect(actualResult).toEqual(expectedResult);
+  }
+
   function testMessageValidation(key, filters) {
     var testFiles = getMessageTestFiles(key);
     expect(testFiles.length).toBeGreaterThan(0);
 
-    var noError = validator.validationError.NONE;
     for (var i = 0; i < testFiles.length; i++) {
       // TODO(hansmuller): Temporarily skipping array pointer overflow tests.
       if (testFiles[i].indexOf("overflow") != -1) {
@@ -217,11 +240,7 @@ define([
       for (var j = 0; err === noError && j < filters.length; ++j)
         err = filters[j](messageValidator);
 
-      var actualResult = (err === noError) ? "PASS" : err;
-      var expectedResult = readTestExpected(testFiles[i]);
-      if (actualResult != expectedResult)
-        console.log("[Test message validation failed: " + testFiles[i] + " ]");
-      expect(actualResult).toEqual(expectedResult);
+      checkValidationResult(testFiles[i], err);
     }
   }
 
@@ -235,14 +254,49 @@ define([
         testInterface.ConformanceTestInterfaceStub.prototype.validator]);
   }
 
-  function testIntegrationMessageValidation() {
-    testMessageValidation("integration_", [
-        testInterface.IntegrationTestInterface1Stub.prototype.validator,
-        testInterface.IntegrationTestInterface2Proxy.prototype.validator]);
+  function testIntegratedMessageValidation() {
+    var testFiles = getMessageTestFiles("integration_");
+    expect(testFiles.length).toBeGreaterThan(0);
+
+    for (var i = 0; i < testFiles.length; i++) {
+      // TODO(hansmuller): Temporarily skipping array pointer overflow tests.
+      if (testFiles[i].indexOf("overflow") != -1) {
+        console.log("[Skipping " + testFiles[i] + "]");
+        continue;
+      }
+
+      var testMessage = readTestMessage(testFiles[i]);
+      var handles = new Array(testMessage.handleCount);
+      var testMessagePipe = new core.createMessagePipe();
+      expect(testMessagePipe.result).toBe(core.RESULT_OK);
+
+      var writeMessageValue = core.writeMessage(
+          testMessagePipe.handle0,
+          new Uint8Array(testMessage.buffer.arrayBuffer),
+          new Array(testMessage.handleCount),
+          core.WRITE_MESSAGE_FLAG_NONE);
+      expect(writeMessageValue).toBe(core.RESULT_OK);
+
+      var testConnection = new connection.TestConnection(
+          testMessagePipe.handle1,
+          testInterface.IntegrationTestInterface1Stub,
+          testInterface.IntegrationTestInterface2Proxy);
+
+      var validationError = noError;
+      testConnection.router_.validationErrorHandler = function(err) {
+        validationError = err;
+      }
+
+      testConnection.router_.connector_.deliverMessage();
+      checkValidationResult(testFiles[i], validationError);
+
+      testConnection.close();
+      expect(core.close(testMessagePipe.handle0)).toBe(core.RESULT_OK);
+    }
   }
 
   expect(checkTestMessageParser()).toBeNull();
   testConformanceMessageValidation();
-  testIntegrationMessageValidation();
+  testIntegratedMessageValidation();
   this.result = "PASS";
 });