MockHTTPUpstreamTest Class Reference

Inheritance diagram for MockHTTPUpstreamTest:

Public Member Functions
void	SetUp () override
void	TearDown () override
std::unique_ptr< StrictMock< MockHTTPHandler > >	openTransaction ()
Public Member Functions inherited from HTTPUpstreamTest< MockHTTPCodecPair >
	HTTPUpstreamTest (std::vector< int64_t > flowControl={-1,-1,-1})
void	resumeWrites ()
virtual void	onWriteChain (folly::AsyncTransportWrapper::WriteCallback *callback, std::shared_ptr< IOBuf > iob, WriteFlags)
void	handleWrite (folly::AsyncTransportWrapper::WriteCallback *callback)
void	SetUp () override
void	commonSetUp (unique_ptr< HTTPCodec > codec)
unique_ptr< typename MockHTTPCodecPair::Codec >	makeServerCodec ()
void	enableExHeader (typename MockHTTPCodecPair::Codec *serverCodec)
void	parseOutput (HTTPCodec &serverCodec)
void	readAndLoop (const std::string &input)
void	readAndLoop (IOBuf *buf)
void	readAndLoop (const uint8_t *input, size_t length)
void	testBasicRequest ()
void	testBasicRequestHttp10 (bool keepalive)
void	onCreate (const HTTPSessionBase &) override
void	onDestroy (const HTTPSessionBase &) override
void	onSettingsOutgoingStreamsFull (const HTTPSessionBase &) override
void	onSettingsOutgoingStreamsNotFull (const HTTPSessionBase &) override
void	TearDown () override
std::unique_ptr< StrictMock< MockHTTPHandler > >	openTransaction (bool expectStartPaused=false)
std::unique_ptr< NiceMock< MockHTTPHandler > >	openNiceTransaction (bool expectStartPaused=false)
void	testSimpleUpgrade (const std::string &upgradeReqHeader, const std::string &upgradeRespHeader, CodecProtocol respCodecVersion)
MockByteEventTracker *	setMockByteEventTracker ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()

Public Attributes
MockHTTPCodec *	codecPtr_ {nullptr}
HTTPCodec::Callback *	codecCb_ {nullptr}
bool	reusable_ {true}
uint32_t	nextOutgoingTxn_ {1}

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 ()
	Test ()
	Test ()
Protected Attributes inherited from HTTPUpstreamTest< MockHTTPCodecPair >
bool	sessionCreated_
bool	sessionDestroyed_
bool	transactionsFull_
bool	transportGood_
EventBase	eventBase_
EventBase *	eventBasePtr_
MockAsyncTransport *	transport_
folly::AsyncTransportWrapper::ReadCallback *	readCallback_
folly::AsyncTransport::ReplaySafetyCallback *	replaySafetyCallback_
folly::HHWheelTimer::UniquePtr	transactionTimeouts_
std::vector< int64_t >	flowControl_
wangle::TransportInfo	mockTransportInfo_
SocketAddress	localAddr_
SocketAddress	peerAddr_
HTTPUpstreamSession *	httpSession_
IOBufQueue	writes_
std::vector< folly::AsyncTransportWrapper::WriteCallback * >	cbs_
bool	failWrites_
bool	pauseWrites_
bool	writeInLoop_

Detailed Description

Definition at line 1738 of file HTTPUpstreamSessionTest.cpp.

Member Function Documentation

std::unique_ptr<StrictMock<MockHTTPHandler> > MockHTTPUpstreamTest::openTransaction ( )

inline

Definition at line 1783 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_EQ, and handler().

                                                               {
    // Returns a mock handler with txn_ field set in it
    auto handler = std::make_unique<StrictMock<MockHTTPHandler>>();
    handler->expectTransaction();
    auto txn = httpSession_->newTransaction(handler.get());
    EXPECT_EQ(txn, handler->txn_);
    return handler;
  }

void MockHTTPUpstreamTest::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Reimplemented in MockHTTP2UpstreamTest.

Definition at line 1740 of file HTTPUpstreamSessionTest.cpp.

References testing::_, folly::IOBufQueue::append(), codec, EXPECT_CALL, EXPECT_LT, testing::Invoke(), max, folly::gen::move, testing::Return(), and fizz::detail::writeBuf().

Referenced by MockHTTP2UpstreamTest::SetUp().

                        {
    auto codec = std::make_unique<NiceMock<MockHTTPCodec>>();
    codecPtr_ = codec.get();
    EXPECT_CALL(*codec, supportsParallelRequests())
      .WillRepeatedly(Return(true));
    EXPECT_CALL(*codec, getTransportDirection())
      .WillRepeatedly(Return(TransportDirection::UPSTREAM));
    EXPECT_CALL(*codec, setCallback(_))
      .WillRepeatedly(SaveArg<0>(&codecCb_));
    EXPECT_CALL(*codec, isReusable())
      .WillRepeatedly(ReturnPointee(&reusable_));
    EXPECT_CALL(*codec, isWaitingToDrain())
      .WillRepeatedly(ReturnPointee(&reusable_));
    EXPECT_CALL(*codec, getDefaultWindowSize())
      .WillRepeatedly(Return(65536));
    EXPECT_CALL(*codec, getProtocol())
      .WillRepeatedly(Return(CodecProtocol::SPDY_3_1));
    EXPECT_CALL(*codec, generateGoaway(_, _, _, _))
      .WillRepeatedly(Invoke([&] (IOBufQueue& writeBuf,
                                  HTTPCodec::StreamID lastStream,
                                  ErrorCode,
                                  std::shared_ptr<folly::IOBuf>) {
            EXPECT_LT(lastStream, std::numeric_limits<int32_t>::max());
            if (reusable_) {
              writeBuf.append("GOAWAY", 6);
              reusable_ = false;
            }
            return 6;
          }));
    EXPECT_CALL(*codec, createStream())
      .WillRepeatedly(Invoke([&] {
            auto ret = nextOutgoingTxn_;
            nextOutgoingTxn_ += 2;
            return ret;
          }));

    commonSetUp(std::move(codec));
  }

void MockHTTPUpstreamTest::TearDown ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 1779 of file HTTPUpstreamSessionTest.cpp.

References EXPECT_TRUE.

                           {
    EXPECT_TRUE(sessionDestroyed_);
  }

Member Data Documentation

HTTPCodec::Callback* MockHTTPUpstreamTest::codecCb_ {nullptr}

Definition at line 1793 of file HTTPUpstreamSessionTest.cpp.

MockHTTPCodec* MockHTTPUpstreamTest::codecPtr_ {nullptr}

Definition at line 1792 of file HTTPUpstreamSessionTest.cpp.

uint32_t MockHTTPUpstreamTest::nextOutgoingTxn_ {1}

Definition at line 1795 of file HTTPUpstreamSessionTest.cpp.

bool MockHTTPUpstreamTest::reusable_ {true}

Definition at line 1794 of file HTTPUpstreamSessionTest.cpp.

---

The documentation for this class was generated from the following file:

• proxygen/lib/http/session/test/HTTPUpstreamSessionTest.cpp