proxygen: proxygen::MockHTTPTransaction Class Reference

#include <HTTPTransactionMocks.h>

Inheritance diagram for proxygen::MockHTTPTransaction:

Public Member Functions
	MockHTTPTransaction (TransportDirection direction, HTTPCodec::StreamID id, uint32_t seqNo, const HTTP2PriorityQueue &egressQueue, folly::HHWheelTimer timer=nullptr, const folly::Optional< std::chrono::milliseconds > &transactionTimeout=folly::Optional< std::chrono::milliseconds >(), HTTPSessionStats stats=nullptr, bool useFlowControl=false, uint32_t receiveInitialWindowSize=0, uint32_t sendInitialWindowSize=0, http2::PriorityUpdate priority=http2::DefaultPriority, folly::Optional< HTTPCodec::StreamID > assocStreamId=HTTPCodec::NoStream, folly::Optional< HTTPCodec::ExAttributes > exAttributes=HTTPCodec::NoExAttributes)

	MockHTTPTransaction (TransportDirection direction, HTTPCodec::StreamID id, uint32_t seqNo, const HTTP2PriorityQueue &egressQueue, const WheelTimerInstance &timeout, HTTPSessionStats *stats=nullptr, bool useFlowControl=false, uint32_t receiveInitialWindowSize=0, uint32_t sendInitialWindowSize=0, http2::PriorityUpdate priority=http2::DefaultPriority, folly::Optional< HTTPCodec::StreamID > assocStreamId=HTTPCodec::NoStream, folly::Optional< HTTPCodec::ExAttributes > exAttributes=HTTPCodec::NoExAttributes)

	MockHTTPTransaction (TransportDirection direction, HTTPCodec::StreamID id, uint32_t seqNo, const HTTP2PriorityQueue &egressQueue, const WheelTimerInstance &timeout, folly::Optional< HTTPCodec::ExAttributes > exAttributes)

	MOCK_CONST_METHOD0 (extraResponseExpected, bool())

	MOCK_METHOD1 (setHandler, void(HTTPTransactionHandler *))

void	setHandlerUnmocked (HTTPTransactionHandler *handler)

	MOCK_CONST_METHOD0 (canSendHeaders, bool())

	MOCK_METHOD1 (sendHeaders, void(const HTTPMessage &headers))

	MOCK_METHOD1 (sendHeadersWithEOM, void(const HTTPMessage &headers))

	MOCK_METHOD1 (sendBody, void(std::shared_ptr< folly::IOBuf >))

void	sendBody (std::unique_ptr< folly::IOBuf > iob) noexceptoverride

	MOCK_METHOD1 (sendChunkHeader, void(size_t))

	MOCK_METHOD0 (sendChunkTerminator, void())

	MOCK_METHOD1 (sendTrailers, void(const HTTPHeaders &trailers))

	MOCK_METHOD0 (sendEOM, void())

	MOCK_METHOD0 (sendAbort, void())

	MOCK_METHOD0 (drop, void())

	MOCK_METHOD0 (pauseIngress, void())

	MOCK_METHOD0 (resumeIngress, void())

	MOCK_CONST_METHOD0 (handlerEgressPaused, bool())

	MOCK_METHOD1 (newPushedTransaction, HTTPTransaction (HTTPPushTransactionHandler ))

	MOCK_METHOD1 (setReceiveWindow, void(uint32_t))

	MOCK_CONST_METHOD0 (getReceiveWindow, const Window &())

	MOCK_METHOD1 (addWaitingForReplaySafety, void(folly::AsyncTransport::ReplaySafetyCallback *))

	MOCK_METHOD1 (removeWaitingForReplaySafety, void(folly::AsyncTransport::ReplaySafetyCallback *))

void	enablePush ()

Public Member Functions inherited from proxygen::HTTPTransaction
	HTTPTransaction (TransportDirection direction, HTTPCodec::StreamID id, uint32_t seqNo, Transport &transport, HTTP2PriorityQueueBase &egressQueue, folly::HHWheelTimer timer=nullptr, const folly::Optional< std::chrono::milliseconds > &defaultTimeout=folly::Optional< std::chrono::milliseconds >(), HTTPSessionStats stats=nullptr, bool useFlowControl=false, uint32_t receiveInitialWindowSize=0, uint32_t sendInitialWindowSize=0, http2::PriorityUpdate=http2::DefaultPriority, folly::Optional< HTTPCodec::StreamID > assocStreamId=HTTPCodec::NoStream, folly::Optional< HTTPCodec::ExAttributes > exAttributes=HTTPCodec::NoExAttributes)

	~HTTPTransaction () override

