FilterTests.cpp File Reference

#include <folly/portability/GTest.h>
#include <limits>
#include <proxygen/lib/http/HTTPHeaderSize.h>
#include <proxygen/lib/http/HTTPMessage.h>
#include <proxygen/lib/http/codec/FlowControlFilter.h>
#include <proxygen/lib/http/codec/HTTPChecks.h>
#include <proxygen/lib/http/codec/test/MockHTTPCodec.h>
#include <proxygen/lib/http/codec/test/TestUtils.h>
#include <random>

Go to the source code of this file.

Classes
class	MockFlowControlCallback
class	FilterTest
class	HTTPChecksTest
class	FlowControlFilterTest< initSize >

Typedefs
using	DefaultFlowControl = FlowControlFilterTest< 0 >
using	BigWindow = FlowControlFilterTest< 1000000 >

Functions
	MATCHER (IsFlowException,"")
	TEST_F (DefaultFlowControl, FlowControlConstruct)
	TEST_F (DefaultFlowControl, SendUpdate)
	TEST_F (BigWindow, RecvTooMuch)
	TEST_F (BigWindow, RemoteIncrease)
	TEST_F (HTTPChecksTest, SendTraceBodyDeath)
	TEST_F (HTTPChecksTest, SendGetBody)
	TEST_F (HTTPChecksTest, RecvTraceBody)

Typedef Documentation

using BigWindow = FlowControlFilterTest<1000000>

Definition at line 100 of file FilterTests.cpp.

using DefaultFlowControl = FlowControlFilterTest<0>

Definition at line 99 of file FilterTests.cpp.

Function Documentation

MATCHER	(	IsFlowException	,
		""
	)

Definition at line 102 of file FilterTests.cpp.

References proxygen::FLOW_CONTROL_ERROR.

                             {
  return arg->hasCodecStatusCode() &&
    arg->getCodecStatusCode() == ErrorCode::FLOW_CONTROL_ERROR &&
    !arg->hasHttpStatusCode() &&
    !arg->hasProxygenError();
}

TEST_F	(	DefaultFlowControl	,
		FlowControlConstruct
	)

Definition at line 109 of file FilterTests.cpp.

References ASSERT_EQ, EXPECT_CALL, EXPECT_DEATH_NO_CORE, proxygen::makeBuf(), and proxygen::HTTPCodec::NoPadding.

                                                 {
  // Constructing the filter with a low capacity defaults to kInitialCapacity
  // initial capacity, so no window update should have been generated in
  // the constructor
  InSequence enforceSequence;
  ASSERT_EQ(writeBuf_.chainLength(), 0);

  // Our send window is limited to kInitialCapacity
  chain_->generateBody(writeBuf_, 1,
                       makeBuf(kInitialCapacity - 1),
                       HTTPCodec::NoPadding, false);

  // the window isn't full yet, so getting a window update shouldn't give a
  // callback informing us that it is open again
  callbackStart_->onWindowUpdate(0, 1);

  // Now fill the window (2 more bytes)
  EXPECT_CALL(flowCallback_, onConnectionSendWindowClosed());
  chain_->generateBody(writeBuf_, 1, makeBuf(2), HTTPCodec::NoPadding, false);
  // get the callback informing the window is open once we get a window update
  EXPECT_CALL(flowCallback_, onConnectionSendWindowOpen());
  callbackStart_->onWindowUpdate(0, 1);

  // Overflowing the window is fatal. Write 2 bytes (only 1 byte left in window)
  EXPECT_DEATH_NO_CORE(chain_->generateBody(writeBuf_, 1, makeBuf(2),
                                            HTTPCodec::NoPadding, false),
                       ".*");
}

TEST_F	(	DefaultFlowControl	,
		SendUpdate
	)

Definition at line 138 of file FilterTests.cpp.

References testing::_, callback_, codec_, EXPECT_CALL, proxygen::makeBuf(), and testing::Return().

                                       {
  // Make sure we send a window update when the window decreases below half
  InSequence enforceSequence;
  EXPECT_CALL(callback_, onBody(_, _, _))
    .WillRepeatedly(Return());

  // Have half the window outstanding
  callbackStart_->onBody(1, makeBuf(kInitialCapacity / 2 + 1), 0);
  filter_->ingressBytesProcessed(writeBuf_, kInitialCapacity / 2);

  // It should wait until the "+1" is ack'd to generate the coallesced update
  EXPECT_CALL(*codec_,
              generateWindowUpdate(_, 0, kInitialCapacity / 2 + 1));
  filter_->ingressBytesProcessed(writeBuf_, 1);
}

TEST_F	(	BigWindow	,
		RecvTooMuch
	)

Definition at line 154 of file FilterTests.cpp.

