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_HTTP_HTTP_STREAM_POOL_TEST_UTIL_H_ 6 #define NET_HTTP_HTTP_STREAM_POOL_TEST_UTIL_H_ 7 8 #include <list> 9 #include <memory> 10 #include <optional> 11 #include <set> 12 #include <string> 13 #include <vector> 14 15 #include "net/base/completion_once_callback.h" 16 #include "net/base/net_errors.h" 17 #include "net/base/request_priority.h" 18 #include "net/dns/host_resolver.h" 19 #include "net/http/http_stream_key.h" 20 #include "net/socket/socket_test_util.h" 21 #include "net/socket/stream_socket.h" 22 #include "net/traffic_annotation/network_traffic_annotation.h" 23 #include "url/scheme_host_port.h" 24 25 namespace net { 26 27 class IOBuffer; 28 class SSLInfo; 29 30 // A fake ServiceEndpointRequest implementation that provides testing harnesses. 31 class FakeServiceEndpointRequest : public HostResolver::ServiceEndpointRequest { 32 public: 33 FakeServiceEndpointRequest(); 34 ~FakeServiceEndpointRequest() override; 35 set_start_result(int start_result)36 void set_start_result(int start_result) { start_result_ = start_result; } 37 set_endpoints(std::vector<ServiceEndpoint> endpoints)38 FakeServiceEndpointRequest& set_endpoints( 39 std::vector<ServiceEndpoint> endpoints) { 40 endpoints_ = std::move(endpoints); 41 return *this; 42 } 43 add_endpoint(ServiceEndpoint endpoint)44 FakeServiceEndpointRequest& add_endpoint(ServiceEndpoint endpoint) { 45 endpoints_.emplace_back(std::move(endpoint)); 46 return *this; 47 } 48 set_aliases(std::set<std::string> aliases)49 FakeServiceEndpointRequest& set_aliases(std::set<std::string> aliases) { 50 aliases_ = std::move(aliases); 51 return *this; 52 } 53 set_crypto_ready(bool endpoints_crypto_ready)54 FakeServiceEndpointRequest& set_crypto_ready(bool endpoints_crypto_ready) { 55 endpoints_crypto_ready_ = endpoints_crypto_ready; 56 return *this; 57 } 58 set_resolve_error_info(ResolveErrorInfo resolve_error_info)59 FakeServiceEndpointRequest& set_resolve_error_info( 60 ResolveErrorInfo resolve_error_info) { 61 resolve_error_info_ = resolve_error_info; 62 return *this; 63 } 64 priority()65 RequestPriority priority() const { return priority_; } set_priority(RequestPriority priority)66 FakeServiceEndpointRequest& set_priority(RequestPriority priority) { 67 priority_ = priority; 68 return *this; 69 } 70 71 FakeServiceEndpointRequest& CompleteStartSynchronously(int rv); 72 73 FakeServiceEndpointRequest& CallOnServiceEndpointsUpdated(); 74 75 FakeServiceEndpointRequest& CallOnServiceEndpointRequestFinished(int rv); 76 77 // HostResolver::ServiceEndpointRequest methods: 78 int Start(Delegate* delegate) override; 79 const std::vector<ServiceEndpoint>& GetEndpointResults() override; 80 const std::set<std::string>& GetDnsAliasResults() override; 81 bool EndpointsCryptoReady() override; 82 ResolveErrorInfo GetResolveErrorInfo() override; 83 void ChangeRequestPriority(RequestPriority priority) override; 84 85 private: 86 raw_ptr<Delegate> delegate_; 87 88 int start_result_ = ERR_IO_PENDING; 89 std::vector<ServiceEndpoint> endpoints_; 90 std::set<std::string> aliases_; 91 bool endpoints_crypto_ready_ = false; 92 ResolveErrorInfo resolve_error_info_; 93 RequestPriority priority_ = RequestPriority::IDLE; 94 }; 95 96 // A fake HostResolver that implements the ServiceEndpointRequest API using 97 // FakeServiceEndpointRequest. 98 class FakeServiceEndpointResolver : public HostResolver { 99 public: 100 FakeServiceEndpointResolver(); 101 102 FakeServiceEndpointResolver(const FakeServiceEndpointResolver&) = delete; 103 FakeServiceEndpointResolver& operator=(const FakeServiceEndpointResolver&) = 104 delete; 105 106 ~FakeServiceEndpointResolver() override; 107 108 FakeServiceEndpointRequest* AddFakeRequest(); 109 110 // HostResolver methods: 111 void OnShutdown() override; 112 std::unique_ptr<ResolveHostRequest> CreateRequest( 113 url::SchemeHostPort host, 114 NetworkAnonymizationKey network_anonymization_key, 115 NetLogWithSource net_log, 116 std::optional<ResolveHostParameters> optional_parameters) override; 117 std::unique_ptr<ResolveHostRequest> CreateRequest( 118 const HostPortPair& host, 119 const NetworkAnonymizationKey& network_anonymization_key, 120 const NetLogWithSource& net_log, 121 const std::optional<ResolveHostParameters>& optional_parameters) override; 122 std::unique_ptr<ServiceEndpointRequest> CreateServiceEndpointRequest( 123 Host host, 124 NetworkAnonymizationKey network_anonymization_key, 125 NetLogWithSource net_log, 126 ResolveHostParameters parameters) override; 127 128 private: 129 std::list<std::unique_ptr<FakeServiceEndpointRequest>> requests_; 130 }; 131 132 // A helper to build a ServiceEndpoint. 133 class ServiceEndpointBuilder { 134 public: 135 ServiceEndpointBuilder(); 136 ~ServiceEndpointBuilder(); 137 138 ServiceEndpointBuilder& add_v4(std::string_view addr, uint16_t port = 80); 139 140 ServiceEndpointBuilder& add_v6(std::string_view addr, uint16_t port = 80); 141 142 ServiceEndpointBuilder& add_ip_endpoint(IPEndPoint ip_endpoint); 143 144 ServiceEndpointBuilder& set_alpns(std::vector<std::string> alpns); 145 146 ServiceEndpointBuilder& set_ech_config_list( 147 std::vector<uint8_t> ech_config_list); 148 endpoint()149 ServiceEndpoint endpoint() const { return endpoint_; } 150 151 private: 152 ServiceEndpoint endpoint_; 153 }; 154 155 class FakeStreamSocket : public MockClientSocket { 156 public: 157 static std::unique_ptr<FakeStreamSocket> CreateForSpdy(); 158 159 FakeStreamSocket(); 160 161 FakeStreamSocket(const FakeStreamSocket&) = delete; 162 FakeStreamSocket& operator=(const FakeStreamSocket&) = delete; 163 164 ~FakeStreamSocket() override; 165 set_is_connected(bool connected)166 void set_is_connected(bool connected) { connected_ = connected; } 167 set_is_idle(bool is_idle)168 void set_is_idle(bool is_idle) { is_idle_ = is_idle; } 169 set_was_ever_used(bool was_ever_used)170 void set_was_ever_used(bool was_ever_used) { was_ever_used_ = was_ever_used; } 171 set_peer_addr(IPEndPoint peer_addr)172 void set_peer_addr(IPEndPoint peer_addr) { peer_addr_ = peer_addr; } 173 set_ssl_info(SSLInfo ssl_info)174 void set_ssl_info(SSLInfo ssl_info) { ssl_info_ = std::move(ssl_info); } 175 176 // StreamSocket implementation: 177 int Read(IOBuffer* buf, 178 int buf_len, 179 CompletionOnceCallback callback) override; 180 int Write(IOBuffer* buf, 181 int buf_len, 182 CompletionOnceCallback callback, 183 const NetworkTrafficAnnotationTag& traffic_annotation) override; 184 int Connect(CompletionOnceCallback callback) override; 185 bool IsConnected() const override; 186 bool IsConnectedAndIdle() const override; 187 bool WasEverUsed() const override; 188 bool GetSSLInfo(SSLInfo* ssl_info) override; 189 190 private: 191 bool is_idle_ = true; 192 bool was_ever_used_ = false; 193 std::optional<SSLInfo> ssl_info_; 194 }; 195 196 // Convert a ClientSocketPool::GroupId to an HttpStreamKey. 197 HttpStreamKey GroupIdToHttpStreamKey(const ClientSocketPool::GroupId& group_id); 198 199 } // namespace net 200 201 #endif // NET_HTTP_HTTP_STREAM_POOL_TEST_UTIL_H_ 202