1// gRPC-Web library
2import { grpc } from "@improbable-eng/grpc-web";
3
4import { debug } from "../../../client/grpc-web/src/debug";
5import { assert } from "chai";
6// Generated Test Classes
7import { PingRequest, PingResponse } from "../_proto/improbable/grpcweb/test/test_pb";
8import { TestService } from "../_proto/improbable/grpcweb/test/test_pb_service";
9import { DEBUG } from "./util";
10import { headerTrailerCombos, runWithHttp1AndHttp2 } from "./testRpcCombinations";
11import { conditionallyRunTestSuite, SuiteEnum } from "../suiteUtils";
12
13if (process.env.DISABLE_WEBSOCKET_TESTS) {
14  console.log(`Skipping "clientWebsockets" suite as "DISABLE_WEBSOCKET_TESTS" is set`);
15  describe("skipping client-streaming (websockets)", () => {
16    it("should skip client-streaming request tests", (done) => {
17      done();
18    });
19  });
20} else {
21  conditionallyRunTestSuite(SuiteEnum.clientWebsockets, () => {
22    runWithHttp1AndHttp2(({testHostUrl}) => {
23      describe("client-streaming (websockets)", () => {
24        headerTrailerCombos((withHeaders, withTrailers) => {
25          it("should make a client-streaming request", (done) => {
26            let didGetOnHeaders = false;
27            let didGetMessage = false;
28            const client = grpc.client(TestService.PingStream, {
29              debug: DEBUG,
30              host: testHostUrl,
31              transport: grpc.WebsocketTransport(),
32            });
33            client.onHeaders((headers: grpc.Metadata) => {
34              DEBUG && debug("headers", headers);
35              didGetOnHeaders = true;
36              if (withHeaders) {
37                assert.deepEqual(headers.get("HeaderTestKey1"), ["ServerValue1"]);
38                assert.deepEqual(headers.get("HeaderTestKey2"), ["ServerValue2"]);
39              }
40            });
41            client.onMessage((message: PingResponse) => {
42              assert.ok(message instanceof PingResponse);
43              assert.deepEqual(message.getValue(), "one,two");
44              didGetMessage = true;
45            });
46            client.onEnd((status: grpc.Code, statusMessage: string, trailers: grpc.Metadata) => {
47              DEBUG && debug("status", status, "statusMessage", statusMessage);
48              assert.strictEqual(status, grpc.Code.OK, "expected OK (0)");
49              assert.strictEqual(statusMessage, "", "expected no message");
50              if (withTrailers) {
51                assert.deepEqual(trailers.get("TrailerTestKey1"), ["ServerValue1"]);
52                assert.deepEqual(trailers.get("TrailerTestKey2"), ["ServerValue2"]);
53              }
54              assert.ok(didGetOnHeaders, "didGetOnHeaders");
55              assert.ok(didGetMessage, "didGetMessage");
56              done();
57            });
58            client.start();
59
60            const pingOne = new PingRequest();
61            pingOne.setSendHeaders(withHeaders);
62            pingOne.setSendTrailers(withTrailers);
63            pingOne.setValue(`one`);
64            client.send(pingOne);
65
66            const pingTwo = new PingRequest();
67            pingTwo.setValue(`two`);
68            client.send(pingTwo);
69
70            client.finishSend();
71          });
72        });
73      });
74
75      describe("bidirectional (websockets)", () => {
76        headerTrailerCombos((withHeaders, withTrailers) => {
77          it("should make a bidirectional request that is terminated by the client", (done) => {
78            let didGetOnHeaders = false;
79            let counter = 1;
80            let lastMessage = `helloworld:${counter}`;
81            const ping = new PingRequest();
82            ping.setSendHeaders(withHeaders);
83            ping.setSendTrailers(withTrailers);
84            ping.setValue(lastMessage);
85
86            const client = grpc.client(TestService.PingPongBidi, {
87              debug: DEBUG,
88              host: testHostUrl,
89              transport: grpc.WebsocketTransport(),
90            });
91            client.onHeaders((headers: grpc.Metadata) => {
92              DEBUG && debug("headers", headers);
93              didGetOnHeaders = true;
94              if (withHeaders) {
95                assert.deepEqual(headers.get("HeaderTestKey1"), ["ServerValue1"]);
96                assert.deepEqual(headers.get("HeaderTestKey2"), ["ServerValue2"]);
97              }
98            });
99            client.onMessage((message: PingResponse) => {
100              assert.ok(message instanceof PingResponse);
101              assert.deepEqual(message.getValue(), lastMessage);
102
103              if (counter === 10) {
104                client.finishSend();
105              } else {
106                counter++;
107                lastMessage = `helloworld:${counter}`;
108                const ping = new PingRequest();
109                ping.setValue(lastMessage);
110                client.send(ping);
111              }
112            });
113            client.onEnd((status: grpc.Code, statusMessage: string, trailers: grpc.Metadata) => {
114              DEBUG && debug("status", status, "statusMessage", statusMessage);
115              assert.strictEqual(status, grpc.Code.OK, "expected OK (0)");
116              assert.strictEqual(statusMessage, "", "expected no message");
117              if (withTrailers) {
118                assert.deepEqual(trailers.get("TrailerTestKey1"), ["ServerValue1"]);
119                assert.deepEqual(trailers.get("TrailerTestKey2"), ["ServerValue2"]);
120              }
121              assert.ok(didGetOnHeaders, "didGetOnHeaders");
122
123              assert.equal(counter, 10, "counter should have been incremented to 10");
124              done();
125            });
126            client.start();
127
128            // send initial message
129            client.send(ping);
130          });
131        });
132
133        headerTrailerCombos((withHeaders, withTrailers) => {
134          it("should make a bidirectional request that is terminated by the server", (done) => {
135            let didGetOnHeaders = false;
136            let didGetOnMessage = false;
137
138            let counter = 1;
139            let lastMessage = `helloworld:${counter}`;
140            const ping = new PingRequest();
141            ping.setSendHeaders(withHeaders);
142            ping.setSendTrailers(withTrailers);
143            ping.setValue(lastMessage);
144
145            const client = grpc.client(TestService.PingPongBidi, {
146              debug: DEBUG,
147              host: testHostUrl,
148              transport: grpc.WebsocketTransport(),
149            });
150            client.onHeaders((headers: grpc.Metadata) => {
151              DEBUG && debug("headers", headers);
152              didGetOnHeaders = true;
153              if (withHeaders) {
154                assert.deepEqual(headers.get("HeaderTestKey1"), ["ServerValue1"]);
155                assert.deepEqual(headers.get("HeaderTestKey2"), ["ServerValue2"]);
156              }
157            });
158            client.onMessage((message: PingResponse) => {
159              assert.ok(message instanceof PingResponse);
160              assert.deepEqual(message.getValue(), lastMessage);
161
162              if (counter === 10) {
163                const ping = new PingRequest();
164                ping.setFailureType(PingRequest.FailureType.CODE);
165                ping.setErrorCodeReturned(grpc.Code.OK);
166                client.send(ping);
167              } else {
168                counter++;
169                lastMessage = `helloworld:${counter}`;
170                const ping = new PingRequest();
171                ping.setValue(lastMessage);
172                client.send(ping);
173              }
174            });
175            client.onEnd((status: grpc.Code, statusMessage: string, trailers: grpc.Metadata) => {
176              DEBUG && debug("status", status, "statusMessage", statusMessage);
177              assert.strictEqual(status, grpc.Code.OK, "expected OK (0)");
178              assert.strictEqual(statusMessage, "", "expected no message");
179              if (withTrailers) {
180                assert.deepEqual(trailers.get("TrailerTestKey1"), ["ServerValue1"]);
181                assert.deepEqual(trailers.get("TrailerTestKey2"), ["ServerValue2"]);
182              }
183              assert.ok(didGetOnHeaders, "didGetOnHeaders");
184
185              assert.equal(counter, 10, "counter should have been incremented to 10");
186              done();
187            });
188            client.start();
189
190            // send initial message
191            client.send(ping);
192          });
193        });
194      });
195    });
196  });
197}
198