proxygen: fizz::client::test Namespace Reference

using fizz::client::test::MockHandshakeCallback = typedef MockHandshakeCallbackT<ClientStateMachine>

Definition at line 87 of file Mocks.h.

CachedPsk fizz::client::test::getTestPsk	(	std::string	pskName,
		std::chrono::system_clock::time_point	issueTime
	)

Definition at line 16 of file Utilities.h.

Referenced by fizz::client::test::SynchronizedLruPskCacheTest::getCachedPsk(), and fizz::client::test::ClientProtocolTest::getCachedPsk().

                                                {
   CachedPsk psk;
   psk.psk = std::move(pskName);
   psk.secret = "resumptionsecret";
   psk.type = PskType::Resumption;
   psk.version = ProtocolVersion::tls_1_3;
   psk.cipher = CipherSuite::TLS_AES_128_GCM_SHA256;
   psk.group = NamedGroup::x25519;
   psk.maxEarlyDataSize = 0;
   psk.ticketAgeAdd = 0x11111111;
   psk.ticketIssueTime = issueTime;
   psk.ticketExpirationTime = issueTime + std::chrono::seconds(10);
   psk.alpn = "h2";
   return psk;
 }

fizz::client::test::MATCHER_P	(	BufMatches	,
		expected	,
		""
	)

Definition at line 179 of file AsyncFizzClientTest.cpp.

References folly::eq.

                                     {
   folly::IOBufEqualTo eq;
   return eq(*arg, *expected);
 }

void fizz::client::test::pskEq	(	const CachedPsk &	psk1,
		const CachedPsk &	psk2
	)

Definition at line 34 of file Utilities.h.

References fizz::client::CachedPsk::alpn, fizz::client::CachedPsk::cipher, EXPECT_EQ, fizz::client::CachedPsk::group, fizz::client::CachedPsk::maxEarlyDataSize, fizz::client::CachedPsk::psk, fizz::client::CachedPsk::secret, fizz::client::CachedPsk::ticketAgeAdd, fizz::client::CachedPsk::ticketExpirationTime, fizz::client::CachedPsk::ticketIssueTime, fizz::client::CachedPsk::type, and fizz::client::CachedPsk::version.

Referenced by TEST_F().

                                                          {
   EXPECT_EQ(psk1.psk, psk2.psk);
   EXPECT_EQ(psk1.secret, psk2.secret);
   EXPECT_EQ(psk1.type, psk2.type);
   EXPECT_EQ(psk1.version, psk2.version);
   EXPECT_EQ(psk1.cipher, psk2.cipher);
   EXPECT_EQ(psk1.group, psk2.group);
   EXPECT_EQ(psk1.maxEarlyDataSize, psk2.maxEarlyDataSize);
   EXPECT_EQ(psk1.ticketAgeAdd, psk2.ticketAgeAdd);
   EXPECT_EQ(psk1.ticketIssueTime, psk2.ticketIssueTime);
   EXPECT_EQ(psk1.ticketExpirationTime, psk2.ticketExpirationTime);
   EXPECT_EQ(psk1.alpn, psk2.alpn);
 }

fizz::client::test::TEST_F	(	SynchronizedLruPskCacheTest	,
		TestBasic
	)

Definition at line 39 of file SynchronizedLruPskCacheTest.cpp.

References EXPECT_FALSE, EXPECT_TRUE, and pskEq().

                                                {
   auto psk = getCachedPsk();
   cache_->putPsk("fizz", psk);
   auto cachedPsk = cache_->getPsk("fizz");
   EXPECT_TRUE(cachedPsk);
   pskEq(psk, *cachedPsk);
 
   cache_->removePsk("fizz");
   EXPECT_FALSE(cache_->getPsk("fizz"));
 }

fizz::client::test::TEST_F	(	SynchronizedLruPskCacheTest	,
		TestEviction
	)

Definition at line 50 of file SynchronizedLruPskCacheTest.cpp.

References EXPECT_FALSE, i, and folly::sformat().

                                                   {
   for (int i : {1, 2, 3}) {
     auto pskName = folly::sformat("psk {}", i);
     auto psk = getCachedPsk(pskName);
     cache_->putPsk(pskName, psk);
   }
 
   // Prime 1 to be evicted
   cache_->getPsk("psk 2");
   cache_->getPsk("psk 3");
 
   auto evictingPsk = getCachedPsk("psk 4");
   cache_->putPsk("psk 4", evictingPsk);
 
   auto psk1 = cache_->getPsk("psk 1");
   EXPECT_FALSE(psk1);
 }

fizz::client::test::TEST_F	(	FizzClientTest	,
		TestConnect
	)

Definition at line 61 of file FizzClientTest.cpp.

References testing::_, EXPECT_CALL, testing::InvokeWithoutArgs(), folly::none, sni, and string.

                                     {
   EXPECT_CALL(
       *MockClientStateMachineInstance::instance,
       _processConnect(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([] { return Actions(); }));
   const auto sni = std::string("www.example.com");
   fizzClient_->fizzClient_.connect(context_, nullptr, sni, folly::none);
 }

fizz::client::test::TEST_F	(	FizzClientTest	,
		TestConnectPskIdentity
	)

Definition at line 70 of file FizzClientTest.cpp.

References testing::_, context, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), folly::gen::move, fizz::client::CachedPsk::psk, sni, and string.

                                                {
   std::string psk("psk");
   EXPECT_CALL(
       *MockClientStateMachineInstance::instance,
       _processConnect(_, _, _, _, _, _))
       .WillOnce(
           Invoke([psk](
                      const State&,
                      std::shared_ptr<const FizzClientContext> context,
                      std::shared_ptr<const CertificateVerifier> verifier,
                      folly::Optional<std::string> sni,
                      folly::Optional<CachedPsk> cachedPsk,
                      const std::shared_ptr<ClientExtensions>& extensions) {
             EXPECT_TRUE(cachedPsk);
             EXPECT_EQ(cachedPsk->psk, psk);
             EXPECT_EQ(sni, "www.example.com");
             return Actions();
           }));
   const auto sni = std::string("www.example.com");
   CachedPsk cachedPsk;
   cachedPsk.psk = psk;
   fizzClient_->fizzClient_.connect(
       context_, nullptr, sni, std::move(cachedPsk));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestConnect
	)

Definition at line 184 of file AsyncFizzClientTest.cpp.

References folly::netops::connect().

                                          {
   connect();
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestReadSingle
	)

Definition at line 188 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                             {
   connect();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(
           InvokeWithoutArgs([]() { return detail::actions(WaitForData()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestReadMulti
	)

Definition at line 196 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                            {
   connect();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }))
       .WillOnce(
           InvokeWithoutArgs([]() { return detail::actions(WaitForData()); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestWrite
	)

Definition at line 205 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                        {
   connect();
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestWriteMulti
	)

Definition at line 212 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                             {
   connect();
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP POST"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestWriteErrorState
	)

Definition at line 222 of file AsyncFizzClientTest.cpp.

References testing::_, folly::netops::connect(), folly::IOBuf::copyBuffer(), folly::pushmi::operators::error(), EXPECT_CALL, ON_CALL, testing::Return(), and socket_.

                                                  {
   connect();
   ON_CALL(*socket_, error()).WillByDefault(Return(true));
   EXPECT_CALL(writeCallback_, writeErr_(0, _));
   client_->writeChain(&writeCallback_, IOBuf::copyBuffer("test"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestHandshake
	)

Definition at line 229 of file AsyncFizzClientTest.cpp.

References EXPECT_TRUE.

                                            {
   completeHandshake();
   EXPECT_TRUE(client_->isReplaySafe());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestExporterAPI
	)

Definition at line 234 of file AsyncFizzClientTest.cpp.

References EXPECT_THROW.

                                              {
   EXPECT_THROW(
       client_->getEkm("EXPORTER-Some-Label", nullptr, 32), std::runtime_error);
   completeHandshake();
   client_->getEkm("EXPORTER-Some-Label", nullptr, 32);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestHandshakeError
	)

Definition at line 241 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                 {
   connect();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(ReportError("unit test"), WaitForData());
       }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestHandshakeErrorDelete
	)

Definition at line 251 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                       {
   connect();
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(ReportError("unit test"), WaitForData());
       }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_))
       .WillOnce(InvokeWithoutArgs([this]() { client_.reset(); }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestInvalidTransitionNoAlert
	)

Definition at line 256 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::none, and fizz::client::ClientStateMachine::processAppWrite().

                                                          {
   auto actions = ClientStateMachine().processAppWrite(state_, AppWrite());
   expectError<FizzException>(actions, none, "invalid event");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestInvalidWriteNewSessionTicket
	)

Definition at line 261 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::none, and fizz::client::ClientStateMachine::processWriteNewSessionTicket().

                                                              {
   auto actions = ClientStateMachine().processWriteNewSessionTicket(
       state_, WriteNewSessionTicket());
   expectError<FizzException>(actions, none, "invalid event");
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestDeliverAppData
	)

Definition at line 262 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                 {
   completeHandshake();
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(
             DeliverAppData{IOBuf::copyBuffer("HI")}, WaitForData());
       }));
   EXPECT_CALL(readCallback_, readBufferAvailable_(_));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestInvalidTransitionAlert
	)

Definition at line 267 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), EXPECT_CALL, fizz::client::ClientStateMachine::processAppWrite(), and fizz::unexpected_message.

                                                        {
   setMockRecord();
   EXPECT_CALL(*mockWrite_, _write(_));
   auto actions = ClientStateMachine().processAppWrite(state_, AppWrite());
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "invalid event");
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestWriteToSocket
	)

Definition at line 274 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::WriteToSocket::contents, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, fizz::Handshake, fizz::handshake, testing::InvokeWithoutArgs(), folly::gen::move, socket_, and fizz::detail::write().

                                                {
   completeHandshake();
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         TLSContent record;
         record.contentType = ContentType::handshake;
         record.data = IOBuf::copyBuffer("XYZ");
         record.encryptionLevel = EncryptionLevel::Handshake;
         WriteToSocket write;
         write.contents.emplace_back(std::move(record));
         return detail::actions(std::move(write), WaitForData());
       }));
   EXPECT_CALL(*socket_, writeChain(_, _, _));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestInvalidTransitionError
	)

Definition at line 275 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::Error, and fizz::client::ClientStateMachine::processAppWrite().

                                                        {
   state_.state() = StateEnum::Error;
   auto actions = ClientStateMachine().processAppWrite(state_, AppWrite());
   expectActions<ReportError>(actions);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectFlow
	)

Definition at line 281 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), fizz::TLSContent::contentType, fizz::Connect::context, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::Connect::sni, fizz::Connect::verifier, verifier_, fizz::detail::write(), and fizz::x25519.

                                             {
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextReadRecordLayer>();
         mockRead_ = ret.get();
         return ret;
       }));
   EXPECT_CALL(*factory_, makePlaintextWriteRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextWriteRecordLayer>();
         mockWrite_ = ret.get();
         EXPECT_CALL(*ret, _writeInitialClientHello(_))
             .WillOnce(Invoke([](Buf& encoded) {
               EXPECT_TRUE(IOBufEqualTo()(
                   encoded, encodeHandshake(getDefaultClientHello())));
               TLSContent record;
               record.contentType = ContentType::handshake;
               record.encryptionLevel = EncryptionLevel::Plaintext;
               record.data = IOBuf::copyBuffer("writtenchlo");
               return record;
             }));
         return ret;
       }));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("keyshare");
         }));
         mockKex = ret.get();
         return ret;
       }));
 
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   connect.verifier = verifier_;
   auto actions = detail::processEvent(state_, std::move(connect));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenchlo")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.readRecordLayer().get(), mockRead_);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.encodedClientHello(), encodeHandshake(getDefaultClientHello())));
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::x25519).get(), mockKex);
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_EQ(*state_.sni(), "www.hostname.com");
   Random random;
   random.fill(0x44);
   EXPECT_EQ(*state_.clientRandom(), random);
   EXPECT_FALSE(state_.attemptedPsk().hasValue());
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.earlyWriteRecordLayer().get(), nullptr);
   EXPECT_FALSE(state_.earlyDataParams().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestMutateState
	)

Definition at line 291 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::client::Error, EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), fizz::test::State::state(), and uint32_t.

                                              {
   completeHandshake();
   client_->setReadCB(&readCallback_);
   uint32_t numTimesRun = 0;
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([&numTimesRun]() {
         return detail::actions(
             [&numTimesRun](State& newState) {
               numTimesRun++;
               newState.state() = StateEnum::Error;
             },
             WaitForData());
       }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
   EXPECT_EQ(client_->getState().state(), StateEnum::Error);
   EXPECT_EQ(numTimesRun, 1);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestCloseHandshake
	)

Definition at line 309 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), folly::netops::connect(), EXPECT_CALL, and socket_.

                                                 {
   connect();
   expectAppClose();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   client_->closeNow();
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestConnecting
	)

Definition at line 317 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::netops::connect(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), ON_CALL, testing::Return(), and socket_.

                                             {
   ON_CALL(*socket_, connecting()).WillByDefault(Return(true));
   EXPECT_TRUE(client_->connecting());
   ON_CALL(*socket_, connecting()).WillByDefault(Return(false));
   connect();
   EXPECT_TRUE(client_->connecting());
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(ReportHandshakeSuccess(), WaitForData());
       }));
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("ClientHello"));
   EXPECT_FALSE(client_->connecting());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestGoodSocket
	)

Definition at line 332 of file AsyncFizzClientTest.cpp.

References folly::netops::connect(), EXPECT_FALSE, EXPECT_TRUE, ON_CALL, testing::Return(), and socket_.

                                             {
   connect();
   ON_CALL(*socket_, good()).WillByDefault(Return(true));
   EXPECT_TRUE(client_->good());
   ON_CALL(*socket_, good()).WillByDefault(Return(false));
   EXPECT_FALSE(client_->good());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestGoodState
	)

Definition at line 340 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::client::Error, EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, testing::InvokeWithoutArgs(), ON_CALL, testing::Return(), socket_, and fizz::test::State::state().

                                            {
   completeHandshake();
   ON_CALL(*socket_, good()).WillByDefault(Return(true));
   EXPECT_TRUE(client_->good());
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(
             [](State& newState) { newState.state() = StateEnum::Error; });
       }));
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   EXPECT_FALSE(client_->good());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskFlow
	)

Definition at line 350 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::TLSContent::contentType, fizz::Connect::context, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::detail::getFinishedData(), fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::NotAttempted, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::ResumptionPskBinder, fizz::Connect::sni, fizz::TLS_AES_128_GCM_SHA256, fizz::Connect::verifier, verifier_, fizz::detail::write(), and fizz::x25519.

                                                {
   auto psk = getCachedPsk();
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextReadRecordLayer>();
         mockRead_ = ret.get();
         return ret;
       }));
   EXPECT_CALL(*factory_, makePlaintextWriteRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextWriteRecordLayer>();
         mockWrite_ = ret.get();
         EXPECT_CALL(*ret, _writeInitialClientHello(_))
             .WillOnce(Invoke([](Buf&) {
               TLSContent record;
               record.contentType = ContentType::handshake;
               record.encryptionLevel = EncryptionLevel::Plaintext;
               record.data = IOBuf::copyBuffer("writtenchlo");
               return record;
             }));
         return ret;
       }));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("keyshare");
         }));
         mockKex = ret.get();
         return ret;
       }));
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   Sequence contextSeq;
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumptionsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(EarlySecrets::ResumptionPskBinder, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'k'});
       }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bk")))
       .InSequence(contextSeq)
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("binder"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
 
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   connect.cachedPsk = psk;
   connect.verifier = verifier_;
   auto actions = detail::processEvent(state_, std::move(connect));
 
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenchlo")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.readRecordLayer().get(), mockRead_);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::x25519).get(), mockKex);
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_EQ(*state_.sni(), "www.hostname.com");
   Random random;
   random.fill(0x44);
   EXPECT_EQ(*state_.clientRandom(), random);
   EXPECT_TRUE(state_.legacySessionId().value()->empty());
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_EQ(state_.attemptedPsk()->psk, psk.psk);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_EQ(state_.earlyWriteRecordLayer().get(), nullptr);
   EXPECT_FALSE(state_.earlyDataParams().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestSocketConnect
	)

Definition at line 353 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), EXPECT_CALL, fizz::client::test::MockClientStateMachineInstance::instance, testing::Invoke(), testing::InvokeWithoutArgs(), folly::EventBase::loop(), and string.

                                                {
   MockConnectCallback cb;
   EventBase evb;
   auto evbClient = AsyncFizzClientT<MockClientStateMachineInstance>::UniquePtr(
       new AsyncFizzClientT<MockClientStateMachineInstance>(&evb, context_));
 
   machine_ = MockClientStateMachineInstance::instance;
   auto server = std::make_unique<TestServer>();
 
   EXPECT_CALL(*machine_, _processConnect(_, _, _, _, _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return detail::actions(ReportHandshakeSuccess(), WaitForData());
       }));
   EXPECT_CALL(cb, _connectSuccess()).WillOnce(Invoke([&evbClient]() {
     evbClient->closeNow();
   }));
 
   evbClient->connect(
       server->getAddress(),
       &cb,
       nullptr,
       std::string("www.example.com"),
       pskIdentity_);
 
   evb.loop();
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestSocketConnectWithUnsupportedTransport
	)