void	reset (bool useFlowControl, uint32_t receiveInitialWindowSize, uint32_t receiveStreamWindowSize, uint32_t sendInitialWindowSize)

HTTPCodec::StreamID	getID () const

uint32_t	getSequenceNumber () const

const Transport &	getTransport () const

Transport &	getTransport ()

virtual void	setHandler (Handler *handler)

const Handler *	getHandler () const

http2::PriorityUpdate	getPriority () const

std::tuple< uint64_t, uint64_t, double >	getPrioritySummary () const

bool	getPriorityFallback () const

HTTPTransactionEgressSM::State	getEgressState () const

HTTPTransactionIngressSM::State	getIngressState () const

bool	isUpstream () const

bool	isDownstream () const

void	getLocalAddress (folly::SocketAddress &addr) const

void	getPeerAddress (folly::SocketAddress &addr) const

const folly::SocketAddress &	getLocalAddress () const noexcept

const folly::SocketAddress &	getPeerAddress () const noexcept

const wangle::TransportInfo &	getSetupTransportInfo () const noexcept

void	getCurrentTransportInfo (wangle::TransportInfo *tinfo) const

HTTPSessionStats *	getSessionStats () const

virtual bool	extraResponseExpected () const

virtual void	setReceiveWindow (uint32_t capacity)

virtual const Window &	getReceiveWindow () const

uint32_t	getMaxDeferredSize ()

void	onIngressHeadersComplete (std::unique_ptr< HTTPMessage > msg)

void	onIngressBody (std::unique_ptr< folly::IOBuf > chain, uint16_t padding)

void	onIngressChunkHeader (size_t length)

void	onIngressChunkComplete ()

void	onIngressTrailers (std::unique_ptr< HTTPHeaders > trailers)

void	onIngressUpgrade (UpgradeProtocol protocol)

void	onIngressEOM ()

void	onError (const HTTPException &error)

void	onGoaway (ErrorCode code)

void	onIngressTimeout ()

void	onIngressWindowUpdate (uint32_t amount)

void	onIngressSetSendWindow (uint32_t newWindowSize)

bool	onWriteReady (uint32_t maxEgress, double ratio)

void	onEgressTimeout ()

void	onEgressHeaderFirstByte ()

void	onEgressBodyFirstByte ()

void	onEgressBodyLastByte ()

void	onEgressTrackedByte ()

void	onEgressLastByteAck (std::chrono::milliseconds latency)

void	setTransportCallback (TransportCallback *cb)

bool	isIngressStarted () const

bool	isIngressEOMQueued () const

bool	isIngressComplete () const

bool	isIngressEOMSeen () const

bool	isEgressStarted () const

bool	isEgressEOMQueued () const

bool	isEgressComplete () const

bool	isRemoteInitiated () const

bool	isEgressEOMSeen () const

virtual bool	canSendHeaders () const

virtual void	sendHeaders (const HTTPMessage &headers)

virtual void	sendHeadersWithEOM (const HTTPMessage &headers)

virtual void	sendHeadersWithOptionalEOM (const HTTPMessage &headers, bool eom)

virtual void	sendChunkHeader (size_t length)

virtual void	sendChunkTerminator ()

virtual void	sendTrailers (const HTTPHeaders &trailers)

virtual void	sendEOM ()

virtual void	sendAbort ()

virtual void	pauseIngress ()

virtual void	resumeIngress ()

bool	isIngressPaused () const

void	pauseEgress ()

void	resumeEgress ()

void	setEgressRateLimit (uint64_t bitsPerSecond)

bool	isEgressPaused () const

bool	isFlowControlPaused () const

bool	supportsPushTransactions () const

virtual HTTPTransaction *	newPushedTransaction (HTTPPushTransactionHandler *handler)

virtual HTTPTransaction *	newExTransaction (HTTPTransactionHandler *handler, bool unidirectional=false)

