proxygen: MockCodecDownstreamTest Class Reference

Inheritance diagram for MockCodecDownstreamTest:

Public Member Functions
	MockCodecDownstreamTest ()

void	onWriteChain (folly::AsyncTransportWrapper::WriteCallback *callback, std::shared_ptr< IOBuf >, WriteFlags)

	~MockCodecDownstreamTest () override

void	SetUp () override

template<class T >
void	onIngressImpl (T f)

void	testGoaway (bool doubleGoaway, bool dropConnection)

void	testConnFlowControlBlocked (bool timeout)

Public Member Functions inherited from testing::Test
virtual	~Test ()

virtual	~Test ()

virtual	~Test ()

Protected Attributes
EventBase	eventBase_

StrictMock< MockHTTPCodec > *	codec_

std::string	userAgent_ {"MockCodec"}

HTTPCodec::Callback *	codecCallback_ {nullptr}

NiceMock< MockAsyncTransport > *	transport_

folly::AsyncTransportWrapper::ReadCallback *	transportCb_

folly::HHWheelTimer::UniquePtr	transactionTimeouts_

StrictMock< MockController >	mockController_

HTTPDownstreamSession *	httpSession_

HTTPCodec::StreamID	pushStreamID_ {0}

bool	reusable_ {true}

bool	transportGood_ {true}

bool	drainPending_ {false}

bool	doubleGoaway_ {false}

bool	liveGoaways_ {false}

bool	invokeWriteSuccess_ {false}

uint32_t	writeCount_ {0}

std::vector< folly::AsyncTransportWrapper::WriteCallback * >	cbs_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc

typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc

typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc

typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc

typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc

typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc

Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()

static void	TearDownTestCase ()

static bool	HasFatalFailure ()

static bool	HasNonfatalFailure ()

static bool	HasFailure ()

static void	RecordProperty (const std::string &key, const std::string &value)

static void	RecordProperty (const std::string &key, int value)

static void	SetUpTestCase ()

static void	TearDownTestCase ()

static bool	HasFatalFailure ()

static bool	HasNonfatalFailure ()

static bool	HasFailure ()

static void	RecordProperty (const std::string &key, const std::string &value)

static void	RecordProperty (const std::string &key, int value)

static void	SetUpTestCase ()

static void	TearDownTestCase ()

static bool	HasFatalFailure ()

static bool	HasNonfatalFailure ()

static bool	HasFailure ()

static void	RecordProperty (const std::string &key, const std::string &value)

static void	RecordProperty (const std::string &key, int value)

Protected Member Functions inherited from testing::Test
	Test ()

virtual void	TearDown ()

	Test ()

virtual void	TearDown ()

	Test ()

virtual void	TearDown ()

Detailed Description

Definition at line 52 of file MockCodecDownstreamTest.cpp.

Constructor & Destructor Documentation

MockCodecDownstreamTest::MockCodecDownstreamTest ( )

inline

Definition at line 54 of file MockCodecDownstreamTest.cpp.

