proxygen
DownstreamTransactionTest.cpp
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2015-present, Facebook, Inc.
3  * All rights reserved.
4  *
5  * This source code is licensed under the BSD-style license found in the
6  * LICENSE file in the root directory of this source tree. An additional grant
7  * of patent rights can be found in the PATENTS file in the same directory.
8  *
9  */
10 #include <folly/io/async/EventBase.h>
11 #include <proxygen/lib/http/codec/SPDYConstants.h>
12 #include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
13 #include <proxygen/lib/http/codec/test/TestUtils.h>
14 #include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
15 #include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
16 #include <proxygen/lib/test/TestAsyncTransport.h>
17 #include <folly/io/async/test/MockAsyncTransport.h>
18 
19 
20 
21 using namespace proxygen;
22 using namespace testing;
23 
24 using folly::IOBuf;
25 using folly::IOBufQueue;
26 using std::string;
27 using std::unique_ptr;
28 using std::vector;
29 
30 class DownstreamTransactionTest : public testing::Test {
31  public:
32  DownstreamTransactionTest() {}
33 
34  void SetUp() override {
35  EXPECT_CALL(transport_, describe(_))
36  .WillRepeatedly(Return());
37  }
38 
39  void setupRequestResponseFlow(HTTPTransaction* txn, uint32_t size,
40  bool delayResponse=false) {
41  EXPECT_CALL(handler_, setTransaction(txn));
42  EXPECT_CALL(handler_, detachTransaction());
43  EXPECT_CALL(transport_, detach(txn));
44  if (delayResponse) {
45  EXPECT_CALL(handler_, onHeadersComplete(_));
46  } else {
47  EXPECT_CALL(handler_, onHeadersComplete(_))
48  .WillOnce(Invoke([=](std::shared_ptr<HTTPMessage> /*msg*/) {
49  auto response = makeResponse(200);
50  txn->sendHeaders(*response.get());
51  txn->sendBody(makeBuf(size));
52  txn->sendEOM();
53  }));
54  }
55  EXPECT_CALL(transport_, sendHeaders(txn, _, _, _))
56  .WillOnce(Invoke([=](Unused, const HTTPMessage& headers, Unused, Unused) {
57  EXPECT_EQ(headers.getStatusCode(), 200);
58  }));
59  EXPECT_CALL(transport_, sendBody(txn, _, false, false))
60  .WillRepeatedly(Invoke([=](Unused, std::shared_ptr<folly::IOBuf> body,
61  Unused, Unused) {
62  auto cur = body->computeChainDataLength();
63  sent_ += cur;
64  return cur;
65  }));
66  if (delayResponse) {
67  EXPECT_CALL(transport_, sendEOM(txn, _));
68  } else {
69  EXPECT_CALL(transport_, sendEOM(txn, _))
70  .WillOnce(InvokeWithoutArgs([=]() {
71  CHECK_EQ(sent_, size);
72  txn->onIngressBody(makeBuf(size), 0);
73  txn->onIngressEOM();
74  return 5;
75  }));
76  }
77  EXPECT_CALL(handler_, onBody(_))
78  .WillRepeatedly(Invoke([=](std::shared_ptr<folly::IOBuf> body) {
79  received_ += body->computeChainDataLength();
80  }));
81  EXPECT_CALL(handler_, onEOM())
82  .WillOnce(InvokeWithoutArgs([=] {
83  CHECK_EQ(received_, size);
84  }));
85  EXPECT_CALL(transport_, notifyPendingEgress())
86  .WillOnce(InvokeWithoutArgs([=] {
87  txn->onWriteReady(size, 1);
88  }))
89  .WillOnce(DoDefault()); // The second call is for sending the eom
90 
91  txn->setHandler(&handler_);
92  }
93 
94  protected:
95  folly::EventBase eventBase_;
96  folly::HHWheelTimer::UniquePtr transactionTimeouts_{
97  folly::HHWheelTimer::newTimer(
98  &eventBase_,
99  std::chrono::milliseconds(folly::HHWheelTimer::DEFAULT_TICK_INTERVAL),
100  folly::AsyncTimeout::InternalEnum::NORMAL,
101  std::chrono::milliseconds(500))};
102  MockHTTPTransactionTransport transport_;
103  StrictMock<MockHTTPHandler> handler_;
104  HTTP2PriorityQueue txnEgressQueue_;
105  uint32_t received_{0};
106  uint32_t sent_{0};
107 };
108 
113 TEST_F(DownstreamTransactionTest, SimpleCallbackForwarding) {
114  // flow control is disabled
115  HTTPTransaction txn(
116  TransportDirection::DOWNSTREAM,
117  HTTPCodec::StreamID(1), 1, transport_,
118  txnEgressQueue_, transactionTimeouts_.get(),
119  std::chrono::milliseconds(500));
120  setupRequestResponseFlow(&txn, 100);
121 
122  txn.onIngressHeadersComplete(makeGetRequest());
123  eventBase_.loop();
124 }
125 
129 TEST_F(DownstreamTransactionTest, RegularWindowUpdate) {
130  HTTPTransaction txn(
131  TransportDirection::DOWNSTREAM,
132  HTTPCodec::StreamID(1), 1, transport_,
133  txnEgressQueue_, transactionTimeouts_.get(),
134  std::chrono::milliseconds(500),
135  nullptr,
136  true, // flow control enabled
137  400,
138  spdy::kInitialWindow);
139  uint32_t reqBodySize = 220;
140  setupRequestResponseFlow(&txn, reqBodySize);
141 
142  // test that the window update is generated
143  EXPECT_CALL(transport_, sendWindowUpdate(_, reqBodySize));
144 
145  // run the test
146  txn.onIngressHeadersComplete(makeGetRequest());
147  eventBase_.loop();
148 }
149 
150 TEST_F(DownstreamTransactionTest, NoWindowUpdate) {
151  HTTPTransaction txn(
152  TransportDirection::DOWNSTREAM,
153  HTTPCodec::StreamID(1), 1, transport_,
154  txnEgressQueue_, transactionTimeouts_.get(),
155  std::chrono::milliseconds(500),
156  nullptr,
157  true, // flow control enabled
158  450, // more than 2x req size
159  spdy::kInitialWindow);
160  uint32_t reqBodySize = 220;
161  setupRequestResponseFlow(&txn, reqBodySize, true);
162 
163  EXPECT_CALL(transport_, sendWindowUpdate(_, reqBodySize))
164  .Times(0);
165 
166  // run the test
167  txn.onIngressHeadersComplete(makeGetRequest());
168  txn.onIngressBody(makeBuf(reqBodySize), 0);
169  txn.onIngressEOM();
170  auto response = makeResponse(200);
171  txn.sendHeaders(*response.get());
172  txn.sendBody(makeBuf(reqBodySize));
173  txn.sendEOM();
174  eventBase_.loop();
175 }
176 
181 TEST_F(DownstreamTransactionTest, WindowIncrease) {
182  // set initial window size higher than per-stream window
183  HTTPTransaction txn(
184  TransportDirection::DOWNSTREAM,
185  HTTPCodec::StreamID(1), 1, transport_,
186  txnEgressQueue_, transactionTimeouts_.get(),
187  std::chrono::milliseconds(500),
188  nullptr,
189  true, // flow control enabled
190  spdy::kInitialWindow,
191  spdy::kInitialWindow);
192  uint32_t reqSize = 500;
193  setupRequestResponseFlow(&txn, reqSize);
194 
195  // we expect the difference from the per stream window and the initial window,
196  // together with the bytes sent in the request
197  uint32_t perStreamWindow = spdy::kInitialWindow + 1024 * 1024;
198  uint32_t expectedWindowUpdate =
199  perStreamWindow - spdy::kInitialWindow;
200  EXPECT_CALL(transport_, sendWindowUpdate(_, expectedWindowUpdate));
201 
202  // use a higher window
203  txn.setReceiveWindow(perStreamWindow);
204 
205  txn.onIngressHeadersComplete(makeGetRequest());
206  eventBase_.loop();
207 }
208 
213 TEST_F(DownstreamTransactionTest, WindowDecrease) {
214  // set initial window size higher than per-stream window
215  HTTPTransaction txn(
216  TransportDirection::DOWNSTREAM,
217  HTTPCodec::StreamID(1), 1, transport_,
218  txnEgressQueue_, transactionTimeouts_.get(),
219  std::chrono::milliseconds(500),
220  nullptr,
221  true, // flow control enabled
222  spdy::kInitialWindow,
223  spdy::kInitialWindow);
224  setupRequestResponseFlow(&txn, 500);
225 
226  // in this case, there should be no window update, as we decrease the window
227  // below the number of bytes we're sending
228  EXPECT_CALL(transport_, sendWindowUpdate(_, _)).Times(0);
229 
230  // use a smaller window
231  uint32_t perStreamWindow = spdy::kInitialWindow - 1000;
232  txn.setReceiveWindow(perStreamWindow);
233 
234  txn.onIngressHeadersComplete(makeGetRequest());
235  eventBase_.loop();
236 }
237 
238 TEST_F(DownstreamTransactionTest, ParseErrorCbs) {
239  // Test where the transaction gets on parse error and then a body
240  // callback. This is possible because codecs are stateless between
241  // frames.
242 
243  HTTPTransaction txn(
244  TransportDirection::DOWNSTREAM,
245  HTTPCodec::StreamID(1), 1, transport_,
246  txnEgressQueue_, transactionTimeouts_.get(),
247  std::chrono::milliseconds(500));
248 
249  HTTPException err(HTTPException::Direction::INGRESS, "test");
250  err.setHttpStatusCode(400);
251 
252  InSequence dummy;
253 
254  EXPECT_CALL(handler_, setTransaction(&txn));
255  EXPECT_CALL(handler_, onError(_))
256  .WillOnce(Invoke([] (const HTTPException& ex) {
257  ASSERT_EQ(ex.getDirection(), HTTPException::Direction::INGRESS);
258  ASSERT_EQ(std::string(ex.what()), "test");
259  }));
260  // onBody() is suppressed since ingress is complete after ingress onError()
261  // onEOM() is suppressed since ingress is complete after ingress onError()
262  EXPECT_CALL(transport_, sendAbort(_, _));
263  EXPECT_CALL(handler_, detachTransaction());
264  EXPECT_CALL(transport_, detach(&txn));
265 
266  txn.setHandler(&handler_);
267  txn.onError(err);
268  // Since the transaction is already closed for ingress, giving it
269  // ingress body causes the transaction to be aborted and closed
270  // immediately.
271  txn.onIngressBody(makeBuf(10), 0);
272 
273  eventBase_.loop();
274 }
275 
276 TEST_F(DownstreamTransactionTest, DetachFromNotify) {
277  unique_ptr<StrictMock<MockHTTPHandler>> handler(
278  new StrictMock<MockHTTPHandler>);
279 
280  HTTPTransaction txn(
281  TransportDirection::DOWNSTREAM,
282  HTTPCodec::StreamID(1), 1, transport_,
283  txnEgressQueue_, transactionTimeouts_.get(),
284  std::chrono::milliseconds(500));
285 
286  InSequence dummy;
287 
288  EXPECT_CALL(*handler, setTransaction(&txn));
289  EXPECT_CALL(*handler, onHeadersComplete(_))
290  .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
291  auto response = makeResponse(200);
292  txn.sendHeaders(*response.get());
293  txn.sendBody(makeBuf(10));
294  }));
295  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
296  .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
297  EXPECT_EQ(headers.getStatusCode(), 200);
298  }));
299  EXPECT_CALL(transport_, notifyEgressBodyBuffered(10));
300  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-10))
301  .WillOnce(InvokeWithoutArgs([&] () {
302  txn.setHandler(nullptr);
303  handler.reset();
304  }));
305  EXPECT_CALL(transport_, detach(&txn));
306 
307  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");
308 
309  txn.setHandler(handler.get());
310  txn.onIngressHeadersComplete(makeGetRequest());
311  txn.onError(err);
312 }
313 
314 TEST_F(DownstreamTransactionTest, DeferredEgress) {
315  EXPECT_CALL(transport_, describe(_))
316  .WillRepeatedly(Return());
317  EXPECT_CALL(transport_, notifyPendingEgress())
318  .WillRepeatedly(Return());
319 
320  HTTPTransaction txn(
321  TransportDirection::DOWNSTREAM,
322  HTTPCodec::StreamID(1), 1, transport_,
323  txnEgressQueue_, transactionTimeouts_.get(),
324  std::chrono::milliseconds(500),
325  nullptr, true, 10, 10);
326 
327  InSequence dummy;
328 
329  EXPECT_CALL(handler_, setTransaction(&txn));
330  EXPECT_CALL(handler_, onHeadersComplete(_))
331  .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
332  auto response = makeResponse(200);
333  txn.sendHeaders(*response.get());
334  txn.sendBody(makeBuf(10));
335  txn.sendBody(makeBuf(20));
336  }));
337  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
338  .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
339  EXPECT_EQ(headers.getStatusCode(), 200);
340  }));
341 
342  // when enqueued
343  EXPECT_CALL(transport_, notifyEgressBodyBuffered(10));
344  EXPECT_CALL(handler_, onEgressPaused());
345  // sendBody
346  EXPECT_CALL(transport_, notifyEgressBodyBuffered(20));
347 
348  txn.setHandler(&handler_);
349  txn.onIngressHeadersComplete(makeGetRequest());
350 
351  // onWriteReady, send, then dequeue (SPDY window now full)
352  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-20));
353 
354  EXPECT_EQ(txn.onWriteReady(20, 1), false);
355 
356  // enqueued after window update
357  EXPECT_CALL(transport_, notifyEgressBodyBuffered(20));
358 
359  txn.onIngressWindowUpdate(20);
360 
361  // Buffer released on error
362  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-20));
363  EXPECT_CALL(handler_, onError(_));
364  EXPECT_CALL(handler_, detachTransaction());
365  EXPECT_CALL(transport_, detach(&txn));
366 
367  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");
368  txn.onError(err);
369 }
370 
371 TEST_F(DownstreamTransactionTest, InternalError) {
372  unique_ptr<StrictMock<MockHTTPHandler>> handler(
373  new StrictMock<MockHTTPHandler>);
374 
375  HTTPTransaction txn(
376  TransportDirection::DOWNSTREAM,
377  HTTPCodec::StreamID(1), 1, transport_,
378  txnEgressQueue_, transactionTimeouts_.get(),
379  std::chrono::milliseconds(500));
380 
381  InSequence dummy;
382 
383  EXPECT_CALL(*handler, setTransaction(&txn));
384  EXPECT_CALL(*handler, onHeadersComplete(_))
385  .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
386  auto response = makeResponse(200);
387  txn.sendHeaders(*response.get());
388  }));
389  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
390  .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
391  EXPECT_EQ(headers.getStatusCode(), 200);
392  }));
393  EXPECT_CALL(transport_, sendAbort(&txn, ErrorCode::INTERNAL_ERROR));
394  EXPECT_CALL(*handler, detachTransaction());
395  EXPECT_CALL(transport_, detach(&txn));
396 
397  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");
398 
399  txn.setHandler(handler.get());
400  txn.onIngressHeadersComplete(makeGetRequest());
401  txn.sendAbort();
402 }
403 
404 TEST_F(DownstreamTransactionTest, UnpausedFlowControlViolation) {
405  StrictMock<MockHTTPHandler> handler;
406 
407  InSequence enforceOrder;
408  HTTPTransaction txn(
409  TransportDirection::DOWNSTREAM,
410  HTTPCodec::StreamID(1), 1, transport_,
411  txnEgressQueue_, transactionTimeouts_.get(),
412  std::chrono::milliseconds(500),
413  nullptr,
414  true, // flow control enabled
415  400,
416  spdy::kInitialWindow);
417 
418  EXPECT_CALL(handler, setTransaction(&txn));
419  EXPECT_CALL(handler, onHeadersComplete(_));
420  EXPECT_CALL(transport_, sendAbort(&txn, ErrorCode::FLOW_CONTROL_ERROR));
421  EXPECT_CALL(handler, detachTransaction());
422  EXPECT_CALL(transport_, detach(&txn));
423 
424  txn.setHandler(&handler);
425  txn.onIngressHeadersComplete(makePostRequest(401));
426  txn.onIngressBody(makeBuf(401), 0);
427 }
proxygen::HTTPTransaction::setHandler
virtual void setHandler(Handler *handler)
Definition: HTTPTransaction.h:477
DownstreamTransactionTest::transport_
MockHTTPTransactionTransport transport_
Definition: DownstreamTransactionTest.cpp:102
proxygen::HTTPTransaction::onWriteReady
bool onWriteReady(uint32_t maxEgress, double ratio)
Definition: HTTPTransaction.cpp:801
proxygen::makeBuf
std::unique_ptr< folly::IOBuf > makeBuf(uint32_t size)
Definition: TestUtils.cpp:36
ASSERT_EQ
#define ASSERT_EQ(val1, val2)
Definition: gtest.h:1956
proxygen::HTTPMessage::getStatusCode
uint16_t getStatusCode() const
Definition: HTTPMessage.cpp:340
EXPECT_EQ
#define EXPECT_EQ(val1, val2)
Definition: gtest.h:1922
proxygen::HTTPTransaction::onIngressBody
void onIngressBody(std::unique_ptr< folly::IOBuf > chain, uint16_t padding)
Definition: HTTPTransaction.cpp:217
folly::HHWheelTimer::DEFAULT_TICK_INTERVAL
static int DEFAULT_TICK_INTERVAL
Definition: HHWheelTimer.h:163
proxygen::makePostRequest
std::unique_ptr< HTTPMessage > makePostRequest(uint32_t contentLength)
Definition: TestUtils.cpp:124
testing::InvokeWithoutArgs
PolymorphicAction< internal::InvokeWithoutArgsAction< FunctionImpl > > InvokeWithoutArgs(FunctionImpl function_impl)
Definition: gmock-actions.h:1168
handler
void handler(int, siginfo_t *, void *)
Definition: StackTraceTest.cpp:74
folly::size
constexpr auto size(C const &c) -> decltype(c.size())
Definition: Access.h:45
folly::HHWheelTimer::newTimer
static UniquePtr newTimer(Args &&...args)
Definition: HHWheelTimer.h:61
proxygen::HTTPException::getDirection
Direction getDirection() const
Definition: HTTPException.h:67
testing::Invoke
PolymorphicAction< internal::InvokeAction< FunctionImpl > > Invoke(FunctionImpl function_impl)
Definition: gmock-more-actions.h:114
dummy
void dummy()
Definition: DwarfBenchmark.cpp:21
proxygen::HTTPTransaction::sendBody
virtual void sendBody(std::unique_ptr< folly::IOBuf > body)
Definition: HTTPTransaction.cpp:784
proxygen::HTTPTransaction::sendHeaders
virtual void sendHeaders(const HTTPMessage &headers)
Definition: HTTPTransaction.cpp:780
folly::HHWheelTimer::UniquePtr
std::unique_ptr< HHWheelTimer, Destructor > UniquePtr
Definition: HHWheelTimer.h:57
proxygen::makeResponse
std::unique_ptr< HTTPMessage > makeResponse(uint16_t statusCode)
Definition: TestUtils.cpp:147
DownstreamTransactionTest::setupRequestResponseFlow
void setupRequestResponseFlow(HTTPTransaction *txn, uint32_t size, bool delayResponse=false)
Definition: DownstreamTransactionTest.cpp:39
testing::DoDefault
internal::DoDefaultAction DoDefault()
Definition: gmock-actions.h:1099
DownstreamTransactionTest::handler_
StrictMock< MockHTTPHandler > handler_
Definition: DownstreamTransactionTest.cpp:103
string
const char * string
Definition: Conv.cpp:212
transport_
AsyncFizzClient::UniquePtr transport_
Definition: FizzClientCommand.cpp:206
proxygen::makeGetRequest
std::unique_ptr< HTTPMessage > makeGetRequest()
Definition: TestUtils.cpp:98
EXPECT_CALL
#define EXPECT_CALL(obj, call)
Definition: gmock-spec-builders.h:1845
proxygen::HTTPCodec::StreamID
uint64_t StreamID
Definition: HTTPCodec.h:49
testing::_
const internal::AnythingMatcher _
Definition: gmock-matchers.h:3729
proxygen::TEST_F
TEST_F(HeaderTableTests, IndexTranslation)
Definition: HeaderTableTests.cpp:54
proxygen::Exception::what
const char * what(void) const noexceptoverride
Definition: Exception.cpp:26
testing::Return
internal::ReturnAction< R > Return(R value)
Definition: gmock-actions.h:1061
proxygen::spdy::kInitialWindow
const uint32_t kInitialWindow
Definition: SPDYConstants.cpp:144