bool	onPushedTransaction (HTTPTransaction *txn)

bool	onExTransaction (HTTPTransaction *txn)

bool	isPushed () const

bool	isExTransaction () const

bool	isUnidirectional () const

void	setIdleTimeout (std::chrono::milliseconds transactionTimeout)

bool	hasIdleTimeout () const

std::chrono::milliseconds	getIdleTimeout () const

folly::Optional< HTTPCodec::StreamID >	getAssocTxnId () const

folly::Optional< HTTPCodec::StreamID >	getControlStream () const

folly::Optional< HTTPCodec::ExAttributes >	getExAttributes () const

const std::set< HTTPCodec::StreamID > &	getPushedTransactions () const

std::set< HTTPCodec::StreamID >	getExTransactions () const

void	removePushedTransaction (HTTPCodec::StreamID pushStreamId)

void	removeExTransaction (HTTPCodec::StreamID exStreamId)

void	refreshTimeout ()

bool	testAndSetFirstByteSent ()

bool	testAndClearActive ()

bool	testAndSetFirstHeaderByteSent ()

void	incrementPendingByteEvents ()

void	decrementPendingByteEvents ()

void	timeoutExpired () noexceptoverride

void	describe (std::ostream &os) const

void	updateAndSendPriority (int8_t newPriority)

void	updateAndSendPriority (const http2::PriorityUpdate &pri)

void	onPriorityUpdate (const http2::PriorityUpdate &priority)

virtual void	addWaitingForReplaySafety (folly::AsyncTransport::ReplaySafetyCallback *callback)

virtual void	removeWaitingForReplaySafety (folly::AsyncTransport::ReplaySafetyCallback *callback)

virtual bool	needToBlockForReplaySafety () const

int32_t	getRecvToAck () const

bool	isPrioritySampled () const

void	setPrioritySampled (bool sampled)

void	updateContentionsCount (uint64_t contentions)

void	updateRelativeWeight (double ratio)

void	updateSessionBytesSheduled (uint64_t bytes)

void	updateTransactionBytesSent (uint64_t bytes)

bool	getPrioritySampleSummary (PrioritySampleSummary &summary) const

HPACKTableInfo &	getHPACKTableInfo ()

bool	hasPendingBody () const

void	setLastByteFlushedTrackingEnabled (bool enabled)

Public Member Functions inherited from folly::HHWheelTimer::Callback
	Callback ()=default

virtual	~Callback ()

virtual void	callbackCanceled () noexcept

void	cancelTimeout ()

bool	isScheduled () const

std::chrono::milliseconds	getTimeRemaining ()

Public Member Functions inherited from folly::DelayedDestructionBase
virtual	~DelayedDestructionBase ()=default

Public Attributes
testing::NiceMock< MockHTTPTransactionTransport >	mockTransport_

const folly::SocketAddress	defaultAddress_

MockHTTPCodec	mockCodec_

wangle::TransportInfo	setupTransportInfo_

Additional Inherited Members
Public Types inherited from proxygen::HTTPTransaction
using	Handler = HTTPTransactionHandler

using	PushHandler = HTTPPushTransactionHandler

using	TransportCallback = HTTPTransactionTransportCallback

Protected Member Functions inherited from folly::HHWheelTimer::Callback
virtual std::chrono::steady_clock::time_point	getCurTime ()

Protected Member Functions inherited from folly::DelayedDestructionBase
	DelayedDestructionBase ()

uint32_t	getDestructorGuardCount () const

Detailed Description

Definition at line 127 of file HTTPTransactionMocks.h.

Constructor & Destructor Documentation

proxygen::MockHTTPTransaction::MockHTTPTransaction	(	TransportDirection	direction,
		HTTPCodec::StreamID	id,
		uint32_t	seqNo,
		const HTTP2PriorityQueue &	egressQueue,
		folly::HHWheelTimer *	timer = `nullptr`,
		const folly::Optional< std::chrono::milliseconds > &	transactionTimeout = `folly::Optional<std::chrono::milliseconds>()`,
		HTTPSessionStats *	stats = `nullptr`,
		bool	useFlowControl = `false`,
		uint32_t	receiveInitialWindowSize = `0`,
		uint32_t	sendInitialWindowSize = `0`,
		http2::PriorityUpdate	priority = `http2::DefaultPriority`,
		folly::Optional< HTTPCodec::StreamID >	assocStreamId = `HTTPCodec::NoStream`,
		folly::Optional< HTTPCodec::ExAttributes >	exAttributes = `HTTPCodec::NoExAttributes`
	)