References testing::_, folly::IOBufQueue::append(), testing::Assign(), codec_, EXPECT_CALL, folly::getEventBase(), testing::Invoke(), testing::InvokeWithoutArgs(), kDefaultIngressSettings, proxygen::localAddr, proxygen::mockTransportInfo, onWriteChain(), proxygen::peerAddr, testing::Return(), testing::ReturnRef(), transport_, and fizz::detail::writeBuf().

     : eventBase_(),
       codec_(new StrictMock<MockHTTPCodec>()),
       transport_(new NiceMock<MockAsyncTransport>()),
       transactionTimeouts_(makeInternalTimeoutSet(&eventBase_)) {
 
     EXPECT_CALL(*transport_, writeChain(_, _, _))
       .WillRepeatedly(Invoke(this, &MockCodecDownstreamTest::onWriteChain));
     EXPECT_CALL(*transport_, good())
       .WillRepeatedly(ReturnPointee(&transportGood_));
     EXPECT_CALL(*transport_, closeNow())
       .WillRepeatedly(Assign(&transportGood_, false));
     EXPECT_CALL(*transport_, getEventBase())
       .WillRepeatedly(Return(&eventBase_));
     EXPECT_CALL(*transport_, setReadCB(_))
       .WillRepeatedly(SaveArg<0>(&transportCb_));
     EXPECT_CALL(mockController_, getGracefulShutdownTimeout())
       .WillRepeatedly(Return(std::chrono::milliseconds(0)));
     EXPECT_CALL(mockController_, attachSession(_));
     EXPECT_CALL(*codec_, setCallback(_))
       .WillRepeatedly(SaveArg<0>(&codecCallback_));
     EXPECT_CALL(*codec_, supportsParallelRequests())
       .WillRepeatedly(Return(true));
     EXPECT_CALL(*codec_, supportsPushTransactions())
       .WillRepeatedly(Return(true));
     EXPECT_CALL(*codec_, getTransportDirection())
       .WillRepeatedly(Return(TransportDirection::DOWNSTREAM));
     EXPECT_CALL(*codec_, getEgressSettings());
     EXPECT_CALL(*codec_, supportsStreamFlowControl())
       .WillRepeatedly(Return(true));
     EXPECT_CALL(*codec_, getProtocol())
       .WillRepeatedly(Return(CodecProtocol::SPDY_3_1));
     EXPECT_CALL(*codec_, getUserAgent())
       .WillRepeatedly(ReturnRef(userAgent_));
     EXPECT_CALL(*codec_, setParserPaused(_))
       .WillRepeatedly(Return());
     EXPECT_CALL(*codec_, supportsSessionFlowControl())
       .WillRepeatedly(Return(true)); // simulate spdy 3.1
     EXPECT_CALL(*codec_, getIngressSettings())
       .WillRepeatedly(Return(&kDefaultIngressSettings));
     EXPECT_CALL(*codec_, isReusable())
       .WillRepeatedly(ReturnPointee(&reusable_));
     EXPECT_CALL(*codec_, isWaitingToDrain())
       .WillRepeatedly(ReturnPointee(&drainPending_));
     EXPECT_CALL(*codec_, generateSettings(_));
     EXPECT_CALL(*codec_, getDefaultWindowSize())
       .WillRepeatedly(Return(65536));
     EXPECT_CALL(*codec_, createStream())
       .WillRepeatedly(InvokeWithoutArgs([&] {
             return pushStreamID_ += 2;
           }));
     EXPECT_CALL(*codec_, enableDoubleGoawayDrain())
       .WillRepeatedly(Invoke([&] { doubleGoaway_ = true; }));
     EXPECT_CALL(*codec_, generateGoaway(_, _, _, _))
         .WillRepeatedly(Invoke([this](IOBufQueue& writeBuf,
                                       HTTPCodec::StreamID /*lastStream*/,
                                       ErrorCode,
                                       std::shared_ptr<folly::IOBuf>) {
           if (reusable_) {
             reusable_ = false;
             drainPending_ = doubleGoaway_;
           } else if (!drainPending_) {
             return 0;
           } else {
             drainPending_ = false;
           }
           if (liveGoaways_) {
             writeBuf.append(string("x"));
           }
           return 1;
         }));
     EXPECT_CALL(*codec_, generateRstStream(_, _, _))
       .WillRepeatedly(Return(1));
     EXPECT_CALL(*codec_, addPriorityNodes(_, _, _))
       .WillOnce(Return(0));
     EXPECT_CALL(*codec_, mapPriorityToDependency(_))
       .WillRepeatedly(Return(0));
 
     HTTPSession::setDefaultReadBufferLimit(65536);
     httpSession_ = new HTTPDownstreamSession(
         transactionTimeouts_.get(),
         AsyncTransportWrapper::UniquePtr(transport_), localAddr, peerAddr,
         &mockController_, std::unique_ptr<HTTPCodec>(codec_),
         mockTransportInfo, nullptr);
     httpSession_->startNow();
     eventBase_.loop();
   }