Definition at line 380 of file AsyncFizzClientTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_THAT, testing::HasSubstr(), testing::Invoke(), testing::Return(), socket_, and string.

                                                                        {
   MockConnectCallback cb;
   EXPECT_CALL(cb, _connectErr(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_THAT(ex.what(), HasSubstr("could not find underlying socket"));
       }));
   EXPECT_CALL(*socket_, getWrappedTransport()).WillOnce(Return(nullptr));
   client_->connect(
       SocketAddress(),
       &cb,
       nullptr,
       std::string("www.example.com"),
       pskIdentity_);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestHandshakeConnectWithUnopenedSocket
	)

Definition at line 395 of file AsyncFizzClientTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_FALSE, EXPECT_THAT, testing::HasSubstr(), fizz::client::test::MockClientStateMachineInstance::instance, testing::Invoke(), string, folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                                                                     {
   client_.reset();
   EventBase evb;
   auto evbClient = AsyncFizzClientT<MockClientStateMachineInstance>::UniquePtr(
       new AsyncFizzClientT<MockClientStateMachineInstance>(&evb, context_));
   machine_ = MockClientStateMachineInstance::instance;
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeError(_))
       .WillOnce(Invoke([](exception_wrapper ex) {
         EXPECT_THAT(
             ex.what().toStdString(),
             HasSubstr("handshake connect called but socket isn't open"));
       }));
   EXPECT_CALL(*machine_, _processConnect(_, _, _, _, _, _)).Times(0);
   evbClient->connect(
       &handshakeCallback_,
       nullptr,
       std::string("www.example.com"),
       pskIdentity_);
   EXPECT_FALSE(evbClient->good());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestSocketConnectWithOpenSocket
	)

Definition at line 416 of file AsyncFizzClientTest.cpp.

References testing::_, folly::AsyncSocketException::ALREADY_OPEN, folly::AsyncSocket::ConnectCallback::connectErr(), EXPECT_CALL, EXPECT_THAT, testing::HasSubstr(), testing::Invoke(), testing::Return(), socket_, and string.

                                                              {
   MockConnectCallback cb;
   EXPECT_CALL(cb, _connectErr(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_THAT(ex.what(), HasSubstr("socket already open"));
       }));
   EventBase evb;
   MockAsyncSocket mockSocket(&evb);
   EXPECT_CALL(*socket_, getWrappedTransport()).WillOnce(Return(&mockSocket));
   EXPECT_CALL(mockSocket, connect_(_, _, _, _, _))
       .WillOnce(Invoke([](AsyncSocket::ConnectCallback* cb,
                           const SocketAddress&,
                           int,
                           const AsyncSocket::OptionMap&,
                           const SocketAddress&) {
         cb->connectErr(AsyncSocketException(
             AsyncSocketException::ALREADY_OPEN, "socket already open"));
       }));
   EXPECT_CALL(*machine_, _processConnect(_, _, _, _, _, _)).Times(0);
   client_->connect(
       SocketAddress(),
       &cb,
       nullptr,
       std::string("www.example.com"),
       pskIdentity_);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestApplicationProtocol
	)

Definition at line 443 of file AsyncFizzClientTest.cpp.

References EXPECT_EQ.

                                                      {
   completeHandshake();
   EXPECT_EQ(client_->getApplicationProtocol(), "h2");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskEarlyFlow
	)

Definition at line 446 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::Attempted, fizz::Connect::cachedPsk, fizz::ClientEarlyTraffic, folly::netops::connect(), fizz::TLSContent::contentType, fizz::Connect::context, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::EarlyExporter, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::detail::getFinishedData(), fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), makeRandom(), folly::gen::move, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::ResumptionPskBinder, fizz::Connect::sni, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::Connect::verifier, verifier_, fizz::detail::write(), and fizz::x25519.

                                                     {
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 9000;
   EXPECT_CALL(*factory_, makePlaintextReadRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextReadRecordLayer>();
         mockRead_ = ret.get();
         return ret;
       }));
   EXPECT_CALL(*factory_, makePlaintextWriteRecordLayer())
       .WillOnce(Invoke([this]() {
         auto ret = std::make_unique<MockPlaintextWriteRecordLayer>();
         mockWrite_ = ret.get();
         EXPECT_CALL(*ret, _writeInitialClientHello(_))
             .WillOnce(Invoke([](Buf&) {
               TLSContent record;
               record.contentType = ContentType::handshake;
               record.encryptionLevel = EncryptionLevel::Plaintext;
               record.data = IOBuf::copyBuffer("writtenchlo");
               return record;
             }));
         return ret;
       }));
   EXPECT_CALL(*factory_, makeRandom()).WillOnce(Invoke([]() {
     Random random;
     random.fill(0x44);
     return random;
   }));
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("keyshare");
         }));
         mockKex = ret.get();
         return ret;
       }));
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   Sequence contextSeq;
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumptionsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(EarlySecrets::ResumptionPskBinder, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'k'});
       }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("bk")))
       .InSequence(contextSeq)
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("binder"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("chlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::EarlyExporter, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'e', 'e'});
       }));
 
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(EarlySecrets::ClientEarlyTraffic, RangeMatches("chlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'e', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cet"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientearlykey"),
                           IOBuf::copyBuffer("clientearlyiv")};
       }));
   MockAead* earlyAead;
   MockEncryptedWriteRecordLayer* earlyRecordLayer;
   expectAeadCreation({{"clientearlykey", &earlyAead}});
   expectEncryptedWriteRecordLayerCreation(
       &earlyRecordLayer, &earlyAead, StringPiece("cet"));
 
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   connect.cachedPsk = psk;
   connect.verifier = verifier_;
   auto actions = detail::processEvent(state_, std::move(connect));
 
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenchlo")));
   auto earlySuccess = expectAction<ReportEarlyHandshakeSuccess>(actions);
   EXPECT_EQ(earlySuccess.maxEarlyDataSize, 9000);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.readRecordLayer().get(), mockRead_);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::x25519).get(), mockKex);
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_EQ(*state_.sni(), "www.hostname.com");
   Random random;
   random.fill(0x44);
   EXPECT_EQ(*state_.clientRandom(), random);
   EXPECT_TRUE(state_.legacySessionId().value()->empty());
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_EQ(state_.attemptedPsk()->psk, psk.psk);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Attempted);
   EXPECT_EQ(state_.earlyWriteRecordLayer().get(), earlyRecordLayer);
   EXPECT_EQ(state_.earlyDataParams()->version, TestProtocolVersion);
   EXPECT_EQ(
       state_.earlyDataParams()->cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.earlyDataParams()->serverCert, mockLeaf_);
   EXPECT_EQ(state_.earlyDataParams()->clientCert, mockClientCert_);
   EXPECT_EQ(state_.earlyDataParams()->alpn, "h2");
   EXPECT_TRUE(IOBufEqualTo()(
       state_.earlyDataParams()->earlyExporterSecret, IOBuf::copyBuffer("ee")));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestApplicationProtocolNone
	)

Definition at line 448 of file AsyncFizzClientTest.cpp.

References folly::netops::connect(), EXPECT_CALL, and EXPECT_EQ.

                                                          {
   connect();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   fullHandshakeSuccess(false, "");
   EXPECT_EQ(client_->getApplicationProtocol(), "");
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestPskResumed
	)

Definition at line 455 of file AsyncFizzClientTest.cpp.

References folly::netops::connect(), EXPECT_CALL, and EXPECT_TRUE.

                                             {
   connect();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   fullHandshakeSuccess(false, "h2", nullptr, nullptr, true);
   EXPECT_TRUE(client_->pskResumed());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestNoPskResumption
	)

Definition at line 462 of file AsyncFizzClientTest.cpp.

References folly::netops::connect(), EXPECT_CALL, and EXPECT_FALSE.

                                                  {
   connect();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   fullHandshakeSuccess(false, "h2", nullptr, nullptr, false);
   EXPECT_FALSE(client_->pskResumed());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestGetCertsNone
	)

Definition at line 469 of file AsyncFizzClientTest.cpp.

References EXPECT_EQ.

                                               {
   completeHandshake();
   EXPECT_EQ(client_->getSelfCert(), nullptr);
   EXPECT_EQ(client_->getPeerCert(), nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestGetCerts
	)

Definition at line 475 of file AsyncFizzClientTest.cpp.

References clientCert, folly::netops::connect(), EXPECT_CALL, EXPECT_EQ, and serverCert.

                                           {
   auto clientCert = std::make_shared<MockCert>();
   auto serverCert = std::make_shared<MockCert>();
   connect();
   EXPECT_CALL(handshakeCallback_, _fizzHandshakeSuccess());
   fullHandshakeSuccess(false, "h2", clientCert, serverCert);
   EXPECT_CALL(*clientCert, getX509());
   EXPECT_EQ(client_->getSelfCert(), nullptr);
   EXPECT_CALL(*serverCert, getX509());
   EXPECT_EQ(client_->getPeerCert(), nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshake
	)

Definition at line 487 of file AsyncFizzClientTest.cpp.

References EXPECT_TRUE.

                                                 {
   completeEarlyHandshake();
   fullHandshakeSuccess(true);
   EXPECT_TRUE(client_->isReplaySafe());
   EXPECT_TRUE(client_->pskResumed());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyParams
	)

Definition at line 494 of file AsyncFizzClientTest.cpp.

References clientCert, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::gen::move, params, and serverCert.

                                              {
   auto clientCert = std::make_shared<MockCert>();
   auto serverCert = std::make_shared<MockCert>();
   auto params = getEarlyDataParams();
   params.clientCert = clientCert;
   params.serverCert = serverCert;
   completeEarlyHandshake(std::move(params));
   EXPECT_EQ(client_->getApplicationProtocol(), "h2");
   EXPECT_CALL(*clientCert, getX509());
   EXPECT_EQ(client_->getSelfCert(), nullptr);
   EXPECT_CALL(*serverCert, getX509());
   EXPECT_EQ(client_->getPeerCert(), nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyApplicationProtocolNone
	)

Definition at line 508 of file AsyncFizzClientTest.cpp.

References EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::gen::move, folly::none, and params.

                                                               {
   auto params = getEarlyDataParams();
   params.alpn = none;
   completeEarlyHandshake(std::move(params));
   EXPECT_EQ(client_->getApplicationProtocol(), "");
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeWrite
	)

Definition at line 515 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                      {
   completeEarlyHandshake();
 
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
 
   fullHandshakeSuccess(true);
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP POST"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeReplaySafeCallback
	)

Definition at line 529 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, testing::Invoke(), and testing::InvokeWithoutArgs().

                                                                   {
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(InvokeWithoutArgs([]() { return detail::actions(); }));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).WillOnce(Invoke([this]() {
     client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP POST"));
   }));
   fullHandshakeSuccess(true);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeReplaySafeCallbackRemoved
	)

Definition at line 541 of file AsyncFizzClientTest.cpp.

References EXPECT_CALL.

                                                                          {
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReplaySafetyCallback(nullptr);
 
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(true);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeOverLimit
	)

Definition at line 550 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::EarlyAppWrite::data, fizz::AppWrite::data, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), s, and fizz::detail::write().

                                                          {
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
 
   auto earlyWrite = IOBuf::copyBuffer("earlywrite");
   auto longWrite = IOBuf::create(2000);
   std::memset(longWrite->writableData(), 'a', 2000);
   longWrite->append(2000);
   auto shortWrite = IOBuf::copyBuffer("shortwrite");
   auto replaySafeWrite = IOBuf::copyBuffer("replaysafe");
 
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([&earlyWrite](const State&, EarlyAppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, earlyWrite));
         return detail::actions();
       }));
   client_->writeChain(nullptr, earlyWrite->clone());
   client_->writeChain(nullptr, longWrite->clone());
   client_->writeChain(nullptr, shortWrite->clone());
 
   Sequence s;
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([&longWrite](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, longWrite));
         return detail::actions();
       }));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([&shortWrite](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, shortWrite));
         return detail::actions();
       }));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([&replaySafeWrite](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, replaySafeWrite));
         return detail::actions();
       }));
 
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_())
       .WillOnce(Invoke([this, &replaySafeWrite]() {
         client_->writeChain(nullptr, replaySafeWrite->clone());
       }));
   fullHandshakeSuccess(true);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectNoHostNoPsk
	)

Definition at line 579 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, and fizz::client::detail::processEvent().

                                                    {
   Connect connect;
   connect.context = context_;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.attemptedPsk().hasValue());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskBadVersion
	)

Definition at line 589 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::tls_1_2.

                                                      {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.version = ProtocolVersion::tls_1_2;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.attemptedPsk().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeAllOverLimit
	)

Definition at line 597 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::create(), fizz::AppWrite::data, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), and fizz::detail::write().

                                                             {
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
 
   auto buf = IOBuf::create(2000);
   std::memset(buf->writableData(), 'a', 2000);
   buf->append(2000);
   client_->writeChain(nullptr, buf->clone());
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(Invoke([&buf](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, buf));
         return detail::actions();
       }));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_());
   fullHandshakeSuccess(true);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskBadCipher
	)

Definition at line 602 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::client::detail::processEvent(), fizz::TLS_AES_128_GCM_SHA256, and fizz::TLS_AES_256_GCM_SHA384.

                                                     {
   context_->setSupportedCiphers({CipherSuite::TLS_AES_128_GCM_SHA256});
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.attemptedPsk().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedFatalError
	)

Definition at line 615 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), folly::IOBuf::copyBuffer(), folly::IOBuf::create(), EXPECT_CALL, fizz::client::FatalConnectionError, folly::gen::move, and socket_.

                                                                   {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::FatalConnectionError);
   completeEarlyHandshake();
 
   auto buf = IOBuf::create(2000);
   std::memset(buf->writableData(), 'a', 2000);
   buf->append(2000);
   client_->writeChain(nullptr, std::move(buf));
   client_->writeChain(&writeCallback_, IOBuf::copyBuffer("write"));
 
   EXPECT_CALL(writeCallback_, writeErr_(0, _));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectSeparatePskIdentity
	)

Definition at line 616 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Connect::sni.

                                                            {
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   auto psk = getCachedPsk();
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.attemptedPsk()->psk, psk.psk);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskIdentityWithoutSni
	)

Definition at line 629 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, and fizz::client::detail::processEvent().

                                                              {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.attemptedPsk()->psk, psk.psk);
   EXPECT_FALSE(state_.sni().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedPendingWriteError
	)

Definition at line 631 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::client::FatalConnectionError, folly::AsyncSocketException::getType(), testing::Invoke(), and socket_.

                                                                          {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::FatalConnectionError);
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectNoSni
	)

Definition at line 642 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, folly::netops::connect(), fizz::Connect::context, fizz::encodeHandshake(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), fizz::server_name, fizz::Connect::verifier, and verifier_.

                                              {
   Connect connect;
   connect.context = context_;
   connect.verifier = verifier_;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   auto chlo = getDefaultClientHello();
   TestMessages::removeExtension(chlo, ExtensionType::server_name);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.encodedClientHello(), encodeHandshake(std::move(chlo))));
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_FALSE(state_.sni().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedAutoResendNoData
	)

Definition at line 646 of file AsyncFizzClientTest.cpp.

References fizz::client::AutomaticResend, and EXPECT_CALL.

                                                                         {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_());
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedAutoResend
	)

Definition at line 655 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::client::AutomaticResend, folly::IOBuf::copyBuffer(), fizz::EarlyAppWrite::data, fizz::AppWrite::data, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), and fizz::detail::write().

                                                                   {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
 
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([](const State&, EarlyAppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaa")));
         return detail::actions();
       }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("aaaa"));
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([](const State&, EarlyAppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("bbbb")));
         return detail::actions();
       }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("bbbb"));
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(Invoke([](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaabbbb")));
         return detail::actions();
       }));
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectNoAlpn
	)

Definition at line 658 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, chlo, folly::netops::connect(), fizz::Connect::context, fizz::encodeHandshake(), EXPECT_EQ, EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::Connect::sni.

                                               {
   context_->setSupportedAlpns({});
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   auto chlo = getDefaultClientHello();
   TestMessages::removeExtension(
       chlo, ExtensionType::application_layer_protocol_negotiation);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.encodedClientHello(), encodeHandshake(std::move(chlo))));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectExtension
	)

