lib/mvfst
1
0
Fork 0
mirror of https://github.com/facebookincubator/mvfst.git synced 2025-08-08 09:42:06 +03:00
Code Activity

Move tests to split callbacks

Browse Source 
Summary:
Maine change is `MockConnectionCallback` -> `MockConnectionSetupCallback` + `MockConnectionCallbackNew`.
Everything else is changing tests to use the two new classes.

Differential Revision: D33076321

fbshipit-source-id: a938b63ce59f07f549b3e725caad8785348db7ed
This commit is contained in:
Konstantin Tsoy
2022-02-02 14:01:45 -08:00
committed by Facebook GitHub Bot
parent 60ef432691
commit 1ca4c4e66c
17 changed files with 281 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
quic/api/test/MockQuicSocket.h
View File

@@ -17,14 +17,11 @@ class MockQuicSocket : public QuicSocket {
public: public:
using SharedBuf = std::shared_ptr<folly::IOBuf>; using SharedBuf = std::shared_ptr<folly::IOBuf>;
MockQuicSocket(folly::EventBase* /*eventBase*/, ConnectionCallback& connCb)
: setupCb_(&connCb), connCb_(&connCb) {}
MockQuicSocket( MockQuicSocket(
folly::EventBase* /*eventBase*/, folly::EventBase* /*eventBase*/,
ConnectionSetupCallback& setupCb, ConnectionSetupCallback* setupCb,
ConnectionCallbackNew* connCb) ConnectionCallbackNew* connCb)
: setupCb_(&setupCb), connCb_(connCb) {} : setupCb_(setupCb), connCb_(connCb) {}
MOCK_CONST_METHOD0(good, bool()); MOCK_CONST_METHOD0(good, bool());
MOCK_CONST_METHOD0(replaySafe, bool()); MOCK_CONST_METHOD0(replaySafe, bool());

30
quic/api/test/Mocks.h
View File

@@ -101,9 +101,23 @@ class MockWriteCallback : public QuicSocket::WriteCallback {
void(std::pair<QuicErrorCode, folly::Optional<folly::StringPiece>>)); void(std::pair<QuicErrorCode, folly::Optional<folly::StringPiece>>));
}; };
class MockConnectionCallback : public QuicSocket::ConnectionCallback { class MockConnectionSetupCallback : public QuicSocket::ConnectionSetupCallback {
public: public:
~MockConnectionCallback() override = default; ~MockConnectionSetupCallback() override = default;
GMOCK_METHOD1_(
,
noexcept,
,
onConnectionSetupError,
void(std::pair<QuicErrorCode, std::string>));
GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
GMOCK_METHOD0_(, noexcept, , onTransportReady, void());
GMOCK_METHOD0_(, noexcept, , onFirstPeerPacketProcessed, void());
};
class MockConnectionCallbackNew : public QuicSocket::ConnectionCallbackNew {
public:
~MockConnectionCallbackNew() override = default;
GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId)); GMOCK_METHOD1_(, noexcept, , onFlowControlUpdate, void(StreamId));
GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId)); GMOCK_METHOD1_(, noexcept, , onNewBidirectionalStream, void(StreamId));
@@ -115,19 +129,12 @@ class MockConnectionCallback : public QuicSocket::ConnectionCallback {
onStopSending, onStopSending,
void(StreamId, ApplicationErrorCode)); void(StreamId, ApplicationErrorCode));
GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void()); GMOCK_METHOD0_(, noexcept, , onConnectionEnd, void());
void onConnectionSetupError(
std::pair<QuicErrorCode, std::string> code) noexcept override {
onConnectionError(std::move(code));
}
GMOCK_METHOD1_( GMOCK_METHOD1_(
, ,
noexcept, noexcept,
, ,
onConnectionError, onConnectionError,
void(std::pair<QuicErrorCode, std::string>)); void(std::pair<QuicErrorCode, std::string>));
GMOCK_METHOD0_(, noexcept, , onReplaySafe, void());
GMOCK_METHOD0_(, noexcept, , onTransportReady, void());
GMOCK_METHOD0_(, noexcept, , onFirstPeerPacketProcessed, void());
GMOCK_METHOD1_(, noexcept, , onBidirectionalStreamsAvailable, void(uint64_t)); GMOCK_METHOD1_(, noexcept, , onBidirectionalStreamsAvailable, void(uint64_t));
GMOCK_METHOD1_( GMOCK_METHOD1_(
, ,
@@ -211,9 +218,10 @@ class MockQuicTransport : public QuicServerTransport {
MockQuicTransport( MockQuicTransport(
folly::EventBase* evb, folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock, std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb, ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) std::shared_ptr<const fizz::server::FizzServerContext> ctx)
: QuicServerTransport(evb, std::move(sock), cb, ctx) {} : QuicServerTransport(evb, std::move(sock), connSetupCb, connCb, ctx) {}
virtual ~MockQuicTransport() { virtual ~MockQuicTransport() {
customDestructor(); customDestructor();

17
quic/api/test/QuicStreamAsyncTransportTest.cpp
View File

@@ -43,7 +43,11 @@ class QuicStreamAsyncTransportTest : public Test {
const folly::SocketAddress& /*addr*/, const folly::SocketAddress& /*addr*/,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) { std::shared_ptr<const fizz::server::FizzServerContext> ctx) {
auto transport = quic::QuicServerTransport::make( auto transport = quic::QuicServerTransport::make(
evb, std::move(socket), serverConnectionCB_, std::move(ctx)); evb,
std::move(socket),
&serverConnectionSetupCB_,
&serverConnectionCB_,
std::move(ctx));
CHECK(serverSocket_.get() == nullptr); CHECK(serverSocket_.get() == nullptr);
serverSocket_ = transport; serverSocket_ = transport;
return transport; return transport;
@@ -91,7 +95,8 @@ class QuicStreamAsyncTransportTest : public Test {
void createClient() { void createClient() {
clientEvbThread_ = std::thread([&]() { clientEvb_.loopForever(); }); clientEvbThread_ = std::thread([&]() { clientEvb_.loopForever(); });
EXPECT_CALL(clientConnectionCB_, onTransportReady()).WillOnce(Invoke([&]() { EXPECT_CALL(clientConnectionSetupCB_, onTransportReady())
.WillOnce(Invoke([&]() {
clientAsyncWrapper_ = clientAsyncWrapper_ =
QuicStreamAsyncTransport::createWithNewStream(client_); QuicStreamAsyncTransport::createWithNewStream(client_);
ASSERT_TRUE(clientAsyncWrapper_); ASSERT_TRUE(clientAsyncWrapper_);
@@ -128,7 +133,7 @@ class QuicStreamAsyncTransportTest : public Test {
&clientEvb_, std::move(sock), std::move(fizzClientContext)); &clientEvb_, std::move(sock), std::move(fizzClientContext));
client_->setHostname("echo.com"); client_->setHostname("echo.com");
client_->addNewPeerAddress(serverAddr_); client_->addNewPeerAddress(serverAddr_);
client_->start(&clientConnectionCB_); client_->start(&clientConnectionSetupCB_, &clientConnectionCB_);
}); });
std::move(future).get(1s); std::move(future).get(1s);
@@ -152,7 +157,8 @@ class QuicStreamAsyncTransportTest : public Test {
protected: protected:
std::shared_ptr<QuicServer> server_; std::shared_ptr<QuicServer> server_;
folly::SocketAddress serverAddr_; folly::SocketAddress serverAddr_;
NiceMock<MockConnectionCallback> serverConnectionCB_; NiceMock<MockConnectionSetupCallback> serverConnectionSetupCB_;
NiceMock<MockConnectionCallbackNew> serverConnectionCB_;
std::shared_ptr<quic::QuicSocket> serverSocket_; std::shared_ptr<quic::QuicSocket> serverSocket_;
QuicStreamAsyncTransport::UniquePtr serverAsyncWrapper_; QuicStreamAsyncTransport::UniquePtr serverAsyncWrapper_;
folly::test::MockWriteCallback serverWriteCB_; folly::test::MockWriteCallback serverWriteCB_;
@@ -162,7 +168,8 @@ class QuicStreamAsyncTransportTest : public Test {
std::shared_ptr<QuicClientTransport> client_; std::shared_ptr<QuicClientTransport> client_;
folly::EventBase clientEvb_; folly::EventBase clientEvb_;
std::thread clientEvbThread_; std::thread clientEvbThread_;
NiceMock<MockConnectionCallback> clientConnectionCB_; NiceMock<MockConnectionSetupCallback> clientConnectionSetupCB_;
NiceMock<MockConnectionCallbackNew> clientConnectionCB_;
QuicStreamAsyncTransport::UniquePtr clientAsyncWrapper_; QuicStreamAsyncTransport::UniquePtr clientAsyncWrapper_;
folly::Promise<folly::Unit> startPromise_; folly::Promise<folly::Unit> startPromise_;
folly::test::MockWriteCallback clientWriteCB_; folly::test::MockWriteCallback clientWriteCB_;

15
quic/api/test/QuicTransportBaseTest.cpp
View File

@@ -198,9 +198,11 @@ class TestQuicTransport
TestQuicTransport( TestQuicTransport(
folly::EventBase* evb, folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket, std::unique_ptr<folly::AsyncUDPSocket> socket,
ConnectionCallback& cb) ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb)
: QuicTransportBase(evb, std::move(socket)) { : QuicTransportBase(evb, std::move(socket)) {
setConnectionCallback(&cb); setConnectionSetupCallback(connSetupCb);
setConnectionCallbackNew(connCb);
auto conn = std::make_unique<QuicServerConnectionState>( auto conn = std::make_unique<QuicServerConnectionState>(
FizzServerQuicHandshakeContext::Builder().build()); FizzServerQuicHandshakeContext::Builder().build());
conn->clientConnectionId = ConnectionId({10, 9, 8, 7}); conn->clientConnectionId = ConnectionId({10, 9, 8, 7});
@@ -504,7 +506,7 @@ class QuicTransportImplTest : public Test {
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(evb.get()); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(evb.get());
socketPtr = socket.get(); socketPtr = socket.get();
transport = std::make_shared<TestQuicTransport>( transport = std::make_shared<TestQuicTransport>(
evb.get(), std::move(socket), connCallback); evb.get(), std::move(socket), &connSetupCallback, &connCallback);
auto& conn = *transport->transportConn; auto& conn = *transport->transportConn;
conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal = conn.flowControlState.peerAdvertisedInitialMaxStreamOffsetBidiLocal =
kDefaultStreamWindowSize; kDefaultStreamWindowSize;
@@ -530,7 +532,8 @@ class QuicTransportImplTest : public Test {
protected: protected:
std::unique_ptr<folly::EventBase> evb; std::unique_ptr<folly::EventBase> evb;
NiceMock<MockConnectionCallback> connCallback; NiceMock<MockConnectionSetupCallback> connSetupCallback;
NiceMock<MockConnectionCallbackNew> connCallback;
TestByteEventCallback byteEventCallback; TestByteEventCallback byteEventCallback;
std::shared_ptr<TestQuicTransport> transport; std::shared_ptr<TestQuicTransport> transport;
folly::test::MockAsyncUDPSocket* socketPtr; folly::test::MockAsyncUDPSocket* socketPtr;
@@ -2812,8 +2815,8 @@ TEST_F(QuicTransportImplTest, GetLocalAddressUnboundSocket) {
} }
TEST_F(QuicTransportImplTest, GetLocalAddressBadSocket) { TEST_F(QuicTransportImplTest, GetLocalAddressBadSocket) {
auto badTransport = auto badTransport = std::make_shared<TestQuicTransport>(
std::make_shared<TestQuicTransport>(evb.get(), nullptr, connCallback); evb.get(), nullptr, &connSetupCallback, &connCallback);
badTransport->closeWithoutWrite(); badTransport->closeWithoutWrite();
SocketAddress localAddr = badTransport->getLocalAddress(); SocketAddress localAddr = badTransport->getLocalAddress();
EXPECT_FALSE(localAddr.isInitialized()); EXPECT_FALSE(localAddr.isInitialized());

7
quic/api/test/QuicTransportTest.cpp
View File

@@ -69,8 +69,8 @@ class QuicTransportTest : public Test {
std::unique_ptr<MockAsyncUDPSocket> sock = std::unique_ptr<MockAsyncUDPSocket> sock =
std::make_unique<NiceMock<MockAsyncUDPSocket>>(&evb_); std::make_unique<NiceMock<MockAsyncUDPSocket>>(&evb_);
socket_ = sock.get(); socket_ = sock.get();
transport_.reset( transport_.reset(new TestQuicTransport(
new TestQuicTransport(&evb_, std::move(sock), connCallback_)); &evb_, std::move(sock), &connSetupCallback_, &connCallback_));
// Set the write handshake state to tell the client that the handshake has // Set the write handshake state to tell the client that the handshake has
// a cipher. // a cipher.
auto aead = std::make_unique<NiceMock<MockAead>>(); auto aead = std::make_unique<NiceMock<MockAead>>();
@@ -114,7 +114,8 @@ class QuicTransportTest : public Test {
protected: protected:
folly::EventBase evb_; folly::EventBase evb_;
MockAsyncUDPSocket* socket_; MockAsyncUDPSocket* socket_;
NiceMock<MockConnectionCallback> connCallback_; NiceMock<MockConnectionSetupCallback> connSetupCallback_;
NiceMock<MockConnectionCallbackNew> connCallback_;
NiceMock<MockWriteCallback> writeCallback_; NiceMock<MockWriteCallback> writeCallback_;
MockAead* aead_; MockAead* aead_;
std::unique_ptr<PacketNumberCipher> headerCipher_; std::unique_ptr<PacketNumberCipher> headerCipher_;

6
quic/api/test/TestQuicTransport.h
View File

@@ -21,9 +21,11 @@ class TestQuicTransport
TestQuicTransport( TestQuicTransport(
folly::EventBase* evb, folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> socket, std::unique_ptr<folly::AsyncUDPSocket> socket,
ConnectionCallback& cb) ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb)
: QuicTransportBase(evb, std::move(socket)) { : QuicTransportBase(evb, std::move(socket)) {
setConnectionCallback(&cb); setConnectionSetupCallback(connSetupCb);
setConnectionCallbackNew(connCb);
conn_.reset(new QuicServerConnectionState( conn_.reset(new QuicServerConnectionState(
FizzServerQuicHandshakeContext::Builder().build())); FizzServerQuicHandshakeContext::Builder().build()));
conn_->clientConnectionId = ConnectionId({9, 8, 7, 6}); conn_->clientConnectionId = ConnectionId({9, 8, 7, 6});

152
quic/fizz/client/test/QuicClientTransportTest.cpp
View File

@@ -67,9 +67,8 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
serverCtx->setSupportedAlpns({"h1q-fb", "hq"}); serverCtx->setSupportedAlpns({"h1q-fb", "hq"});
server_ = createServer(ProcessId::ZERO); server_ = createServer(ProcessId::ZERO);
serverAddr = server_->getAddress(); serverAddr = server_->getAddress();
ON_CALL(clientConnCallback, onTransportReady()).WillByDefault(Invoke([&] { ON_CALL(clientConnSetupCallback, onTransportReady())
connected_ = true; .WillByDefault(Invoke([&] { connected_ = true; }));
}));
clientCtx = createClientContext(); clientCtx = createClientContext();
verifier = createTestCertificateVerifier(); verifier = createTestCertificateVerifier();
@@ -165,7 +164,7 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
} }
void expectTransportCallbacks() { void expectTransportCallbacks() {
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
} }
void expectStatsCallbacks() { void expectStatsCallbacks() {
@@ -244,7 +243,8 @@ class QuicClientTransportIntegrationTest : public TestWithParam<TestingParams> {
std::string hostname; std::string hostname;
folly::EventBase eventbase_; folly::EventBase eventbase_;
folly::SocketAddress serverAddr; folly::SocketAddress serverAddr;
NiceMock<MockConnectionCallback> clientConnCallback; NiceMock<MockConnectionSetupCallback> clientConnSetupCallback;
NiceMock<MockConnectionCallbackNew> clientConnCallback;
NiceMock<MockReadCallback> readCb; NiceMock<MockReadCallback> readCb;
std::shared_ptr<TestingQuicClientTransport> client; std::shared_ptr<TestingQuicClientTransport> client;
std::shared_ptr<fizz::server::FizzServerContext> serverCtx; std::shared_ptr<fizz::server::FizzServerContext> serverCtx;
@@ -328,9 +328,9 @@ void QuicClientTransportIntegrationTest::sendRequestAndResponseAndWait(
TEST_P(QuicClientTransportIntegrationTest, NetworkTest) { TEST_P(QuicClientTransportIntegrationTest, NetworkTest) {
expectTransportCallbacks(); expectTransportCallbacks();
expectStatsCallbacks(); expectStatsCallbacks();
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
EXPECT_EQ(client->getConn().peerConnectionIds.size(), 1); EXPECT_EQ(client->getConn().peerConnectionIds.size(), 1);
EXPECT_EQ( EXPECT_EQ(
@@ -349,9 +349,9 @@ TEST_P(QuicClientTransportIntegrationTest, NetworkTest) {
TEST_P(QuicClientTransportIntegrationTest, FlowControlLimitedTest) { TEST_P(QuicClientTransportIntegrationTest, FlowControlLimitedTest) {
expectTransportCallbacks(); expectTransportCallbacks();
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -369,13 +369,13 @@ TEST_P(QuicClientTransportIntegrationTest, FlowControlLimitedTest) {
} }
TEST_P(QuicClientTransportIntegrationTest, ALPNTest) { TEST_P(QuicClientTransportIntegrationTest, ALPNTest) {
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
ASSERT_EQ(client->getAppProtocol(), "h1q-fb"); ASSERT_EQ(client->getAppProtocol(), "h1q-fb");
client->close(folly::none); client->close(folly::none);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
ASSERT_EQ(client->getAppProtocol(), folly::none); ASSERT_EQ(client->getAppProtocol(), folly::none);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
eventbase_.loopForever(); eventbase_.loopForever();
} }
@@ -399,7 +399,7 @@ TEST_P(QuicClientTransportIntegrationTest, TLSAlert) {
ASSERT_EQ(client->getAppProtocol(), folly::none); ASSERT_EQ(client->getAppProtocol(), folly::none);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
eventbase_.loopForever(); eventbase_.loopForever();
} }
@@ -418,7 +418,7 @@ TEST_P(QuicClientTransportIntegrationTest, BadServerTest) {
EXPECT_NE(localError, nullptr); EXPECT_NE(localError, nullptr);
this->checkTransportSummaryEvent(qLogger); this->checkTransportSummaryEvent(qLogger);
})); }));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
eventbase_.loop(); eventbase_.loop();
} }
@@ -429,9 +429,9 @@ TEST_P(QuicClientTransportIntegrationTest, NetworkTestConnected) {
TransportSettings settings; TransportSettings settings;
settings.connectUDP = true; settings.connectUDP = true;
client->setTransportSettings(settings); client->setTransportSettings(settings);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -451,9 +451,9 @@ TEST_P(QuicClientTransportIntegrationTest, SetTransportSettingsAfterStart) {
TransportSettings settings; TransportSettings settings;
settings.connectUDP = true; settings.connectUDP = true;
client->setTransportSettings(settings); client->setTransportSettings(settings);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -484,7 +484,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttSuccess) {
return true; return true;
}, },
[]() -> Buf { return nullptr; }); []() -> Buf { return nullptr; });
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_TRUE(performedValidation); EXPECT_TRUE(performedValidation);
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
EXPECT_TRUE(client->serverInitialParamsSet()); EXPECT_TRUE(client->serverInitialParamsSet());
@@ -499,7 +499,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttSuccess) {
EXPECT_EQ( EXPECT_EQ(
client->peerAdvertisedInitialMaxStreamDataUni(), client->peerAdvertisedInitialMaxStreamDataUni(),
kDefaultStreamWindowSize); kDefaultStreamWindowSize);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
ASSERT_EQ(client->getAppProtocol(), "h1q-fb"); ASSERT_EQ(client->getAppProtocol(), "h1q-fb");
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
@@ -514,7 +514,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttSuccess) {
auto data = IOBuf::copyBuffer("hello"); auto data = IOBuf::copyBuffer("hello");
auto expected = std::shared_ptr<IOBuf>(IOBuf::copyBuffer("echo ")); auto expected = std::shared_ptr<IOBuf>(IOBuf::copyBuffer("echo "));
expected->prependChain(data->clone()); expected->prependChain(data->clone());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
sendRequestAndResponseAndWait(*expected, data->clone(), streamId, &readCb); sendRequestAndResponseAndWait(*expected, data->clone(), streamId, &readCb);
EXPECT_FALSE(client->getConn().zeroRttWriteCipher); EXPECT_FALSE(client->getConn().zeroRttWriteCipher);
EXPECT_TRUE(client->getConn().statelessResetToken.has_value()); EXPECT_TRUE(client->getConn().statelessResetToken.has_value());
@@ -561,7 +561,7 @@ TEST_P(QuicClientTransportIntegrationTest, ZeroRttRetryPacketTest) {
return true; return true;
}, },
[]() -> Buf { return nullptr; }); []() -> Buf { return nullptr; });
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_TRUE(performedValidation); EXPECT_TRUE(performedValidation);
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
EXPECT_TRUE(client->serverInitialParamsSet()); EXPECT_TRUE(client->serverInitialParamsSet());
@@ -576,7 +576,7 @@ TEST_P(QuicClientTransportIntegrationTest, ZeroRttRetryPacketTest) {
EXPECT_EQ( EXPECT_EQ(
client->peerAdvertisedInitialMaxStreamDataUni(), client->peerAdvertisedInitialMaxStreamDataUni(),
kDefaultStreamWindowSize); kDefaultStreamWindowSize);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
ASSERT_EQ(client->getAppProtocol(), "h1q-fb"); ASSERT_EQ(client->getAppProtocol(), "h1q-fb");
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
@@ -592,7 +592,7 @@ TEST_P(QuicClientTransportIntegrationTest, ZeroRttRetryPacketTest) {
auto expected = std::shared_ptr<IOBuf>(IOBuf::copyBuffer("echo ")); auto expected = std::shared_ptr<IOBuf>(IOBuf::copyBuffer("echo "));
expected->prependChain(data->clone()); expected->prependChain(data->clone());
EXPECT_CALL(clientConnCallback, onReplaySafe()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onReplaySafe()).WillOnce(Invoke([&] {
EXPECT_TRUE(!client->getConn().retryToken.empty()); EXPECT_TRUE(!client->getConn().retryToken.empty());
})); }));
sendRequestAndResponseAndWait(*expected, data->clone(), streamId, &readCb); sendRequestAndResponseAndWait(*expected, data->clone(), streamId, &readCb);
@@ -622,7 +622,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttRejection) {
return true; return true;
}, },
[]() -> Buf { return nullptr; }); []() -> Buf { return nullptr; });
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_TRUE(performedValidation); EXPECT_TRUE(performedValidation);
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
EXPECT_TRUE(client->serverInitialParamsSet()); EXPECT_TRUE(client->serverInitialParamsSet());
@@ -639,7 +639,7 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttRejection) {
kDefaultStreamWindowSize); kDefaultStreamWindowSize);
client->serverInitialParamsSet() = false; client->serverInitialParamsSet() = false;
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
ASSERT_EQ(client->getAppProtocol(), "h1q-fb"); ASSERT_EQ(client->getAppProtocol(), "h1q-fb");
CHECK(client->getConn().zeroRttWriteCipher); CHECK(client->getConn().zeroRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
@@ -685,9 +685,9 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttNotAttempted) {
return true; return true;
}, },
[]() -> Buf { return nullptr; }); []() -> Buf { return nullptr; });
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
EXPECT_FALSE(client->getConn().zeroRttWriteCipher); EXPECT_FALSE(client->getConn().zeroRttWriteCipher);
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
@@ -726,10 +726,10 @@ TEST_P(QuicClientTransportIntegrationTest, TestZeroRttInvalidAppParams) {
return false; return false;
}, },
[]() -> Buf { return nullptr; }); []() -> Buf { return nullptr; });
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_TRUE(performedValidation); EXPECT_TRUE(performedValidation);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
EXPECT_FALSE(client->getConn().zeroRttWriteCipher); EXPECT_FALSE(client->getConn().zeroRttWriteCipher);
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
@@ -759,9 +759,9 @@ TEST_P(QuicClientTransportIntegrationTest, ChangeEventBase) {
NiceMock<MockReadCallback> readCb2; NiceMock<MockReadCallback> readCb2;
folly::ScopedEventBaseThread newEvb; folly::ScopedEventBaseThread newEvb;
expectTransportCallbacks(); expectTransportCallbacks();
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -799,9 +799,9 @@ TEST_P(QuicClientTransportIntegrationTest, ResetClient) {
server2 = nullptr; server2 = nullptr;
}; };
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
CHECK(client->getConn().oneRttWriteCipher); CHECK(client->getConn().oneRttWriteCipher);
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -844,9 +844,9 @@ TEST_P(QuicClientTransportIntegrationTest, TestStatelessResetToken) {
server2 = nullptr; server2 = nullptr;
}; };
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_CALL(clientConnCallback, onTransportReady()).WillOnce(Invoke([&] { EXPECT_CALL(clientConnSetupCallback, onTransportReady()).WillOnce(Invoke([&] {
token1 = client->getConn().statelessResetToken; token1 = client->getConn().statelessResetToken;
eventbase_.terminateLoopSoon(); eventbase_.terminateLoopSoon();
})); }));
@@ -895,7 +895,7 @@ TEST_P(QuicClientTransportIntegrationTest, D6DEnabledTest) {
server_->setTransportSettings(serverSettings); server_->setTransportSettings(serverSettings);
// we only use 1 worker in test // we only use 1 worker in test
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(1, statsCallbacks_.size()); EXPECT_EQ(1, statsCallbacks_.size());
EXPECT_CALL(*statsCallbacks_[0], onConnectionD6DStarted()) EXPECT_CALL(*statsCallbacks_[0], onConnectionD6DStarted())
.WillOnce(Invoke([&] { eventbase_.terminateLoopSoon(); })); .WillOnce(Invoke([&] { eventbase_.terminateLoopSoon(); }));
@@ -933,7 +933,7 @@ TEST_F(QuicClientTransportTest, ReadErrorCloseTransprot) {
TEST_F(QuicClientTransportTest, FirstPacketProcessedCallback) { TEST_F(QuicClientTransportTest, FirstPacketProcessedCallback) {
client->addNewPeerAddress(serverAddr); client->addNewPeerAddress(serverAddr);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
originalConnId = client->getConn().clientConnectionId; originalConnId = client->getConn().clientConnectionId;
ServerConnectionIdParams params(0, 0, 0); ServerConnectionIdParams params(0, 0, 0);
@@ -955,7 +955,7 @@ TEST_F(QuicClientTransportTest, FirstPacketProcessedCallback) {
headerCipher, headerCipher,
initialPacketNum); initialPacketNum);
initialPacketNum++; initialPacketNum++;
EXPECT_CALL(clientConnCallback, onFirstPeerPacketProcessed()).Times(1); EXPECT_CALL(clientConnSetupCallback, onFirstPeerPacketProcessed()).Times(1);
deliverData(serverAddr, ackPacket->coalesce()); deliverData(serverAddr, ackPacket->coalesce());
EXPECT_FALSE(client->hasWriteCipher()); EXPECT_FALSE(client->hasWriteCipher());
@@ -971,7 +971,7 @@ TEST_F(QuicClientTransportTest, FirstPacketProcessedCallback) {
headerCipher, headerCipher,
initialPacketNum); initialPacketNum);
initialPacketNum++; initialPacketNum++;
EXPECT_CALL(clientConnCallback, onFirstPeerPacketProcessed()).Times(0); EXPECT_CALL(clientConnSetupCallback, onFirstPeerPacketProcessed()).Times(0);
deliverData(serverAddr, oneMoreAckPacket->coalesce()); deliverData(serverAddr, oneMoreAckPacket->coalesce());
EXPECT_FALSE(client->hasWriteCipher()); EXPECT_FALSE(client->hasWriteCipher());
@@ -988,7 +988,7 @@ TEST_F(QuicClientTransportTest, CustomTransportParam) {
TEST_F(QuicClientTransportTest, CloseSocketOnWriteError) { TEST_F(QuicClientTransportTest, CloseSocketOnWriteError) {
client->addNewPeerAddress(serverAddr); client->addNewPeerAddress(serverAddr);
EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(EBADF, -1)); EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(EBADF, -1));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_FALSE(client->isClosed()); EXPECT_FALSE(client->isClosed());
EXPECT_CALL(clientConnCallback, onConnectionError(_)); EXPECT_CALL(clientConnCallback, onConnectionError(_));
@@ -1115,7 +1115,7 @@ TEST_F(QuicClientTransportTest, NetworkUnreachableIsFatalToConn) {
setupCryptoLayer(); setupCryptoLayer();
EXPECT_CALL(clientConnCallback, onConnectionError(_)); EXPECT_CALL(clientConnCallback, onConnectionError(_));
EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(ENETUNREACH, -1)); EXPECT_CALL(*sock, write(_, _)).WillOnce(SetErrnoAndReturn(ENETUNREACH, -1));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
loopForWrites(); loopForWrites();
} }
@@ -1131,7 +1131,7 @@ TEST_F(QuicClientTransportTest, HappyEyeballsWithSingleV4Address) {
EXPECT_FALSE(conn.happyEyeballsState.finished); EXPECT_FALSE(conn.happyEyeballsState.finished);
EXPECT_FALSE(conn.peerAddress.isInitialized()); EXPECT_FALSE(conn.peerAddress.isInitialized());
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
EXPECT_TRUE(conn.happyEyeballsState.finished); EXPECT_TRUE(conn.happyEyeballsState.finished);
EXPECT_EQ(conn.peerAddress, serverAddr); EXPECT_EQ(conn.peerAddress, serverAddr);
@@ -1150,7 +1150,7 @@ TEST_F(QuicClientTransportTest, HappyEyeballsWithSingleV6Address) {
EXPECT_FALSE(conn.happyEyeballsState.finished); EXPECT_FALSE(conn.happyEyeballsState.finished);
EXPECT_FALSE(conn.peerAddress.isInitialized()); EXPECT_FALSE(conn.peerAddress.isInitialized());
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
EXPECT_TRUE(conn.happyEyeballsState.finished); EXPECT_TRUE(conn.happyEyeballsState.finished);
EXPECT_EQ(conn.peerAddress, serverAddrV6); EXPECT_EQ(conn.peerAddress, serverAddrV6);
@@ -1159,7 +1159,7 @@ TEST_F(QuicClientTransportTest, HappyEyeballsWithSingleV6Address) {
TEST_F(QuicClientTransportTest, IdleTimerResetOnWritingFirstData) { TEST_F(QuicClientTransportTest, IdleTimerResetOnWritingFirstData) {
client->addNewPeerAddress(serverAddr); client->addNewPeerAddress(serverAddr);
setupCryptoLayer(); setupCryptoLayer();
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
loopForWrites(); loopForWrites();
ASSERT_FALSE(client->getConn().receivedNewPacketBeforeWrite); ASSERT_FALSE(client->getConn().receivedNewPacketBeforeWrite);
ASSERT_TRUE(client->idleTimeout().isScheduled()); ASSERT_TRUE(client->idleTimeout().isScheduled());
@@ -1320,7 +1320,7 @@ class QuicClientTransportHappyEyeballsTest
return buf->computeChainDataLength(); return buf->computeChainDataLength();
})); }));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
@@ -1334,8 +1334,8 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_FALSE(conn.happyEyeballsState.finished); EXPECT_FALSE(conn.happyEyeballsState.finished);
if (firstPacketType == ServerFirstPacketType::ServerHello) { if (firstPacketType == ServerFirstPacketType::ServerHello) {
EXPECT_CALL(clientConnCallback, onTransportReady()); EXPECT_CALL(clientConnSetupCallback, onTransportReady());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
} }
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
EXPECT_CALL(*secondSock, pauseRead()); EXPECT_CALL(*secondSock, pauseRead());
@@ -1365,7 +1365,7 @@ class QuicClientTransportHappyEyeballsTest
return buf->computeChainDataLength(); return buf->computeChainDataLength();
})); }));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
@@ -1402,8 +1402,8 @@ class QuicClientTransportHappyEyeballsTest
socketWrites.clear(); socketWrites.clear();
EXPECT_FALSE(conn.happyEyeballsState.finished); EXPECT_FALSE(conn.happyEyeballsState.finished);
if (firstPacketType == ServerFirstPacketType::ServerHello) { if (firstPacketType == ServerFirstPacketType::ServerHello) {
EXPECT_CALL(clientConnCallback, onTransportReady()); EXPECT_CALL(clientConnSetupCallback, onTransportReady());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
} }
EXPECT_CALL(*sock, write(firstAddress, _)) EXPECT_CALL(*sock, write(firstAddress, _))
.Times(AtLeast(1)) .Times(AtLeast(1))
@@ -1441,7 +1441,7 @@ class QuicClientTransportHappyEyeballsTest
return buf->computeChainDataLength(); return buf->computeChainDataLength();
})); }));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
@@ -1479,8 +1479,8 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_FALSE(conn.happyEyeballsState.finished); EXPECT_FALSE(conn.happyEyeballsState.finished);
if (firstPacketType == ServerFirstPacketType::ServerHello) { if (firstPacketType == ServerFirstPacketType::ServerHello) {
EXPECT_CALL(clientConnCallback, onTransportReady()); EXPECT_CALL(clientConnSetupCallback, onTransportReady());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
} }
EXPECT_CALL(*sock, write(_, _)).Times(0); EXPECT_CALL(*sock, write(_, _)).Times(0);
EXPECT_CALL(*sock, pauseRead()); EXPECT_CALL(*sock, pauseRead());
@@ -1514,7 +1514,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*secondSock, bind(_, _)) EXPECT_CALL(*secondSock, bind(_, _))
.WillOnce(Invoke( .WillOnce(Invoke(
[](const folly::SocketAddress&, auto) { throw std::exception(); })); [](const folly::SocketAddress&, auto) { throw std::exception(); }));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_FALSE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1531,7 +1531,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)) EXPECT_CALL(*sock, write(firstAddress, _))
.WillOnce(SetErrnoAndReturn(EAGAIN, -1)); .WillOnce(SetErrnoAndReturn(EAGAIN, -1));
EXPECT_CALL(*secondSock, write(_, _)); EXPECT_CALL(*secondSock, write(_, _));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
// Continue trying first socket // Continue trying first socket
@@ -1556,7 +1556,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, pauseRead()).Times(2); EXPECT_CALL(*sock, pauseRead()).Times(2);
EXPECT_CALL(*sock, close()).Times(1); EXPECT_CALL(*sock, close()).Times(1);
EXPECT_CALL(*secondSock, write(_, _)); EXPECT_CALL(*secondSock, write(_, _));
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
// Give up first socket // Give up first socket
@@ -1580,7 +1580,7 @@ class QuicClientTransportHappyEyeballsTest
// Socket is paused read for the second time when QuicClientTransport dies // Socket is paused read for the second time when QuicClientTransport dies
EXPECT_CALL(*sock, pauseRead()).Times(2); EXPECT_CALL(*sock, pauseRead()).Times(2);
EXPECT_CALL(*sock, close()).Times(1); EXPECT_CALL(*sock, close()).Times(1);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
// Give up first socket // Give up first socket
@@ -1613,7 +1613,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1649,7 +1649,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1690,7 +1690,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1734,7 +1734,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1770,7 +1770,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1811,7 +1811,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1860,7 +1860,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1897,7 +1897,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -1931,7 +1931,7 @@ class QuicClientTransportHappyEyeballsTest
EXPECT_CALL(*sock, write(firstAddress, _)); EXPECT_CALL(*sock, write(firstAddress, _));
EXPECT_CALL(*secondSock, write(_, _)).Times(0); EXPECT_CALL(*secondSock, write(_, _)).Times(0);
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
EXPECT_EQ(conn.peerAddress, firstAddress); EXPECT_EQ(conn.peerAddress, firstAddress);
EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress); EXPECT_EQ(conn.happyEyeballsState.secondPeerAddress, secondAddress);
EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled()); EXPECT_TRUE(client->happyEyeballsConnAttemptDelayTimeout().isScheduled());
@@ -2155,7 +2155,7 @@ class QuicClientTransportVersionAndRetryTest
~QuicClientTransportVersionAndRetryTest() override = default; ~QuicClientTransportVersionAndRetryTest() override = default;
void start() override { void start() override {
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
originalConnId = client->getConn().clientConnectionId; originalConnId = client->getConn().clientConnectionId;
// create server chosen connId with processId = 0 and workerId = 0 // create server chosen connId with processId = 0 and workerId = 0
ServerConnectionIdParams params(0, 0, 0); ServerConnectionIdParams params(0, 0, 0);
@@ -2186,7 +2186,7 @@ class QuicClientVersionParamInvalidTest
// force the server to declare that the version negotiated was invalid.; // force the server to declare that the version negotiated was invalid.;
mockClientHandshake->negotiatedVersion = MVFST2; mockClientHandshake->negotiatedVersion = MVFST2;
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
originalConnId = client->getConn().clientConnectionId; originalConnId = client->getConn().clientConnectionId;
} }
}; };
@@ -3934,8 +3934,8 @@ TEST_F(
EXPECT_THROW(deliverData(packet.second->coalesce()), std::runtime_error); EXPECT_THROW(deliverData(packet.second->coalesce()), std::runtime_error);
EXPECT_EQ(client->getConn().oneRttWriteCipher.get(), nullptr); EXPECT_EQ(client->getConn().oneRttWriteCipher.get(), nullptr);
EXPECT_CALL(clientConnCallback, onTransportReady()).Times(0); EXPECT_CALL(clientConnSetupCallback, onTransportReady()).Times(0);
EXPECT_CALL(clientConnCallback, onReplaySafe()).Times(0); EXPECT_CALL(clientConnSetupCallback, onReplaySafe()).Times(0);
client->close(folly::none); client->close(folly::none);
} }
@@ -4886,8 +4886,8 @@ class QuicZeroRttClientTest : public QuicClientTransportAfterStartTestBase {
} }
void startClient() { void startClient() {
EXPECT_CALL(clientConnCallback, onTransportReady()); EXPECT_CALL(clientConnSetupCallback, onTransportReady());
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
EXPECT_EQ(socketWrites.size(), 1); EXPECT_EQ(socketWrites.size(), 1);
EXPECT_TRUE( EXPECT_TRUE(
@@ -4947,7 +4947,7 @@ TEST_F(QuicZeroRttClientTest, TestReplaySafeCallback) {
loopForWrites(); loopForWrites();
EXPECT_TRUE(zeroRttPacketsOutstanding()); EXPECT_TRUE(zeroRttPacketsOutstanding());
assertWritten(false, LongHeader::Types::ZeroRtt); assertWritten(false, LongHeader::Types::ZeroRtt);
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
mockClientHandshake->setZeroRttRejected(false); mockClientHandshake->setZeroRttRejected(false);
recvServerHello(); recvServerHello();
@@ -5021,7 +5021,7 @@ TEST_F(QuicZeroRttClientTest, TestEarlyRetransmit0Rtt) {
loopForWrites(); loopForWrites();
EXPECT_TRUE(zeroRttPacketsOutstanding()); EXPECT_TRUE(zeroRttPacketsOutstanding());
assertWritten(false, LongHeader::Types::ZeroRtt); assertWritten(false, LongHeader::Types::ZeroRtt);
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
mockClientHandshake->setZeroRttRejected(false); mockClientHandshake->setZeroRttRejected(false);
recvServerHello(); recvServerHello();
@@ -5091,7 +5091,7 @@ TEST_F(QuicZeroRttClientTest, TestZeroRttRejection) {
client->writeChain(streamId, IOBuf::copyBuffer("hello"), true); client->writeChain(streamId, IOBuf::copyBuffer("hello"), true);
loopForWrites(); loopForWrites();
EXPECT_TRUE(zeroRttPacketsOutstanding()); EXPECT_TRUE(zeroRttPacketsOutstanding());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
mockClientHandshake->setZeroRttRejected(true); mockClientHandshake->setZeroRttRejected(true);
EXPECT_CALL(*mockQuicPskCache_, removePsk(hostname_)); EXPECT_CALL(*mockQuicPskCache_, removePsk(hostname_));
recvServerHello(); recvServerHello();
@@ -5353,7 +5353,7 @@ class QuicProcessDataTest : public QuicClientTransportAfterStartTestBase,
// force the server to declare that the version negotiated was invalid.; // force the server to declare that the version negotiated was invalid.;
mockClientHandshake->negotiatedVersion = QuicVersion::QUIC_V1; mockClientHandshake->negotiatedVersion = QuicVersion::QUIC_V1;
client->setSupportedVersions({QuicVersion::QUIC_V1}); client->setSupportedVersions({QuicVersion::QUIC_V1});
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
} }
}; };

15
quic/fizz/client/test/QuicClientTransportTestUtil.h
View File

@@ -498,10 +498,10 @@ class QuicClientTransportTestBase : public virtual testing::Test {
} }
virtual void start() { virtual void start() {
EXPECT_CALL(clientConnCallback, onTransportReady()); EXPECT_CALL(clientConnSetupCallback, onTransportReady());
EXPECT_CALL(clientConnCallback, onReplaySafe()); EXPECT_CALL(clientConnSetupCallback, onReplaySafe());
setUpSocketExpectations(); setUpSocketExpectations();
client->start(&clientConnCallback); client->start(&clientConnSetupCallback, &clientConnCallback);
setConnectionIds(); setConnectionIds();
EXPECT_TRUE(client->idleTimeout().isScheduled()); EXPECT_TRUE(client->idleTimeout().isScheduled());
@@ -536,7 +536,11 @@ class QuicClientTransportTestBase : public virtual testing::Test {
return client->getNonConstConn(); return client->getNonConstConn();
} }
MockConnectionCallback& getConnCallback() { MockConnectionSetupCallback& getConnSetupCallback() {
return clientConnSetupCallback;
}
MockConnectionCallbackNew& getConnCallback() {
return clientConnCallback; return clientConnCallback;
} }
@@ -877,7 +881,8 @@ class QuicClientTransportTestBase : public virtual testing::Test {
std::deque<TestReadData> socketReads; std::deque<TestReadData> socketReads;
testing::NiceMock<MockDeliveryCallback> deliveryCallback; testing::NiceMock<MockDeliveryCallback> deliveryCallback;
testing::NiceMock<MockReadCallback> readCb; testing::NiceMock<MockReadCallback> readCb;
testing::NiceMock<MockConnectionCallback> clientConnCallback; testing::NiceMock<MockConnectionSetupCallback> clientConnSetupCallback;
testing::NiceMock<MockConnectionCallbackNew> clientConnCallback;
folly::test::MockAsyncUDPSocket* sock; folly::test::MockAsyncUDPSocket* sock;
std::shared_ptr<TestingQuicClientTransport::DestructionCallback> std::shared_ptr<TestingQuicClientTransport::DestructionCallback>
destructionCallback; destructionCallback;

3
quic/samples/echo/EchoHandler.h
View File

@@ -14,7 +14,8 @@
namespace quic { namespace quic {
namespace samples { namespace samples {
class EchoHandler : public quic::QuicSocket::ConnectionCallback, class EchoHandler : public quic::QuicSocket::ConnectionSetupCallback,
public quic::QuicSocket::ConnectionCallbackNew,
public quic::QuicSocket::ReadCallback, public quic::QuicSocket::ReadCallback,
public quic::QuicSocket::WriteCallback { public quic::QuicSocket::WriteCallback {
public: public:

2
quic/samples/echo/EchoServer.h
View File

@@ -46,7 +46,7 @@ class EchoServerTransportFactory : public quic::QuicServerTransportFactory {
CHECK_EQ(evb, sock->getEventBase()); CHECK_EQ(evb, sock->getEventBase());
auto echoHandler = std::make_unique<EchoHandler>(evb); auto echoHandler = std::make_unique<EchoHandler>(evb);
auto transport = quic::QuicServerTransport::make( auto transport = quic::QuicServerTransport::make(
evb, std::move(sock), *echoHandler, ctx); evb, std::move(sock), echoHandler.get(), echoHandler.get(), ctx);
echoHandler->setQuicSocket(transport); echoHandler->setQuicSocket(transport);
echoHandlers_.push_back(std::move(echoHandler)); echoHandlers_.push_back(std::move(echoHandler));
return transport; return transport;

18
quic/server/QuicServerTransport.cpp
View File

@@ -36,6 +36,24 @@ QuicServerTransport::QuicServerTransport(
conn_->ackStates = AckStates(startingPacketNum); conn_->ackStates = AckStates(startingPacketNum);
} }
QuicServerTransport::QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connStreamsCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory,
PacketNum startingPacketNum)
: QuicServerTransport(
evb,
std::move(sock),
connSetupCb,
connStreamsCb,
std::move(ctx),
std::move(cryptoFactory)) {
conn_->ackStates = AckStates(startingPacketNum);
}
QuicServerTransport::QuicServerTransport( QuicServerTransport::QuicServerTransport(
folly::EventBase* evb, folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock, std::unique_ptr<folly::AsyncUDPSocket> sock,

9
quic/server/QuicServerTransport.h
View File

@@ -95,6 +95,15 @@ class QuicServerTransport
std::unique_ptr<CryptoFactory> cryptoFactory, std::unique_ptr<CryptoFactory> cryptoFactory,
PacketNum startingPacketNum); PacketNum startingPacketNum);
QuicServerTransport(
folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connStreamsCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx,
std::unique_ptr<CryptoFactory> cryptoFactory,
PacketNum startingPacketNum);
~QuicServerTransport() override; ~QuicServerTransport() override;
virtual void setRoutingCallback(RoutingCallback* callback) noexcept; virtual void setRoutingCallback(RoutingCallback* callback) noexcept;

3
quic/server/handshake/test/DefaultAppTokenValidatorTest.cpp
View File

@@ -313,7 +313,8 @@ TEST(DefaultAppTokenValidatorTest, TestInvalidAppParams) {
auto quicStats = std::make_shared<MockQuicStats>(); auto quicStats = std::make_shared<MockQuicStats>();
conn.statsCallback = quicStats.get(); conn.statsCallback = quicStats.get();
MockConnectionCallback connCallback; MockConnectionSetupCallback connSetupCallback;
MockConnectionCallbackNew connCallback;
AppToken appToken; AppToken appToken;
appToken.transportParams = createTicketTransportParameters( appToken.transportParams = createTicketTransportParameters(

114
quic/server/test/QuicServerTest.cpp
View File

@@ -71,9 +71,14 @@ TEST_F(SimpleQuicServerWorkerTest, RejectCid) {
auto mockSock = auto mockSock =
std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_); std::make_unique<folly::test::MockAsyncUDPSocket>(&eventbase_);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(addr)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(addr));
MockConnectionCallback mockConnectionCallback; MockConnectionSetupCallback mockConnectionSetupCallback;
MockConnectionCallbackNew mockConnectionCallback;
MockQuicTransport::Ptr transportPtr = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr transportPtr = std::make_shared<MockQuicTransport>(
&eventbase_, std::move(mockSock), mockConnectionCallback, nullptr); &eventbase_,
std::move(mockSock),
&mockConnectionSetupCallback,
&mockConnectionCallback,
nullptr);
workerCb_ = std::make_shared<NiceMock<MockWorkerCallback>>(); workerCb_ = std::make_shared<NiceMock<MockWorkerCallback>>();
worker_ = std::make_unique<QuicServerWorker>(workerCb_); worker_ = std::make_unique<QuicServerWorker>(workerCb_);
auto includeCid = getTestConnectionId(0); auto includeCid = getTestConnectionId(0);
@@ -164,13 +169,18 @@ class QuicServerWorkerTest : public Test {
socketFactory_ = std::make_unique<MockQuicUDPSocketFactory>(); socketFactory_ = std::make_unique<MockQuicUDPSocketFactory>();
EXPECT_CALL(*socketFactory_, _make(_, _)).WillRepeatedly(Return(nullptr)); EXPECT_CALL(*socketFactory_, _make(_, _)).WillRepeatedly(Return(nullptr));
worker_->setNewConnectionSocketFactory(socketFactory_.get()); worker_->setNewConnectionSocketFactory(socketFactory_.get());
NiceMock<MockConnectionCallback> connCb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock = std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>( std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
&eventbase_); &eventbase_);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
transport_.reset(new MockQuicTransport( transport_.reset(new MockQuicTransport(
worker_->getEventBase(), std::move(mockSock), connCb, nullptr)); worker_->getEventBase(),
std::move(mockSock),
&connSetupCb,
&connCb,
nullptr));
factory_ = std::make_unique<MockQuicServerTransportFactory>(); factory_ = std::make_unique<MockQuicServerTransportFactory>();
EXPECT_CALL(*transport_, getEventBase()) EXPECT_CALL(*transport_, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
@@ -536,12 +546,17 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
std::make_unique<SlidingWindowRateLimiter>([]() { return 2; }, 60s)); std::make_unique<SlidingWindowRateLimiter>([]() { return 2; }, 60s));
EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1); EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1);
NiceMock<MockConnectionCallback> connCb1; NiceMock<MockConnectionSetupCallback> connSetupCb1;
NiceMock<MockConnectionCallbackNew> connCb1;
auto mockSock1 = auto mockSock1 =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_));
MockQuicTransport::Ptr testTransport1 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport1 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock1), connCb1, nullptr); worker_->getEventBase(),
std::move(mockSock1),
&connSetupCb1,
&connCb1,
nullptr);
EXPECT_CALL(*testTransport1, getEventBase()) EXPECT_CALL(*testTransport1, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*testTransport1, getOriginalPeerAddress()) EXPECT_CALL(*testTransport1, getOriginalPeerAddress())
@@ -568,12 +583,17 @@ TEST_F(QuicServerWorkerTest, RateLimit) {
eventbase_.loop(); eventbase_.loop();
auto caddr2 = folly::SocketAddress("2.3.4.5", 1234); auto caddr2 = folly::SocketAddress("2.3.4.5", 1234);
NiceMock<MockConnectionCallback> connCb2; NiceMock<MockConnectionSetupCallback> connSetupCb2;
NiceMock<MockConnectionCallbackNew> connCb2;
auto mockSock2 = auto mockSock2 =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2)); EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2));
MockQuicTransport::Ptr testTransport2 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport2 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock2), connCb2, nullptr); worker_->getEventBase(),
std::move(mockSock2),
&connSetupCb2,
&connCb2,
nullptr);
EXPECT_CALL(*testTransport2, getEventBase()) EXPECT_CALL(*testTransport2, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*testTransport2, getOriginalPeerAddress()) EXPECT_CALL(*testTransport2, getOriginalPeerAddress())
@@ -622,12 +642,17 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
worker_->setUnfinishedHandshakeLimit([]() { return 2; }); worker_->setUnfinishedHandshakeLimit([]() { return 2; });
EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1); EXPECT_CALL(*quicStats_, onConnectionRateLimited()).Times(1);
NiceMock<MockConnectionCallback> connCb1; NiceMock<MockConnectionSetupCallback> connSetupCb1;
NiceMock<MockConnectionCallbackNew> connCb1;
auto mockSock1 = auto mockSock1 =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock1, address()).WillRepeatedly(ReturnRef(fakeAddress_));
MockQuicTransport::Ptr testTransport1 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport1 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock1), connCb1, nullptr); worker_->getEventBase(),
std::move(mockSock1),
&connSetupCb1,
&connCb1,
nullptr);
EXPECT_CALL(*testTransport1, getEventBase()) EXPECT_CALL(*testTransport1, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*testTransport1, getOriginalPeerAddress()) EXPECT_CALL(*testTransport1, getOriginalPeerAddress())
@@ -653,12 +678,17 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
eventbase_.loop(); eventbase_.loop();
auto caddr2 = folly::SocketAddress("2.3.4.5", 1234); auto caddr2 = folly::SocketAddress("2.3.4.5", 1234);
NiceMock<MockConnectionCallback> connCb2; NiceMock<MockConnectionSetupCallback> connSetupCb2;
NiceMock<MockConnectionCallbackNew> connCb2;
auto mockSock2 = auto mockSock2 =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2)); EXPECT_CALL(*mockSock2, address()).WillRepeatedly(ReturnRef(caddr2));
MockQuicTransport::Ptr testTransport2 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport2 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock2), connCb2, nullptr); worker_->getEventBase(),
std::move(mockSock2),
&connSetupCb2,
&connCb2,
nullptr);
EXPECT_CALL(*testTransport2, getEventBase()) EXPECT_CALL(*testTransport2, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*testTransport2, getOriginalPeerAddress()) EXPECT_CALL(*testTransport2, getOriginalPeerAddress())
@@ -703,12 +733,17 @@ TEST_F(QuicServerWorkerTest, UnfinishedHandshakeLimit) {
// Finish a handshake. // Finish a handshake.
worker_->onHandshakeFinished(); worker_->onHandshakeFinished();
auto caddr4 = folly::SocketAddress("4.3.4.5", 1234); auto caddr4 = folly::SocketAddress("4.3.4.5", 1234);
NiceMock<MockConnectionCallback> connCb4; NiceMock<MockConnectionSetupCallback> connSetupCb4;
NiceMock<MockConnectionCallbackNew> connCb4;
auto mockSock4 = auto mockSock4 =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock4, address()).WillRepeatedly(ReturnRef(caddr4)); EXPECT_CALL(*mockSock4, address()).WillRepeatedly(ReturnRef(caddr4));
MockQuicTransport::Ptr testTransport4 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport4 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock4), connCb4, nullptr); worker_->getEventBase(),
std::move(mockSock4),
&connSetupCb4,
&connCb4,
nullptr);
EXPECT_CALL(*testTransport4, getEventBase()) EXPECT_CALL(*testTransport4, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*testTransport4, getOriginalPeerAddress()) EXPECT_CALL(*testTransport4, getOriginalPeerAddress())
@@ -824,12 +859,17 @@ TEST_F(QuicServerWorkerTest, TestRetryInvalidInitialDstConnId) {
} }
TEST_F(QuicServerWorkerTest, QuicServerWorkerUnbindBeforeCidAvailable) { TEST_F(QuicServerWorkerTest, QuicServerWorkerUnbindBeforeCidAvailable) {
NiceMock<MockConnectionCallback> connCb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
auto mockSock = auto mockSock =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
MockQuicTransport::Ptr testTransport = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr testTransport = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock), connCb, nullptr); worker_->getEventBase(),
std::move(mockSock),
&connSetupCb,
&connCb,
nullptr);
EXPECT_CALL(*testTransport, getEventBase()) EXPECT_CALL(*testTransport, getEventBase())
.WillRepeatedly(Return(&eventbase_)); .WillRepeatedly(Return(&eventbase_));
@@ -1000,13 +1040,18 @@ TEST_F(QuicServerWorkerTest, QuicServerNewConnection) {
// transport2's connid available. // transport2's connid available.
ConnectionId connId2({2, 4, 5, 6}); ConnectionId connId2({2, 4, 5, 6});
folly::SocketAddress clientAddr2("2.3.4.5", 2345); folly::SocketAddress clientAddr2("2.3.4.5", 2345);
NiceMock<MockConnectionCallback> connCb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
auto mockSock = auto mockSock =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_); std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(&eventbase_);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
MockQuicTransport::Ptr transport2 = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr transport2 = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock), connCb, nullptr); worker_->getEventBase(),
std::move(mockSock),
&connSetupCb,
&connCb,
nullptr);
EXPECT_CALL(*transport2, getEventBase()).WillRepeatedly(Return(&eventbase_)); EXPECT_CALL(*transport2, getEventBase()).WillRepeatedly(Return(&eventbase_));
EXPECT_CALL(*transport2, getOriginalPeerAddress()) EXPECT_CALL(*transport2, getOriginalPeerAddress())
.WillRepeatedly(ReturnRef(kClientAddr)); .WillRepeatedly(ReturnRef(kClientAddr));
@@ -1384,12 +1429,17 @@ TEST_F(QuicServerWorkerTest, AcceptObserver) {
worker_->addAcceptObserver(cb.get()); worker_->addAcceptObserver(cb.get());
auto initTestSocketAndTransport = [this]() { auto initTestSocketAndTransport = [this]() {
NiceMock<MockConnectionCallback> connCb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
auto mockSock = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>( auto mockSock = std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
&eventbase_); &eventbase_);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(fakeAddress_));
MockQuicTransport::Ptr mockTransport = std::make_shared<MockQuicTransport>( MockQuicTransport::Ptr mockTransport = std::make_shared<MockQuicTransport>(
worker_->getEventBase(), std::move(mockSock), connCb, nullptr); worker_->getEventBase(),
std::move(mockSock),
&connSetupCb,
&connCb,
nullptr);
EXPECT_CALL(*mockTransport, setRoutingCallback(nullptr)); EXPECT_CALL(*mockTransport, setRoutingCallback(nullptr));
EXPECT_CALL(*mockTransport, setTransportStatsCallback(nullptr)); EXPECT_CALL(*mockTransport, setTransportStatsCallback(nullptr));
EXPECT_CALL(*mockTransport, getEventBase()) EXPECT_CALL(*mockTransport, getEventBase())
@@ -2041,13 +2091,18 @@ class QuicServerTest : public Test {
// create mock transport // create mock transport
std::shared_ptr<MockQuicTransport> transport; std::shared_ptr<MockQuicTransport> transport;
eventBase->runInEventBaseThreadAndWait([&] { eventBase->runInEventBaseThreadAndWait([&] {
NiceMock<MockConnectionCallback> cb; NiceMock<MockConnectionSetupCallback> connSetupcb;
NiceMock<MockConnectionCallbackNew> connCb;
std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock = std::unique_ptr<folly::test::MockAsyncUDPSocket> mockSock =
std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>( std::make_unique<NiceMock<folly::test::MockAsyncUDPSocket>>(
eventBase); eventBase);
EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(serverAddr)); EXPECT_CALL(*mockSock, address()).WillRepeatedly(ReturnRef(serverAddr));
transport = std::make_shared<MockQuicTransport>( transport = std::make_shared<MockQuicTransport>(
eventBase, std::move(mockSock), cb, quic::test::createServerCtx()); eventBase,
std::move(mockSock),
&connSetupcb,
&connCb,
quic::test::createServerCtx());
}); });
auto makeTransport = auto makeTransport =
@@ -2315,7 +2370,8 @@ class QuicServerTakeoverTest : public Test {
Buf& data, Buf& data,
folly::Baton<>& baton) { folly::Baton<>& baton) {
std::shared_ptr<MockQuicTransport> transport; std::shared_ptr<MockQuicTransport> transport;
NiceMock<MockConnectionCallback> cb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
auto makeTransport = auto makeTransport =
[&](folly::EventBase* eventBase, [&](folly::EventBase* eventBase,
std::unique_ptr<folly::AsyncUDPSocket>& socket, std::unique_ptr<folly::AsyncUDPSocket>& socket,
@@ -2323,7 +2379,7 @@ class QuicServerTakeoverTest : public Test {
std::shared_ptr<const fizz::server::FizzServerContext> std::shared_ptr<const fizz::server::FizzServerContext>
ctx) noexcept { ctx) noexcept {
transport = std::make_shared<MockQuicTransport>( transport = std::make_shared<MockQuicTransport>(
eventBase, std::move(socket), cb, ctx); eventBase, std::move(socket), &connSetupCb, &connCb, ctx);
transport->setClientConnectionId(clientConnId); transport->setClientConnectionId(clientConnId);
// setup expectations // setup expectations
EXPECT_CALL(*transport, getEventBase()) EXPECT_CALL(*transport, getEventBase())
@@ -2882,7 +2938,8 @@ TEST_F(QuicServerTest, ZeroRttPacketRoute) {
setUpTransportFactoryForWorkers(evbs); setUpTransportFactoryForWorkers(evbs);
std::shared_ptr<MockQuicTransport> transport; std::shared_ptr<MockQuicTransport> transport;
NiceMock<MockConnectionCallback> cb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
folly::Baton<> b; folly::Baton<> b;
// create payload // create payload
StreamId id = 1; StreamId id = 1;
@@ -2900,7 +2957,7 @@ TEST_F(QuicServerTest, ZeroRttPacketRoute) {
const folly::SocketAddress&, const folly::SocketAddress&,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) noexcept { std::shared_ptr<const fizz::server::FizzServerContext> ctx) noexcept {
transport = std::make_shared<MockQuicTransport>( transport = std::make_shared<MockQuicTransport>(
eventBase, std::move(socket), cb, ctx); eventBase, std::move(socket), &connSetupCb, &connCb, ctx);
EXPECT_CALL(*transport, getEventBase()) EXPECT_CALL(*transport, getEventBase())
.WillRepeatedly(Return(eventBase)); .WillRepeatedly(Return(eventBase));
EXPECT_CALL(*transport, setSupportedVersions(_)); EXPECT_CALL(*transport, setSupportedVersions(_));
@@ -2976,7 +3033,8 @@ TEST_F(QuicServerTest, ZeroRttBeforeInitial) {
setUpTransportFactoryForWorkers(evbs); setUpTransportFactoryForWorkers(evbs);
std::shared_ptr<MockQuicTransport> transport; std::shared_ptr<MockQuicTransport> transport;
NiceMock<MockConnectionCallback> cb; NiceMock<MockConnectionSetupCallback> connSetupCb;
NiceMock<MockConnectionCallbackNew> connCb;
folly::Baton<> b; folly::Baton<> b;
// create payload // create payload
StreamId id = 1; StreamId id = 1;
@@ -2995,7 +3053,7 @@ TEST_F(QuicServerTest, ZeroRttBeforeInitial) {
const folly::SocketAddress&, const folly::SocketAddress&,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) noexcept { std::shared_ptr<const fizz::server::FizzServerContext> ctx) noexcept {
transport = std::make_shared<MockQuicTransport>( transport = std::make_shared<MockQuicTransport>(
eventBase, std::move(socket), cb, ctx); eventBase, std::move(socket), &connSetupCb, &connCb, ctx);
EXPECT_CALL(*transport, getEventBase()) EXPECT_CALL(*transport, getEventBase())
.WillRepeatedly(Return(eventBase)); .WillRepeatedly(Return(eventBase));
EXPECT_CALL(*transport, setSupportedVersions(_)); EXPECT_CALL(*transport, setSupportedVersions(_));

8
quic/server/test/QuicServerTransportTest.cpp
View File

@@ -2896,14 +2896,14 @@ class QuicUnencryptedServerTransportTest : public QuicServerTransportTest {
TEST_F(QuicUnencryptedServerTransportTest, FirstPacketProcessedCallback) { TEST_F(QuicUnencryptedServerTransportTest, FirstPacketProcessedCallback) {
getFakeHandshakeLayer()->allowZeroRttKeys(); getFakeHandshakeLayer()->allowZeroRttKeys();
EXPECT_CALL(connCallback, onFirstPeerPacketProcessed()).Times(1); EXPECT_CALL(connSetupCallback, onFirstPeerPacketProcessed()).Times(1);
recvClientHello(); recvClientHello();
loopForWrites(); loopForWrites();
AckBlocks acks; AckBlocks acks;
acks.insert(0); acks.insert(0);
auto aead = getInitialCipher(); auto aead = getInitialCipher();
auto headerCipher = getInitialHeaderCipher(); auto headerCipher = getInitialHeaderCipher();
EXPECT_CALL(connCallback, onFirstPeerPacketProcessed()).Times(0); EXPECT_CALL(connSetupCallback, onFirstPeerPacketProcessed()).Times(0);
deliverData(packetToBufCleartext( deliverData(packetToBufCleartext(
createAckPacket( createAckPacket(
server->getNonConstConn(), server->getNonConstConn(),
@@ -3857,14 +3857,14 @@ class QuicServerTransportHandshakeTest
// If 0-rtt is accepted, one rtt write cipher will be available after CHLO // If 0-rtt is accepted, one rtt write cipher will be available after CHLO
// is processed // is processed
if (GetParam().acceptZeroRtt) { if (GetParam().acceptZeroRtt) {
EXPECT_CALL(connCallback, onTransportReady()); EXPECT_CALL(connSetupCallback, onTransportReady());
} }
recvClientHello(); recvClientHello();
// If 0-rtt is disabled, one rtt write cipher will be available after CFIN // If 0-rtt is disabled, one rtt write cipher will be available after CFIN
// is processed // is processed
if (!GetParam().acceptZeroRtt) { if (!GetParam().acceptZeroRtt) {
EXPECT_CALL(connCallback, onTransportReady()); EXPECT_CALL(connSetupCallback, onTransportReady());
} }
// onConnectionIdBound is always invoked after CFIN is processed // onConnectionIdBound is always invoked after CFIN is processed
EXPECT_CALL(routingCallback, onConnectionIdBound(_)); EXPECT_CALL(routingCallback, onConnectionIdBound(_));

21
quic/server/test/QuicServerTransportTestUtil.h
View File

@@ -31,9 +31,15 @@ class TestingQuicServerTransport : public QuicServerTransport {
TestingQuicServerTransport( TestingQuicServerTransport(
folly::EventBase* evb, folly::EventBase* evb,
std::unique_ptr<folly::AsyncUDPSocket> sock, std::unique_ptr<folly::AsyncUDPSocket> sock,
ConnectionCallback& cb, ConnectionSetupCallback* connSetupCb,
ConnectionCallbackNew* connCb,
std::shared_ptr<const fizz::server::FizzServerContext> ctx) std::shared_ptr<const fizz::server::FizzServerContext> ctx)
: QuicServerTransport(evb, std::move(sock), cb, std::move(ctx)) {} : QuicServerTransport(
evb,
std::move(sock),
connSetupCb,
connCb,
std::move(ctx)) {}
QuicTransportBase* getTransport() { QuicTransportBase* getTransport() {
return this; return this;
@@ -135,7 +141,7 @@ class QuicServerTransportTestBase : public virtual testing::Test {
connIdAlgo_ = std::make_unique<DefaultConnectionIdAlgo>(); connIdAlgo_ = std::make_unique<DefaultConnectionIdAlgo>();
ccFactory_ = std::make_shared<ServerCongestionControllerFactory>(); ccFactory_ = std::make_shared<ServerCongestionControllerFactory>();
server = std::make_shared<TestingQuicServerTransport>( server = std::make_shared<TestingQuicServerTransport>(
&evb, std::move(sock), connCallback, serverCtx); &evb, std::move(sock), &connSetupCallback, &connCallback, serverCtx);
server->setCongestionControllerFactory(ccFactory_); server->setCongestionControllerFactory(ccFactory_);
server->setCongestionControl(CongestionControlType::Cubic); server->setCongestionControl(CongestionControlType::Cubic);
server->setRoutingCallback(&routingCallback); server->setRoutingCallback(&routingCallback);
@@ -192,7 +198,11 @@ class QuicServerTransportTestBase : public virtual testing::Test {
return server->getNonConstConn(); return server->getNonConstConn();
} }
MockConnectionCallback& getConnCallback() { MockConnectionSetupCallback& getConnSetupCallback() {
return connSetupCallback;
}
MockConnectionCallbackNew& getConnCallback() {
return connCallback; return connCallback;
} }
@@ -548,7 +558,8 @@ class QuicServerTransportTestBase : public virtual testing::Test {
folly::EventBase evb; folly::EventBase evb;
folly::SocketAddress serverAddr; folly::SocketAddress serverAddr;
folly::SocketAddress clientAddr; folly::SocketAddress clientAddr;
testing::NiceMock<MockConnectionCallback> connCallback; testing::NiceMock<MockConnectionSetupCallback> connSetupCallback;
testing::NiceMock<MockConnectionCallbackNew> connCallback;
testing::NiceMock<MockRoutingCallback> routingCallback; testing::NiceMock<MockRoutingCallback> routingCallback;
testing::NiceMock<MockHandshakeFinishedCallback> handshakeFinishedCallback; testing::NiceMock<MockHandshakeFinishedCallback> handshakeFinishedCallback;
folly::Optional<ConnectionId> clientConnectionId; folly::Optional<ConnectionId> clientConnectionId;

2
quic/server/test/QuicSocketTest.cpp
View File

@@ -21,7 +21,7 @@ using folly::IOBuf;
class QuicSocketTest : public Test { class QuicSocketTest : public Test {
public: public:
void SetUp() override { void SetUp() override {
socket_ = std::make_shared<MockQuicSocket>(&evb_, handler_); socket_ = std::make_shared<MockQuicSocket>(&evb_, &handler_, &handler_);
handler_.setQuicSocket(socket_); handler_.setQuicSocket(socket_);
} }