MockCodecDownstreamTest::~MockCodecDownstreamTest ( )

inlineoverride

Definition at line 153 of file MockCodecDownstreamTest.cpp.

References folly::AsyncSocketException::UNKNOWN.

                                       {
     AsyncSocketException ex(AsyncSocketException::UNKNOWN, "");
     for (auto& cb : cbs_) {
       cb->writeErr(0, ex);
     }
   }

Member Function Documentation

template<class T >

void MockCodecDownstreamTest::onIngressImpl ( T f )

inline

Definition at line 167 of file MockCodecDownstreamTest.cpp.

References testing::_, codec_, folly::IOBuf::computeChainDataLength(), EXPECT_CALL, f, testing::Invoke(), and folly::detail::timeout.

                           {
     EXPECT_CALL(*codec_, onIngress(_))
       .WillOnce(Invoke([&f] (const IOBuf& buf) {
             CHECK_GT(buf.computeChainDataLength(), 0);
             // The test should be independent of the dummy buffer,
             // so don't pass it in.
             f();
             return buf.computeChainDataLength();
           }));
 
     void* buf;
     size_t bufSize;
     transportCb_->getReadBuffer(&buf, &bufSize);
     transportCb_->readDataAvailable(bufSize);
   }

void MockCodecDownstreamTest::onWriteChain	(	folly::AsyncTransportWrapper::WriteCallback *	callback,
		std::shared_ptr< IOBuf >	,
		WriteFlags
	)

inline

Definition at line 142 of file MockCodecDownstreamTest.cpp.

References folly::AsyncWriter::WriteCallback::writeSuccess().

Referenced by MockCodecDownstreamTest().

                                 {
     writeCount_++;
     if (invokeWriteSuccess_) {
       callback->writeSuccess();
     } else {
       cbs_.push_back(callback);
     }
   }

void MockCodecDownstreamTest::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 160 of file MockCodecDownstreamTest.cpp.

                         {
     HTTPSession::setDefaultWriteBufferLimit(65536);
   }

void MockCodecDownstreamTest::testConnFlowControlBlocked ( bool timeout )

Definition at line 968 of file MockCodecDownstreamTest.cpp.