References testing::_, ASSERT_EQ, ASSERT_FALSE, ASSERT_GT, ASSERT_TRUE, callback_, EXPECT_CALL, testing::Invoke(), proxygen::makeBuf(), and string.

                               {
  // Constructing the filter with a large capacity causes a WINDOW_UPDATE
  // for stream zero to be generated
  ASSERT_GT(writeBuf_.chainLength(), 0);

  InSequence enforceSequence;
  EXPECT_CALL(callback_, onBody(_, _, _));
  EXPECT_CALL(callback_, onError(0, IsFlowException(), _))
      .WillOnce(Invoke([](HTTPCodec::StreamID,
                          std::shared_ptr<HTTPException> exc,
                          bool /*newTxn*/) {
        ASSERT_EQ(
            "Failed to reserve receive window, window size=0, "
            "amount=1",
            std::string(exc->what()));
      }));

  // Receive the max amount advertised
  callbackStart_->onBody(1, makeBuf(recvWindow_), 0);
  ASSERT_TRUE(chain_->isReusable());
  // Receive 1 byte too much
  callbackStart_->onBody(1, makeBuf(1), 0);
  ASSERT_FALSE(chain_->isReusable());
}

TEST_F	(	BigWindow	,
		RemoteIncrease
	)

Definition at line 179 of file FilterTests.cpp.

References testing::_, ASSERT_EQ, ASSERT_FALSE, callback_, EXPECT_CALL, testing::Invoke(), proxygen::makeBuf(), max, proxygen::HTTPCodec::NoPadding, and string.

                                  {
  // The remote side sends us a window update for stream=0, increasing our
  // available window
  InSequence enforceSequence;

  ASSERT_EQ(filter_->getAvailableSend(), kInitialCapacity);
  callbackStart_->onWindowUpdate(0, 10);
  ASSERT_EQ(filter_->getAvailableSend(), kInitialCapacity + 10);

  EXPECT_CALL(flowCallback_, onConnectionSendWindowClosed());
  chain_->generateBody(writeBuf_, 1,
                       makeBuf(kInitialCapacity + 10),
                       HTTPCodec::NoPadding, false);
  ASSERT_EQ(filter_->getAvailableSend(), 0);

  // Now the remote side sends a HUGE update (just barely legal)
  // Since the window was full, this generates a callback from the filter
  // telling us the window is no longer full.
  EXPECT_CALL(flowCallback_, onConnectionSendWindowOpen());
  callbackStart_->onWindowUpdate(0, std::numeric_limits<int32_t>::max());
  ASSERT_EQ(filter_->getAvailableSend(), std::numeric_limits<int32_t>::max());

  // Now overflow it by 1
  EXPECT_CALL(callback_, onError(0, IsFlowException(), _))
      .WillOnce(Invoke([](HTTPCodec::StreamID,
                          std::shared_ptr<HTTPException> exc,
                          bool /*newTxn*/) {
        ASSERT_EQ(
            "Failed to update send window, outstanding=0, "
            "amount=1",
            std::string(exc->what()));
      }));
  callbackStart_->onWindowUpdate(0, 1);
  ASSERT_FALSE(chain_->isReusable());
}

TEST_F	(	HTTPChecksTest	,
		SendTraceBodyDeath
	)

Definition at line 215 of file FilterTests.cpp.

References EXPECT_DEATH_NO_CORE, proxygen::getPostRequest(), and proxygen::HTTPMessage::setMethod().

                                           {
  // It is NOT allowed to send a TRACE with a body.

  HTTPMessage msg = getPostRequest();
  msg.setMethod("TRACE");

  EXPECT_DEATH_NO_CORE(chain_->generateHeader(writeBuf_, 0, msg), ".*");
}

TEST_F	(	HTTPChecksTest	,
		SendGetBody
	)

Definition at line 224 of file FilterTests.cpp.

References testing::_, codec_, EXPECT_CALL, proxygen::getPostRequest(), and proxygen::HTTPMessage::setMethod().

                                    {
  // It is allowed to send a GET with a content-length. It is up to the
  // server to ignore it.

  EXPECT_CALL(*codec_, generateHeader(_, _, _, _, _));

  HTTPMessage msg = getPostRequest();
  msg.setMethod("GET");

  chain_->generateHeader(writeBuf_, 0, msg);
}

TEST_F	(	HTTPChecksTest	,
		RecvTraceBody
	)

Definition at line 236 of file FilterTests.cpp.

References testing::_, ASSERT_EQ, ASSERT_TRUE, callback_, EXPECT_CALL, testing::Invoke(), proxygen::makePostRequest(), and folly::gen::move.

                                      {
  // In proxygen, we deal with receiving a TRACE with a body by 400'ing it

  EXPECT_CALL(callback_, onError(_, _, _))
    .WillOnce(Invoke([] (HTTPCodec::StreamID,
                         std::shared_ptr<HTTPException> exc,
                         bool newTxn) {
                       ASSERT_TRUE(newTxn);
                       ASSERT_EQ(exc->getHttpStatusCode(), 400);
                       ASSERT_EQ(0,
                         strcmp("RFC2616: Request Body Not Allowed",
                                exc->what()));
        }));

  auto msg = makePostRequest();
  msg->setMethod("TRACE");

  callbackStart_->onHeadersComplete(0, std::move(msg));
}