Definition at line 674 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), chlo, folly::netops::connect(), fizz::Connect::context, folly::IOBuf::copyBuffer(), fizz::encodeHandshake(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::Extension::extension_data, fizz::Extension::extension_type, fizz::Connect::extensions, testing::InvokeWithoutArgs(), folly::gen::move, fizz::client::detail::processEvent(), fizz::Connect::sni, fizz::token_binding, fizz::Connect::verifier, and verifier_.

                                                  {
   Connect connect;
   connect.context = context_;
   connect.verifier = verifier_;
   connect.sni = "www.hostname.com";
   auto extensions = std::make_shared<MockClientExtensions>();
   connect.extensions = extensions;
   EXPECT_CALL(*extensions, getClientHelloExtensions())
       .WillOnce(InvokeWithoutArgs([]() {
         Extension ext;
         ext.extension_type = ExtensionType::token_binding;
         ext.extension_data = folly::IOBuf::copyBuffer("some extension");
         std::vector<Extension> exts;
         exts.push_back(std::move(ext));
         return exts;
       }));
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   auto chlo = getDefaultClientHello();
   Extension ext;
   ext.extension_type = ExtensionType::token_binding;
   ext.extension_data = folly::IOBuf::copyBuffer("some extension");
   chlo.extensions.push_back(std::move(ext));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.encodedClientHello(), encodeHandshake(std::move(chlo))));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedAutoResendOrder
	)

Definition at line 681 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::client::AutomaticResend, folly::IOBuf::copyBuffer(), folly::IOBuf::create(), fizz::EarlyAppWrite::data, fizz::AppWrite::data, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), s, and fizz::detail::write().

                                                                        {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
 
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([](const State&, EarlyAppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaa")));
         return detail::actions();
       }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("aaaa"));
   auto buf = IOBuf::create(2000);
   std::memset(buf->writableData(), 'b', 2000);
   buf->append(2000);
   client_->writeChain(nullptr, buf->clone());
 
   Sequence s;
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaa")));
         return detail::actions();
       }));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([&buf](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, buf));
         return detail::actions();
       }));
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .InSequence(s)
       .WillOnce(Invoke([](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("cccc")));
         return detail::actions();
       }));
 
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).WillOnce(Invoke([this]() {
     client_->writeChain(nullptr, IOBuf::copyBuffer("cccc"));
   }));
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectMultipleShares
	)

Definition at line 703 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::netops::connect(), fizz::Connect::context, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, fizz::client::detail::processEvent(), fizz::secp256r1, fizz::Connect::sni, and fizz::x25519.

                                                       {
   MockKeyExchange* mockKex1;
   MockKeyExchange* mockKex2;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::x25519))
       .WillOnce(InvokeWithoutArgs([&mockKex1]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("x25519share");
         }));
         mockKex1 = ret.get();
         return ret;
       }));
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::secp256r1))
       .WillOnce(InvokeWithoutArgs([&mockKex2]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("p256share");
         }));
         mockKex2 = ret.get();
         return ret;
       }));
 
   context_->setDefaultShares({NamedGroup::x25519, NamedGroup::secp256r1});
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.keyExchangers()->size(), 2);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::x25519).get(), mockKex1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::secp256r1).get(), mockKex2);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyHandshakeRejectedAutoResendDeletedBuffer
	)

Definition at line 724 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::client::AutomaticResend, folly::IOBuf::copyBuffer(), fizz::EarlyAppWrite::data, fizz::AppWrite::data, EXPECT_CALL, EXPECT_TRUE, testing::Invoke(), and fizz::detail::write().

                                                                                {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
 
   auto buf = IOBuf::copyBuffer("aaaa");
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([&buf](const State&, EarlyAppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaa")));
         buf.reset();
         return detail::actions();
       }));
   client_->write(nullptr, buf->data(), buf->length());
 
   EXPECT_CALL(*machine_, _processAppWrite(_, _))
       .WillOnce(Invoke([](const State&, AppWrite& write) {
         EXPECT_TRUE(IOBufEqualTo()(write.data, IOBuf::copyBuffer("aaaa")));
         return detail::actions();
       }));
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectCachedGroup
	)

Definition at line 740 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, fizz::client::detail::processEvent(), fizz::secp256r1, and fizz::x25519.

                                                    {
   context_->setDefaultShares({NamedGroup::x25519});
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::secp256r1))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("p256share");
         }));
         mockKex = ret.get();
         return ret;
       }));
 
   auto psk = getCachedPsk();
   psk.group = NamedGroup::secp256r1;
 
   Connect connect;
   connect.context = context_;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::secp256r1).get(), mockKex);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectResendDifferentAlpn
	)

Definition at line 746 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, folly::AsyncSocketException::getType(), testing::Invoke(), and socket_.

                                                                 {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false, "h3");
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectResendDifferentNoAlpn
	)

Definition at line 761 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, folly::AsyncSocketException::getType(), testing::Invoke(), and socket_.

                                                                   {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   completeEarlyHandshake();
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false, "h3");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectNoShares
	)

Definition at line 768 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Connect::sni.

                                                 {
   context_->setDefaultShares({});
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.keyExchangers()->size(), 0);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectResendDifferentVersion
	)

Definition at line 776 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, socket_, and fizz::tls_1_2.

                                                                    {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto params = getEarlyDataParams();
   params.version = ProtocolVersion::tls_1_2;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskEarly
	)

Definition at line 780 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_TRUE, folly::gen::move, and fizz::client::detail::processEvent().

                                                 {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 1000;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Attempted);
   EXPECT_TRUE(state_.earlyDataParams().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectResendDifferentCipher
	)

Definition at line 793 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, socket_, and fizz::TLS_AES_256_GCM_SHA384.

                                                                   {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto params = getEarlyDataParams();
   params.cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskEarlyNoAlpn
	)

Definition at line 795 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_TRUE, folly::gen::move, folly::none, and fizz::client::detail::processEvent().

                                                       {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 1000;
   psk.alpn = folly::none;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Attempted);
   EXPECT_TRUE(state_.earlyDataParams().hasValue());
   EXPECT_EQ(state_.earlyDataParams()->alpn, folly::none);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectNoClientCert
	)

Definition at line 810 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, and socket_.

                                                          {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto params = getEarlyDataParams();
   params.clientCert = std::make_shared<MockCert>();
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskEarlyDisabled
	)

Definition at line 812 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::NotAttempted, and fizz::client::detail::processEvent().

                                                         {
   context_->setSendEarlyData(false);
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 1000;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_FALSE(state_.earlyDataParams().hasValue());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskEarlyAlpnMismatch
	)

Definition at line 827 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::NotAttempted, and fizz::client::detail::processEvent().

                                                             {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 1000;
   psk.alpn = "gopher";
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::NotAttempted);
   EXPECT_FALSE(state_.earlyDataParams().hasValue());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectNoServerCert
	)

Definition at line 827 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, and socket_.

                                                          {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto params = getEarlyDataParams();
   params.clientCert = std::make_shared<MockCert>();
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectCompat
	)

Definition at line 842 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Connect::sni.

                                               {
   context_->setCompatibilityMode(true);
   Connect connect;
   connect.context = context_;
   connect.sni = "www.hostname.com";
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_FALSE(state_.legacySessionId().value()->empty());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectDifferentServerIdentity
	)

Definition at line 844 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, testing::Return(), and socket_.

                                                                     {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto cert1 = std::make_shared<MockCert>();
   auto cert2 = std::make_shared<MockCert>();
   auto params = getEarlyDataParams();
   params.serverCert = cert1;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   EXPECT_CALL(*cert1, getIdentity()).WillOnce(Return("id1"));
   EXPECT_CALL(*cert2, getIdentity()).WillOnce(Return("id2"));
   fullHandshakeSuccess(false, "h2", nullptr, cert2);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectCompatEarly
	)

Definition at line 855 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, and fizz::client::detail::processEvent().

                                                    {
   context_->setCompatibilityMode(true);
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.maxEarlyDataSize = 1000;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket, ReportEarlyHandshakeSuccess>(
       actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Attempted);
   EXPECT_TRUE(state_.earlyDataParams().hasValue());
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_FALSE(state_.legacySessionId().value()->empty());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectSameServerIdentity
	)

Definition at line 865 of file AsyncFizzClientTest.cpp.

References fizz::client::AutomaticResend, EXPECT_CALL, fizz::sm::getEarlyDataParams(), folly::gen::move, params, and testing::Return().

                                                                {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto cert1 = std::make_shared<MockCert>();
   auto cert2 = std::make_shared<MockCert>();
   auto params = getEarlyDataParams();
   params.serverCert = cert1;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_());
   EXPECT_CALL(*cert1, getIdentity()).WillOnce(Return("id"));
   EXPECT_CALL(*cert2, getIdentity()).WillOnce(Return("id"));
   fullHandshakeSuccess(false, "h2", nullptr, cert2);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloFlow
	)

Definition at line 873 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientHandshakeTraffic, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::Handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::NotAttempted, fizz::OneRtt, fizz::client::detail::processEvent(), fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                 {
   setupExpectingServerHello();
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("chlo")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("shloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKex_, generateSharedSecret(RangeMatches("servershare")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("sharedsecret"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sht"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cht"));
 
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.serverHandshakeSecret(), IOBuf::copyBuffer("sht")));
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_EQ(state_.serverCert(), nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectDifferentClientIdentity
	)

Definition at line 880 of file AsyncFizzClientTest.cpp.

References testing::_, testing::AtLeast(), fizz::client::AutomaticResend, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, fizz::sm::getEarlyDataParams(), folly::AsyncSocketException::getType(), testing::Invoke(), folly::gen::move, params, testing::Return(), and socket_.

                                                                     {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto cert1 = std::make_shared<MockCert>();
   auto cert2 = std::make_shared<MockCert>();
   auto params = getEarlyDataParams();
   params.clientCert = cert1;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(readCallback_, readErr_(_))
       .WillOnce(Invoke([](const AsyncSocketException& ex) {
         EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
       }));
   EXPECT_CALL(*socket_, closeNow()).Times(AtLeast(1));
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_()).Times(0);
   EXPECT_CALL(*cert1, getIdentity()).WillOnce(Return("id1"));
   EXPECT_CALL(*cert2, getIdentity()).WillOnce(Return("id2"));
   fullHandshakeSuccess(false, "h2", cert2, nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectSameClientIdentity
	)

Definition at line 901 of file AsyncFizzClientTest.cpp.

References fizz::client::AutomaticResend, EXPECT_CALL, fizz::sm::getEarlyDataParams(), folly::gen::move, params, and testing::Return().

                                                                {
   client_->setEarlyDataRejectionPolicy(
       EarlyDataRejectionPolicy::AutomaticResend);
   auto cert1 = std::make_shared<MockCert>();
   auto cert2 = std::make_shared<MockCert>();
   auto params = getEarlyDataParams();
   params.clientCert = cert1;
   completeEarlyHandshake(std::move(params));
   client_->setReplaySafetyCallback(&mockReplayCallback_);
   EXPECT_CALL(mockReplayCallback_, onReplaySafe_());
   EXPECT_CALL(*cert1, getIdentity()).WillOnce(Return("id"));
   EXPECT_CALL(*cert2, getIdentity()).WillOnce(Return("id"));
   fullHandshakeSuccess(false, "h2", cert2, nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyRejectRemovePsk
	)

Definition at line 916 of file AsyncFizzClientTest.cpp.

References EXPECT_CALL.

                                                       {
   EXPECT_CALL(*mockPskCache_, removePsk(*pskIdentity_));
   completeEarlyHandshake();
   fullHandshakeSuccess(false);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyWriteRejected
	)

Definition at line 922 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, failed, testing::Invoke(), folly::gen::move, fizz::client::ReportEarlyWriteFailed::write, and fizz::detail::write().

                                                     {
   completeEarlyHandshake();
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([](const State&, EarlyAppWrite& write) {
         ReportEarlyWriteFailed failed;
         failed.write = std::move(write);
         return detail::actions(std::move(failed));
       }));
   EXPECT_CALL(writeCallback_, writeSuccess_());
   client_->writeChain(&writeCallback_, IOBuf::copyBuffer("HTTP GET"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestEarlyWriteRejectedNullCallback
	)

Definition at line 934 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, failed, testing::Invoke(), folly::gen::move, fizz::client::ReportEarlyWriteFailed::write, and fizz::detail::write().

                                                                 {
   completeEarlyHandshake();
   EXPECT_CALL(*machine_, _processEarlyAppWrite(_, _))
       .WillOnce(Invoke([](const State&, EarlyAppWrite& write) {
         ReportEarlyWriteFailed failed;
         failed.write = std::move(write);
         return detail::actions(std::move(failed));
       }));
   client_->writeChain(nullptr, IOBuf::copyBuffer("HTTP GET"));
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestErrorStopsActions
	)

Definition at line 945 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_FALSE, EXPECT_TRUE, and testing::InvokeWithoutArgs().

                                                    {
   completeHandshake();
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return detail::actions(ReportError("unit test")); }));
   EXPECT_FALSE(client_->error());
   socketReadCallback_->readBufferAvailable(IOBuf::copyBuffer("Data"));
   EXPECT_TRUE(client_->error());
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestNewCachedPskActions
	)

Definition at line 956 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, and testing::InvokeWithoutArgs().

                                                      {
   completeHandshake();
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return detail::actions(NewCachedPsk(), WaitForData()); }));
   EXPECT_CALL(*mockPskCache_, putPsk(*pskIdentity_, _));
   socketReadCallback_->readBufferAvailable(
       IOBuf::copyBuffer("NewSessionTicket"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloAfterHrrFlow
	)

Definition at line 957 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientHandshakeTraffic, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::Handshake, fizz::HelloRetryRequest, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::NotAttempted, fizz::client::detail::processEvent(), fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHello(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                         {
   setupExpectingServerHelloAfterHrr();
   mockKeyScheduler_ = new MockKeyScheduler();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   Sequence contextSeq;
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("shloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKex_, generateSharedSecret(RangeMatches("servershare")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("sharedsecret"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sht"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cht"));
 
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.serverHandshakeSecret(), IOBuf::copyBuffer("sht")));
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.pskType(), PskType::NotAttempted);
   EXPECT_EQ(state_.serverCert(), nullptr);
 }

fizz::client::test::TEST_F	(	AsyncFizzClientTest	,
		TestNewCachedPskActionsWithEmptyPskIdentity
	)

Definition at line 967 of file AsyncFizzClientTest.cpp.

References testing::_, fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, testing::InvokeWithoutArgs(), and folly::none.

                                                                          {
   pskIdentity_ = folly::none;
   completeHandshake();
   client_->setReadCB(&readCallback_);
   EXPECT_CALL(*machine_, _processSocketData(_, _))
       .WillOnce(InvokeWithoutArgs(
           []() { return detail::actions(NewCachedPsk(), WaitForData()); }));
   EXPECT_CALL(*mockPskCache_, putPsk(_, _)).Times(0);
   socketReadCallback_->readBufferAvailable(
       IOBuf::copyBuffer("NewSessionTicket"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskFlow
	)

Definition at line 1033 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientHandshakeTraffic, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::Handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::OneRtt, fizz::client::detail::processEvent(), fizz::Resumption, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHelloPsk(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                    {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("chlo")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("shloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKex_, generateSharedSecret(RangeMatches("servershare")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("sharedsecret"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumptionsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sht"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cht"));
 
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.serverHandshakeSecret(), IOBuf::copyBuffer("sht")));
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::OneRtt);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.serverCert(), mockLeaf_);
   EXPECT_EQ(state_.clientCert(), mockClientCert_);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskNoDhFlow
	)

Definition at line 1121 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientHandshakeTraffic, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::Handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::key_share, folly::gen::move, fizz::None, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), fizz::Resumption, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHelloPsk(), fizz::test::TestProtocolVersion, and fizz::TLS_AES_128_GCM_SHA256.

                                                        {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   mockKeyScheduler_ = new MockKeyScheduler();
   mockHandshakeContext_ = new MockHandshakeContext();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext_);
       }));
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(BufMatches("chlo")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("shloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumptionsecret")));
   EXPECT_CALL(*mockKeyScheduler_, deriveHandshakeSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sht"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cht"));
 
   auto shlo = TestMessages::serverHelloPsk();
   TestMessages::removeExtension(shlo, ExtensionType::key_share);
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.serverHandshakeSecret(), IOBuf::copyBuffer("sht")));
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::None);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.serverCert(), mockLeaf_);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskAfterHrrFlow
	)

