/proc/self/cwd/test/mocks/network/mocks.h
Line | Count | Source (jump to first uncovered line) |
1 | | #pragma once |
2 | | |
3 | | #include <algorithm> |
4 | | #include <cstdint> |
5 | | #include <list> |
6 | | #include <ostream> |
7 | | #include <string> |
8 | | #include <vector> |
9 | | |
10 | | #include "envoy/config/core/v3/address.pb.h" |
11 | | #include "envoy/config/core/v3/base.pb.h" |
12 | | #include "envoy/config/listener/v3/udp_listener_config.pb.h" |
13 | | #include "envoy/network/connection.h" |
14 | | #include "envoy/network/drain_decision.h" |
15 | | #include "envoy/network/filter.h" |
16 | | #include "envoy/network/resolver.h" |
17 | | #include "envoy/network/socket.h" |
18 | | #include "envoy/network/transport_socket.h" |
19 | | #include "envoy/stats/scope.h" |
20 | | |
21 | | #include "source/common/network/dns_resolver/dns_factory_util.h" |
22 | | #include "source/common/network/filter_manager_impl.h" |
23 | | #include "source/common/network/socket_interface.h" |
24 | | #include "source/common/network/socket_interface_impl.h" |
25 | | #include "source/common/stats/isolated_store_impl.h" |
26 | | #include "source/common/stream_info/filter_state_impl.h" |
27 | | |
28 | | #include "test/mocks/event/mocks.h" |
29 | | #include "test/mocks/network/connection.h" |
30 | | #include "test/mocks/network/io_handle.h" |
31 | | #include "test/mocks/stream_info/mocks.h" |
32 | | #include "test/test_common/printers.h" |
33 | | |
34 | | #include "gmock/gmock.h" |
35 | | |
36 | | namespace Envoy { |
37 | | namespace Network { |
38 | | |
39 | | class MockActiveDnsQuery : public ActiveDnsQuery { |
40 | | public: |
41 | | MockActiveDnsQuery(); |
42 | | ~MockActiveDnsQuery() override; |
43 | | |
44 | | // Network::ActiveDnsQuery |
45 | | MOCK_METHOD(void, cancel, (CancelReason reason)); |
46 | | }; |
47 | | |
48 | | class MockFilterManager : public FilterManager { |
49 | | public: |
50 | | MOCK_METHOD(void, addWriteFilter, (WriteFilterSharedPtr filter)); |
51 | | MOCK_METHOD(void, addFilter, (FilterSharedPtr filter)); |
52 | | MOCK_METHOD(void, addReadFilter, (ReadFilterSharedPtr filter)); |
53 | | MOCK_METHOD(void, removeReadFilter, (ReadFilterSharedPtr filter)); |
54 | | MOCK_METHOD(bool, initializeReadFilters, ()); |
55 | | }; |
56 | | |
57 | | class MockDnsResolver : public DnsResolver { |
58 | | public: |
59 | | MockDnsResolver(); |
60 | | ~MockDnsResolver() override; |
61 | | |
62 | | // Network::DnsResolver |
63 | | MOCK_METHOD(ActiveDnsQuery*, resolve, |
64 | | (const std::string& dns_name, DnsLookupFamily dns_lookup_family, ResolveCb callback)); |
65 | | MOCK_METHOD(void, resetNetworking, ()); |
66 | | |
67 | | testing::NiceMock<MockActiveDnsQuery> active_query_; |
68 | | }; |
69 | | |
70 | | class MockDnsResolverFactory : public DnsResolverFactory { |
71 | | public: |
72 | 1 | MockDnsResolverFactory() = default; |
73 | 1 | ~MockDnsResolverFactory() override = default; |
74 | | |
75 | | MOCK_METHOD(DnsResolverSharedPtr, createDnsResolver, |
76 | | (Event::Dispatcher & dispatcher, Api::Api& api, |
77 | | const envoy::config::core::v3::TypedExtensionConfig& typed_dns_resolver_config), |
78 | | (const, override)); |
79 | 6 | std::string name() const override { return std::string(CaresDnsResolver); }; |
80 | 2 | ProtobufTypes::MessagePtr createEmptyConfigProto() override { |
81 | 2 | return ProtobufTypes::MessagePtr{ |
82 | 2 | new envoy::extensions::network::dns_resolver::cares::v3::CaresDnsResolverConfig()}; |
83 | 2 | } |
84 | | }; |
85 | | |
86 | | class MockAddressResolver : public Address::Resolver { |
87 | | public: |
88 | | MockAddressResolver(); |
89 | | ~MockAddressResolver() override; |
90 | | |
91 | | MOCK_METHOD(Address::InstanceConstSharedPtr, resolve, |
92 | | (const envoy::config::core::v3::SocketAddress&)); |
93 | | MOCK_METHOD(std::string, name, (), (const)); |
94 | | }; |
95 | | |
96 | | class MockReadFilterCallbacks : public ReadFilterCallbacks { |
97 | | public: |
98 | | MockReadFilterCallbacks(); |
99 | | ~MockReadFilterCallbacks() override; |
100 | | |
101 | | MOCK_METHOD(Connection&, connection, ()); |
102 | | MOCK_METHOD(const Socket&, socket, ()); |
103 | | MOCK_METHOD(void, continueReading, ()); |
104 | | MOCK_METHOD(void, injectReadDataToFilterChain, (Buffer::Instance & data, bool end_stream)); |
105 | | MOCK_METHOD(Upstream::HostDescriptionConstSharedPtr, upstreamHost, ()); |
106 | | MOCK_METHOD(void, upstreamHost, (Upstream::HostDescriptionConstSharedPtr host)); |
107 | | MOCK_METHOD(bool, startUpstreamSecureTransport, ()); |
108 | | |
109 | | testing::NiceMock<MockConnection> connection_; |
110 | | Upstream::HostDescriptionConstSharedPtr host_; |
111 | | }; |
112 | | |
113 | | class MockReadFilter : public ReadFilter { |
114 | | public: |
115 | | MockReadFilter(); |
116 | | ~MockReadFilter() override; |
117 | | |
118 | | MOCK_METHOD(FilterStatus, onData, (Buffer::Instance & data, bool end_stream)); |
119 | | MOCK_METHOD(FilterStatus, onNewConnection, ()); |
120 | | MOCK_METHOD(void, initializeReadFilterCallbacks, (ReadFilterCallbacks & callbacks)); |
121 | | MOCK_METHOD(bool, startUpstreamSecureTransport, ()); |
122 | | |
123 | | ReadFilterCallbacks* callbacks_{}; |
124 | | }; |
125 | | |
126 | | class MockWriteFilterCallbacks : public WriteFilterCallbacks { |
127 | | public: |
128 | | MockWriteFilterCallbacks(); |
129 | | ~MockWriteFilterCallbacks() override; |
130 | | |
131 | | MOCK_METHOD(Connection&, connection, ()); |
132 | | MOCK_METHOD(const Socket&, socket, ()); |
133 | | MOCK_METHOD(void, injectWriteDataToFilterChain, (Buffer::Instance & data, bool end_stream)); |
134 | | |
135 | | testing::NiceMock<MockConnection> connection_; |
136 | | }; |
137 | | |
138 | | class MockWriteFilter : public WriteFilter { |
139 | | public: |
140 | | MockWriteFilter(); |
141 | | ~MockWriteFilter() override; |
142 | | |
143 | | MOCK_METHOD(FilterStatus, onWrite, (Buffer::Instance & data, bool end_stream)); |
144 | | MOCK_METHOD(void, initializeWriteFilterCallbacks, (WriteFilterCallbacks & callbacks)); |
145 | | |
146 | | WriteFilterCallbacks* write_callbacks_{}; |
147 | | }; |
148 | | |
149 | | class MockFilter : public Filter { |
150 | | public: |
151 | | MockFilter(); |
152 | | ~MockFilter() override; |
153 | | |
154 | | MOCK_METHOD(FilterStatus, onData, (Buffer::Instance & data, bool end_stream)); |
155 | | MOCK_METHOD(FilterStatus, onNewConnection, ()); |
156 | | MOCK_METHOD(FilterStatus, onWrite, (Buffer::Instance & data, bool end_stream)); |
157 | | MOCK_METHOD(void, initializeReadFilterCallbacks, (ReadFilterCallbacks & callbacks)); |
158 | | MOCK_METHOD(void, initializeWriteFilterCallbacks, (WriteFilterCallbacks & callbacks)); |
159 | | |
160 | | ReadFilterCallbacks* callbacks_{}; |
161 | | WriteFilterCallbacks* write_callbacks_{}; |
162 | | }; |
163 | | |
164 | | class MockTcpListenerCallbacks : public TcpListenerCallbacks { |
165 | | public: |
166 | | MockTcpListenerCallbacks(); |
167 | | ~MockTcpListenerCallbacks() override; |
168 | | |
169 | 0 | void onAccept(ConnectionSocketPtr&& socket) override { onAccept_(socket); } |
170 | | |
171 | | MOCK_METHOD(void, onAccept_, (ConnectionSocketPtr & socket)); |
172 | | MOCK_METHOD(void, onReject, (RejectCause), (override)); |
173 | | MOCK_METHOD(void, recordConnectionsAcceptedOnSocketEvent, (uint32_t), (override)); |
174 | | }; |
175 | | |
176 | | class MockUdpListenerCallbacks : public UdpListenerCallbacks { |
177 | | public: |
178 | | MockUdpListenerCallbacks(); |
179 | | ~MockUdpListenerCallbacks() override; |
180 | | |
181 | | MOCK_METHOD(void, onData, (UdpRecvData && data)); |
182 | | MOCK_METHOD(void, onDatagramsDropped, (uint32_t dropped)); |
183 | | MOCK_METHOD(void, onReadReady, ()); |
184 | | MOCK_METHOD(void, onWriteReady, (const Socket& socket)); |
185 | | MOCK_METHOD(void, onReceiveError, (Api::IoError::IoErrorCode err)); |
186 | | MOCK_METHOD(Network::UdpPacketWriter&, udpPacketWriter, ()); |
187 | | MOCK_METHOD(uint32_t, workerIndex, (), (const)); |
188 | | MOCK_METHOD(void, onDataWorker, (Network::UdpRecvData && data)); |
189 | | MOCK_METHOD(void, post, (Network::UdpRecvData && data)); |
190 | | MOCK_METHOD(size_t, numPacketsExpectedPerEventLoop, (), (const)); |
191 | | }; |
192 | | |
193 | | class MockDrainDecision : public DrainDecision { |
194 | | public: |
195 | | MockDrainDecision(); |
196 | | ~MockDrainDecision() override; |
197 | | |
198 | | MOCK_METHOD(bool, drainClose, (), (const)); |
199 | | MOCK_METHOD(Common::CallbackHandlePtr, addOnDrainCloseCb, (DrainCloseCb cb), (const, override)); |
200 | | }; |
201 | | |
202 | | class MockListenerFilter : public ListenerFilter { |
203 | | public: |
204 | 0 | MockListenerFilter(size_t max_read_bytes = 0) : listener_filter_max_read_bytes_(max_read_bytes) {} |
205 | | ~MockListenerFilter() override; |
206 | | |
207 | 0 | size_t maxReadBytes() const override { return listener_filter_max_read_bytes_; } |
208 | | |
209 | | MOCK_METHOD(void, destroy_, ()); |
210 | | MOCK_METHOD(Network::FilterStatus, onAccept, (ListenerFilterCallbacks&)); |
211 | | MOCK_METHOD(Network::FilterStatus, onData, (Network::ListenerFilterBuffer&)); |
212 | | |
213 | | size_t listener_filter_max_read_bytes_{0}; |
214 | | }; |
215 | | |
216 | | class MockListenerFilterManager : public ListenerFilterManager { |
217 | | public: |
218 | | MockListenerFilterManager(); |
219 | | ~MockListenerFilterManager() override; |
220 | | |
221 | | void addAcceptFilter(const Network::ListenerFilterMatcherSharedPtr& listener_filter_matcher, |
222 | 0 | ListenerFilterPtr&& filter) override { |
223 | 0 | addAcceptFilter_(listener_filter_matcher, filter); |
224 | 0 | } |
225 | | |
226 | | MOCK_METHOD(void, addAcceptFilter_, |
227 | | (const Network::ListenerFilterMatcherSharedPtr&, Network::ListenerFilterPtr&)); |
228 | | }; |
229 | | |
230 | | #ifdef ENVOY_ENABLE_QUIC |
231 | | |
232 | | } // namespace Network |
233 | | } // namespace Envoy |
234 | | |
235 | | #include "quiche/quic/platform/api/quic_socket_address.h" |
236 | | |
237 | | namespace Envoy { |
238 | | namespace Network { |
239 | | |
240 | | class MockQuicListenerFilter : public QuicListenerFilter { |
241 | | public: |
242 | | MOCK_METHOD(Network::FilterStatus, onAccept, (ListenerFilterCallbacks&)); |
243 | | MOCK_METHOD(bool, shouldAdvertiseServerPreferredAddress, (const quic::QuicSocketAddress&), |
244 | | (const)); |
245 | | MOCK_METHOD(Network::FilterStatus, onPeerAddressChanged, |
246 | | (const quic::QuicSocketAddress&, Network::Connection&)); |
247 | | }; |
248 | | |
249 | | class MockQuicListenerFilterManager : public QuicListenerFilterManager { |
250 | | public: |
251 | | MOCK_METHOD(void, addFilter, |
252 | | (const Network::ListenerFilterMatcherSharedPtr&, QuicListenerFilterPtr&&)); |
253 | | MOCK_METHOD(bool, shouldAdvertiseServerPreferredAddress, (const quic::QuicSocketAddress&), |
254 | | (const)); |
255 | | |
256 | | MOCK_METHOD(void, onPeerAddressChanged, (const quic::QuicSocketAddress&, Connection&)); |
257 | | }; |
258 | | |
259 | | #endif |
260 | | |
261 | | class MockFilterChain : public DrainableFilterChain { |
262 | | public: |
263 | | MockFilterChain(); |
264 | | ~MockFilterChain() override; |
265 | | |
266 | | // Network::DrainableFilterChain |
267 | | MOCK_METHOD(const DownstreamTransportSocketFactory&, transportSocketFactory, (), (const)); |
268 | | MOCK_METHOD(std::chrono::milliseconds, transportSocketConnectTimeout, (), (const)); |
269 | | MOCK_METHOD(const NetworkFilterFactoriesList&, networkFilterFactories, (), (const)); |
270 | | MOCK_METHOD(void, startDraining, ()); |
271 | | MOCK_METHOD(absl::string_view, name, (), (const)); |
272 | | }; |
273 | | |
274 | | class MockFilterChainInfo : public FilterChainInfo { |
275 | | public: |
276 | | MockFilterChainInfo(); |
277 | | |
278 | | // Network::FilterChainInfo |
279 | | MOCK_METHOD(absl::string_view, name, (), (const)); |
280 | | |
281 | | std::string filter_chain_name_{"mock"}; |
282 | | }; |
283 | | |
284 | | class MockFilterChainManager : public FilterChainManager { |
285 | | public: |
286 | | MockFilterChainManager(); |
287 | | ~MockFilterChainManager() override; |
288 | | |
289 | | // Network::FilterChainManager |
290 | | MOCK_METHOD(const FilterChain*, findFilterChain, |
291 | | (const ConnectionSocket& socket, const StreamInfo::StreamInfo& info), (const)); |
292 | | }; |
293 | | |
294 | | class MockFilterChainFactory : public FilterChainFactory { |
295 | | public: |
296 | | MockFilterChainFactory(); |
297 | | ~MockFilterChainFactory() override; |
298 | | |
299 | | MOCK_METHOD(bool, createNetworkFilterChain, |
300 | | (Connection & connection, const NetworkFilterFactoriesList& filter_factories)); |
301 | | MOCK_METHOD(bool, createListenerFilterChain, (ListenerFilterManager & listener)); |
302 | | MOCK_METHOD(void, createUdpListenerFilterChain, |
303 | | (UdpListenerFilterManager & listener, UdpReadFilterCallbacks& callbacks)); |
304 | | MOCK_METHOD(bool, createQuicListenerFilterChain, (QuicListenerFilterManager & listener)); |
305 | | }; |
306 | | |
307 | | class MockListenSocket : public Socket { |
308 | | public: |
309 | | MockListenSocket(); |
310 | 1 | ~MockListenSocket() override = default; |
311 | | |
312 | 0 | void addOption(const Socket::OptionConstSharedPtr& option) override { addOption_(option); } |
313 | 0 | void addOptions(const Socket::OptionsSharedPtr& options) override { addOptions_(options); } |
314 | | |
315 | 1 | ConnectionInfoSetter& connectionInfoProvider() override { return *connection_info_provider_; } |
316 | 0 | const ConnectionInfoProvider& connectionInfoProvider() const override { |
317 | 0 | return *connection_info_provider_; |
318 | 0 | } |
319 | 0 | ConnectionInfoProviderSharedPtr connectionInfoProviderSharedPtr() const override { |
320 | 0 | return connection_info_provider_; |
321 | 0 | } |
322 | | MOCK_METHOD(IoHandle&, ioHandle, ()); |
323 | | MOCK_METHOD(SocketPtr, duplicate, ()); |
324 | | MOCK_METHOD(const IoHandle&, ioHandle, (), (const)); |
325 | | MOCK_METHOD(Socket::Type, socketType, (), (const)); |
326 | | MOCK_METHOD(Address::Type, addressType, (), (const)); |
327 | | MOCK_METHOD(absl::optional<Address::IpVersion>, ipVersion, (), (const)); |
328 | | MOCK_METHOD(void, close, ()); |
329 | | MOCK_METHOD(bool, isOpen, (), (const)); |
330 | | MOCK_METHOD(void, addOption_, (const Socket::OptionConstSharedPtr& option)); |
331 | | MOCK_METHOD(void, addOptions_, (const Socket::OptionsSharedPtr& options)); |
332 | | MOCK_METHOD(const OptionsSharedPtr&, options, (), (const)); |
333 | | MOCK_METHOD(IoHandlePtr, socket, (Socket::Type, Address::Type, Address::IpVersion), (const)); |
334 | | MOCK_METHOD(IoHandlePtr, socketForAddrPtr, (Socket::Type, const Address::InstanceConstSharedPtr), |
335 | | (const)); |
336 | | MOCK_METHOD(Api::SysCallIntResult, bind, (const Address::InstanceConstSharedPtr)); |
337 | | MOCK_METHOD(Api::SysCallIntResult, connect, (const Address::InstanceConstSharedPtr)); |
338 | | MOCK_METHOD(Api::SysCallIntResult, listen, (int)); |
339 | | MOCK_METHOD(Api::SysCallIntResult, setSocketOption, (int, int, const void*, socklen_t)); |
340 | | MOCK_METHOD(Api::SysCallIntResult, getSocketOption, (int, int, void*, socklen_t*), (const)); |
341 | | MOCK_METHOD(Api::SysCallIntResult, ioctl, |
342 | | (unsigned long, void*, unsigned long, void*, unsigned long, unsigned long*)); |
343 | | MOCK_METHOD(Api::SysCallIntResult, setBlockingForTest, (bool)); |
344 | | |
345 | | std::unique_ptr<MockIoHandle> io_handle_; |
346 | | Network::ConnectionInfoSetterSharedPtr connection_info_provider_; |
347 | | OptionsSharedPtr options_; |
348 | | bool socket_is_open_ = true; |
349 | | }; |
350 | | |
351 | | class MockSocketOption : public Socket::Option { |
352 | | public: |
353 | | MockSocketOption(); |
354 | | ~MockSocketOption() override; |
355 | | |
356 | | MOCK_METHOD(bool, setOption, (Socket&, envoy::config::core::v3::SocketOption::SocketState state), |
357 | | (const)); |
358 | | MOCK_METHOD(void, hashKey, (std::vector<uint8_t>&), (const)); |
359 | | MOCK_METHOD(absl::optional<Socket::Option::Details>, getOptionDetails, |
360 | | (const Socket&, envoy::config::core::v3::SocketOption::SocketState state), (const)); |
361 | | MOCK_METHOD(bool, isSupported, (), (const)); |
362 | | }; |
363 | | |
364 | | class MockConnectionSocket : public ConnectionSocket { |
365 | | public: |
366 | | MockConnectionSocket(); |
367 | | ~MockConnectionSocket() override; |
368 | | |
369 | 0 | void addOption(const Socket::OptionConstSharedPtr& option) override { addOption_(option); } |
370 | 745 | void addOptions(const Socket::OptionsSharedPtr& options) override { addOptions_(options); } |
371 | | |
372 | 7.18k | ConnectionInfoSetter& connectionInfoProvider() override { return *connection_info_provider_; } |
373 | 0 | const ConnectionInfoProvider& connectionInfoProvider() const override { |
374 | 0 | return *connection_info_provider_; |
375 | 0 | } |
376 | 0 | ConnectionInfoProviderSharedPtr connectionInfoProviderSharedPtr() const override { |
377 | 0 | return connection_info_provider_; |
378 | 0 | } |
379 | | MOCK_METHOD(void, setDetectedTransportProtocol, (absl::string_view)); |
380 | | MOCK_METHOD(absl::string_view, detectedTransportProtocol, (), (const)); |
381 | | MOCK_METHOD(void, setRequestedApplicationProtocols, (const std::vector<absl::string_view>&)); |
382 | | MOCK_METHOD(const std::vector<std::string>&, requestedApplicationProtocols, (), (const)); |
383 | | MOCK_METHOD(void, setRequestedServerName, (absl::string_view)); |
384 | | MOCK_METHOD(absl::string_view, requestedServerName, (), (const)); |
385 | | MOCK_METHOD(void, setJA3Hash, (absl::string_view)); |
386 | | MOCK_METHOD(absl::string_view, ja3Hash, (), (const)); |
387 | | MOCK_METHOD(void, addOption_, (const Socket::OptionConstSharedPtr&)); |
388 | | MOCK_METHOD(void, addOptions_, (const Socket::OptionsSharedPtr&)); |
389 | | MOCK_METHOD(const Network::ConnectionSocket::OptionsSharedPtr&, options, (), (const)); |
390 | | MOCK_METHOD(SocketPtr, duplicate, ()); |
391 | | MOCK_METHOD(IoHandle&, ioHandle, ()); |
392 | | MOCK_METHOD(const IoHandle&, ioHandle, (), (const)); |
393 | | MOCK_METHOD(Socket::Type, socketType, (), (const)); |
394 | | MOCK_METHOD(Address::Type, addressType, (), (const)); |
395 | | MOCK_METHOD(absl::optional<Address::IpVersion>, ipVersion, (), (const)); |
396 | | MOCK_METHOD(void, close, ()); |
397 | | MOCK_METHOD(bool, isOpen, (), (const)); |
398 | | MOCK_METHOD(IoHandlePtr, socket, (Socket::Type, Address::Type, Address::IpVersion), (const)); |
399 | | MOCK_METHOD(IoHandlePtr, socketForAddrPtr, (Socket::Type, const Address::InstanceConstSharedPtr), |
400 | | (const)); |
401 | | MOCK_METHOD(Api::SysCallIntResult, bind, (const Address::InstanceConstSharedPtr)); |
402 | | MOCK_METHOD(Api::SysCallIntResult, connect, (const Address::InstanceConstSharedPtr)); |
403 | | MOCK_METHOD(Api::SysCallIntResult, listen, (int)); |
404 | | MOCK_METHOD(Api::SysCallIntResult, setSocketOption, (int, int, const void*, socklen_t)); |
405 | | MOCK_METHOD(Api::SysCallIntResult, getSocketOption, (int, int, void*, socklen_t*), (const)); |
406 | | MOCK_METHOD(Api::SysCallIntResult, ioctl, |
407 | | (unsigned long, void*, unsigned long, void*, unsigned long, unsigned long*)); |
408 | | MOCK_METHOD(Api::SysCallIntResult, setBlockingForTest, (bool)); |
409 | | MOCK_METHOD(absl::optional<std::chrono::milliseconds>, lastRoundTripTime, ()); |
410 | | MOCK_METHOD(absl::optional<uint64_t>, congestionWindowInBytes, (), (const)); |
411 | | MOCK_METHOD(void, dumpState, (std::ostream&, int), (const)); |
412 | | |
413 | | IoHandlePtr io_handle_; |
414 | | std::shared_ptr<Network::ConnectionInfoSetterImpl> connection_info_provider_; |
415 | | }; |
416 | | |
417 | | class MockListenerFilterCallbacks : public ListenerFilterCallbacks { |
418 | | public: |
419 | | MockListenerFilterCallbacks(); |
420 | | ~MockListenerFilterCallbacks() override; |
421 | | |
422 | | MOCK_METHOD(ConnectionSocket&, socket, ()); |
423 | | MOCK_METHOD(Event::Dispatcher&, dispatcher, ()); |
424 | | MOCK_METHOD(void, continueFilterChain, (bool)); |
425 | | MOCK_METHOD(void, setDynamicMetadata, (const std::string&, const ProtobufWkt::Struct&)); |
426 | | MOCK_METHOD(envoy::config::core::v3::Metadata&, dynamicMetadata, ()); |
427 | | MOCK_METHOD(const envoy::config::core::v3::Metadata&, dynamicMetadata, (), (const)); |
428 | | MOCK_METHOD(StreamInfo::FilterState&, filterState, (), ()); |
429 | | |
430 | | StreamInfo::FilterStateImpl filter_state_; |
431 | | NiceMock<MockConnectionSocket> socket_; |
432 | | }; |
433 | | |
434 | | class MockListenSocketFactory : public ListenSocketFactory { |
435 | | public: |
436 | 3 | MockListenSocketFactory() = default; |
437 | | |
438 | | MOCK_METHOD(Network::Socket::Type, socketType, (), (const)); |
439 | | MOCK_METHOD(const Network::Address::InstanceConstSharedPtr&, localAddress, (), (const)); |
440 | | MOCK_METHOD(Network::SocketSharedPtr, getListenSocket, (uint32_t)); |
441 | | MOCK_METHOD(bool, reusePort, (), (const)); |
442 | | MOCK_METHOD(Network::ListenSocketFactoryPtr, clone, (), (const)); |
443 | | MOCK_METHOD(void, closeAllSockets, ()); |
444 | | MOCK_METHOD(void, doFinalPreWorkerInit, ()); |
445 | | }; |
446 | | |
447 | | class MockUdpPacketWriterFactory : public UdpPacketWriterFactory { |
448 | | public: |
449 | | MockUdpPacketWriterFactory() = default; |
450 | | |
451 | | MOCK_METHOD(Network::UdpPacketWriterPtr, createUdpPacketWriter, |
452 | | (Network::IoHandle&, Stats::Scope&), ()); |
453 | | }; |
454 | | |
455 | | class MockUdpListenerConfig : public UdpListenerConfig { |
456 | | public: |
457 | | MockUdpListenerConfig(uint32_t concurrency = 1); |
458 | | ~MockUdpListenerConfig() override; |
459 | | |
460 | | MOCK_METHOD(ActiveUdpListenerFactory&, listenerFactory, ()); |
461 | | MOCK_METHOD(UdpPacketWriterFactory&, packetWriterFactory, ()); |
462 | | MOCK_METHOD(UdpListenerWorkerRouter&, listenerWorkerRouter, (const Network::Address::Instance&)); |
463 | | MOCK_METHOD(const envoy::config::listener::v3::UdpListenerConfig&, config, ()); |
464 | | |
465 | | UdpListenerWorkerRouterPtr udp_listener_worker_router_; |
466 | | envoy::config::listener::v3::UdpListenerConfig config_; |
467 | | }; |
468 | | |
469 | | class MockListenerConfig : public ListenerConfig { |
470 | | public: |
471 | | MockListenerConfig(); |
472 | | ~MockListenerConfig() override; |
473 | | |
474 | | MOCK_METHOD(FilterChainManager&, filterChainManager, ()); |
475 | | MOCK_METHOD(FilterChainFactory&, filterChainFactory, ()); |
476 | | MOCK_METHOD(std::vector<ListenSocketFactoryPtr>&, listenSocketFactories, ()); |
477 | | MOCK_METHOD(bool, bindToPort, (), (const)); |
478 | | MOCK_METHOD(bool, handOffRestoredDestinationConnections, (), (const)); |
479 | | MOCK_METHOD(uint32_t, perConnectionBufferLimitBytes, (), (const)); |
480 | | MOCK_METHOD(std::chrono::milliseconds, listenerFiltersTimeout, (), (const)); |
481 | | MOCK_METHOD(bool, continueOnListenerFiltersTimeout, (), (const)); |
482 | | MOCK_METHOD(Stats::Scope&, listenerScope, ()); |
483 | | MOCK_METHOD(uint64_t, listenerTag, (), (const)); |
484 | | MOCK_METHOD(const std::string&, name, (), (const)); |
485 | | MOCK_METHOD(Network::UdpListenerConfigOptRef, udpListenerConfig, ()); |
486 | | MOCK_METHOD(InternalListenerConfigOptRef, internalListenerConfig, ()); |
487 | | MOCK_METHOD(ConnectionBalancer&, connectionBalancer, (const Network::Address::Instance&)); |
488 | | MOCK_METHOD(ResourceLimit&, openConnections, ()); |
489 | | MOCK_METHOD(uint32_t, tcpBacklogSize, (), (const)); |
490 | | MOCK_METHOD(uint32_t, maxConnectionsToAcceptPerSocketEvent, (), (const)); |
491 | | MOCK_METHOD(Init::Manager&, initManager, ()); |
492 | | MOCK_METHOD(bool, ignoreGlobalConnLimit, (), (const)); |
493 | | |
494 | 0 | envoy::config::core::v3::TrafficDirection direction() const override { |
495 | 0 | return envoy::config::core::v3::UNSPECIFIED; |
496 | 0 | } |
497 | | |
498 | 0 | const std::vector<AccessLog::InstanceSharedPtr>& accessLogs() const override { |
499 | 0 | return empty_access_logs_; |
500 | 0 | } |
501 | | |
502 | | testing::NiceMock<MockFilterChainFactory> filter_chain_factory_; |
503 | | std::vector<ListenSocketFactoryPtr> socket_factories_; |
504 | | SocketSharedPtr socket_; |
505 | | Stats::IsolatedStoreImpl store_; |
506 | | std::string name_; |
507 | | const std::vector<AccessLog::InstanceSharedPtr> empty_access_logs_; |
508 | | }; |
509 | | |
510 | | class MockListener : public Listener { |
511 | | public: |
512 | | MockListener(); |
513 | | ~MockListener() override; |
514 | | |
515 | | MOCK_METHOD(void, onDestroy, ()); |
516 | | MOCK_METHOD(void, enable, ()); |
517 | | MOCK_METHOD(void, disable, ()); |
518 | | MOCK_METHOD(void, setRejectFraction, (UnitFloat)); |
519 | | MOCK_METHOD(void, configureLoadShedPoints, (Server::LoadShedPointProvider&)); |
520 | | }; |
521 | | |
522 | | class MockConnectionHandler : public virtual ConnectionHandler { |
523 | | public: |
524 | | MockConnectionHandler(); |
525 | | ~MockConnectionHandler() override; |
526 | | |
527 | | MOCK_METHOD(uint64_t, numConnections, (), (const)); |
528 | | MOCK_METHOD(void, incNumConnections, ()); |
529 | | MOCK_METHOD(void, decNumConnections, ()); |
530 | | MOCK_METHOD(void, addListener, |
531 | | (absl::optional<uint64_t> overridden_listener, ListenerConfig& config, |
532 | | Runtime::Loader& runtime)); |
533 | | MOCK_METHOD(void, removeListeners, (uint64_t listener_tag)); |
534 | | MOCK_METHOD(void, removeFilterChains, |
535 | | (uint64_t listener_tag, const std::list<const Network::FilterChain*>& filter_chains, |
536 | | std::function<void()> completion)); |
537 | | MOCK_METHOD(void, stopListeners, |
538 | | (uint64_t listener_tag, const Network::ExtraShutdownListenerOptions& options)); |
539 | | MOCK_METHOD(void, stopListeners, ()); |
540 | | MOCK_METHOD(void, disableListeners, ()); |
541 | | MOCK_METHOD(void, enableListeners, ()); |
542 | | MOCK_METHOD(void, setListenerRejectFraction, (UnitFloat), (override)); |
543 | | MOCK_METHOD(const std::string&, statPrefix, (), (const)); |
544 | | |
545 | | uint64_t num_handler_connections_{}; |
546 | | }; |
547 | | |
548 | | class MockUdpListenerWorkerRouter : public UdpListenerWorkerRouter { |
549 | | public: |
550 | | ~MockUdpListenerWorkerRouter() override; |
551 | | |
552 | | MOCK_METHOD(void, registerWorkerForListener, (UdpListenerCallbacks & listener)); |
553 | | MOCK_METHOD(void, unregisterWorkerForListener, (UdpListenerCallbacks & listener)); |
554 | | MOCK_METHOD(void, deliver, (uint32_t dest_worker_index, UdpRecvData&& data)); |
555 | | }; |
556 | | |
557 | | class MockIp : public Address::Ip { |
558 | | public: |
559 | | MockIp(); |
560 | | ~MockIp() override; |
561 | | |
562 | | MOCK_METHOD(const std::string&, addressAsString, (), (const)); |
563 | | MOCK_METHOD(bool, isAnyAddress, (), (const)); |
564 | | MOCK_METHOD(bool, isUnicastAddress, (), (const)); |
565 | | MOCK_METHOD(const Address::Ipv4*, ipv4, (), (const)); |
566 | | MOCK_METHOD(const Address::Ipv6*, ipv6, (), (const)); |
567 | | MOCK_METHOD(uint32_t, port, (), (const)); |
568 | | MOCK_METHOD(Address::IpVersion, version, (), (const)); |
569 | | MOCK_METHOD(bool, v6only, (), (const)); |
570 | | }; |
571 | | |
572 | | class MockResolvedAddress : public Address::Instance { |
573 | | public: |
574 | | MockResolvedAddress(const std::string& logical, const std::string& physical); |
575 | | ~MockResolvedAddress() override; |
576 | | |
577 | 0 | bool operator==(const Address::Instance& other) const override { |
578 | 0 | return asString() == other.asString(); |
579 | 0 | } |
580 | | |
581 | | MOCK_METHOD(Api::SysCallIntResult, bind, (os_fd_t), (const)); |
582 | | MOCK_METHOD(Api::SysCallIntResult, connect, (os_fd_t), (const)); |
583 | | MOCK_METHOD(const Address::Ip*, ip, (), (const)); |
584 | | MOCK_METHOD(const Address::Pipe*, pipe, (), (const)); |
585 | | MOCK_METHOD(Address::EnvoyInternalAddress*, envoyInternalAddress, (), (const)); |
586 | | MOCK_METHOD(IoHandlePtr, socket, (Socket::Type), (const)); |
587 | | MOCK_METHOD(Address::Type, type, (), (const)); |
588 | | MOCK_METHOD(const sockaddr*, sockAddr, (), (const)); |
589 | | MOCK_METHOD(socklen_t, sockAddrLen, (), (const)); |
590 | | MOCK_METHOD(absl::string_view, addressType, (), (const)); |
591 | | |
592 | 0 | const std::string& asString() const override { return physical_; } |
593 | 0 | absl::string_view asStringView() const override { return physical_; } |
594 | 0 | const std::string& logicalName() const override { return logical_; } |
595 | 0 | const Network::SocketInterface& socketInterface() const override { |
596 | 0 | return SocketInterfaceSingleton::get(); |
597 | 0 | } |
598 | | |
599 | | const std::string logical_; |
600 | | const std::string physical_; |
601 | | }; |
602 | | |
603 | | class MockTransportSocketCallbacks : public TransportSocketCallbacks { |
604 | | public: |
605 | | MockTransportSocketCallbacks(); |
606 | | ~MockTransportSocketCallbacks() override; |
607 | | |
608 | | MOCK_METHOD(IoHandle&, ioHandle, ()); |
609 | | MOCK_METHOD(const IoHandle&, ioHandle, (), (const)); |
610 | | MOCK_METHOD(Connection&, connection, ()); |
611 | | MOCK_METHOD(bool, shouldDrainReadBuffer, ()); |
612 | | MOCK_METHOD(void, setTransportSocketIsReadable, ()); |
613 | | MOCK_METHOD(void, raiseEvent, (ConnectionEvent)); |
614 | | MOCK_METHOD(void, flushWriteBuffer, ()); |
615 | | |
616 | | testing::NiceMock<MockConnection> connection_; |
617 | | }; |
618 | | |
619 | | class MockUdpPacketWriter : public UdpPacketWriter { |
620 | | public: |
621 | | MockUdpPacketWriter(); |
622 | | ~MockUdpPacketWriter() override; |
623 | | |
624 | | MOCK_METHOD(Api::IoCallUint64Result, writePacket, |
625 | | (const Buffer::Instance& buffer, const Address::Ip* local_ip, |
626 | | const Address::Instance& peer_address)); |
627 | | MOCK_METHOD(bool, isWriteBlocked, (), (const)); |
628 | | MOCK_METHOD(void, setWritable, ()); |
629 | | MOCK_METHOD(uint64_t, getMaxPacketSize, (const Address::Instance& peer_address), (const)); |
630 | | MOCK_METHOD(bool, isBatchMode, (), (const)); |
631 | | MOCK_METHOD(Network::UdpPacketWriterBuffer, getNextWriteLocation, |
632 | | (const Address::Ip* local_ip, const Address::Instance& peer_address)); |
633 | | MOCK_METHOD(Api::IoCallUint64Result, flush, ()); |
634 | | }; |
635 | | |
636 | | class MockUdpListener : public UdpListener { |
637 | | public: |
638 | | MockUdpListener(); |
639 | | ~MockUdpListener() override; |
640 | | |
641 | | MOCK_METHOD(void, onDestroy, ()); |
642 | | MOCK_METHOD(void, enable, ()); |
643 | | MOCK_METHOD(void, disable, ()); |
644 | | MOCK_METHOD(void, setRejectFraction, (UnitFloat), (override)); |
645 | | MOCK_METHOD(void, configureLoadShedPoints, (Server::LoadShedPointProvider&)); |
646 | | MOCK_METHOD(Event::Dispatcher&, dispatcher, ()); |
647 | | MOCK_METHOD(Address::InstanceConstSharedPtr&, localAddress, (), (const)); |
648 | | MOCK_METHOD(Api::IoCallUint64Result, send, (const UdpSendData&)); |
649 | | MOCK_METHOD(Api::IoCallUint64Result, flush, ()); |
650 | | MOCK_METHOD(void, activateRead, ()); |
651 | | |
652 | | Event::MockDispatcher dispatcher_; |
653 | | }; |
654 | | |
655 | | class MockUdpReadFilterCallbacks : public UdpReadFilterCallbacks { |
656 | | public: |
657 | | MockUdpReadFilterCallbacks(); |
658 | | ~MockUdpReadFilterCallbacks() override; |
659 | | |
660 | | MOCK_METHOD(UdpListener&, udpListener, ()); |
661 | | |
662 | | testing::NiceMock<MockUdpListener> udp_listener_; |
663 | | }; |
664 | | |
665 | | class MockUdpListenerReadFilter : public UdpListenerReadFilter { |
666 | | public: |
667 | | MockUdpListenerReadFilter(UdpReadFilterCallbacks& callbacks); |
668 | | ~MockUdpListenerReadFilter() override; |
669 | | |
670 | | MOCK_METHOD(Network::FilterStatus, onData, (UdpRecvData&)); |
671 | | MOCK_METHOD(Network::FilterStatus, onReceiveError, (Api::IoError::IoErrorCode)); |
672 | | }; |
673 | | |
674 | | class MockUdpListenerFilterManager : public UdpListenerFilterManager { |
675 | | public: |
676 | | MockUdpListenerFilterManager(); |
677 | | ~MockUdpListenerFilterManager() override; |
678 | | |
679 | 0 | void addReadFilter(UdpListenerReadFilterPtr&& filter) override { addReadFilter_(filter); } |
680 | | |
681 | | MOCK_METHOD(void, addReadFilter_, (Network::UdpListenerReadFilterPtr&)); |
682 | | }; |
683 | | |
684 | | class MockConnectionBalancer : public ConnectionBalancer { |
685 | | public: |
686 | | MockConnectionBalancer(); |
687 | | ~MockConnectionBalancer() override; |
688 | | |
689 | | MOCK_METHOD(void, registerHandler, (BalancedConnectionHandler & handler)); |
690 | | MOCK_METHOD(void, unregisterHandler, (BalancedConnectionHandler & handler)); |
691 | | MOCK_METHOD(BalancedConnectionHandler&, pickTargetHandler, |
692 | | (BalancedConnectionHandler & current_handler)); |
693 | | }; |
694 | | |
695 | | class MockListenerFilterMatcher : public ListenerFilterMatcher { |
696 | | public: |
697 | | MockListenerFilterMatcher(); |
698 | | ~MockListenerFilterMatcher() override; |
699 | | MOCK_METHOD(bool, matches, (Network::ListenerFilterCallbacks & cb), (const)); |
700 | | }; |
701 | | |
702 | | class MockUdpPacketProcessor : public UdpPacketProcessor { |
703 | | public: |
704 | | MOCK_METHOD(void, processPacket, |
705 | | (Address::InstanceConstSharedPtr local_address, |
706 | | Address::InstanceConstSharedPtr peer_address, Buffer::InstancePtr buffer, |
707 | | MonotonicTime receive_time)); |
708 | | MOCK_METHOD(void, onDatagramsDropped, (uint32_t dropped)); |
709 | | MOCK_METHOD(uint64_t, maxDatagramSize, (), (const)); |
710 | | MOCK_METHOD(size_t, numPacketsExpectedPerEventLoop, (), (const)); |
711 | | }; |
712 | | |
713 | | class MockSocketInterface : public SocketInterfaceImpl { |
714 | | public: |
715 | | explicit MockSocketInterface(const std::vector<Address::IpVersion>& versions) |
716 | 0 | : versions_(versions.begin(), versions.end()) {} |
717 | | MOCK_METHOD(IoHandlePtr, socket, |
718 | | (Socket::Type, Address::Type, Address::IpVersion, bool, const SocketCreationOptions&), |
719 | | (const)); |
720 | | MOCK_METHOD(IoHandlePtr, socket, |
721 | | (Socket::Type, const Address::InstanceConstSharedPtr, const SocketCreationOptions&), |
722 | | (const)); |
723 | 0 | bool ipFamilySupported(int domain) override { |
724 | 0 | const auto to_version = domain == AF_INET ? Address::IpVersion::v4 : Address::IpVersion::v6; |
725 | 0 | return std::any_of(versions_.begin(), versions_.end(), |
726 | 0 | [to_version](auto version) { return to_version == version; }); |
727 | 0 | } |
728 | | const std::vector<Address::IpVersion> versions_; |
729 | | }; |
730 | | |
731 | | } // namespace Network |
732 | | } // namespace Envoy |