DownstreamTransactionTest.cpp File Reference

#include <folly/io/async/EventBase.h>
#include <proxygen/lib/http/codec/SPDYConstants.h>
#include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <proxygen/lib/http/session/test/HTTPSessionMocks.h>
#include <proxygen/lib/http/session/test/HTTPTransactionMocks.h>
#include <proxygen/lib/test/TestAsyncTransport.h>
#include <folly/io/async/test/MockAsyncTransport.h>

Go to the source code of this file.

Classes
class	DownstreamTransactionTest

Functions
	TEST_F (DownstreamTransactionTest, SimpleCallbackForwarding)
	TEST_F (DownstreamTransactionTest, RegularWindowUpdate)
	TEST_F (DownstreamTransactionTest, NoWindowUpdate)
	TEST_F (DownstreamTransactionTest, WindowIncrease)
	TEST_F (DownstreamTransactionTest, WindowDecrease)
	TEST_F (DownstreamTransactionTest, ParseErrorCbs)
	TEST_F (DownstreamTransactionTest, DetachFromNotify)
	TEST_F (DownstreamTransactionTest, DeferredEgress)
	TEST_F (DownstreamTransactionTest, InternalError)
	TEST_F (DownstreamTransactionTest, UnpausedFlowControlViolation)

Function Documentation

TEST_F	(	DownstreamTransactionTest	,
		SimpleCallbackForwarding
	)

Test that the the transaction properly forwards callbacks to the handler and that it interacts with its transport as expected.

Definition at line 113 of file DownstreamTransactionTest.cpp.

References proxygen::DOWNSTREAM, proxygen::makeGetRequest(), and transport_.

                                                            {
  // flow control is disabled
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500));
  setupRequestResponseFlow(&txn, 100);

  txn.onIngressHeadersComplete(makeGetRequest());
  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		RegularWindowUpdate
	)

Testing that we're sending a window update for simple requests

Definition at line 129 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, EXPECT_CALL, proxygen::spdy::kInitialWindow, proxygen::makeGetRequest(), transport_, and uint32_t.

                                                       {
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr,
    true, // flow control enabled
    400,
    spdy::kInitialWindow);
  uint32_t reqBodySize = 220;
  setupRequestResponseFlow(&txn, reqBodySize);

  // test that the window update is generated
  EXPECT_CALL(transport_, sendWindowUpdate(_, reqBodySize));

  // run the test
  txn.onIngressHeadersComplete(makeGetRequest());
  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		NoWindowUpdate
	)

Definition at line 150 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, EXPECT_CALL, proxygen::spdy::kInitialWindow, proxygen::makeBuf(), proxygen::makeGetRequest(), proxygen::makeResponse(), transport_, and uint32_t.

                                                  {
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr,
    true, // flow control enabled
    450, // more than 2x req size
    spdy::kInitialWindow);
  uint32_t reqBodySize = 220;
  setupRequestResponseFlow(&txn, reqBodySize, true);

  EXPECT_CALL(transport_, sendWindowUpdate(_, reqBodySize))
    .Times(0);

  // run the test
  txn.onIngressHeadersComplete(makeGetRequest());
  txn.onIngressBody(makeBuf(reqBodySize), 0);
  txn.onIngressEOM();
  auto response = makeResponse(200);
  txn.sendHeaders(*response.get());
  txn.sendBody(makeBuf(reqBodySize));
  txn.sendEOM();
  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		WindowIncrease
	)

Testing window increase using window update; we're actually using this in production to avoid bumping the window using the SETTINGS frame

Definition at line 181 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, EXPECT_CALL, proxygen::spdy::kInitialWindow, proxygen::makeGetRequest(), transport_, and uint32_t.

                                                  {
  // set initial window size higher than per-stream window
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr,
    true, // flow control enabled
    spdy::kInitialWindow,
    spdy::kInitialWindow);
  uint32_t reqSize = 500;
  setupRequestResponseFlow(&txn, reqSize);

  // we expect the difference from the per stream window and the initial window,
  // together with the bytes sent in the request
  uint32_t perStreamWindow = spdy::kInitialWindow + 1024 * 1024;
  uint32_t expectedWindowUpdate =
    perStreamWindow - spdy::kInitialWindow;
  EXPECT_CALL(transport_, sendWindowUpdate(_, expectedWindowUpdate));

  // use a higher window
  txn.setReceiveWindow(perStreamWindow);

  txn.onIngressHeadersComplete(makeGetRequest());
  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		WindowDecrease
	)