inline

Definition at line 129 of file HTTPTransactionMocks.h.

References testing::_, EXPECT_CALL, handler(), testing::Invoke(), proxygen::MockHTTPTransactionTransport::mockCodec_, ON_CALL, testing::Return(), and testing::ReturnRef().

                                                :
       HTTPTransaction(direction, id, seqNo, mockTransport_,
                       const_cast<HTTP2PriorityQueue&>(egressQueue),
                       timer, transactionTimeout, stats, useFlowControl,
                       receiveInitialWindowSize,
                       sendInitialWindowSize,
                       priority, assocStreamId, exAttributes),
       defaultAddress_("127.0.0.1", 80) {
     EXPECT_CALL(mockTransport_, getLocalAddressNonConst())
       .WillRepeatedly(testing::ReturnRef(defaultAddress_));
     EXPECT_CALL(mockTransport_, getPeerAddressNonConst())
       .WillRepeatedly(testing::ReturnRef(defaultAddress_));
     EXPECT_CALL(mockTransport_, getCodecNonConst())
       .WillRepeatedly(testing::ReturnRef(mockCodec_));
     EXPECT_CALL(mockTransport_, getSetupTransportInfoNonConst())
       .WillRepeatedly(testing::ReturnRef(setupTransportInfo_));
 
     // Some tests unfortunately require a half-mocked HTTPTransaction.
     ON_CALL(*this, setHandler(testing::_))
       .WillByDefault(testing::Invoke([this] (HTTPTransactionHandler* handler) {
             this->setHandlerUnmocked(handler);
         }));
 
     // By default we expect canSendHeaders in test to return true
     // Tests that specifically require canSendHeaders to return false need
     // to set the behavior locally.  This is due to the fact that the mocked
     // methods below imply internal state is not correctly tracked/managed
     // in the context of tests
     ON_CALL(*this, canSendHeaders()).WillByDefault(testing::Return(true));
   }

proxygen::MockHTTPTransaction::MockHTTPTransaction	(	TransportDirection	direction,
		HTTPCodec::StreamID	id,
		uint32_t	seqNo,
		const HTTP2PriorityQueue &	egressQueue,
		const WheelTimerInstance &	timeout,
		HTTPSessionStats *	stats = `nullptr`,
		bool	useFlowControl = `false`,
		uint32_t	receiveInitialWindowSize = `0`,
		uint32_t	sendInitialWindowSize = `0`,
		http2::PriorityUpdate	priority = `http2::DefaultPriority`,
		folly::Optional< HTTPCodec::StreamID >	assocStreamId = `HTTPCodec::NoStream`,
		folly::Optional< HTTPCodec::ExAttributes >	exAttributes = `HTTPCodec::NoExAttributes`
	)

inline

Definition at line 177 of file HTTPTransactionMocks.h.

                                                :
   MockHTTPTransaction(direction,
                       id,
                       seqNo,
                       egressQueue,
                       timeout.getWheelTimer(),
                       timeout.getDefaultTimeout(),
                       stats,
                       useFlowControl,
                       receiveInitialWindowSize,
                       sendInitialWindowSize,
                       priority,
                       assocStreamId,
                       exAttributes) {}

proxygen::MockHTTPTransaction::MockHTTPTransaction	(	TransportDirection	direction,
		HTTPCodec::StreamID	id,
		uint32_t	seqNo,
		const HTTP2PriorityQueue &	egressQueue,
		const WheelTimerInstance &	timeout,
		folly::Optional< HTTPCodec::ExAttributes >	exAttributes
	)

inline

Definition at line 206 of file HTTPTransactionMocks.h.

References proxygen::MockHTTPTransactionTransport::MOCK_CONST_METHOD0(), and proxygen::MockHTTPTransactionTransport::MOCK_METHOD1().

                                                                          :
   MockHTTPTransaction(direction,
                       id,
                       seqNo,
                       egressQueue,
                       timeout.getWheelTimer(),
                       timeout.getDefaultTimeout(),
                       nullptr,
                       false,
                       0,
                       0,
                       http2::DefaultPriority,
                       HTTPCodec::NoStream,
                       exAttributes) {}