Definition at line 1206 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::ClientHandshakeTraffic, folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::Handshake, fizz::HelloRetryRequest, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::client::detail::processEvent(), fizz::Resumption, fizz::ServerHandshakeTraffic, fizz::test::TestMessages::serverHelloPsk(), fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                            {
   setupExpectingServerHelloAfterHrr();
   state_.attemptedPsk() = getCachedPsk();
   mockKeyScheduler_ = new MockKeyScheduler();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   Sequence contextSeq;
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("shloencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo_shlo"); }));
   EXPECT_CALL(*mockKex_, generateSharedSecret(RangeMatches("servershare")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("sharedsecret"); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveHandshakeSecret(RangeMatches("sharedsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ServerHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'h', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(
           HandshakeSecrets::ClientHandshakeTraffic, RangeMatches("chlo_shlo")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'h', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cht"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sht"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cht"));
 
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(state_.handshakeContext().get(), mockHandshakeContext_);
   EXPECT_EQ(state_.keyScheduler().get(), mockKeyScheduler_);
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(state_.group(), NamedGroup::x25519);
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.clientHandshakeSecret(), IOBuf::copyBuffer("cht")));
   EXPECT_TRUE(IOBufEqualTo()(
       *state_.serverHandshakeSecret(), IOBuf::copyBuffer("sht")));
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
   EXPECT_EQ(state_.serverCert(), mockLeaf_);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHello
	)

Definition at line 1283 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::client::detail::processEvent(), and fizz::test::TestMessages::serverHello().

                                             {
   setupExpectingServerHello();
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPsk
	)

Definition at line 1291 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::client::detail::processEvent(), fizz::Resumption, and fizz::test::TestMessages::serverHelloPsk().

                                                {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.pskType(), PskType::Resumption);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskRejected
	)

Definition at line 1301 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::client::detail::processEvent(), fizz::Rejected, and fizz::test::TestMessages::serverHello().

                                                        {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.pskType(), PskType::Rejected);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloExtraData
	)

Definition at line 1311 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, fizz::client::detail::processEvent(), testing::Return(), fizz::test::TestMessages::serverHello(), and fizz::unexpected_message.

                                                      {
   setupExpectingServerHello();
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "data after server hello");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloBadVersion
	)

Definition at line 1320 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), folly::gen::move, fizz::client::detail::processEvent(), fizz::protocol_version, fizz::test::TestMessages::removeExtension(), fizz::ServerSupportedVersions::selected_version, fizz::test::TestMessages::serverHello(), fizz::supported_versions, and fizz::tls_1_1.

                                                       {
   setupExpectingServerHello();
   auto shlo = TestMessages::serverHello();
   TestMessages::removeExtension(shlo, ExtensionType::supported_versions);
   ServerSupportedVersions supportedVersions;
   supportedVersions.selected_version = ProtocolVersion::tls_1_1;
   shlo.extensions.push_back(encodeExtension(std::move(supportedVersions)));
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions,
       AlertDescription::protocol_version,
       "unsupported server version");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloBadCipher
	)

Definition at line 1334 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::serverHello().

                                                      {
   setupExpectingServerHello();
   auto shlo = TestMessages::serverHello();
   shlo.cipher_suite = static_cast<CipherSuite>(0x03ff);
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported cipher");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloBadGroup
	)

Definition at line 1343 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), fizz::KeyShareEntry::group, fizz::handshake_failure, fizz::KeyShareEntry::key_exchange, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), fizz::secp256r1, fizz::ServerKeyShare::server_share, fizz::test::TestMessages::serverHello(), and fizz::x25519.

                                                     {
   context_->setSupportedGroups({NamedGroup::x25519});
   setupExpectingServerHello();
   auto shlo = TestMessages::serverHello();
   TestMessages::removeExtension(shlo, ExtensionType::key_share);
   ServerKeyShare serverKeyShare;
   serverKeyShare.server_share.group = NamedGroup::secp256r1;
   serverKeyShare.server_share.key_exchange =
       folly::IOBuf::copyBuffer("servershare");
   shlo.extensions.push_back(encodeExtension(std::move(serverKeyShare)));
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported group");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloNoKeyShare
	)

Definition at line 1358 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::test::TestMessages::serverHello().

                                                       {
   setupExpectingServerHello();
   auto shlo = TestMessages::serverHello();
   TestMessages::removeExtension(shlo, ExtensionType::key_share);
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "did not send share");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloHrrBadVersion
	)

Definition at line 1367 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::client::detail::processEvent(), fizz::test::TestMessages::serverHello(), and fizz::tls_1_2.

                                                          {
   setupExpectingServerHelloAfterHrr();
   state_.version() = ProtocolVersion::tls_1_2;
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "version does not match");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloHrrBadCipher
	)

Definition at line 1375 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::client::detail::processEvent(), fizz::test::TestMessages::serverHello(), and fizz::TLS_AES_256_GCM_SHA384.

                                                         {
   setupExpectingServerHelloAfterHrr();
   state_.cipher() = CipherSuite::TLS_AES_256_GCM_SHA384;
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "cipher does not match");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloHrrBadGroup
	)

Definition at line 1383 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, folly::gen::move, fizz::client::detail::processEvent(), fizz::secp256r1, and fizz::test::TestMessages::serverHello().

                                                        {
   setupExpectingServerHelloAfterHrr();
   auto mockKex = std::make_unique<MockKeyExchange>();
   mockKex->setDefaults();
   std::map<NamedGroup, std::unique_ptr<KeyExchange>> kexs;
   kexs.emplace(NamedGroup::secp256r1, std::move(mockKex));
   state_.keyExchangers() = std::move(kexs);
 
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "group");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskAcceptedNotSent
	)

Definition at line 1396 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, fizz::illegal_parameter, fizz::key_share, fizz::key_share_old, fizz::client::detail::processEvent(), fizz::server_name, fizz::test::TestMessages::serverHelloPsk(), and fizz::supported_versions.

                                                               {
   setupExpectingServerHello();
   state_.requestedExtensions() = std::vector<ExtensionType>(
       {ExtensionType::supported_versions,
        ExtensionType::key_share,
        ExtensionType::key_share_old,
        ExtensionType::server_name,
        ExtensionType::application_layer_protocol_negotiation});
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "unexpected extension in shlo: pre_shared_key");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloOtherPskAccepted
	)

Definition at line 1411 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), fizz::ServerPresharedKey::selected_identity, and fizz::test::TestMessages::serverHello().

                                                             {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   auto shlo = TestMessages::serverHello();
   ServerPresharedKey pskExt;
   pskExt.selected_identity = 1;
   shlo.extensions.push_back(encodeExtension(std::move(pskExt)));
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "non-0 psk");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskDifferentHash
	)

Definition at line 1423 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::client::detail::processEvent(), fizz::test::TestMessages::serverHelloPsk(), and fizz::TLS_AES_256_GCM_SHA384.

                                                             {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   state_.attemptedPsk()->cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectError<FizzException>(
       actions,
       AlertDescription::handshake_failure,
       "incompatible cipher in psk");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskDifferentCompatibleCipher
	)

Definition at line 1434 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::client::detail::processEvent(), fizz::test::TestMessages::serverHelloPsk(), fizz::TLS_AES_128_GCM_SHA256, and fizz::TLS_CHACHA20_POLY1305_SHA256.

                                                                         {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   state_.attemptedPsk()->cipher = CipherSuite::TLS_CHACHA20_POLY1305_SHA256;
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingEncryptedExtensions);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskDheNotSupported
	)

Definition at line 1445 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::client::detail::processEvent(), fizz::psk_ke, and fizz::test::TestMessages::serverHelloPsk().

                                                               {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_ke});
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   auto actions = detail::processEvent(state_, TestMessages::serverHelloPsk());
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported psk mode");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloExtensions
	)

Definition at line 1454 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_CALL, and fizz::client::detail::processEvent().

                                                       {
   setupExpectingEncryptedExtensions();
   auto ext = std::make_shared<MockClientExtensions>();
   state_.extensions() = ext;
   EXPECT_CALL(*ext, onEncryptedExtensions(_));
   auto actions = detail::processEvent(state_, TestMessages::encryptedExt());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloPskKeNotSupported
	)

Definition at line 1464 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::psk_dhe_ke, fizz::test::TestMessages::removeExtension(), and fizz::test::TestMessages::serverHelloPsk().

                                                              {
   context_->setSupportedPskModes({PskKeyExchangeMode::psk_dhe_ke});
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   auto shlo = TestMessages::serverHelloPsk();
   TestMessages::removeExtension(shlo, ExtensionType::key_share);
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported psk mode");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestServerHelloBadSessionId
	)

Definition at line 1475 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::serverHello().

                                                         {
   setupExpectingServerHello();
   auto shlo = TestMessages::serverHello();
   shlo.legacy_session_id_echo = IOBuf::copyBuffer("hi!!");
   auto actions = detail::processEvent(state_, std::move(shlo));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "session id");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestConnectPskKeNoShares
	)

Definition at line 1484 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Connect::cachedPsk, folly::netops::connect(), fizz::Connect::context, EXPECT_EQ, EXPECT_TRUE, folly::gen::move, folly::none, and fizz::client::detail::processEvent().

                                                      {
   Connect connect;
   connect.context = context_;
   auto psk = getCachedPsk();
   psk.group = folly::none;
   connect.cachedPsk = psk;
   auto actions = detail::processEvent(state_, std::move(connect));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
 
   auto& encodedHello = *state_.encodedClientHello();
 
   // Get rid of handshake header (type + version)
   encodedHello->trimStart(4);
   auto decodedHello = decode<ClientHello>(std::move(encodedHello));
   auto keyShare = getExtension<ClientKeyShare>(decodedHello.extensions);
   EXPECT_TRUE(keyShare->client_shares.empty());
   EXPECT_TRUE(state_.keyExchangers()->empty());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestFlow
	)

Definition at line 1505 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), chlo, fizz::ClientKeyShare::client_shares, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeExtension(), fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, fizz::findExtension(), fizz::TLSMessage::fragment, fizz::KeyShareEntry::group, fizz::handshake, fizz::HelloRetryRequest, fizz::test::TestMessages::helloRetryRequest(), testing::Invoke(), testing::InvokeWithoutArgs(), fizz::KeyShareEntry::key_exchange, fizz::key_share, folly::gen::move, fizz::NotAttempted, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::secp256r1, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, verifier_, and fizz::detail::write().

                                                       {
   setupExpectingServerHello();
   state_.clientRandom()->fill(0x66);
   auto mockHandshakeContext1 = new MockHandshakeContext();
   auto mockHandshakeContext2 = new MockHandshakeContext();
   Sequence contextSeq;
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext1);
       }));
   EXPECT_CALL(*mockHandshakeContext1, appendToTranscript(BufMatches("chlo")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext1, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo1"); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext2);
       }));
   EXPECT_CALL(*mockHandshakeContext2, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockHandshakeContext2, appendToTranscript(BufMatches("hrrencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext2, appendToTranscript(_))
       .InSequence(contextSeq);
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::secp256r1))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("keyshare");
         }));
         mockKex = ret.get();
         return ret;
       }));
   auto chlo = getDefaultClientHello();
   chlo.random.fill(0x66);
   ClientKeyShare keyShare;
   KeyShareEntry entry;
   entry.group = NamedGroup::secp256r1;
   entry.key_exchange = folly::IOBuf::copyBuffer("keyshare");
   keyShare.client_shares.push_back(std::move(entry));
   auto it = chlo.extensions.erase(
       findExtension(chlo.extensions, ExtensionType::key_share));
   chlo.extensions.insert(it, encodeExtension(std::move(keyShare)));
   auto encodedExpectedChlo = encodeHandshake(std::move(chlo));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, encodedExpectedChlo));
     content.data = IOBuf::copyBuffer("writtenchlo");
     return content;
   }));
 
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("writtenchlo")));
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.readRecordLayer().get(), mockRead_);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_TRUE(
       IOBufEqualTo()(*state_.encodedClientHello(), encodedExpectedChlo));
   EXPECT_EQ(
       StringPiece((*state_.encodedClientHello())->coalesce()),
       StringPiece(encodedExpectedChlo->coalesce()));
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::secp256r1).get(), mockKex);
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_EQ(*state_.sni(), "www.hostname.com");
   Random random;
   random.fill(0x66);
   EXPECT_EQ(*state_.clientRandom(), random);
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestPskFlow
	)

Definition at line 1603 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, fizz::detail::getFinishedData(), fizz::handshake, fizz::HelloRetryRequest, fizz::test::TestMessages::helloRetryRequest(), testing::Invoke(), testing::InvokeWithoutArgs(), fizz::NotAttempted, fizz::Plaintext, fizz::client::detail::processEvent(), random(), fizz::ResumptionPskBinder, fizz::secp256r1, fizz::test::TestProtocolVersion, fizz::TLS_AES_128_GCM_SHA256, fizz::TLSMessage::type, verifier_, and fizz::detail::write().

                                                          {
   auto psk = getCachedPsk();
   setupExpectingServerHello();
   state_.attemptedPsk() = psk;
   state_.clientRandom()->fill(0x66);
   auto mockHandshakeContext1 = new MockHandshakeContext();
   auto mockHandshakeContext2 = new MockHandshakeContext();
   mockKeyScheduler_ = new MockKeyScheduler();
   EXPECT_CALL(*factory_, makeKeyScheduler(CipherSuite::TLS_AES_128_GCM_SHA256))
       .WillOnce(InvokeWithoutArgs(
           [=]() { return std::unique_ptr<KeyScheduler>(mockKeyScheduler_); }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveEarlySecret(RangeMatches("resumptionsecret")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(EarlySecrets::ResumptionPskBinder, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'b', 'k'});
       }));
   Sequence contextSeq;
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext1);
       }));
   EXPECT_CALL(*mockHandshakeContext1, appendToTranscript(BufMatches("chlo")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext1, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("chlo1"); }));
   EXPECT_CALL(
       *factory_, makeHandshakeContext(CipherSuite::TLS_AES_128_GCM_SHA256))
       .InSequence(contextSeq)
       .WillOnce(InvokeWithoutArgs([=]() {
         return std::unique_ptr<HandshakeContext>(mockHandshakeContext2);
       }));
   EXPECT_CALL(*mockHandshakeContext2, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockHandshakeContext2, appendToTranscript(BufMatches("hrrencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext2, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext2, getFinishedData(RangeMatches("bk")))
       .InSequence(contextSeq)
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("binder"); }));
   EXPECT_CALL(*mockHandshakeContext2, appendToTranscript(_))
       .InSequence(contextSeq);
   MockKeyExchange* mockKex;
   EXPECT_CALL(*factory_, makeKeyExchange(NamedGroup::secp256r1))
       .WillOnce(InvokeWithoutArgs([&mockKex]() {
         auto ret = std::make_unique<MockKeyExchange>();
         EXPECT_CALL(*ret, generateKeyPair());
         EXPECT_CALL(*ret, getKeyShare()).WillOnce(InvokeWithoutArgs([]() {
           return IOBuf::copyBuffer("keyshare");
         }));
         mockKex = ret.get();
         return ret;
       }));
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     content.data = IOBuf::copyBuffer("writtenchlo");
     return content;
   }));
 
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.readRecordLayer().get(), mockRead_);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.writeRecordLayer().get(), mockWrite_);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Plaintext);
   EXPECT_EQ(state_.keyExchangers()->size(), 1);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::secp256r1).get(), mockKex);
   EXPECT_EQ(state_.verifier(), verifier_);
   EXPECT_EQ(*state_.sni(), "www.hostname.com");
   Random random;
   random.fill(0x66);
   EXPECT_EQ(*state_.clientRandom(), random);
   EXPECT_FALSE(state_.sentCCS());
   EXPECT_EQ(state_.version(), TestProtocolVersion);
   EXPECT_EQ(state_.cipher(), CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_EQ(state_.keyExchangeType(), KeyExchangeType::HelloRetryRequest);
   EXPECT_EQ(state_.attemptedPsk()->psk, psk.psk);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::NotAttempted);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequest
	)

Definition at line 1704 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::helloRetryRequest(), and fizz::client::detail::processEvent().

                                                   {
   setupExpectingServerHello();
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestPskDifferentHash
	)

Definition at line 1713 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, EXPECT_FALSE, fizz::test::TestMessages::helloRetryRequest(), fizz::client::detail::processEvent(), and fizz::TLS_AES_256_GCM_SHA384.

                                                                   {
   setupExpectingServerHello();
   state_.attemptedPsk() = getCachedPsk();
   state_.attemptedPsk()->cipher = CipherSuite::TLS_AES_256_GCM_SHA384;
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.attemptedPsk().hasValue());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestDoubleHelloRetryRequest
	)

