1 // Copyright 2024 The Chromium Authors 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_QUIC_QUIC_SESSION_POOL_TEST_BASE_H_ 6 #define NET_QUIC_QUIC_SESSION_POOL_TEST_BASE_H_ 7 8 #include <sys/types.h> 9 10 #include <memory> 11 #include <ostream> 12 #include <set> 13 #include <string> 14 #include <utility> 15 16 #include "base/functional/bind.h" 17 #include "base/functional/callback.h" 18 #include "base/logging.h" 19 #include "base/memory/raw_ptr.h" 20 #include "base/test/scoped_feature_list.h" 21 #include "net/base/features.h" 22 #include "net/base/mock_network_change_notifier.h" 23 #include "net/base/net_error_details.h" 24 #include "net/base/privacy_mode.h" 25 #include "net/base/session_usage.h" 26 #include "net/base/test_proxy_delegate.h" 27 #include "net/cert/mock_cert_verifier.h" 28 #include "net/dns/mock_host_resolver.h" 29 #include "net/http/http_stream.h" 30 #include "net/http/transport_security_state.h" 31 #include "net/http/transport_security_state_test_util.h" 32 #include "net/log/net_log.h" 33 #include "net/quic/crypto/proof_verifier_chromium.h" 34 #include "net/quic/mock_crypto_client_stream_factory.h" 35 #include "net/quic/mock_quic_context.h" 36 #include "net/quic/mock_quic_data.h" 37 #include "net/quic/platform/impl/quic_test_flags_utils.h" 38 #include "net/quic/quic_session_pool.h" 39 #include "net/quic/quic_test_packet_maker.h" 40 #include "net/quic/quic_test_packet_printer.h" 41 #include "net/quic/test_task_runner.h" 42 #include "net/socket/datagram_client_socket.h" 43 #include "net/socket/socket_test_util.h" 44 #include "net/ssl/test_ssl_config_service.h" 45 #include "net/test/test_with_task_environment.h" 46 #include "net/third_party/quiche/src/quiche/quic/core/quic_session.h" 47 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" 48 #include "net/url_request/static_http_user_agent_settings.h" 49 50 namespace net::test { 51 52 class QuicSessionPoolTestBase : public WithTaskEnvironment { 53 public: 54 static constexpr char kDefaultServerHostName[] = "www.example.org"; 55 static constexpr char kServer2HostName[] = "mail.example.org"; 56 static constexpr char kServer3HostName[] = "docs.example.org"; 57 static constexpr char kServer4HostName[] = "images.example.org"; 58 static constexpr char kServer5HostName[] = "accounts.example.org"; 59 static constexpr char kProxy1HostName[] = "proxy1.example.org"; 60 static constexpr char kProxy2HostName[] = "proxy2.example.org"; 61 static constexpr char kDifferentHostname[] = "different.example.com"; 62 static constexpr int kDefaultServerPort = 443; 63 static constexpr char kDefaultUrl[] = "https://www.example.org/"; 64 static constexpr char kServer2Url[] = "https://mail.example.org/"; 65 static constexpr char kServer3Url[] = "https://docs.example.org/"; 66 static constexpr char kServer4Url[] = "https://images.example.org/"; 67 static constexpr char kServer5Url[] = "https://images.example.org/"; 68 static constexpr char kProxy1Url[] = "https://proxy1.example.org/"; 69 static constexpr char kProxy2Url[] = "https://proxy2.example.org/"; 70 static constexpr size_t kMinRetryTimeForDefaultNetworkSecs = 1; 71 static constexpr size_t kWaitTimeForNewNetworkSecs = 10; 72 static constexpr uint64_t kConnectUdpContextId = 0; 73 74 protected: 75 explicit QuicSessionPoolTestBase( 76 quic::ParsedQuicVersion version, 77 std::vector<base::test::FeatureRef> enabled_features = {}, 78 std::vector<base::test::FeatureRef> disabled_features = {}); 79 ~QuicSessionPoolTestBase(); 80 81 void Initialize(); 82 83 // Make a NEW_CONNECTION_ID frame available for client such that connection 84 // migration can begin with a new connection ID. A side effect of calling 85 // this function is that ACK_FRAME that should have been sent for the first 86 // packet read might be skipped in the unit test. If the order of ACKing is 87 // important for a test, use QuicTestPacketMaker::MakeNewConnectionIdPacket 88 // instead. 89 void MaybeMakeNewConnectionIdAvailableToSession( 90 const quic::QuicConnectionId& new_cid, 91 quic::QuicSession* session, 92 uint64_t sequence_number = 1u); 93 94 // Helper for building requests and invoking `QuicSessionRequest::Request`. 95 // This `Request` method has lots of arguments, most of which are always at 96 // their default values, so this helper supports specifying only the 97 // non-default arguments relevant to a specific test. 98 struct RequestBuilder { 99 RequestBuilder(QuicSessionPoolTestBase* test, QuicSessionPool* pool); 100 explicit RequestBuilder(QuicSessionPoolTestBase* test); 101 ~RequestBuilder(); 102 103 RequestBuilder(const RequestBuilder&) = delete; 104 RequestBuilder& operator=(const RequestBuilder&) = delete; 105 106 // Call the request's `Request` method with the parameters in the builder. 107 // The builder becomes invalid after this call. 108 int CallRequest(); 109 110 // Arguments to request.Request(). 111 url::SchemeHostPort destination{url::kHttpsScheme, kDefaultServerHostName, 112 kDefaultServerPort}; 113 quic::ParsedQuicVersion quic_version; 114 ProxyChain proxy_chain = ProxyChain::Direct(); 115 std::optional<NetworkTrafficAnnotationTag> proxy_annotation_tag = 116 TRAFFIC_ANNOTATION_FOR_TESTS; 117 raw_ptr<HttpUserAgentSettings> http_user_agent_settings = nullptr; 118 SessionUsage session_usage = SessionUsage::kDestination; 119 PrivacyMode privacy_mode = PRIVACY_MODE_DISABLED; 120 RequestPriority priority = DEFAULT_PRIORITY; 121 SocketTag socket_tag; 122 NetworkAnonymizationKey network_anonymization_key; 123 SecureDnsPolicy secure_dns_policy = SecureDnsPolicy::kAllow; 124 bool require_dns_https_alpn = false; 125 int cert_verify_flags = 0; 126 GURL url = GURL(kDefaultUrl); 127 NetLogWithSource net_log; 128 NetErrorDetails net_error_details; 129 CompletionOnceCallback failed_on_default_network_callback; 130 CompletionOnceCallback callback; 131 132 // The resulting request. 133 QuicSessionRequest request; 134 }; 135 136 std::unique_ptr<HttpStream> CreateStream(QuicSessionRequest* request); 137 138 bool HasActiveSession( 139 const url::SchemeHostPort& scheme_host_port, 140 PrivacyMode privacy_mode = PRIVACY_MODE_DISABLED, 141 const NetworkAnonymizationKey& network_anonymization_key = 142 NetworkAnonymizationKey(), 143 const ProxyChain& proxy_chain = ProxyChain::Direct(), 144 SessionUsage session_usage = SessionUsage::kDestination, 145 bool require_dns_https_alpn = false); 146 bool HasActiveJob(const url::SchemeHostPort& scheme_host_port, 147 const PrivacyMode privacy_mode, 148 bool require_dns_https_alpn = false); 149 150 // Get the pending, not activated session, if there is only one session alive. 151 QuicChromiumClientSession* GetPendingSession( 152 const url::SchemeHostPort& scheme_host_port); 153 QuicChromiumClientSession* GetActiveSession( 154 const url::SchemeHostPort& scheme_host_port, 155 PrivacyMode privacy_mode = PRIVACY_MODE_DISABLED, 156 const NetworkAnonymizationKey& network_anonymization_key = 157 NetworkAnonymizationKey(), 158 const ProxyChain& proxy_chain = ProxyChain::Direct(), 159 SessionUsage session_usage = SessionUsage::kDestination, 160 bool require_dns_https_alpn = false); 161 162 int GetSourcePortForNewSessionAndGoAway( 163 const url::SchemeHostPort& destination); 164 int GetSourcePortForNewSessionInner(const url::SchemeHostPort& destination, 165 bool goaway_received); 166 167 static ProofVerifyDetailsChromium DefaultProofVerifyDetails(); 168 169 void NotifyIPAddressChanged(); 170 171 std::unique_ptr<quic::QuicEncryptedPacket> 172 ConstructServerConnectionClosePacket(uint64_t num); 173 std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientRstPacket( 174 uint64_t packet_number, 175 quic::QuicRstStreamErrorCode error_code); 176 std::unique_ptr<quic::QuicEncryptedPacket> ConstructGetRequestPacket( 177 uint64_t packet_number, 178 quic::QuicStreamId stream_id, 179 bool fin); 180 std::unique_ptr<quic::QuicEncryptedPacket> ConstructConnectUdpRequestPacket( 181 uint64_t packet_number, 182 quic::QuicStreamId stream_id, 183 std::string authority, 184 std::string path, 185 bool fin); 186 std::unique_ptr<quic::QuicEncryptedPacket> ConstructConnectUdpRequestPacket( 187 QuicTestPacketMaker& packet_maker, 188 uint64_t packet_number, 189 quic::QuicStreamId stream_id, 190 std::string authority, 191 std::string path, 192 bool fin); 193 std::string ConstructClientH3DatagramFrame( 194 uint64_t quarter_stream_id, 195 uint64_t context_id, 196 std::unique_ptr<quic::QuicEncryptedPacket> inner); 197 std::unique_ptr<quic::QuicEncryptedPacket> ConstructClientH3DatagramPacket( 198 uint64_t packet_number, 199 uint64_t quarter_stream_id, 200 uint64_t context_id, 201 std::unique_ptr<quic::QuicEncryptedPacket> inner); 202 std::unique_ptr<quic::QuicEncryptedPacket> ConstructOkResponsePacket( 203 QuicTestPacketMaker& packet_maker, 204 uint64_t packet_number, 205 quic::QuicStreamId stream_id, 206 bool fin); 207 std::unique_ptr<quic::QuicEncryptedPacket> ConstructOkResponsePacket( 208 uint64_t packet_number, 209 quic::QuicStreamId stream_id, 210 bool fin); 211 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket(); 212 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( 213 uint64_t packet_number); 214 std::unique_ptr<quic::QuicReceivedPacket> ConstructInitialSettingsPacket( 215 QuicTestPacketMaker& packet_maker, 216 uint64_t packet_number); 217 std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerSettingsPacket( 218 uint64_t packet_number); 219 220 std::unique_ptr<quic::QuicEncryptedPacket> ConstructAckPacket( 221 test::QuicTestPacketMaker& packet_maker, 222 uint64_t packet_number, 223 uint64_t packet_num_received, 224 uint64_t smallest_received, 225 uint64_t largest_received); 226 std::string ConstructDataHeader(size_t body_len); 227 228 std::unique_ptr<quic::QuicEncryptedPacket> ConstructServerDataPacket( 229 uint64_t packet_number, 230 quic::QuicStreamId stream_id, 231 bool fin, 232 std::string_view data); 233 234 std::string ConstructH3Datagram( 235 uint64_t stream_id, 236 uint64_t context_id, 237 std::unique_ptr<quic::QuicEncryptedPacket> packet); 238 239 quic::QuicStreamId GetNthClientInitiatedBidirectionalStreamId(int n) const; 240 quic::QuicStreamId GetQpackDecoderStreamId() const; 241 std::string StreamCancellationQpackDecoderInstruction(int n) const; 242 std::string StreamCancellationQpackDecoderInstruction( 243 int n, 244 bool create_stream) const; 245 quic::QuicStreamId GetNthServerInitiatedUnidirectionalStreamId(int n); 246 247 void OnFailedOnDefaultNetwork(int rv); 248 249 const quic::QuicConnectionId kNewCID = quic::test::TestConnectionId(12345678); 250 const url::SchemeHostPort kDefaultDestination{ 251 url::kHttpsScheme, kDefaultServerHostName, kDefaultServerPort}; 252 253 quic::test::QuicFlagSaver flags_; // Save/restore all QUIC flag values. 254 std::unique_ptr<MockHostResolverBase> host_resolver_; 255 TestSSLConfigService ssl_config_service_{SSLContextConfig()}; 256 std::unique_ptr<MockClientSocketFactory> socket_factory_; 257 MockCryptoClientStreamFactory crypto_client_stream_factory_; 258 MockQuicContext context_; 259 const quic::ParsedQuicVersion version_; 260 QuicTestPacketMaker client_maker_; 261 QuicTestPacketMaker server_maker_; 262 std::unique_ptr<HttpServerProperties> http_server_properties_; 263 std::unique_ptr<MockCertVerifier> cert_verifier_; 264 TransportSecurityState transport_security_state_; 265 std::unique_ptr<TestProxyDelegate> proxy_delegate_; 266 std::unique_ptr<ScopedMockNetworkChangeNotifier> 267 scoped_mock_network_change_notifier_; 268 std::unique_ptr<QuicSessionPool> factory_; 269 270 NetLogWithSource net_log_; 271 TestCompletionCallback callback_; 272 const CompletionRepeatingCallback failed_on_default_network_callback_; 273 bool failed_on_default_network_ = false; 274 NetErrorDetails net_error_details_; 275 StaticHttpUserAgentSettings http_user_agent_settings_ = {"test-lang", 276 "test-ua"}; 277 278 raw_ptr<QuicParams> quic_params_; 279 base::test::ScopedFeatureList scoped_feature_list_; 280 }; 281 282 } // namespace net::test 283 284 #endif // NET_QUIC_QUIC_SESSION_POOL_TEST_BASE_H_ 285