Testing that we're not sending window update when per-stream window size is smaller than the initial window size

Definition at line 213 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, EXPECT_CALL, proxygen::spdy::kInitialWindow, proxygen::makeGetRequest(), transport_, and uint32_t.

                                                  {
  // set initial window size higher than per-stream window
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr,
    true, // flow control enabled
    spdy::kInitialWindow,
    spdy::kInitialWindow);
  setupRequestResponseFlow(&txn, 500);

  // in this case, there should be no window update, as we decrease the window
  // below the number of bytes we're sending
  EXPECT_CALL(transport_, sendWindowUpdate(_, _)).Times(0);

  // use a smaller window
  uint32_t perStreamWindow = spdy::kInitialWindow - 1000;
  txn.setReceiveWindow(perStreamWindow);

  txn.onIngressHeadersComplete(makeGetRequest());
  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		ParseErrorCbs
	)

Definition at line 238 of file DownstreamTransactionTest.cpp.

References testing::_, ASSERT_EQ, proxygen::DOWNSTREAM, dummy(), EXPECT_CALL, proxygen::HTTPException::getDirection(), proxygen::HTTPException::INGRESS, testing::Invoke(), proxygen::makeBuf(), string, transport_, and proxygen::Exception::what().

                                                 {
  // Test where the transaction gets on parse error and then a body
  // callback. This is possible because codecs are stateless between
  // frames.

  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500));

  HTTPException err(HTTPException::Direction::INGRESS, "test");
  err.setHttpStatusCode(400);

  InSequence dummy;

  EXPECT_CALL(handler_, setTransaction(&txn));
  EXPECT_CALL(handler_, onError(_))
    .WillOnce(Invoke([] (const HTTPException& ex) {
          ASSERT_EQ(ex.getDirection(), HTTPException::Direction::INGRESS);
          ASSERT_EQ(std::string(ex.what()), "test");
        }));
  // onBody() is suppressed since ingress is complete after ingress onError()
  // onEOM() is suppressed since ingress is complete after ingress onError()
  EXPECT_CALL(transport_, sendAbort(_, _));
  EXPECT_CALL(handler_, detachTransaction());
  EXPECT_CALL(transport_, detach(&txn));

  txn.setHandler(&handler_);
  txn.onError(err);
  // Since the transaction is already closed for ingress, giving it
  // ingress body causes the transaction to be aborted and closed
  // immediately.
  txn.onIngressBody(makeBuf(10), 0);

  eventBase_.loop();
}

TEST_F	(	DownstreamTransactionTest	,
		DetachFromNotify
	)

Definition at line 276 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, dummy(), EXPECT_CALL, EXPECT_EQ, proxygen::HTTPMessage::getStatusCode(), handler(), proxygen::HTTPException::INGRESS_AND_EGRESS, testing::Invoke(), testing::InvokeWithoutArgs(), proxygen::makeBuf(), proxygen::makeGetRequest(), proxygen::makeResponse(), and transport_.

                                                    {
  unique_ptr<StrictMock<MockHTTPHandler>> handler(
    new StrictMock<MockHTTPHandler>);

  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500));

  InSequence dummy;

  EXPECT_CALL(*handler, setTransaction(&txn));
  EXPECT_CALL(*handler, onHeadersComplete(_))
      .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
        auto response = makeResponse(200);
        txn.sendHeaders(*response.get());
        txn.sendBody(makeBuf(10));
      }));
  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
    .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
          EXPECT_EQ(headers.getStatusCode(), 200);
        }));
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(10));
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-10))
    .WillOnce(InvokeWithoutArgs([&] () {
          txn.setHandler(nullptr);
          handler.reset();
        }));
  EXPECT_CALL(transport_, detach(&txn));

  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");

  txn.setHandler(handler.get());
  txn.onIngressHeadersComplete(makeGetRequest());
  txn.onError(err);
}

TEST_F	(	DownstreamTransactionTest	,
		DeferredEgress
	)