Member Function Documentation

void proxygen::MockHTTPTransaction::enablePush ( )

inline

Definition at line 261 of file HTTPTransactionMocks.h.

References EXPECT_CALL, proxygen::MockHTTPTransactionTransport::mockCodec_, and testing::Return().

                     {
     EXPECT_CALL(mockCodec_, supportsPushTransactions())
       .WillRepeatedly(testing::Return(true));
   }

proxygen::MockHTTPTransaction::MOCK_CONST_METHOD0	(	extraResponseExpected	,
		bool()
	)

proxygen::MockHTTPTransaction::MOCK_CONST_METHOD0	(	canSendHeaders	,
		bool()
	)

proxygen::MockHTTPTransaction::MOCK_CONST_METHOD0	(	handlerEgressPaused	,
		bool()
	)

proxygen::MockHTTPTransaction::MOCK_CONST_METHOD0	(	getReceiveWindow	,
		const Window &	()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	sendChunkTerminator	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	sendEOM	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	sendAbort	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	drop	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	pauseIngress	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD0	(	resumeIngress	,
		void()
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	setHandler	,
		void(HTTPTransactionHandler *)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	sendHeaders	,
		void(const HTTPMessage &headers)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	sendHeadersWithEOM	,
		void(const HTTPMessage &headers)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	sendBody	,
		void(std::shared_ptr< folly::IOBuf >)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	sendChunkHeader	,
		void(size_t)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	sendTrailers	,
		void(const HTTPHeaders &trailers)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	newPushedTransaction	,
		HTTPTransaction *	HTTPPushTransactionHandler *
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	setReceiveWindow	,
		void(uint32_t)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	addWaitingForReplaySafety	,
		void(folly::AsyncTransport::ReplaySafetyCallback *)
	)

proxygen::MockHTTPTransaction::MOCK_METHOD1	(	removeWaitingForReplaySafety	,
		void(folly::AsyncTransport::ReplaySafetyCallback *)
	)

void proxygen::MockHTTPTransaction::sendBody ( std::unique_ptr< folly::IOBuf > body )

inlineoverridevirtualnoexcept

Send part or all of the egress message body to the Transport. If flow control is enabled, the chunk boundaries may not be respected. This method does not actually write the message out on the wire immediately. All writes happen at the end of the event loop at the earliest. Note: This method may be called zero or more times per message.

Parameters

body	Message body data; the Transport will take care of applying any necessary protocol framing, such as chunk headers.

Reimplemented from proxygen::HTTPTransaction.

Definition at line 239 of file HTTPTransactionMocks.h.

                                                                  {
     sendBody(std::shared_ptr<folly::IOBuf>(iob.release()));
   }

void proxygen::MockHTTPTransaction::setHandlerUnmocked ( HTTPTransactionHandler * handler )

inline

Definition at line 231 of file HTTPTransactionMocks.h.

References proxygen::MockHTTPTransactionTransport::MOCK_CONST_METHOD0(), proxygen::MockHTTPTransactionTransport::MOCK_METHOD1(), proxygen::MockHTTPTransactionTransport::sendBody(), proxygen::HTTPTransaction::Transport::sendHeaders(), and proxygen::HTTPTransaction::setHandler().

                                                            {
     HTTPTransaction::setHandler(handler);
   }

Member Data Documentation

const folly::SocketAddress proxygen::MockHTTPTransaction::defaultAddress_

Definition at line 267 of file HTTPTransactionMocks.h.

MockHTTPCodec proxygen::MockHTTPTransaction::mockCodec_

Definition at line 268 of file HTTPTransactionMocks.h.

testing::NiceMock<MockHTTPTransactionTransport> proxygen::MockHTTPTransaction::mockTransport_

Definition at line 266 of file HTTPTransactionMocks.h.

wangle::TransportInfo proxygen::MockHTTPTransaction::setupTransportInfo_

Definition at line 269 of file HTTPTransactionMocks.h.

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

proxygen/lib/http/session/test/HTTPTransactionMocks.h

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation