Add bazel integration and tests

.gitignore

@@ -1 +1,5 @@
-/bazel-*
+bazel-bin
+bazel-genfiles
+bazel-grpc-web
+bazel-out
+bazel-testlogs

BUILD

@@ -1,9 +0,0 @@
-cc_binary(
-  name = "protoc-gen-grpc-web",
-  srcs = [
-    "javascript/net/grpc/web/grpc_generator.cc",
-  ],
-  deps = [
-    "@com_google_protobuf//:protoc_lib"
-  ],
-)

WORKSPACE

@@ -1,7 +1,15 @@
 workspace(name = "com_github_grpc_grpc_web")
 
 http_archive(
-  name = "com_google_protobuf",
+    name = "io_bazel_rules_closure",
-  url = "https://github.com/google/protobuf/releases/download/v3.5.1/protobuf-cpp-3.5.1.zip",
+    sha256 = "a80acb69c63d5f6437b099c111480a4493bad4592015af2127a2f49fb7512d8d",
-  strip_prefix = "protobuf-3.5.1",
+    strip_prefix = "rules_closure-0.7.0",
+    urls = [
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_closure/archive/0.7.0.tar.gz",
+        "https://github.com/bazelbuild/rules_closure/archive/0.7.0.tar.gz",
+    ],
 )
+
+load("@io_bazel_rules_closure//closure:defs.bzl", "closure_repositories")
+
+closure_repositories()

javascript/net/grpc/web/BUILD.bazel

@@ -0,0 +1,141 @@
+package(default_visibility = ["//visibility:public"])
+
+load("@io_bazel_rules_closure//closure:defs.bzl", "closure_js_binary")
+load("@io_bazel_rules_closure//closure:defs.bzl", "closure_js_library")
+load("@io_bazel_rules_closure//closure:defs.bzl", "closure_js_test")
+
+closure_js_library(
+    name = "abstractclientbase",
+    srcs = [
+        "abstractclientbase.js",
+    ],
+    deps = [
+        ":clientreadablestream",
+        ":error",
+    ],
+)
+
+closure_js_library(
+    name = "clientreadablestream",
+    srcs = [
+        "clientreadablestream.js",
+    ],
+)
+
+closure_js_library(
+    name = "error",
+    srcs = [
+        "error.js",
+    ],
+)
+
+closure_js_library(
+    name = "generictransportinterface",
+    srcs = [
+        "generictransportinterface.js",
+    ],
+    deps = [
+        "@io_bazel_rules_closure//closure/library/net/streams:nodereadablestream",
+        "@io_bazel_rules_closure//closure/library/net:xhrio",
+    ],
+)
+
+closure_js_library(
+    name = "grpcwebclientbase",
+    srcs = [
+        "grpcwebclientbase.js",
+    ],
+    suppress = [
+        "checkTypes",
+        "reportUnknownTypes",
+    ],
+    deps = [
+        ":abstractclientbase",
+        ":grpcwebclientreadablestream",
+        ":statuscode",
+        "@io_bazel_rules_closure//closure/library/crypt:base64",
+        "@io_bazel_rules_closure//closure/library/net:xhrio",
+        "@io_bazel_rules_closure//closure/library/net/rpc:httpcors",
+    ],
+)
+
+closure_js_library(
+    name = "grpcwebclientreadablestream",
+    srcs = [
+        "grpcwebclientreadablestream.js",
+    ],
+    deps = [
+        ":clientreadablestream",
+        ":generictransportinterface",
+        ":grpcwebstreamparser",
+        ":status",
+        ":statuscode",
+        "@io_bazel_rules_closure//closure/library/crypt:base64",
+        "@io_bazel_rules_closure//closure/library/events:events",
+        "@io_bazel_rules_closure//closure/library/net:errorcode",
+        "@io_bazel_rules_closure//closure/library/net:eventtype",
+        "@io_bazel_rules_closure//closure/library/net:xhrio",
+        "@io_bazel_rules_closure//closure/library/net:xmlhttp",
+    ],
+    suppress = [
+        "reportUnknownTypes",
+    ],
+)
+
+closure_js_library(
+    name = "grpcwebstreamparser",
+    srcs = [
+        "grpcwebstreamparser.js",
+    ],
+    suppress = [
+        "reportUnknownTypes",
+    ],
+    deps = [
+        "@io_bazel_rules_closure//closure/library/asserts",
+        "@io_bazel_rules_closure//closure/library/net/streams:streamparser",
+    ],
+)
+
+closure_js_library(
+    name = "status",
+    srcs = [
+        "status.js",
+    ],
+)
+
+closure_js_library(
+    name = "statuscode",
+    srcs = [
+        "statuscode.js",
+    ],
+)
+
+closure_js_test(
+    name = "grpcwebclientbase_test",
+    srcs = [
+        "grpcwebclientbase_test.js",
+    ],
+    entry_points = [
+        "goog:grpc.web.GrpcWebClientBaseTest",
+    ],
+    deps = [
+        "@io_bazel_rules_closure//closure/library:testing",
+    ],
+)
+
+closure_js_test(
+    name = "grpcwebstreamparser_test",
+    srcs = [
+        "grpcwebstreamparser_test.js",
+    ],
+    entry_points = [
+        "goog:grpc.web.GrpcWebStreamParserTest",
+    ],
+    suppress = [
+        "reportUnknownTypes",
+    ],
+    deps = [
+        ":grpcwebstreamparser",
+        "@io_bazel_rules_closure//closure/library:testing",
+    ],
+)