Definition at line 1725 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::HelloRetryRequest, fizz::test::TestMessages::helloRetryRequest(), fizz::client::detail::processEvent(), and fizz::unexpected_message.

                                                         {
   setupExpectingServerHello();
   state_.keyExchangeType() = KeyExchangeType::HelloRetryRequest;
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "two HRRs");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestBadVersion
	)

Definition at line 1734 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::helloRetryRequest(), folly::gen::move, fizz::client::detail::processEvent(), fizz::protocol_version, fizz::test::TestMessages::removeExtension(), fizz::ServerSupportedVersions::selected_version, fizz::supported_versions, and fizz::tls_1_1.

                                                             {
   setupExpectingServerHello();
   auto hrr = TestMessages::helloRetryRequest();
   TestMessages::removeExtension(hrr, ExtensionType::supported_versions);
   ServerSupportedVersions supportedVersions;
   supportedVersions.selected_version = ProtocolVersion::tls_1_1;
   hrr.extensions.push_back(encodeExtension(std::move(supportedVersions)));
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectError<FizzException>(
       actions,
       AlertDescription::protocol_version,
       "unsupported server version");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestBadCipher
	)

Definition at line 1748 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::handshake_failure, fizz::test::TestMessages::helloRetryRequest(), folly::gen::move, and fizz::client::detail::processEvent().

                                                            {
   setupExpectingServerHello();
   auto hrr = TestMessages::helloRetryRequest();
   hrr.cipher_suite = static_cast<CipherSuite>(0x03ff);
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported cipher");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestBadGroup
	)

Definition at line 1757 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::handshake_failure, fizz::test::TestMessages::helloRetryRequest(), fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), and fizz::HelloRetryRequestKeyShare::selected_group.

                                                           {
   setupExpectingServerHello();
   auto hrr = TestMessages::helloRetryRequest();
   TestMessages::removeExtension(hrr, ExtensionType::key_share);
   HelloRetryRequestKeyShare keyShare;
   keyShare.selected_group = static_cast<NamedGroup>(0x8923);
   hrr.extensions.push_back(encodeExtension(std::move(keyShare)));
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectError<FizzException>(
       actions, AlertDescription::handshake_failure, "unsupported group");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestGroupAlreadySent
	)

Definition at line 1769 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::alert, fizz::encodeExtension(), EXPECT_EQ, fizz::test::TestMessages::helloRetryRequest(), fizz::illegal_parameter, fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), fizz::HelloRetryRequestKeyShare::selected_group, fizz::detail::write(), and fizz::x25519.

                                                                   {
   setupExpectingServerHello();
   auto hrr = TestMessages::helloRetryRequest();
   TestMessages::removeExtension(hrr, ExtensionType::key_share);
   HelloRetryRequestKeyShare keyShare;
   keyShare.selected_group = NamedGroup::x25519;
   hrr.extensions.push_back(encodeExtension(std::move(keyShare)));
   auto encryptionLevel = state_.writeRecordLayer()->getEncryptionLevel();
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "already-sent group");
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents[0].encryptionLevel, encryptionLevel);
   EXPECT_EQ(write.contents[0].contentType, ContentType::alert);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestNoKeyShare
	)

Definition at line 1785 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, EXPECT_FALSE, fizz::test::TestMessages::helloRetryRequest(), fizz::key_share, folly::gen::move, fizz::client::detail::processEvent(), fizz::test::TestMessages::removeExtension(), fizz::secp256r1, and fizz::x25519.

                                                             {
   setupExpectingServerHello();
   auto kex = state_.keyExchangers()->at(NamedGroup::x25519).get();
   auto mockKex = std::make_unique<MockKeyExchange>();
   mockKex->setDefaults();
   state_.keyExchangers()->emplace(NamedGroup::secp256r1, std::move(mockKex));
   auto hrr = TestMessages::helloRetryRequest();
   TestMessages::removeExtension(hrr, ExtensionType::key_share);
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_FALSE(state_.group().hasValue());
   EXPECT_EQ(state_.keyExchangers()->size(), 2);
   EXPECT_EQ(state_.keyExchangers()->at(NamedGroup::x25519).get(), kex);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestCookie
	)

Definition at line 1802 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), cookie, fizz::Cookie::cookie, folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_EQ, EXPECT_THAT, testing::HasSubstr(), fizz::test::TestMessages::helloRetryRequest(), folly::gen::move, fizz::client::detail::processEvent(), folly::gen::range(), and string.

                                                         {
   setupExpectingServerHello();
   auto hrr = TestMessages::helloRetryRequest();
   Cookie cookie;
   cookie.cookie = folly::IOBuf::copyBuffer("cookie!!");
   hrr.extensions.push_back(encodeExtension(std::move(cookie)));
   auto actions = detail::processEvent(state_, std::move(hrr));
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   auto range = (*state_.encodedClientHello())->coalesce();
   EXPECT_THAT(std::string(range.begin(), range.end()), HasSubstr("cookie!!"));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestAttemptedEarly
	)

Definition at line 1816 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, EXPECT_EQ, fizz::test::TestMessages::helloRetryRequest(), fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                 {
   setupExpectingServerHello();
   state_.earlyDataType() = EarlyDataType::Attempted;
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_EQ(state_.earlyDataType(), EarlyDataType::Rejected);
   EXPECT_EQ(state_.earlyWriteRecordLayer(), nullptr);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestHelloRetryRequestCompat
	)

Definition at line 1828 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::change_cipher_spec, EXPECT_EQ, EXPECT_TRUE, fizz::handshake, fizz::test::TestMessages::helloRetryRequest(), fizz::Plaintext, fizz::client::detail::processEvent(), and fizz::detail::write().

                                                         {
   context_->setCompatibilityMode(true);
   setupExpectingServerHello();
   auto actions =
       detail::processEvent(state_, TestMessages::helloRetryRequest());
   expectActions<MutateState, WriteToSocket>(actions);
   processStateMutations(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingServerHello);
   EXPECT_TRUE(state_.sentCCS());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsFlow
	)

Definition at line 1845 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_CALL, EXPECT_EQ, and fizz::client::detail::processEvent().

                                                         {
   context_->setSupportedAlpns({"h2"});
   setupExpectingEncryptedExtensions();
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("eeencoding")));
 
   auto actions = detail::processEvent(state_, TestMessages::encryptedExt());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsPsk
	)

Definition at line 1858 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_CALL, EXPECT_EQ, and fizz::client::detail::processEvent().

                                                        {
   context_->setSupportedAlpns({"h2"});
   setupExpectingEncryptedExtensions();
   state_.serverCert() = mockLeaf_;
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("eeencoding")));
 
   auto actions = detail::processEvent(state_, TestMessages::encryptedExt());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
   EXPECT_EQ(state_.serverCert(), mockLeaf_);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsAlpn
	)

Definition at line 1873 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_EQ, and fizz::client::detail::processEvent().

                                                         {
   context_->setSupportedAlpns({"h2"});
   setupExpectingEncryptedExtensions();
   auto actions = detail::processEvent(state_, TestMessages::encryptedExt());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(*state_.alpn(), "h2");
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEmptyAlpn
	)

Definition at line 1883 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                              {
   context_->setSupportedAlpns({"h2"});
   setupExpectingEncryptedExtensions();
   auto ee = TestMessages::encryptedExt();
   TestMessages::removeExtension(
       ee, ExtensionType::application_layer_protocol_negotiation);
   ee.extensions.push_back(encodeExtension(ProtocolNameList()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "alpn list");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsAlpnMismatch
	)

Definition at line 1895 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, and fizz::client::detail::processEvent().

                                                                 {
   context_->setSupportedAlpns({"h3", "h1"});
   setupExpectingEncryptedExtensions();
   auto actions = detail::processEvent(state_, TestMessages::encryptedExt());
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "alpn mismatch");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsNoAlpn
	)

Definition at line 1903 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, fizz::test::TestMessages::encryptedExt(), EXPECT_EQ, EXPECT_FALSE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::test::TestMessages::removeExtension().

                                                           {
   context_->setSupportedAlpns({"h2"});
   setupExpectingEncryptedExtensions();
   auto ee = TestMessages::encryptedExt();
   TestMessages::removeExtension(
       ee, ExtensionType::application_layer_protocol_negotiation);
   auto actions = detail::processEvent(state_, std::move(ee));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_FALSE(state_.alpn().hasValue());
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsDisallowedExtension
	)

Definition at line 1916 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                                        {
   setupExpectingEncryptedExtensions();
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ClientPresharedKey()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "unexpected extension in ee: pre_shared_key");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsUnrequestedExtension
	)

Definition at line 1927 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_layer_protocol_negotiation, fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, fizz::key_share, folly::gen::move, fizz::pre_shared_key, and fizz::client::detail::processEvent().

                                                                         {
   setupExpectingEncryptedExtensions();
   state_.requestedExtensions() = std::vector<ExtensionType>(
       {ExtensionType::key_share,
        ExtensionType::application_layer_protocol_negotiation,
        ExtensionType::pre_shared_key});
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ServerNameList()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "unexpected extension in ee: server_name");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyAccepted
	)

Definition at line 1942 of file ClientProtocolTest.cpp.

References fizz::Accepted, fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), EXPECT_EQ, folly::gen::move, and fizz::client::detail::processEvent().

                                                                  {
   setupExpectingEncryptedExtensionsEarlySent();
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ServerEarlyData()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Accepted);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyRejected
	)

Definition at line 1953 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                  {
   setupExpectingEncryptedExtensionsEarlySent();
   auto ee = TestMessages::encryptedExt();
   auto actions = detail::processEvent(state_, std::move(ee));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyAlreadyRejected
	)

Definition at line 1963 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::encryptedExt(), EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                         {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataType() = EarlyDataType::Rejected;
   auto ee = TestMessages::encryptedExt();
   auto actions = detail::processEvent(state_, std::move(ee));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificate);
   EXPECT_EQ(*state_.earlyDataType(), EarlyDataType::Rejected);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyAcceptedHrr
	)

Definition at line 1974 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                     {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataType() = EarlyDataType::Rejected;
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ServerEarlyData()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions,
       AlertDescription::illegal_parameter,
       "unexpected accepted early data");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyCipherMismatch
	)

Definition at line 1986 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, folly::gen::move, fizz::client::detail::processEvent(), and fizz::TLS_CHACHA20_POLY1305_SHA256.

                                                                        {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.cipher() = CipherSuite::TLS_CHACHA20_POLY1305_SHA256;
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ServerEarlyData()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "different cipher");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEncryptedExtensionsEarlyAlpnMismatch
	)

Definition at line 1996 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::encodeExtension(), fizz::test::TestMessages::encryptedExt(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                                      {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataParams()->alpn = "h3";
   state_.attemptedPsk()->alpn = "h3";
   auto ee = TestMessages::encryptedExt();
   ee.extensions.push_back(encodeExtension(ServerEarlyData()));
   auto actions = detail::processEvent(state_, std::move(ee));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "different alpn");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateFlow
	)

Definition at line 2007 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), and testing::Return().

                                                 {
   setupExpectingCertificate();
   EXPECT_CALL(
       *mockHandshakeContext_, appendToTranscript(BufMatches("certencoding")));
   mockLeaf_ = std::make_shared<MockPeerCert>();
   mockIntermediate_ = std::make_shared<MockPeerCert>();
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert1")))
       .WillOnce(Return(mockLeaf_));
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert2")))
       .WillOnce(Return(mockIntermediate_));
 
   auto certificate = TestMessages::certificate();
   CertificateEntry entry1;
   entry1.cert_data = folly::IOBuf::copyBuffer("cert1");
   certificate.certificate_list.push_back(std::move(entry1));
   CertificateEntry entry2;
   entry2.cert_data = folly::IOBuf::copyBuffer("cert2");
   certificate.certificate_list.push_back(std::move(entry2));
   auto actions = detail::processEvent(state_, std::move(certificate));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain()->size(), 2);
   EXPECT_EQ(state_.unverifiedCertChain()->at(0), mockLeaf_);
   EXPECT_EQ(state_.unverifiedCertChain()->at(1), mockIntermediate_);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificateVerify);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificate
	)

Definition at line 2035 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), folly::IOBuf::copyBuffer(), EXPECT_EQ, folly::gen::move, and fizz::client::detail::processEvent().

                                             {
   setupExpectingCertificate();
   auto certificate = TestMessages::certificate();
   CertificateEntry entry;
   entry.cert_data = folly::IOBuf::copyBuffer("cert");
   certificate.certificate_list.push_back(std::move(entry));
   auto actions = detail::processEvent(state_, std::move(certificate));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain()->size(), 1);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificateVerify);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateWithRequestContext
	)

Definition at line 2048 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), folly::IOBuf::copyBuffer(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                               {
   setupExpectingCertificate();
   auto certificate = TestMessages::certificate();
   certificate.certificate_request_context = IOBuf::copyBuffer("something");
   CertificateEntry entry;
   entry.cert_data = folly::IOBuf::copyBuffer("cert");
   certificate.certificate_list.push_back(std::move(entry));
   auto actions = detail::processEvent(state_, std::move(certificate));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "context must be empty");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateEmpty
	)

Definition at line 2060 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::certificate, fizz::test::TestMessages::certificate(), fizz::illegal_parameter, folly::gen::move, and fizz::client::detail::processEvent().

                                                  {
   setupExpectingCertificate();
   auto certificate = TestMessages::certificate();
   auto actions = detail::processEvent(state_, std::move(certificate));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "no cert");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificateFlow
	)

Definition at line 2068 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::CompressedCertificate::algorithm, cc, fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), fizz::CompressedCertificate::compressed_certificate_message, fizz::test::TestMessages::compressedCertificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), testing::Return(), fizz::CompressedCertificate::uncompressed_length, and fizz::zlib.

                                                           {
   setupExpectingCertificate();
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("compcertencoding")));
   mockLeaf_ = std::make_shared<MockPeerCert>();
   mockIntermediate_ = std::make_shared<MockPeerCert>();
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert1")))
       .WillOnce(Return(mockLeaf_));
   EXPECT_CALL(*factory_, _makePeerCert(BufMatches("cert2")))
       .WillOnce(Return(mockIntermediate_));
 
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
   EXPECT_CALL(*decompressor, decompress(_))
       .WillOnce(Invoke([](const CompressedCertificate& cc) {
         EXPECT_TRUE(IOBufEqualTo()(
             cc.compressed_certificate_message,
             folly::IOBuf::copyBuffer("compressedcerts")));
         EXPECT_EQ(cc.algorithm, CertificateCompressionAlgorithm::zlib);
         EXPECT_EQ(cc.uncompressed_length, 0x111111);
         auto certificate = TestMessages::certificate();
         CertificateEntry entry1;
         entry1.cert_data = folly::IOBuf::copyBuffer("cert1");
         certificate.certificate_list.push_back(std::move(entry1));
         CertificateEntry entry2;
         entry2.cert_data = folly::IOBuf::copyBuffer("cert2");
         certificate.certificate_list.push_back(std::move(entry2));
         return certificate;
       }));
 
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
 
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain()->size(), 2);
   EXPECT_EQ(state_.unverifiedCertChain()->at(0), mockLeaf_);
   EXPECT_EQ(state_.unverifiedCertChain()->at(1), mockIntermediate_);
   EXPECT_EQ(state_.serverCertCompAlgo(), CertificateCompressionAlgorithm::zlib);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificateVerify);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificate
	)

Definition at line 2115 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), cc, fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::compressedCertificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), and fizz::zlib.

                                                       {
   setupExpectingCertificate();
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
   EXPECT_CALL(*decompressor, decompress(_))
       .WillOnce(Invoke([](const CompressedCertificate& cc) {
         auto certificate = TestMessages::certificate();
         CertificateEntry entry;
         entry.cert_data = folly::IOBuf::copyBuffer("cert");
         certificate.certificate_list.push_back(std::move(entry));
         return certificate;
       }));
 
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.unverifiedCertChain()->size(), 1);
   EXPECT_EQ(state_.serverCertCompAlgo(), CertificateCompressionAlgorithm::zlib);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingCertificateVerify);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificateUnknownAlgo
	)

Definition at line 2141 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_certificate, fizz::test::TestMessages::compressedCertificate(), folly::gen::move, and fizz::client::detail::processEvent().

                                                                  {
   setupExpectingCertificate();
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
 
   auto compressedCert = TestMessages::compressedCertificate();
   compressedCert.algorithm = static_cast<CertificateCompressionAlgorithm>(0xff);
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectError<FizzException>(
       actions, AlertDescription::bad_certificate, "unsupported algorithm");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificateDecompressionFailed
	)