References testing::_, folly::IOBufQueue::append(), codec_, EXPECT_CALL, EXPECT_EQ, proxygen::Exception::getProxygenError(), proxygen::HTTP_HEADER_CONTENT_LENGTH, testing::Invoke(), proxygen::kErrorTimeout, proxygen::http2::kInitialWindow, makeBuf(), proxygen::makeGetRequest(), proxygen::makeResponse(), folly::gen::move, testing::Return(), uint64_t, and fizz::detail::writeBuf().

                                                                      {
   // Let the connection level flow control window fill and then make sure
   // control frames still can be processed
   InSequence enforceOrder;
   NiceMock<MockHTTPHandler> handler1;
   NiceMock<MockHTTPHandler> handler2;
   auto wantToWrite = spdy::kInitialWindow + 50000;
   auto wantToWriteStr = folly::to<string>(wantToWrite);
   auto req1 = makeGetRequest();
   auto req2 = makeGetRequest();
   auto resp1 = makeResponse(200);
   resp1->getHeaders().set(HTTP_HEADER_CONTENT_LENGTH, wantToWriteStr);
   auto resp2 = makeResponse(200);
   resp2->getHeaders().set(HTTP_HEADER_CONTENT_LENGTH, wantToWriteStr);
   invokeWriteSuccess_ = true;
 
   EXPECT_CALL(mockController_, getRequestHandler(_, _))
     .WillOnce(Return(&handler1));
   EXPECT_CALL(handler1, setTransaction(_))
     .WillOnce(SaveArg<0>(&handler1.txn_));
   EXPECT_CALL(handler1, onHeadersComplete(_));
   EXPECT_CALL(*codec_, generateHeader(_, 1, _, _, _))
     .WillOnce(Invoke([] (folly::IOBufQueue& writeBuf,
                          HTTPCodec::StreamID,
                          const HTTPMessage&,
                          bool,
                          HTTPHeaderSize*) {
                        writeBuf.append("", 1);
                      }));
   unsigned bodyLen = 0;
   EXPECT_CALL(*codec_, generateBody(_, 1, _, _, false))
       .WillRepeatedly(Invoke([&](folly::IOBufQueue& /*writeBuf*/,
                                  HTTPCodec::StreamID,
                                  std::shared_ptr<folly::IOBuf> chain,
                                  folly::Optional<uint8_t>,
                                  bool /*eom*/) {
         bodyLen += chain->computeChainDataLength();
         return 0; // don't want byte events
       }));
 
   codecCallback_->onMessageBegin(1, req1.get());
   codecCallback_->onHeadersComplete(1, std::move(req1));
   codecCallback_->onWindowUpdate(1, wantToWrite); // ensure the per-stream
                                                   // window doesn't block
   handler1.txn_->sendHeaders(*resp1);
   handler1.txn_->sendBody(makeBuf(wantToWrite)); // conn blocked, stream open
   handler1.txn_->sendEOM();
   eventBase_.loop(); // actually send (most of) the body
   CHECK_EQ(bodyLen, spdy::kInitialWindow); // should have written a full window
 
   EXPECT_CALL(mockController_, getRequestHandler(_, _))
     .WillOnce(Return(&handler2));
   EXPECT_CALL(handler2, setTransaction(_))
     .WillOnce(SaveArg<0>(&handler2.txn_));
   EXPECT_CALL(handler2, onHeadersComplete(_));
   EXPECT_CALL(*codec_, generateHeader(_, 3, _, _, _))
     .WillOnce(Invoke([] (folly::IOBufQueue& writeBuf,
                          HTTPCodec::StreamID,
                          const HTTPMessage&,
                          bool,
                          HTTPHeaderSize*) {
                        writeBuf.append("", 1);
                      }));
 
   auto writeCount = writeCount_;
 
   // Make sure we can send headers of response to a second request
   codecCallback_->onMessageBegin(3, req2.get());
   codecCallback_->onHeadersComplete(3, std::move(req2));
   handler2.txn_->sendHeaders(*resp2);
 
   eventBase_.loop();
 
   EXPECT_EQ(writeCount + 1, writeCount_);
 
   if (timeout) {
     // don't send a window update, the handlers will get timeouts
     EXPECT_CALL(handler1, onError(_))
       .WillOnce(Invoke([] (const HTTPException& ex) {
             EXPECT_EQ(ex.getProxygenError(), kErrorTimeout);
           }));
     EXPECT_CALL(handler2, onError(_))
       .WillOnce(Invoke([] (const HTTPException& ex) {
             EXPECT_EQ(ex.getProxygenError(), kErrorTimeout);
           }));
     EXPECT_CALL(mockController_, detachSession(_));
     // send a window update to refresh the stream level timeout
     codecCallback_->onWindowUpdate(1, 1);
     // silly, the timeout set is internal and there's no fd, so hold the
     // eventBase open until the timeout can fire
     eventBase_.runAfterDelay([] {}, 500);
 
     transactionTimeouts_->cancelAll();
   } else {
     // Give a connection level window update of 10 bytes -- this
     // should allow 10 bytes of the txn1 response to be written
     codecCallback_->onWindowUpdate(0, 10);
     EXPECT_CALL(*codec_, generateBody(_, 1, PtrBufHasLen(uint64_t(10)),
                                       _, false));
     eventBase_.loop();
 
     // Just tear everything down now.
     EXPECT_CALL(handler1, detachTransaction());
     codecCallback_->onAbort(handler1.txn_->getID(),
                             ErrorCode::INTERNAL_ERROR);
     eventBase_.loop();
 
     EXPECT_CALL(handler2, detachTransaction());
     EXPECT_CALL(mockController_, detachSession(_));
     httpSession_->dropConnection();
   }
 
   eventBase_.loop();
 }