javascript/net/grpc/web/grpcwebclientbase_test.js

@@ -0,0 +1,35 @@
+/**
+ *
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+goog.module('grpc.web.GrpcWebClientBaseTest');
+goog.setTestOnly('grpc.web.GrpcWebClientBaseTest');
+
+var testSuite = goog.require('goog.testing.testSuite');
+goog.require('goog.testing.jsunit');
+
+testSuite({
+  setUp: function() {
+  },
+
+  tearDown: function() {
+  },
+
+
+  testTrivial: function() {
+    assertEquals(1, 1);
+  },
+});

javascript/net/grpc/web/grpcwebstreamparser_test.js

@@ -0,0 +1,230 @@
+/**
+ *
+ * Copyright 2018 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+goog.module('grpc.web.GrpcWebStreamParserTest');
+goog.setTestOnly('grpc.web.GrpcWebStreamParserTest');
+
+var GrpcWebStreamParser = goog.require('grpc.web.GrpcWebStreamParser');
+var testSuite = goog.require('goog.testing.testSuite');
+goog.require('goog.testing.jsunit');
+
+var parser;
+var FrameType = GrpcWebStreamParser.FrameType;
+
+
+testSuite({
+  setUp: function() {
+    parser = new GrpcWebStreamParser();
+  },
+
+  tearDown: function() {
+  },
+
+  testInvalidTagError: function() {
+    var arr = new Uint8Array([1, 0]);
+    assertThrows(function() { parser.parse(arr.buffer); });
+  },
+
+  testInvalidInputTypeInt: function() {
+    assertThrows(function() { parser.parse(0); });
+  },
+
+  testInvalidInputTypeObject: function() {
+    assertThrows(function() { parser.parse({}); });
+  },
+
+  testInvalidInputTypeString: function() {
+    assertThrows(function() { parser.parse("abc"); });
+  },
+
+  testBasicMessage: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38, 39]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+  },
+
+  testOneMessageOneTrailer: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38, 39, 128, 0, 0, 0, 2, 40, 41]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(2, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+
+    var trailer = messages[1];
+    assertTrue(FrameType.TRAILER in trailer);
+    assertElementsEquals([40, 41], trailer[FrameType.TRAILER]);
+  },
+
+  testMultipleMessageOneTrailer: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38, 39, 0, 0, 0, 0, 3, 42, 43, 44,
+                              128, 0, 0, 0, 2, 40, 41]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(3, messages.length);
+
+    var message1 = messages[0];
+    assertTrue(FrameType.DATA in message1);
+    assertElementsEquals([38, 39], message1[FrameType.DATA]);
+
+    var message2 = messages[1];
+    assertTrue(FrameType.DATA in message2);
+    assertElementsEquals([42, 43, 44], message2[FrameType.DATA]);
+
+    var trailer = messages[2];
+    assertTrue(FrameType.TRAILER in trailer);
+    assertElementsEquals([40, 41], trailer[FrameType.TRAILER]);
+  },
+
+  testPartialMessage: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38]);
+    var messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([39]);
+    messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+  },
+
+  testMultiplePartialMessages: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38]);
+    var messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([39, 128, 0, 0]);
+    messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+
+    arr = new Uint8Array([0, 3, 40]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([41, 42]);
+    messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var trailer = messages[0];
+    assertTrue(FrameType.TRAILER in trailer);
+    assertElementsEquals([40, 41, 42], trailer[FrameType.TRAILER]);
+  },
+
+  testTrailerOnly: function() {
+    var arr = new Uint8Array([128, 0, 0, 0, 2, 40, 41]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var trailer = messages[0];
+    assertTrue(FrameType.TRAILER in trailer);
+    assertElementsEquals([40, 41], trailer[FrameType.TRAILER]);
+  },
+
+  testEmptyMessage: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 0]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([], message[FrameType.DATA]);
+  },
+
+  testEmptyMessageWithTrailer: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 0, 128, 0, 0, 0, 1, 56]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(2, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([], message[FrameType.DATA]);
+
+    var trailer = messages[1];
+    assertTrue(FrameType.TRAILER in trailer);
+    assertElementsEquals([56], trailer[FrameType.TRAILER]);
+  },
+
+  testErrorAfterFirstMessage: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38, 39]);
+    var messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+
+    arr = new Uint8Array([1, 0]);
+    assertThrows(function() { parser.parse(arr.buffer); });
+  },
+
+  testInvalidMessage: function() {
+    var arr = new Uint8Array([0, 0, 0, 0, 2, 38, 39, 40, 0, 0, 0, 0, 2, 41, 42]);
+    assertThrows(function() { parser.parse(arr.buffer); });
+  },
+
+  testEmptyArray: function() {
+    var arr = new Uint8Array([]);
+    var messages = parser.parse(arr.buffer);
+    assertNull(messages);
+  },
+
+  testMessageAfterEmptyArray: function() {
+    var arr = new Uint8Array([]);
+    var messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([0]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([0, 0, 0]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([]);
+    messages = parser.parse(arr.buffer);
+    assertNull(messages);
+
+    arr = new Uint8Array([2, 38, 39]);
+    messages = parser.parse(arr.buffer);
+    assertEquals(1, messages.length);
+
+    var message = messages[0];
+    assertTrue(FrameType.DATA in message);
+    assertElementsEquals([38, 39], message[FrameType.DATA]);
+  },
+
+});
+