Definition at line 2157 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_certificate, cc, fizz::test::TestMessages::compressedCertificate(), EXPECT_CALL, testing::Invoke(), folly::gen::move, and fizz::client::detail::processEvent().

                                                                          {
   setupExpectingCertificate();
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   EXPECT_CALL(*decompressor, decompress(_))
       .WillOnce(Invoke([](const CompressedCertificate& cc) -> CertificateMsg {
         throw std::runtime_error("foo");
       }));
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectError<FizzException>(
       actions, AlertDescription::bad_certificate, "decompression failed: foo");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificateWithRequestContext
	)

Definition at line 2175 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), cc, fizz::CertificateEntry::cert_data, fizz::certificate, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::compressedCertificate(), folly::IOBuf::copyBuffer(), EXPECT_CALL, fizz::illegal_parameter, testing::Invoke(), folly::gen::move, and fizz::client::detail::processEvent().

                                                                         {
   setupExpectingCertificate();
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
   EXPECT_CALL(*decompressor, decompress(_))
       .WillOnce(Invoke([](const CompressedCertificate& cc) {
         auto certificate = TestMessages::certificate();
         certificate.certificate_request_context =
             IOBuf::copyBuffer("something");
         CertificateEntry entry;
         entry.cert_data = folly::IOBuf::copyBuffer("cert");
         certificate.certificate_list.push_back(std::move(entry));
         return certificate;
       }));
 
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "context must be empty");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCompressedCertificateEmpty
	)

Definition at line 2200 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), cc, fizz::test::TestMessages::certificate(), fizz::test::TestMessages::compressedCertificate(), EXPECT_CALL, fizz::illegal_parameter, testing::Invoke(), folly::gen::move, and fizz::client::detail::processEvent().

                                                            {
   setupExpectingCertificate();
   auto decompressor = std::make_shared<MockCertificateDecompressor>();
   decompressor->setDefaults();
   EXPECT_CALL(*decompressor, decompress(_))
       .WillOnce(Invoke([](const CompressedCertificate& cc) {
         return TestMessages::certificate();
       }));
   auto decompressionMgr = std::make_shared<CertDecompressionManager>();
   decompressionMgr->setDecompressors(
       {std::static_pointer_cast<CertificateDecompressor>(decompressor)});
   context_->setCertDecompressionManager(std::move(decompressionMgr));
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "no cert");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestUnexpectedCompressedCertificate
	)

Definition at line 2218 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::compressedCertificate(), folly::gen::move, fizz::client::detail::processEvent(), and fizz::unexpected_message.

                                                                 {
   setupExpectingCertificate();
   auto compressedCert = TestMessages::compressedCertificate();
   auto actions = detail::processEvent(state_, std::move(compressedCert));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "received unexpectedly");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyFlow
	)

Definition at line 2226 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), folly::IOBuf::copyBuffer(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, EXPECT_EQ, EXPECT_FALSE, testing::Invoke(), fizz::client::detail::processEvent(), fizz::Server, verifier_, and verify().

                                                       {
   setupExpectingCertificateVerify();
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("certcontext"); }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("certverifyencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(
       *mockLeaf_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("certcontext"),
           RangeMatches("signature")));
   EXPECT_CALL(*verifier_, verify(_))
       .WillOnce(Invoke(
           [this](const std::vector<std::shared_ptr<const PeerCert>>& certs) {
             EXPECT_EQ(certs.size(), 2);
             EXPECT_EQ(certs[0], mockLeaf_);
             EXPECT_EQ(certs[1], mockIntermediate_);
           }));
 
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.sigScheme(), SignatureScheme::ecdsa_secp256r1_sha256);
   EXPECT_EQ(state_.serverCert(), mockLeaf_);
   EXPECT_FALSE(state_.unverifiedCertChain().hasValue());
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerify
	)

Definition at line 2262 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), EXPECT_EQ, and fizz::client::detail::processEvent().

                                                   {
   setupExpectingCertificateVerify();
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyNoVerifier
	)

Definition at line 2271 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), EXPECT_EQ, and fizz::client::detail::processEvent().

                                                             {
   setupExpectingCertificateVerify();
   state_.verifier() = nullptr;
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::ExpectingFinished);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyUnsupportedAlgorithm
	)

Definition at line 2281 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateVerify(), fizz::illegal_parameter, fizz::client::detail::processEvent(), and fizz::rsa_pss_sha256.

                                                                       {
   context_->setSupportedSigSchemes({SignatureScheme::rsa_pss_sha256});
   setupExpectingCertificateVerify();
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectError<FizzException>(
       actions, AlertDescription::illegal_parameter, "unsupported sig scheme");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyFailure
	)

Definition at line 2290 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_record_mac, fizz::test::TestMessages::certificateVerify(), fizz::ecdsa_secp256r1_sha256, EXPECT_CALL, fizz::client::detail::processEvent(), fizz::Server, and verify().

                                                          {
   setupExpectingCertificateVerify();
   EXPECT_CALL(
       *mockLeaf_,
       verify(
           SignatureScheme::ecdsa_secp256r1_sha256,
           CertificateVerifyContext::Server,
           RangeMatches("context"),
           RangeMatches("signature")))
       .WillOnce(Throw(
           FizzException("verify failed", AlertDescription::bad_record_mac)));
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectError<FizzException>(
       actions, AlertDescription::bad_record_mac, "verify failed");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyVerifierFailure
	)

Definition at line 2307 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_record_mac, fizz::test::TestMessages::certificateVerify(), EXPECT_CALL, fizz::client::detail::processEvent(), verifier_, and verify().

                                                                  {
   setupExpectingCertificateVerify();
   EXPECT_CALL(*verifier_, verify(_))
       .WillOnce(Throw(FizzVerificationException(
           "verify failed", AlertDescription::bad_record_mac)));
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectError<FizzVerificationException>(
       actions, AlertDescription::bad_record_mac, "verify failed");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateVerifyVerifierFailureOtherException
	)

Definition at line 2318 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::bad_certificate, fizz::test::TestMessages::certificateVerify(), EXPECT_CALL, fizz::client::detail::processEvent(), verifier_, and verify().

                                                                                {
   setupExpectingCertificateVerify();
   EXPECT_CALL(*verifier_, verify(_))
       .WillOnce(Throw(std::runtime_error("no good")));
   auto actions =
       detail::processEvent(state_, TestMessages::certificateVerify());
   expectError<FizzException>(
       actions, AlertDescription::bad_certificate, "verifier failure: no good");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestNoCert
	)

Definition at line 2328 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), EXPECT_EQ, folly::gen::move, folly::none, and fizz::client::detail::processEvent().

                                                          {
   setupExpectingCertificate();
   auto certificateRequest = TestMessages::certificateRequest();
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.clientAuthRequested(), ClientAuthType::RequestedNoMatch);
   EXPECT_EQ(state_.selectedClientCert(), nullptr);
   EXPECT_EQ(state_.clientAuthSigScheme(), folly::none);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestDuplicated
	)

Definition at line 2339 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), folly::gen::move, fizz::client::detail::processEvent(), and fizz::unexpected_message.

                                                              {
   setupExpectingCertificate();
   auto certificateRequest = TestMessages::certificateRequest();
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   certificateRequest = TestMessages::certificateRequest();
   actions = detail::processEvent(state_, std::move(certificateRequest));
   expectError<FizzException>(
       actions,
       AlertDescription::unexpected_message,
       "duplicate certificate request message");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestAlgosMismatch
	)

Definition at line 2353 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), fizz::ecdsa_secp256r1_sha256, fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, folly::none, fizz::client::detail::processEvent(), testing::Return(), fizz::rsa_pss_sha256, and fizz::SignatureAlgorithms::supported_signature_algorithms.

                                                                 {
   setupExpectingCertificateRequest();
   auto certificateRequest = TestMessages::certificateRequest();
 
   SignatureAlgorithms sigAlgs;
   sigAlgs.supported_signature_algorithms = {
       SignatureScheme::ecdsa_secp256r1_sha256};
   certificateRequest.extensions.clear();
   certificateRequest.extensions.emplace_back(
       encodeExtension(std::move(sigAlgs)));
 
   EXPECT_CALL(*mockClientCert_, getSigSchemes())
       .WillOnce(Return(
           std::vector<SignatureScheme>(1, SignatureScheme::rsa_pss_sha256)));
 
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.clientAuthRequested(), ClientAuthType::RequestedNoMatch);
   EXPECT_EQ(state_.selectedClientCert(), nullptr);
   EXPECT_EQ(state_.clientAuthSigScheme(), folly::none);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestContextAlgosUnsupported
	)

Definition at line 2376 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), fizz::ecdsa_secp256r1_sha256, fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, folly::none, fizz::client::detail::processEvent(), testing::Return(), fizz::rsa_pss_sha256, fizz::rsa_pss_sha512, and fizz::SignatureAlgorithms::supported_signature_algorithms.

                                                                           {
   setupExpectingCertificateRequest();
   context_->setSupportedSigSchemes({SignatureScheme::rsa_pss_sha512});
   auto certificateRequest = TestMessages::certificateRequest();
 
   SignatureAlgorithms sigAlgs;
   sigAlgs.supported_signature_algorithms = {
       SignatureScheme::ecdsa_secp256r1_sha256, SignatureScheme::rsa_pss_sha256};
   certificateRequest.extensions.clear();
   certificateRequest.extensions.emplace_back(
       encodeExtension(std::move(sigAlgs)));
 
   EXPECT_CALL(*mockClientCert_, getSigSchemes())
       .WillOnce(Return(
           std::vector<SignatureScheme>(1, SignatureScheme::rsa_pss_sha256)));
 
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.clientAuthRequested(), ClientAuthType::RequestedNoMatch);
   EXPECT_EQ(state_.selectedClientCert(), nullptr);
   EXPECT_EQ(state_.clientAuthSigScheme(), folly::none);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestPrefersContextOrder
	)

Definition at line 2400 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), fizz::ecdsa_secp521r1_sha512, fizz::ed25519, fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), testing::Return(), fizz::rsa_pss_sha512, and fizz::SignatureAlgorithms::supported_signature_algorithms.

                                                                       {
   setupExpectingCertificateRequest();
   context_->setSupportedSigSchemes({SignatureScheme::rsa_pss_sha512,
                                     SignatureScheme::ecdsa_secp521r1_sha512,
                                     SignatureScheme::ed25519});
   auto certificateRequest = TestMessages::certificateRequest();
   SignatureAlgorithms requestAlgos;
   requestAlgos.supported_signature_algorithms = {
       SignatureScheme::ecdsa_secp521r1_sha512,
       SignatureScheme::ed25519,
       SignatureScheme::rsa_pss_sha512};
   certificateRequest.extensions.clear();
   certificateRequest.extensions.emplace_back(
       encodeExtension(std::move(requestAlgos)));
 
   EXPECT_CALL(*mockClientCert_, getSigSchemes())
       .WillOnce(Return(
           std::vector<SignatureScheme>({SignatureScheme::ed25519,
                                         SignatureScheme::ecdsa_secp521r1_sha512,
                                         SignatureScheme::rsa_pss_sha512})));
 
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.clientAuthRequested(), ClientAuthType::Sent);
   EXPECT_EQ(state_.selectedClientCert(), mockClientCert_);
   EXPECT_EQ(state_.clientAuthSigScheme(), SignatureScheme::rsa_pss_sha512);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestCertificateRequestMatch
	)

Definition at line 2429 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::certificateRequest(), EXPECT_CALL, EXPECT_EQ, folly::gen::move, fizz::client::detail::processEvent(), testing::Return(), and fizz::rsa_pss_sha256.

                                                         {
   setupExpectingCertificateRequest();
   auto certificateRequest = TestMessages::certificateRequest();
 
   EXPECT_CALL(*mockClientCert_, getSigSchemes())
       .WillOnce(Return(
           std::vector<SignatureScheme>(1, SignatureScheme::rsa_pss_sha256)));
 
   auto actions = detail::processEvent(state_, std::move(certificateRequest));
   expectActions<MutateState>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.clientAuthRequested(), ClientAuthType::Sent);
   EXPECT_EQ(state_.selectedClientCert(), mockClientCert_);
   EXPECT_EQ(state_.clientAuthSigScheme(), SignatureScheme::rsa_pss_sha256);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedFlow
	)

Definition at line 2445 of file ClientProtocolTest.cpp.

                                              {
   setupExpectingFinished();
   doFinishedFlow(ClientAuthType::NotRequested);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedCertNoMatchFlow
	)

Definition at line 2450 of file ClientProtocolTest.cpp.

References EXPECT_EQ.

                                                         {
   setupExpectingFinished();
   state_.clientAuthRequested() = ClientAuthType::RequestedNoMatch;
   doFinishedFlow(ClientAuthType::RequestedNoMatch);
   EXPECT_EQ(state_.clientCert(), nullptr);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedCertSentFlow
	)

Definition at line 2457 of file ClientProtocolTest.cpp.

References fizz::ecdsa_secp256r1_sha256, and EXPECT_EQ.

                                                      {
   setupExpectingFinished();
   state_.clientAuthRequested() = ClientAuthType::Sent;
   state_.clientAuthSigScheme() = SignatureScheme::ecdsa_secp256r1_sha256;
   state_.selectedClientCert() = mockClientCert_;
   doFinishedFlow(ClientAuthType::Sent);
   EXPECT_EQ(state_.clientCert(), mockClientCert_);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedEarlyFlow
	)

Definition at line 2466 of file ClientProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::AppTraffic, fizz::ClientAppTraffic, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::EarlyData, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::ExporterMaster, fizz::test::TestMessages::finished(), fizz::TLSMessage::fragment, fizz::detail::getFinishedData(), fizz::Handshake, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::client::detail::processEvent(), fizz::ResumptionMaster, fizz::ServerAppTraffic, fizz::TLSMessage::type, and fizz::detail::write().

                                                   {
   setupExpectingFinished();
   state_.earlyDataType() = EarlyDataType::Accepted;
   setMockEarlyRecord();
 
   Sequence contextSeq;
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("sht")))
       .InSequence(contextSeq)
       .WillOnce(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(
       *mockHandshakeContext_,
       appendToTranscript(BufMatches("finishedencoding")))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(
           Invoke([]() { return IOBuf::copyBuffer("sfincontext"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("sfin_eoed"); }));
   EXPECT_CALL(*mockHandshakeContext_, getFinishedData(RangeMatches("cht")))
       .InSequence(contextSeq)
       .WillRepeatedly(
           InvokeWithoutArgs([]() { return IOBuf::copyBuffer("verifydata"); }));
   EXPECT_CALL(*mockHandshakeContext_, appendToTranscript(_))
       .InSequence(contextSeq);
   EXPECT_CALL(*mockHandshakeContext_, getHandshakeContext())
       .InSequence(contextSeq)
       .WillRepeatedly(Invoke([]() { return IOBuf::copyBuffer("fincontext"); }));
   EXPECT_CALL(*mockHandshakeWrite_, _write(_))
       .WillOnce(Invoke([&](TLSMessage& msg) {
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = mockHandshakeWrite_->getEncryptionLevel();
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(IOBufEqualTo()(
             msg.fragment, encodeHandshake(TestMessages::finished())));
         content.data = folly::IOBuf::copyBuffer("finwrite");
         return content;
       }));
   EXPECT_CALL(*mockEarlyWrite_, _write(_))
       .WillOnce(Invoke([&](TLSMessage& msg) {
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = mockEarlyWrite_->getEncryptionLevel();
         EXPECT_EQ(msg.type, ContentType::handshake);
         EXPECT_TRUE(
             IOBufEqualTo()(msg.fragment, encodeHandshake(EndOfEarlyData())));
         content.data = folly::IOBuf::copyBuffer("eoed");
         return content;
       }));
   EXPECT_CALL(*mockKeyScheduler_, deriveMasterSecret());
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ExporterMaster, RangeMatches("sfincontext")));
   EXPECT_CALL(
       *mockKeyScheduler_,
       getSecret(MasterSecrets::ResumptionMaster, RangeMatches("fincontext")))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'r', 'e', 's'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, deriveAppTrafficSecrets(RangeMatches("sfincontext")));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ClientAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'a', 't'});
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sat"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cat"));
   EXPECT_CALL(*mockKeyScheduler_, clearMasterSecret());
 
   auto actions = detail::processEvent(state_, TestMessages::finished());
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::EarlyData);
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("eoed")));
 
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[1].data, IOBuf::copyBuffer("finwrite")));
   auto reportSuccess = expectAction<ReportHandshakeSuccess>(actions);
   EXPECT_EQ(reportSuccess.earlyDataAccepted, true);
   processStateMutations(actions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.earlyWriteRecordLayer().get(), nullptr);
   EXPECT_EQ(state_.state(), StateEnum::Established);
   EXPECT_TRUE(
       IOBufEqualTo()(*state_.resumptionSecret(), IOBuf::copyBuffer("res")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinished
	)

Definition at line 2752 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::finished(), and fizz::client::detail::processEvent().

                                          {
   setupExpectingFinished();
   auto actions = detail::processEvent(state_, TestMessages::finished());
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Established);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedExtraData
	)

