1 //
2 //
3 // Copyright 2015 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include <string>
20
21 #include "gmock/gmock.h"
22 #include "gtest/gtest.h"
23
24 #include <grpc/impl/channel_arg_names.h>
25 #include <grpc/status.h>
26
27 #include "src/core/lib/channel/channel_args.h"
28 #include "test/core/end2end/end2end_tests.h"
29
30 using testing::StartsWith;
31
32 namespace grpc_core {
33 namespace {
34
TestMaxMessageLengthOnClientOnRequest(CoreEnd2endTest & test)35 void TestMaxMessageLengthOnClientOnRequest(CoreEnd2endTest& test) {
36 auto c = test.NewClientCall("/service/method").Create();
37 CoreEnd2endTest::IncomingStatusOnClient server_status;
38 CoreEnd2endTest::IncomingMetadata server_initial_metadata;
39 c.NewBatch(1)
40 .SendInitialMetadata({})
41 .SendMessage("hello world")
42 .SendCloseFromClient()
43 .RecvInitialMetadata(server_initial_metadata)
44 .RecvStatusOnClient(server_status);
45 test.Expect(1, true);
46 test.Step();
47 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
48 EXPECT_EQ(server_status.message(),
49 "CLIENT: Sent message larger than max (11 vs. 5)");
50 }
51
TestMaxMessageLengthOnServerOnRequest(CoreEnd2endTest & test)52 void TestMaxMessageLengthOnServerOnRequest(CoreEnd2endTest& test) {
53 auto c = test.NewClientCall("/service/method").Create();
54 CoreEnd2endTest::IncomingStatusOnClient server_status;
55 CoreEnd2endTest::IncomingMetadata server_initial_metadata;
56 c.NewBatch(1)
57 .SendInitialMetadata({})
58 .SendMessage("hello world")
59 .SendCloseFromClient()
60 .RecvInitialMetadata(server_initial_metadata)
61 .RecvStatusOnClient(server_status);
62 auto s = test.RequestCall(101);
63 test.Expect(101, true);
64 test.Step();
65 CoreEnd2endTest::IncomingCloseOnServer client_close;
66 CoreEnd2endTest::IncomingMessage client_message;
67 s.NewBatch(102).RecvCloseOnServer(client_close).RecvMessage(client_message);
68 test.Expect(102, true);
69 test.Expect(1, true);
70 test.Step();
71 EXPECT_EQ(s.method(), "/service/method");
72 EXPECT_TRUE(client_close.was_cancelled());
73 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
74 EXPECT_EQ(server_status.message(),
75 "SERVER: Received message larger than max (11 vs. 5)");
76 }
77
TestMaxMessageLengthOnClientOnResponse(CoreEnd2endTest & test)78 void TestMaxMessageLengthOnClientOnResponse(CoreEnd2endTest& test) {
79 auto c = test.NewClientCall("/service/method").Create();
80 CoreEnd2endTest::IncomingStatusOnClient server_status;
81 CoreEnd2endTest::IncomingMetadata server_initial_metadata;
82 CoreEnd2endTest::IncomingMessage server_message;
83 c.NewBatch(1)
84 .SendInitialMetadata({})
85 .SendCloseFromClient()
86 .RecvInitialMetadata(server_initial_metadata)
87 .RecvMessage(server_message)
88 .RecvStatusOnClient(server_status);
89 auto s = test.RequestCall(101);
90 test.Expect(101, true);
91 test.Step();
92 CoreEnd2endTest::IncomingCloseOnServer client_close;
93 s.NewBatch(102)
94 .SendInitialMetadata({})
95 .RecvCloseOnServer(client_close)
96 .SendMessage("hello world")
97 .SendStatusFromServer(GRPC_STATUS_OK, "xyz", {});
98 test.Expect(102, true);
99 test.Expect(1, true);
100 test.Step();
101 EXPECT_EQ(s.method(), "/service/method");
102 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
103 EXPECT_EQ(server_status.message(),
104 "CLIENT: Received message larger than max (11 vs. 5)");
105 }
106
TestMaxMessageLengthOnServerOnResponse(CoreEnd2endTest & test)107 void TestMaxMessageLengthOnServerOnResponse(CoreEnd2endTest& test) {
108 auto c = test.NewClientCall("/service/method").Create();
109 CoreEnd2endTest::IncomingStatusOnClient server_status;
110 CoreEnd2endTest::IncomingMetadata server_initial_metadata;
111 CoreEnd2endTest::IncomingMessage server_message;
112 c.NewBatch(1)
113 .SendInitialMetadata({})
114 .SendCloseFromClient()
115 .RecvInitialMetadata(server_initial_metadata)
116 .RecvMessage(server_message)
117 .RecvStatusOnClient(server_status);
118 auto s = test.RequestCall(101);
119 test.Expect(101, true);
120 test.Step();
121 CoreEnd2endTest::IncomingCloseOnServer client_close;
122 s.NewBatch(102)
123 .SendInitialMetadata({})
124 .RecvCloseOnServer(client_close)
125 .SendMessage("hello world")
126 .SendStatusFromServer(GRPC_STATUS_OK, "xyz", {});
127 test.Expect(102, true);
128 test.Expect(1, true);
129 test.Step();
130 EXPECT_EQ(s.method(), "/service/method");
131 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
132 EXPECT_EQ(server_status.message(),
133 "SERVER: Sent message larger than max (11 vs. 5)");
134 }
135
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnRequestViaChannelArg)136 CORE_END2END_TEST(CoreEnd2endTest,
137 MaxMessageLengthOnClientOnRequestViaChannelArg) {
138 SKIP_IF_MINSTACK();
139 SKIP_IF_CHAOTIC_GOOD();
140 InitServer(ChannelArgs());
141 InitClient(ChannelArgs().Set(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, 5));
142 TestMaxMessageLengthOnClientOnRequest(*this);
143 }
144
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnRequestViaServiceConfigWithStringJsonValue)145 CORE_END2END_TEST(
146 CoreEnd2endTest,
147 MaxMessageLengthOnClientOnRequestViaServiceConfigWithStringJsonValue) {
148 SKIP_IF_MINSTACK();
149 SKIP_IF_CHAOTIC_GOOD();
150 InitServer(ChannelArgs());
151 InitClient(ChannelArgs().Set(
152 GRPC_ARG_SERVICE_CONFIG,
153 "{\n"
154 " \"methodConfig\": [ {\n"
155 " \"name\": [\n"
156 " { \"service\": \"service\", \"method\": \"method\" }\n"
157 " ],\n"
158 " \"maxRequestMessageBytes\": \"5\"\n"
159 " } ]\n"
160 "}"));
161 TestMaxMessageLengthOnClientOnRequest(*this);
162 }
163
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnRequestViaServiceConfigWithIntegerJsonValue)164 CORE_END2END_TEST(
165 CoreEnd2endTest,
166 MaxMessageLengthOnClientOnRequestViaServiceConfigWithIntegerJsonValue) {
167 SKIP_IF_MINSTACK();
168 SKIP_IF_CHAOTIC_GOOD();
169 InitServer(ChannelArgs());
170 InitClient(ChannelArgs().Set(
171 GRPC_ARG_SERVICE_CONFIG,
172 "{\n"
173 " \"methodConfig\": [ {\n"
174 " \"name\": [\n"
175 " { \"service\": \"service\", \"method\": \"method\" }\n"
176 " ],\n"
177 " \"maxRequestMessageBytes\": 5\n"
178 " } ]\n"
179 "}"));
180 TestMaxMessageLengthOnClientOnRequest(*this);
181 }
182
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnServerOnRequestViaChannelArg)183 CORE_END2END_TEST(CoreEnd2endTest,
184 MaxMessageLengthOnServerOnRequestViaChannelArg) {
185 SKIP_IF_MINSTACK();
186 SKIP_IF_CHAOTIC_GOOD();
187 InitServer(ChannelArgs().Set(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, 5));
188 InitClient(ChannelArgs());
189 TestMaxMessageLengthOnServerOnRequest(*this);
190 }
191
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnResponseViaChannelArg)192 CORE_END2END_TEST(CoreEnd2endTest,
193 MaxMessageLengthOnClientOnResponseViaChannelArg) {
194 SKIP_IF_MINSTACK();
195 SKIP_IF_CHAOTIC_GOOD();
196 InitServer(ChannelArgs());
197 InitClient(ChannelArgs().Set(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, 5));
198 TestMaxMessageLengthOnClientOnResponse(*this);
199 }
200
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnResponseViaServiceConfigWithStringJsonValue)201 CORE_END2END_TEST(
202 CoreEnd2endTest,
203 MaxMessageLengthOnClientOnResponseViaServiceConfigWithStringJsonValue) {
204 SKIP_IF_MINSTACK();
205 SKIP_IF_CHAOTIC_GOOD();
206 InitServer(ChannelArgs());
207 InitClient(ChannelArgs().Set(
208 GRPC_ARG_SERVICE_CONFIG,
209 "{\n"
210 " \"methodConfig\": [ {\n"
211 " \"name\": [\n"
212 " { \"service\": \"service\", \"method\": \"method\" }\n"
213 " ],\n"
214 " \"maxResponseMessageBytes\": \"5\"\n"
215 " } ]\n"
216 "}"));
217 TestMaxMessageLengthOnClientOnResponse(*this);
218 }
219
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnClientOnResponseViaServiceConfigWithIntegerJsonValue)220 CORE_END2END_TEST(
221 CoreEnd2endTest,
222 MaxMessageLengthOnClientOnResponseViaServiceConfigWithIntegerJsonValue) {
223 SKIP_IF_MINSTACK();
224 SKIP_IF_CHAOTIC_GOOD();
225 InitServer(ChannelArgs());
226 InitClient(ChannelArgs().Set(
227 GRPC_ARG_SERVICE_CONFIG,
228 "{\n"
229 " \"methodConfig\": [ {\n"
230 " \"name\": [\n"
231 " { \"service\": \"service\", \"method\": \"method\" }\n"
232 " ],\n"
233 " \"maxResponseMessageBytes\": 5\n"
234 " } ]\n"
235 "}"));
236 TestMaxMessageLengthOnClientOnResponse(*this);
237 }
238
CORE_END2END_TEST(CoreEnd2endTest,MaxMessageLengthOnServerOnResponseViaChannelArg)239 CORE_END2END_TEST(CoreEnd2endTest,
240 MaxMessageLengthOnServerOnResponseViaChannelArg) {
241 SKIP_IF_MINSTACK();
242 SKIP_IF_CHAOTIC_GOOD();
243 InitServer(ChannelArgs().Set(GRPC_ARG_MAX_SEND_MESSAGE_LENGTH, 5));
244 InitClient(ChannelArgs());
245 TestMaxMessageLengthOnServerOnResponse(*this);
246 }
247
CORE_END2END_TEST(Http2Test,MaxMessageLengthOnServerOnRequestWithCompression)248 CORE_END2END_TEST(Http2Test, MaxMessageLengthOnServerOnRequestWithCompression) {
249 SKIP_IF_MINSTACK();
250 SKIP_IF_CHAOTIC_GOOD();
251 // Set limit via channel args.
252 InitServer(ChannelArgs().Set(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, 5));
253 InitClient(ChannelArgs());
254 auto c = NewClientCall("/service/method").Create();
255 IncomingStatusOnClient server_status;
256 IncomingMetadata server_initial_metadata;
257 c.NewBatch(1)
258 .SendInitialMetadata({{"grpc-internal-encoding-request", "gzip"}})
259 .SendMessage(std::string(1024, 'a'))
260 .SendCloseFromClient()
261 .RecvInitialMetadata(server_initial_metadata)
262 .RecvStatusOnClient(server_status);
263 auto s = RequestCall(101);
264 Expect(101, true);
265 Step();
266 IncomingMessage client_message;
267 IncomingCloseOnServer client_close;
268 s.NewBatch(102).RecvMessage(client_message);
269 s.NewBatch(103).RecvCloseOnServer(client_close);
270 // WARNING!!
271 // It's believed the following line (and the associated batch) is the only
272 // test we have for failing a receive operation in a batch.
273 Expect(102, false);
274 Expect(103, true);
275 Expect(1, true);
276 Step();
277 EXPECT_EQ(s.method(), "/service/method");
278 EXPECT_TRUE(client_close.was_cancelled());
279 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
280 EXPECT_THAT(server_status.message(),
281 StartsWith("SERVER: Received message larger than max"));
282 }
283
CORE_END2END_TEST(Http2Test,MaxMessageLengthOnClientOnResponseWithCompression)284 CORE_END2END_TEST(Http2Test,
285 MaxMessageLengthOnClientOnResponseWithCompression) {
286 SKIP_IF_MINSTACK();
287 SKIP_IF_CHAOTIC_GOOD();
288 // Set limit via channel args.
289 InitServer(ChannelArgs());
290 InitClient(ChannelArgs().Set(GRPC_ARG_MAX_RECEIVE_MESSAGE_LENGTH, 5));
291 auto c = NewClientCall("/service/method").Create();
292 IncomingStatusOnClient server_status;
293 IncomingMetadata server_initial_metadata;
294 IncomingMessage server_message;
295 c.NewBatch(1)
296 .SendInitialMetadata({})
297 .SendCloseFromClient()
298 .RecvInitialMetadata(server_initial_metadata)
299 .RecvMessage(server_message)
300 .RecvStatusOnClient(server_status);
301 auto s = RequestCall(101);
302 Expect(101, true);
303 Step();
304 IncomingCloseOnServer client_close;
305 s.NewBatch(102)
306 .SendInitialMetadata({{"grpc-internal-encoding-request", "gzip"}})
307 .RecvCloseOnServer(client_close)
308 .SendMessage(std::string(1024, 'a'))
309 .SendStatusFromServer(GRPC_STATUS_OK, "xyz", {});
310 Expect(102, true);
311 Expect(1, true);
312 Step();
313 EXPECT_EQ(s.method(), "/service/method");
314 EXPECT_EQ(server_status.status(), GRPC_STATUS_RESOURCE_EXHAUSTED);
315 EXPECT_THAT(server_status.message(),
316 StartsWith("CLIENT: Received message larger than max"));
317 }
318
319 } // namespace
320 } // namespace grpc_core
321