Definition at line 314 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, dummy(), EXPECT_CALL, EXPECT_EQ, proxygen::HTTPMessage::getStatusCode(), proxygen::HTTPException::INGRESS_AND_EGRESS, testing::Invoke(), proxygen::makeBuf(), proxygen::makeGetRequest(), proxygen::makeResponse(), testing::Return(), and transport_.

                                                  {
  EXPECT_CALL(transport_, describe(_))
    .WillRepeatedly(Return());
  EXPECT_CALL(transport_, notifyPendingEgress())
    .WillRepeatedly(Return());

  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr, true, 10, 10);

  InSequence dummy;

  EXPECT_CALL(handler_, setTransaction(&txn));
  EXPECT_CALL(handler_, onHeadersComplete(_))
      .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
        auto response = makeResponse(200);
        txn.sendHeaders(*response.get());
        txn.sendBody(makeBuf(10));
        txn.sendBody(makeBuf(20));
      }));
  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
    .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
          EXPECT_EQ(headers.getStatusCode(), 200);
        }));

  // when enqueued
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(10));
  EXPECT_CALL(handler_, onEgressPaused());
  // sendBody
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(20));

  txn.setHandler(&handler_);
  txn.onIngressHeadersComplete(makeGetRequest());

  // onWriteReady, send, then dequeue (SPDY window now full)
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-20));

  EXPECT_EQ(txn.onWriteReady(20, 1), false);

  // enqueued after window update
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(20));

  txn.onIngressWindowUpdate(20);

  // Buffer released on error
  EXPECT_CALL(transport_, notifyEgressBodyBuffered(-20));
  EXPECT_CALL(handler_, onError(_));
  EXPECT_CALL(handler_, detachTransaction());
  EXPECT_CALL(transport_, detach(&txn));

  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");
  txn.onError(err);
}

TEST_F	(	DownstreamTransactionTest	,
		InternalError
	)

Definition at line 371 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, dummy(), EXPECT_CALL, EXPECT_EQ, proxygen::HTTPMessage::getStatusCode(), handler(), proxygen::HTTPException::INGRESS_AND_EGRESS, proxygen::INTERNAL_ERROR, testing::Invoke(), proxygen::makeGetRequest(), proxygen::makeResponse(), and transport_.

                                                 {
  unique_ptr<StrictMock<MockHTTPHandler>> handler(
    new StrictMock<MockHTTPHandler>);

  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500));

  InSequence dummy;

  EXPECT_CALL(*handler, setTransaction(&txn));
  EXPECT_CALL(*handler, onHeadersComplete(_))
      .WillOnce(Invoke([&](std::shared_ptr<HTTPMessage> /*msg*/) {
        auto response = makeResponse(200);
        txn.sendHeaders(*response.get());
      }));
  EXPECT_CALL(transport_, sendHeaders(&txn, _, _, _))
    .WillOnce(Invoke([&](Unused, const HTTPMessage& headers, Unused, Unused) {
          EXPECT_EQ(headers.getStatusCode(), 200);
        }));
  EXPECT_CALL(transport_, sendAbort(&txn, ErrorCode::INTERNAL_ERROR));
  EXPECT_CALL(*handler, detachTransaction());
  EXPECT_CALL(transport_, detach(&txn));

  HTTPException err(HTTPException::Direction::INGRESS_AND_EGRESS, "test");

  txn.setHandler(handler.get());
  txn.onIngressHeadersComplete(makeGetRequest());
  txn.sendAbort();
}

TEST_F	(	DownstreamTransactionTest	,
		UnpausedFlowControlViolation
	)

Definition at line 404 of file DownstreamTransactionTest.cpp.

References testing::_, proxygen::DOWNSTREAM, EXPECT_CALL, proxygen::FLOW_CONTROL_ERROR, handler(), proxygen::spdy::kInitialWindow, proxygen::makeBuf(), proxygen::makePostRequest(), and transport_.

                                                                {
  StrictMock<MockHTTPHandler> handler;

  InSequence enforceOrder;
  HTTPTransaction txn(
    TransportDirection::DOWNSTREAM,
    HTTPCodec::StreamID(1), 1, transport_,
    txnEgressQueue_, transactionTimeouts_.get(),
    std::chrono::milliseconds(500),
    nullptr,
    true, // flow control enabled
    400,
    spdy::kInitialWindow);

  EXPECT_CALL(handler, setTransaction(&txn));
  EXPECT_CALL(handler, onHeadersComplete(_));
  EXPECT_CALL(transport_, sendAbort(&txn, ErrorCode::FLOW_CONTROL_ERROR));
  EXPECT_CALL(handler, detachTransaction());
  EXPECT_CALL(transport_, detach(&txn));

  txn.setHandler(&handler);
  txn.onIngressHeadersComplete(makePostRequest(401));
  txn.onIngressBody(makeBuf(401), 0);
}