Definition at line 2760 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, fizz::test::TestMessages::finished(), fizz::client::detail::processEvent(), testing::Return(), and fizz::unexpected_message.

                                                   {
   setupExpectingFinished();
   EXPECT_CALL(*mockHandshakeRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
   auto actions = detail::processEvent(state_, TestMessages::finished());
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "data after finished");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedMismatch
	)

Definition at line 2769 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::bad_record_mac, folly::IOBuf::copyBuffer(), fizz::finished, fizz::test::TestMessages::finished(), folly::gen::move, and fizz::client::detail::processEvent().

                                                  {
   setupExpectingFinished();
   auto finished = TestMessages::finished();
   finished.verify_data = IOBuf::copyBuffer("ver1fydata");
   auto actions = detail::processEvent(state_, std::move(finished));
   expectError<FizzException>(
       actions, AlertDescription::bad_record_mac, "finished verify failure");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedRejectedEarly
	)

Definition at line 2778 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::finished(), fizz::client::detail::processEvent(), and fizz::Rejected.

                                                       {
   setupExpectingFinished();
   state_.earlyDataType() = EarlyDataType::Rejected;
   auto actions = detail::processEvent(state_, TestMessages::finished());
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   auto reportSuccess = expectAction<ReportHandshakeSuccess>(actions);
   EXPECT_EQ(reportSuccess.earlyDataAccepted, false);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Established);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestFinishedCompat
	)

Definition at line 2789 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::change_cipher_spec, EXPECT_EQ, EXPECT_TRUE, fizz::test::TestMessages::finished(), fizz::Handshake, fizz::handshake, fizz::Plaintext, fizz::client::detail::processEvent(), and fizz::detail::write().

                                                {
   context_->setCompatibilityMode(true);
   setupExpectingFinished();
   auto actions = detail::processEvent(state_, TestMessages::finished());
   expectActions<MutateState, ReportHandshakeSuccess, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::Handshake);
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   processStateMutations(actions);
   EXPECT_EQ(state_.state(), StateEnum::Established);
   EXPECT_TRUE(state_.sentCCS());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestNewSessionTicket
	)

Definition at line 2805 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), folly::gen::move, fizz::test::TestMessages::newSessionTicket(), fizz::client::detail::processEvent(), fizz::Resumption, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                  {
   setupAcceptingData();
 
   EXPECT_CALL(
       *mockKeyScheduler_,
       getResumptionSecret(RangeMatches("resumptionsecret"), RangeMatches("")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("derivedsecret"); }));
   state_.clientCert() = mockClientCert_;
 
   auto actions = detail::processEvent(state_, TestMessages::newSessionTicket());
   auto newCachedPsk = expectSingleAction<NewCachedPsk>(std::move(actions));
   auto psk = newCachedPsk.psk;
   EXPECT_EQ(psk.psk, "ticket");
   EXPECT_EQ(psk.secret, "derivedsecret");
   EXPECT_EQ(psk.type, PskType::Resumption);
   EXPECT_EQ(psk.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(psk.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(psk.group, NamedGroup::x25519);
   EXPECT_EQ(psk.serverCert, mockLeaf_);
   EXPECT_EQ(psk.clientCert, mockClientCert_);
   EXPECT_EQ(psk.maxEarlyDataSize, 0);
   EXPECT_EQ(psk.ticketAgeAdd, 0x44444444);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestNewSessionTicketNonce
	)

Definition at line 2830 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), EXPECT_CALL, testing::InvokeWithoutArgs(), folly::gen::move, fizz::test::TestMessages::newSessionTicket(), nst, and fizz::client::detail::processEvent().

                                                       {
   setupAcceptingData();
 
   EXPECT_CALL(
       *mockKeyScheduler_,
       getResumptionSecret(
           RangeMatches("resumptionsecret"), RangeMatches("nonce")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("derivedsecret"); }));
 
   auto nst = TestMessages::newSessionTicket();
   nst.ticket_nonce = IOBuf::copyBuffer("nonce");
   auto actions = detail::processEvent(state_, std::move(nst));
   expectSingleAction<NewCachedPsk>(std::move(actions));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestNewSessionTicketEarlyData
	)

Definition at line 2846 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::encodeExtension(), EXPECT_CALL, EXPECT_EQ, testing::InvokeWithoutArgs(), fizz::TicketEarlyData::max_early_data_size, folly::gen::move, fizz::test::TestMessages::newSessionTicket(), nst, fizz::client::detail::processEvent(), fizz::Resumption, fizz::tls_1_3, fizz::TLS_AES_128_GCM_SHA256, and fizz::x25519.

                                                           {
   setupAcceptingData();
 
   EXPECT_CALL(
       *mockKeyScheduler_,
       getResumptionSecret(RangeMatches("resumptionsecret"), RangeMatches("")))
       .WillOnce(InvokeWithoutArgs(
           []() { return IOBuf::copyBuffer("derivedsecret"); }));
 
   auto nst = TestMessages::newSessionTicket();
   TicketEarlyData early;
   early.max_early_data_size = 2000;
   nst.extensions.push_back(encodeExtension(std::move(early)));
   auto actions = detail::processEvent(state_, std::move(nst));
   auto newCachedPsk = expectSingleAction<NewCachedPsk>(std::move(actions));
   auto psk = newCachedPsk.psk;
   EXPECT_EQ(psk.psk, "ticket");
   EXPECT_EQ(psk.secret, "derivedsecret");
   EXPECT_EQ(psk.type, PskType::Resumption);
   EXPECT_EQ(psk.version, ProtocolVersion::tls_1_3);
   EXPECT_EQ(psk.cipher, CipherSuite::TLS_AES_128_GCM_SHA256);
   EXPECT_EQ(psk.group, NamedGroup::x25519);
   EXPECT_EQ(psk.serverCert, mockLeaf_);
   EXPECT_EQ(psk.maxEarlyDataSize, 2000);
   EXPECT_EQ(psk.ticketAgeAdd, 0x44444444);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestAppData
	)

Definition at line 2873 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::appData(), folly::gen::move, and fizz::client::detail::processEvent().

                                         {
   setupAcceptingData();
 
   auto actions = detail::processEvent(state_, TestMessages::appData());
 
   expectSingleAction<DeliverAppData>(std::move(actions));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestAppWrite
	)

Definition at line 2881 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::test::TestMessages::appWrite(), fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                          {
   setupAcceptingData();
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::application_data);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
     content.data = IOBuf::copyBuffer("writtenappdata");
     return content;
   }));
 
   auto actions = detail::processEvent(state_, TestMessages::appWrite());
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
   EXPECT_EQ(
       write.contents[0].encryptionLevel,
       state_.writeRecordLayer()->getEncryptionLevel());
   EXPECT_EQ(write.contents[0].contentType, ContentType::application_data);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestKeyUpdateNotRequested
	)

Definition at line 2903 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_EQ, fizz::test::TestMessages::keyUpdate(), and fizz::client::detail::processEvent().

                                                       {
   setupAcceptingData();
   auto actions = detail::processEvent(state_, TestMessages::keyUpdate(false));
   expectActions<MutateState>(actions);
   EXPECT_EQ(getNumActions<WriteToSocket>(actions, false), 0);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestKeyUpdateExtraData
	)

Definition at line 2910 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), EXPECT_CALL, fizz::test::TestMessages::keyUpdate(), fizz::client::detail::processEvent(), testing::Return(), and fizz::unexpected_message.

                                                    {
   setupAcceptingData();
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData())
       .WillRepeatedly(Return(true));
   auto actions = detail::processEvent(state_, TestMessages::keyUpdate(false));
   expectError<FizzException>(
       actions, AlertDescription::unexpected_message, "data after key_update");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestKeyUpdateRequestFlow
	)

Definition at line 2919 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::AppTraffic, fizz::ClientAppTraffic, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::encodeHandshake(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, fizz::handshake, testing::Invoke(), testing::InvokeWithoutArgs(), fizz::test::TestMessages::keyUpdate(), fizz::client::detail::processEvent(), testing::Return(), fizz::ServerAppTraffic, fizz::TLSMessage::type, and fizz::detail::write().

                                                      {
   setupAcceptingData();
   EXPECT_CALL(*mockKeyScheduler_, serverKeyUpdate());
   EXPECT_CALL(*mockRead_, hasUnparsedHandshakeData()).WillOnce(Return(false));
 
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ServerAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'s', 'a', 't'});
       }));
 
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::handshake);
     EXPECT_TRUE(IOBufEqualTo()(
         msg.fragment, encodeHandshake(TestMessages::keyUpdate(false))));
     content.data = folly::IOBuf::copyBuffer("keyupdated");
     return content;
   }));
 
   EXPECT_CALL(*mockKeyScheduler_, clientKeyUpdate());
   EXPECT_CALL(
       *mockKeyScheduler_, getSecret(AppTrafficSecrets::ClientAppTraffic))
       .WillOnce(InvokeWithoutArgs([]() {
         return std::vector<uint8_t>({'c', 'a', 't'});
       }));
 
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("sat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("serverkey"),
                           IOBuf::copyBuffer("serveriv")};
       }));
   EXPECT_CALL(*mockKeyScheduler_, getTrafficKey(RangeMatches("cat"), _, _))
       .WillOnce(InvokeWithoutArgs([]() {
         return TrafficKey{IOBuf::copyBuffer("clientkey"),
                           IOBuf::copyBuffer("clientiv")};
       }));
 
   MockAead* raead;
   MockAead* waead;
   MockEncryptedReadRecordLayer* rrl;
   MockEncryptedWriteRecordLayer* wrl;
 
   expectAeadCreation(&waead, &raead);
   expectEncryptedReadRecordLayerCreation(&rrl, &raead, StringPiece("sat"));
   expectEncryptedWriteRecordLayerCreation(&wrl, &waead, StringPiece("cat"));
 
   auto actions = detail::processEvent(state_, TestMessages::keyUpdate(true));
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_TRUE(
       IOBufEqualTo()(write.contents[0].data, IOBuf::copyBuffer("keyupdated")));
   EXPECT_EQ(
       write.contents[0].encryptionLevel,
       state_.writeRecordLayer()->getEncryptionLevel());
   EXPECT_EQ(write.contents[0].contentType, ContentType::handshake);
   processStateMutations(actions);
   EXPECT_EQ(state_.readRecordLayer().get(), rrl);
   EXPECT_EQ(
       state_.readRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.writeRecordLayer().get(), wrl);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::AppTraffic);
   EXPECT_EQ(state_.state(), StateEnum::Established);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestInvalidEarlyWrite
	)

Definition at line 2989 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::test::TestMessages::earlyAppWrite(), folly::none, and fizz::client::detail::processEvent().

                                                   {
   setupExpectingServerHello();
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   expectError<FizzException>(actions, folly::none, "invalid early write");
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingSHEarlyWrite
	)

Definition at line 2996 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::Attempted, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::test::TestMessages::earlyAppWrite(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                                       {
   setupExpectingServerHello();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Attempted;
   EXPECT_CALL(*mockEarlyWrite_, _write(_))
       .WillOnce(Invoke([&](TLSMessage& msg) {
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = mockEarlyWrite_->getEncryptionLevel();
         EXPECT_EQ(msg.type, ContentType::application_data);
         EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
         content.data = IOBuf::copyBuffer("writtenappdata");
         return content;
       }));
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEarlyEncryptionLevelRecvSHLO
	)

Definition at line 3018 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::EarlyData, EXPECT_EQ, fizz::Handshake, fizz::client::detail::processEvent(), and fizz::test::TestMessages::serverHello().

                                                              {
   setupExpectingServerHello();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Attempted;
 
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   processStateMutations(actions);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(
       state_.earlyWriteRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::EarlyData);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEarlyEncryptionLevelRecvFinished
	)

Definition at line 3033 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::EarlyData, EXPECT_EQ, fizz::Handshake, fizz::client::detail::processEvent(), and fizz::test::TestMessages::serverHello().

                                                                  {
   setupExpectingServerHello();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Attempted;
 
   auto actions = detail::processEvent(state_, TestMessages::serverHello());
   processStateMutations(actions);
   EXPECT_EQ(
       state_.writeRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::Handshake);
   EXPECT_EQ(
       state_.earlyWriteRecordLayer()->getEncryptionLevel(),
       EncryptionLevel::EarlyData);
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEarlyWriteCompat
	)

Definition at line 3048 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::application_data, fizz::Attempted, fizz::change_cipher_spec, fizz::test::TestMessages::earlyAppWrite(), fizz::EarlyData, EXPECT_EQ, EXPECT_TRUE, fizz::Plaintext, fizz::client::detail::processEvent(), and fizz::detail::write().

                                                  {
   setupExpectingServerHello();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Attempted;
   context_->setCompatibilityMode(true);
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   expectActions<MutateState, WriteToSocket>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   EXPECT_EQ(write.contents.size(), 2);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
   EXPECT_EQ(write.contents[0].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::EarlyData);
   EXPECT_EQ(write.contents[1].contentType, ContentType::application_data);
   processStateMutations(actions);
   EXPECT_TRUE(state_.sentCCS());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEarlyWriteCompatCCSAlreadySent
	)

Definition at line 3066 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), fizz::Attempted, fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, and fizz::client::detail::processEvent().

                                                                {
   setupExpectingServerHello();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Attempted;
   state_.sentCCS() = true;
   context_->setCompatibilityMode(true);
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
 
   expectActions<WriteToSocket>(actions);
   EXPECT_TRUE(state_.sentCCS());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEarlyAcceptedCompatNoEarlyData
	)

Definition at line 3079 of file ClientProtocolTest.cpp.

References fizz::Accepted, fizz::client::detail::actions(), ASSERT_EQ, fizz::change_cipher_spec, fizz::EarlyData, EXPECT_EQ, EXPECT_TRUE, fizz::test::TestMessages::finished(), fizz::Handshake, fizz::handshake, fizz::Plaintext, fizz::client::detail::processEvent(), and fizz::detail::write().

                                                                {
   setupExpectingFinished();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Accepted;
   context_->setCompatibilityMode(true);
 
   auto actions = detail::processEvent(state_, TestMessages::finished());
 
   expectActions<MutateState, WriteToSocket, ReportHandshakeSuccess>(actions);
   auto write = expectAction<WriteToSocket>(actions);
   ASSERT_EQ(write.contents.size(), 3);
   EXPECT_EQ(write.contents[0].contentType, ContentType::change_cipher_spec);
   EXPECT_EQ(write.contents[0].encryptionLevel, EncryptionLevel::Plaintext);
 
   EXPECT_EQ(write.contents[1].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[1].encryptionLevel, EncryptionLevel::EarlyData);
 
   EXPECT_EQ(write.contents[2].contentType, ContentType::handshake);
   EXPECT_EQ(write.contents[2].encryptionLevel, EncryptionLevel::Handshake);
 
   processStateMutations(actions);
   EXPECT_TRUE(state_.sentCCS());
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingSHEarlyWriteRejected
	)

Definition at line 3103 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                               {
   setupExpectingServerHello();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingEEEarlyWrite
	)

Definition at line 3114 of file ClientProtocolTest.cpp.