void MockCodecDownstreamTest::testGoaway	(	bool	doubleGoaway,
		bool	dropConnection
	)

Definition at line 1275 of file MockCodecDownstreamTest.cpp.

References testing::_, testing::Assign(), testing::AtLeast(), codec_, testing::DoAll(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, handler(), testing::Invoke(), proxygen::makeGetRequest(), folly::gen::move, testing::Return(), transport_, folly::AsyncSocketException::UNKNOWN, folly::AsyncWriter::WriteCallback::writeErr(), and folly::AsyncWriter::WriteCallback::writeSuccess().

                                                               {
   NiceMock<MockHTTPHandler> handler;
   MockHTTPHandler pushHandler;
 
   liveGoaways_ = true;
   if (doubleGoaway) {
     EXPECT_CALL(mockController_, getRequestHandler(_, _))
       .WillOnce(Return(&handler));
     EXPECT_CALL(handler, setTransaction(_))
       .WillOnce(SaveArg<0>(&handler.txn_));
 
     EXPECT_CALL(handler, onHeadersComplete(_));
     EXPECT_CALL(handler, onEOM())
       .WillOnce(Invoke([&] {
             handler.sendReply();
           }));
     EXPECT_CALL(*codec_, generateHeader(_, 1, _, _, _));
     EXPECT_CALL(*codec_, generateEOM(_, 1));
     EXPECT_CALL(handler, detachTransaction());
 
     // Turn on double GOAWAY drain
     codec_->enableDoubleGoawayDrain();
   }
 
   // Send a GOAWAY acking uninitiated transactions
   EXPECT_FALSE(drainPending_);
   httpSession_->notifyPendingShutdown();
   EXPECT_EQ(drainPending_, doubleGoaway);
   EXPECT_FALSE(reusable_);
 
   if (doubleGoaway) {
     // Should be able to process new requests
     auto req1 = makeGetRequest();
     codecCallback_->onMessageBegin(1, req1.get());
     codecCallback_->onHeadersComplete(1, std::move(req1));
     codecCallback_->onMessageComplete(1, false);
   }
 
   folly::AsyncTransportWrapper::WriteCallback* cb = nullptr;
   EXPECT_CALL(*transport_, writeChain(_, _, _))
     .WillOnce(Invoke([&] (folly::AsyncTransportWrapper::WriteCallback* callback,
                           const shared_ptr<IOBuf>,
                           WriteFlags) {
                        // don't immediately flush the goaway
                        cb = callback;
                      }));
   if (doubleGoaway || !dropConnection) {
     // single goaway, drop connection doesn't get onIngressEOF
     EXPECT_CALL(*codec_, onIngressEOF());
   }
   eventBase_.loopOnce();
 
   EXPECT_CALL(mockController_, detachSession(_));
   if (dropConnection) {
     EXPECT_CALL(*transport_, closeWithReset())
       .Times(AtLeast(1))
       .WillOnce(DoAll(Assign(&transportGood_, false),
                       Invoke([cb] {
                           AsyncSocketException ex(
                             AsyncSocketException::UNKNOWN, "");
                           cb->writeErr(0, ex);
                         })));
 
     httpSession_->dropConnection();
   } else {
     EXPECT_CALL(*codec_, isBusy());
     httpSession_->closeWhenIdle();
     cb->writeSuccess();
   }
   EXPECT_FALSE(drainPending_);
   EXPECT_FALSE(reusable_);
 }