1 // Copyright 2023 gRPC authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <memory>
16
17 #include "gmock/gmock.h"
18
19 #include "src/core/ext/transport/chaotic_good/client_transport.h"
20 #include "src/core/ext/transport/chaotic_good/server_transport.h"
21 #include "src/core/lib/event_engine/memory_allocator_factory.h"
22 #include "src/core/lib/event_engine/tcp_socket_utils.h"
23 #include "src/core/lib/resource_quota/resource_quota.h"
24 #include "src/core/lib/transport/promise_endpoint.h"
25 #include "test/core/transport/test_suite/fixture.h"
26
27 using grpc_event_engine::experimental::EndpointConfig;
28 using grpc_event_engine::experimental::EventEngine;
29 using grpc_event_engine::experimental::FuzzingEventEngine;
30 using grpc_event_engine::experimental::MemoryQuotaBasedMemoryAllocatorFactory;
31 using grpc_event_engine::experimental::URIToResolvedAddress;
32
33 namespace grpc_core {
34
35 namespace {
36
37 class MockEndpointConfig : public EndpointConfig {
38 public:
39 MOCK_METHOD(absl::optional<int>, GetInt, (absl::string_view key),
40 (const, override));
41 MOCK_METHOD(absl::optional<absl::string_view>, GetString,
42 (absl::string_view key), (const, override));
43 MOCK_METHOD(void*, GetVoidPointer, (absl::string_view key),
44 (const, override));
45 };
46
47 struct EndpointPair {
48 PromiseEndpoint client;
49 PromiseEndpoint server;
50 };
51
CreateEndpointPair(grpc_event_engine::experimental::FuzzingEventEngine * event_engine,ResourceQuotaRefPtr resource_quota,int port)52 EndpointPair CreateEndpointPair(
53 grpc_event_engine::experimental::FuzzingEventEngine* event_engine,
54 ResourceQuotaRefPtr resource_quota, int port) {
55 std::unique_ptr<EventEngine::Endpoint> client_endpoint;
56 std::unique_ptr<EventEngine::Endpoint> server_endpoint;
57
58 const auto resolved_address =
59 URIToResolvedAddress(absl::StrCat("ipv4:127.0.0.1:", port)).value();
60
61 ::testing::StrictMock<MockEndpointConfig> endpoint_config;
62 auto listener = *event_engine->CreateListener(
63 [&server_endpoint](std::unique_ptr<EventEngine::Endpoint> endpoint,
64 MemoryAllocator) {
65 server_endpoint = std::move(endpoint);
66 },
67 [](absl::Status) {}, endpoint_config,
68 std::make_unique<MemoryQuotaBasedMemoryAllocatorFactory>(
69 resource_quota->memory_quota()));
70 GPR_ASSERT(listener->Bind(resolved_address).ok());
71 GPR_ASSERT(listener->Start().ok());
72
73 event_engine->Connect(
74 [&client_endpoint](
75 absl::StatusOr<std::unique_ptr<EventEngine::Endpoint>> endpoint) {
76 GPR_ASSERT(endpoint.ok());
77 client_endpoint = std::move(endpoint).value();
78 },
79 resolved_address, endpoint_config,
80 resource_quota->memory_quota()->CreateMemoryAllocator("client"),
81 Duration::Hours(3));
82
83 while (client_endpoint == nullptr || server_endpoint == nullptr) {
84 event_engine->Tick();
85 }
86
87 return EndpointPair{
88 PromiseEndpoint(std::move(client_endpoint), SliceBuffer()),
89 PromiseEndpoint(std::move(server_endpoint), SliceBuffer())};
90 }
91
92 } // namespace
93
TRANSPORT_FIXTURE(ChaoticGood)94 TRANSPORT_FIXTURE(ChaoticGood) {
95 auto resource_quota = MakeResourceQuota("test");
96 EndpointPair control_endpoints =
97 CreateEndpointPair(event_engine.get(), resource_quota, 1234);
98 EndpointPair data_endpoints =
99 CreateEndpointPair(event_engine.get(), resource_quota, 4321);
100 auto channel_args =
101 ChannelArgs()
102 .SetObject(resource_quota)
103 .SetObject(std::static_pointer_cast<EventEngine>(event_engine));
104 auto client_transport =
105 MakeOrphanable<chaotic_good::ChaoticGoodClientTransport>(
106 std::move(control_endpoints.client), std::move(data_endpoints.client),
107 ChannelArgs().SetObject(resource_quota), event_engine, HPackParser(),
108 HPackCompressor());
109 auto server_transport =
110 MakeOrphanable<chaotic_good::ChaoticGoodServerTransport>(
111 channel_args, std::move(control_endpoints.server),
112 std::move(data_endpoints.server), event_engine, HPackParser(),
113 HPackCompressor());
114 return ClientAndServerTransportPair{std::move(client_transport),
115 std::move(server_transport)};
116 }
117
118 } // namespace grpc_core
119