References testing::_, fizz::client::detail::actions(), fizz::application_data, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::test::TestMessages::earlyAppWrite(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                                       {
   setupExpectingEncryptedExtensionsEarlySent();
   EXPECT_CALL(*mockEarlyWrite_, _write(_))
       .WillOnce(Invoke([&](TLSMessage& msg) {
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = mockEarlyWrite_->getEncryptionLevel();
         EXPECT_EQ(msg.type, ContentType::application_data);
         EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
         content.data = IOBuf::copyBuffer("writtenappdata");
         return content;
       }));
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingEEEarlyWriteRejected
	)

Definition at line 3134 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                               {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingCertEarlyWriteRejected
	)

Definition at line 3145 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                 {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingCertVerifyEarlyWriteRejected
	)

Definition at line 3156 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                       {
   setupExpectingEncryptedExtensionsEarlySent();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingFinishedEarlyWrite
	)

Definition at line 3167 of file ClientProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::application_data, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::test::TestMessages::earlyAppWrite(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                                             {
   setupExpectingFinished();
   setMockEarlyRecord();
   state_.earlyDataType() = EarlyDataType::Accepted;
   EXPECT_CALL(*mockEarlyWrite_, _write(_))
       .WillOnce(Invoke([&](TLSMessage& msg) {
         TLSContent content;
         content.contentType = msg.type;
         content.encryptionLevel = mockEarlyWrite_->getEncryptionLevel();
         EXPECT_EQ(msg.type, ContentType::application_data);
         EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
         content.data = IOBuf::copyBuffer("writtenappdata");
         return content;
       }));
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestExpectingFinishedEarlyWriteRejected
	)

Definition at line 3189 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                                     {
   setupExpectingFinished();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEstablishedEarlyWrite
	)

Definition at line 3200 of file ClientProtocolTest.cpp.

References testing::_, fizz::Accepted, fizz::client::detail::actions(), fizz::application_data, fizz::TLSContent::contentType, folly::IOBuf::copyBuffer(), fizz::TLSContent::data, fizz::test::TestMessages::earlyAppWrite(), fizz::TLSContent::encryptionLevel, EXPECT_CALL, EXPECT_EQ, EXPECT_TRUE, fizz::TLSMessage::fragment, testing::Invoke(), folly::gen::move, fizz::client::detail::processEvent(), fizz::TLSMessage::type, and fizz::detail::write().

                                                       {
   setupAcceptingData();
   state_.earlyDataType() = EarlyDataType::Accepted;
   EXPECT_CALL(*mockWrite_, _write(_)).WillOnce(Invoke([&](TLSMessage& msg) {
     TLSContent content;
     content.contentType = msg.type;
     content.encryptionLevel = mockWrite_->getEncryptionLevel();
     EXPECT_EQ(msg.type, ContentType::application_data);
     EXPECT_TRUE(IOBufEqualTo()(msg.fragment, IOBuf::copyBuffer("appdata")));
     content.data = IOBuf::copyBuffer("writtenappdata");
     return content;
   }));
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
 
   auto write = expectSingleAction<WriteToSocket>(std::move(actions));
   EXPECT_TRUE(IOBufEqualTo()(
       write.contents[0].data, IOBuf::copyBuffer("writtenappdata")));
 }

fizz::client::test::TEST_F	(	ClientProtocolTest	,
		TestEstablishedEarlyWriteRejected
	)

Definition at line 3220 of file ClientProtocolTest.cpp.

References fizz::client::detail::actions(), folly::IOBuf::copyBuffer(), fizz::test::TestMessages::earlyAppWrite(), EXPECT_TRUE, folly::gen::move, fizz::client::detail::processEvent(), and fizz::Rejected.

                                                               {
   setupAcceptingData();
   state_.earlyDataType() = EarlyDataType::Rejected;
 
   auto actions = detail::processEvent(state_, TestMessages::earlyAppWrite());
   auto failedWrite =
       expectSingleAction<ReportEarlyWriteFailed>(std::move(actions));
   EXPECT_TRUE(
       IOBufEqualTo()(failedWrite.write.data, IOBuf::copyBuffer("appdata")));
 }

Classes
class	ActionMoveVisitor

class	AsyncFizzClientTest

class	ClientProtocolTest

class	FizzClientTest

class	MockAsyncFizzClient

class	MockClientExtensions

class	MockClientStateMachine

class	MockClientStateMachineInstance

class	MockConnectCallback

class	MockHandshakeCallbackT

class	MockPskCache

class	SynchronizedLruPskCacheTest

class	TestFizzClient

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation

Typedefs
using	MockHandshakeCallback = MockHandshakeCallbackT< ClientStateMachine >

Functions
	MATCHER_P (BufMatches, expected,"")

	TEST_F (AsyncFizzClientTest, TestConnect)

	TEST_F (AsyncFizzClientTest, TestReadSingle)

	TEST_F (AsyncFizzClientTest, TestReadMulti)

	TEST_F (AsyncFizzClientTest, TestWrite)

	TEST_F (AsyncFizzClientTest, TestWriteMulti)

	TEST_F (AsyncFizzClientTest, TestWriteErrorState)

	TEST_F (AsyncFizzClientTest, TestHandshake)

	TEST_F (AsyncFizzClientTest, TestExporterAPI)

	TEST_F (AsyncFizzClientTest, TestHandshakeError)

	TEST_F (AsyncFizzClientTest, TestHandshakeErrorDelete)

	TEST_F (AsyncFizzClientTest, TestDeliverAppData)

	TEST_F (AsyncFizzClientTest, TestWriteToSocket)

	TEST_F (AsyncFizzClientTest, TestMutateState)

	TEST_F (AsyncFizzClientTest, TestCloseHandshake)

	TEST_F (AsyncFizzClientTest, TestConnecting)

	TEST_F (AsyncFizzClientTest, TestGoodSocket)

	TEST_F (AsyncFizzClientTest, TestGoodState)

	TEST_F (AsyncFizzClientTest, TestSocketConnect)

	TEST_F (AsyncFizzClientTest, TestSocketConnectWithUnsupportedTransport)

	TEST_F (AsyncFizzClientTest, TestHandshakeConnectWithUnopenedSocket)

	TEST_F (AsyncFizzClientTest, TestSocketConnectWithOpenSocket)

	TEST_F (AsyncFizzClientTest, TestApplicationProtocol)

	TEST_F (AsyncFizzClientTest, TestApplicationProtocolNone)

	TEST_F (AsyncFizzClientTest, TestPskResumed)

	TEST_F (AsyncFizzClientTest, TestNoPskResumption)

	TEST_F (AsyncFizzClientTest, TestGetCertsNone)

	TEST_F (AsyncFizzClientTest, TestGetCerts)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshake)

	TEST_F (AsyncFizzClientTest, TestEarlyParams)

	TEST_F (AsyncFizzClientTest, TestEarlyApplicationProtocolNone)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeWrite)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeReplaySafeCallback)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeReplaySafeCallbackRemoved)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeOverLimit)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeAllOverLimit)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedFatalError)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedPendingWriteError)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedAutoResendNoData)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedAutoResend)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedAutoResendOrder)

	TEST_F (AsyncFizzClientTest, TestEarlyHandshakeRejectedAutoResendDeletedBuffer)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectResendDifferentAlpn)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectResendDifferentNoAlpn)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectResendDifferentVersion)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectResendDifferentCipher)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectNoClientCert)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectNoServerCert)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectDifferentServerIdentity)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectSameServerIdentity)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectDifferentClientIdentity)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectSameClientIdentity)

	TEST_F (AsyncFizzClientTest, TestEarlyRejectRemovePsk)

	TEST_F (AsyncFizzClientTest, TestEarlyWriteRejected)

	TEST_F (AsyncFizzClientTest, TestEarlyWriteRejectedNullCallback)

	TEST_F (AsyncFizzClientTest, TestErrorStopsActions)

	TEST_F (AsyncFizzClientTest, TestNewCachedPskActions)

	TEST_F (AsyncFizzClientTest, TestNewCachedPskActionsWithEmptyPskIdentity)

	TEST_F (ClientProtocolTest, TestInvalidTransitionNoAlert)

	TEST_F (ClientProtocolTest, TestInvalidWriteNewSessionTicket)

	TEST_F (ClientProtocolTest, TestInvalidTransitionAlert)

	TEST_F (ClientProtocolTest, TestInvalidTransitionError)

	TEST_F (ClientProtocolTest, TestConnectFlow)

	TEST_F (ClientProtocolTest, TestConnectPskFlow)

	TEST_F (ClientProtocolTest, TestConnectPskEarlyFlow)

	TEST_F (ClientProtocolTest, TestConnectNoHostNoPsk)

	TEST_F (ClientProtocolTest, TestConnectPskBadVersion)

	TEST_F (ClientProtocolTest, TestConnectPskBadCipher)

	TEST_F (ClientProtocolTest, TestConnectSeparatePskIdentity)

	TEST_F (ClientProtocolTest, TestConnectPskIdentityWithoutSni)

	TEST_F (ClientProtocolTest, TestConnectNoSni)

	TEST_F (ClientProtocolTest, TestConnectNoAlpn)

	TEST_F (ClientProtocolTest, TestConnectExtension)

	TEST_F (ClientProtocolTest, TestConnectMultipleShares)

	TEST_F (ClientProtocolTest, TestConnectCachedGroup)

	TEST_F (ClientProtocolTest, TestConnectNoShares)

	TEST_F (ClientProtocolTest, TestConnectPskEarly)

	TEST_F (ClientProtocolTest, TestConnectPskEarlyNoAlpn)

	TEST_F (ClientProtocolTest, TestConnectPskEarlyDisabled)

	TEST_F (ClientProtocolTest, TestConnectPskEarlyAlpnMismatch)

	TEST_F (ClientProtocolTest, TestConnectCompat)

	TEST_F (ClientProtocolTest, TestConnectCompatEarly)

	TEST_F (ClientProtocolTest, TestServerHelloFlow)

	TEST_F (ClientProtocolTest, TestServerHelloAfterHrrFlow)

	TEST_F (ClientProtocolTest, TestServerHelloPskFlow)

	TEST_F (ClientProtocolTest, TestServerHelloPskNoDhFlow)

	TEST_F (ClientProtocolTest, TestServerHelloPskAfterHrrFlow)

	TEST_F (ClientProtocolTest, TestServerHello)

	TEST_F (ClientProtocolTest, TestServerHelloPsk)

	TEST_F (ClientProtocolTest, TestServerHelloPskRejected)

	TEST_F (ClientProtocolTest, TestServerHelloExtraData)

	TEST_F (ClientProtocolTest, TestServerHelloBadVersion)

	TEST_F (ClientProtocolTest, TestServerHelloBadCipher)

	TEST_F (ClientProtocolTest, TestServerHelloBadGroup)

	TEST_F (ClientProtocolTest, TestServerHelloNoKeyShare)

	TEST_F (ClientProtocolTest, TestServerHelloHrrBadVersion)

	TEST_F (ClientProtocolTest, TestServerHelloHrrBadCipher)

	TEST_F (ClientProtocolTest, TestServerHelloHrrBadGroup)

	TEST_F (ClientProtocolTest, TestServerHelloPskAcceptedNotSent)

	TEST_F (ClientProtocolTest, TestServerHelloOtherPskAccepted)

	TEST_F (ClientProtocolTest, TestServerHelloPskDifferentHash)

	TEST_F (ClientProtocolTest, TestServerHelloPskDifferentCompatibleCipher)

	TEST_F (ClientProtocolTest, TestServerHelloPskDheNotSupported)

	TEST_F (ClientProtocolTest, TestServerHelloExtensions)

	TEST_F (ClientProtocolTest, TestServerHelloPskKeNotSupported)

	TEST_F (ClientProtocolTest, TestServerHelloBadSessionId)

	TEST_F (ClientProtocolTest, TestConnectPskKeNoShares)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestFlow)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestPskFlow)

	TEST_F (ClientProtocolTest, TestHelloRetryRequest)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestPskDifferentHash)

	TEST_F (ClientProtocolTest, TestDoubleHelloRetryRequest)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestBadVersion)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestBadCipher)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestBadGroup)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestGroupAlreadySent)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestNoKeyShare)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestCookie)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestAttemptedEarly)

	TEST_F (ClientProtocolTest, TestHelloRetryRequestCompat)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsFlow)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsPsk)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsAlpn)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEmptyAlpn)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsAlpnMismatch)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsNoAlpn)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsDisallowedExtension)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsUnrequestedExtension)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyAccepted)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyRejected)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyAlreadyRejected)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyAcceptedHrr)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyCipherMismatch)

	TEST_F (ClientProtocolTest, TestEncryptedExtensionsEarlyAlpnMismatch)

	TEST_F (ClientProtocolTest, TestCertificateFlow)

	TEST_F (ClientProtocolTest, TestCertificate)

	TEST_F (ClientProtocolTest, TestCertificateWithRequestContext)

	TEST_F (ClientProtocolTest, TestCertificateEmpty)

	TEST_F (ClientProtocolTest, TestCompressedCertificateFlow)

	TEST_F (ClientProtocolTest, TestCompressedCertificate)

	TEST_F (ClientProtocolTest, TestCompressedCertificateUnknownAlgo)

	TEST_F (ClientProtocolTest, TestCompressedCertificateDecompressionFailed)

	TEST_F (ClientProtocolTest, TestCompressedCertificateWithRequestContext)

	TEST_F (ClientProtocolTest, TestCompressedCertificateEmpty)

	TEST_F (ClientProtocolTest, TestUnexpectedCompressedCertificate)

	TEST_F (ClientProtocolTest, TestCertificateVerifyFlow)

	TEST_F (ClientProtocolTest, TestCertificateVerify)

	TEST_F (ClientProtocolTest, TestCertificateVerifyNoVerifier)

	TEST_F (ClientProtocolTest, TestCertificateVerifyUnsupportedAlgorithm)

	TEST_F (ClientProtocolTest, TestCertificateVerifyFailure)

	TEST_F (ClientProtocolTest, TestCertificateVerifyVerifierFailure)

	TEST_F (ClientProtocolTest, TestCertificateVerifyVerifierFailureOtherException)

	TEST_F (ClientProtocolTest, TestCertificateRequestNoCert)

	TEST_F (ClientProtocolTest, TestCertificateRequestDuplicated)

	TEST_F (ClientProtocolTest, TestCertificateRequestAlgosMismatch)

	TEST_F (ClientProtocolTest, TestCertificateRequestContextAlgosUnsupported)

	TEST_F (ClientProtocolTest, TestCertificateRequestPrefersContextOrder)

	TEST_F (ClientProtocolTest, TestCertificateRequestMatch)

	TEST_F (ClientProtocolTest, TestFinishedFlow)

	TEST_F (ClientProtocolTest, TestFinishedCertNoMatchFlow)

	TEST_F (ClientProtocolTest, TestFinishedCertSentFlow)

	TEST_F (ClientProtocolTest, TestFinishedEarlyFlow)

	TEST_F (ClientProtocolTest, TestFinished)

	TEST_F (ClientProtocolTest, TestFinishedExtraData)

	TEST_F (ClientProtocolTest, TestFinishedMismatch)

	TEST_F (ClientProtocolTest, TestFinishedRejectedEarly)

	TEST_F (ClientProtocolTest, TestFinishedCompat)

	TEST_F (ClientProtocolTest, TestNewSessionTicket)

	TEST_F (ClientProtocolTest, TestNewSessionTicketNonce)

	TEST_F (ClientProtocolTest, TestNewSessionTicketEarlyData)

	TEST_F (ClientProtocolTest, TestAppData)

	TEST_F (ClientProtocolTest, TestAppWrite)

	TEST_F (ClientProtocolTest, TestKeyUpdateNotRequested)

	TEST_F (ClientProtocolTest, TestKeyUpdateExtraData)

	TEST_F (ClientProtocolTest, TestKeyUpdateRequestFlow)

	TEST_F (ClientProtocolTest, TestInvalidEarlyWrite)

	TEST_F (ClientProtocolTest, TestExpectingSHEarlyWrite)

	TEST_F (ClientProtocolTest, TestEarlyEncryptionLevelRecvSHLO)

	TEST_F (ClientProtocolTest, TestEarlyEncryptionLevelRecvFinished)

	TEST_F (ClientProtocolTest, TestEarlyWriteCompat)

	TEST_F (ClientProtocolTest, TestEarlyWriteCompatCCSAlreadySent)

	TEST_F (ClientProtocolTest, TestEarlyAcceptedCompatNoEarlyData)

	TEST_F (ClientProtocolTest, TestExpectingSHEarlyWriteRejected)

	TEST_F (ClientProtocolTest, TestExpectingEEEarlyWrite)

	TEST_F (ClientProtocolTest, TestExpectingEEEarlyWriteRejected)

	TEST_F (ClientProtocolTest, TestExpectingCertEarlyWriteRejected)

	TEST_F (ClientProtocolTest, TestExpectingCertVerifyEarlyWriteRejected)

	TEST_F (ClientProtocolTest, TestExpectingFinishedEarlyWrite)

	TEST_F (ClientProtocolTest, TestExpectingFinishedEarlyWriteRejected)

	TEST_F (ClientProtocolTest, TestEstablishedEarlyWrite)

	TEST_F (ClientProtocolTest, TestEstablishedEarlyWriteRejected)

	TEST_F (FizzClientTest, TestConnect)

	TEST_F (FizzClientTest, TestConnectPskIdentity)

	TEST_F (SynchronizedLruPskCacheTest, TestBasic)

	TEST_F (SynchronizedLruPskCacheTest, TestEviction)

CachedPsk	getTestPsk (std::string pskName, std::chrono::system_clock::time_point issueTime)

void	pskEq (const CachedPsk &psk1, const CachedPsk &psk2)