Loading...
Searching...
No Matches
transaction_collector_test.cpp
Go to the documentation of this file.
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20#include "platform/consensus/ordering/pbft/transaction_collector.h"
21
22#include <glog/logging.h>
23#include <gmock/gmock.h>
24#include <gtest/gtest.h>
25
26#include "common/test/test_macros.h"
27
28namespace resdb {
29namespace {
30
31using ::resdb::testing::EqualsProto;
32
33TEST(TransactionCollectorTest, SeqError) {
34 int64_t seq = 11111;
35 TransactionCollector collector(seq, nullptr);
36
37 std::unique_ptr<Request> request = std::make_unique<Request>();
38 SignatureInfo signature;
39
40 EXPECT_EQ(collector.AddRequest(
41 std::move(request), signature,
42 /* is_main_request =*/true,
43 [&](const Request& request, int received_count,
44 TransactionCollector::CollectorDataType* data,
45 std::atomic<TransactionStatue>* status, bool) {}),
46 -2);
47}
48
49TEST(TransactionCollectorTest, AddContextList) {
50 std::vector<std::unique_ptr<Context>> context_list;
51
52 for (int i = 0; i < 1000000; ++i) {
53 auto context = std::make_unique<Context>();
54 context->signature = SignatureInfo();
55
56 context_list.push_back(std::move(context));
57 }
58 TransactionCollector collector(1, nullptr);
59 EXPECT_EQ(collector.SetContextList(1, std::move(context_list)), 0);
60}
61
62TEST(TransactionCollectorTest, AddMainRequest) {
63 int64_t seq = 11111;
64 TransactionCollector collector(seq, nullptr);
65
66 Request expect_request;
67 expect_request.set_seq(seq);
68 std::unique_ptr<Request> request = std::make_unique<Request>(expect_request);
69 SignatureInfo signature;
70 bool is_called = false;
71 EXPECT_EQ(
72 collector.AddRequest(std::move(request), signature,
73 /* is_main_request =*/true,
74 [&](const Request& request, int received_count,
75 TransactionCollector::CollectorDataType* data,
76 std::atomic<TransactionStatue>* status, bool) {
77 EXPECT_THAT(request, EqualsProto(expect_request));
78 EXPECT_EQ(received_count, 1);
79 EXPECT_EQ(*status, TransactionStatue::None);
80 is_called = true;
81 }),
82 0);
83 EXPECT_TRUE(is_called);
84}
85
86TEST(TransactionCollectorTest, AddSameMainRequest) {
87 int64_t seq = 11111;
88 TransactionCollector collector(seq, nullptr);
89
90 Request expect_request;
91 expect_request.set_seq(seq);
92 expect_request.set_hash("hash_main");
93
94 {
95 std::unique_ptr<Request> request =
96 std::make_unique<Request>(expect_request);
97 SignatureInfo signature;
98 bool is_called = false;
99 EXPECT_EQ(collector.AddRequest(
100 std::move(request), signature,
101 /* is_main_request =*/true,
102 [&](const Request& request, int received_count,
103 TransactionCollector::CollectorDataType* data,
104 std::atomic<TransactionStatue>* status, bool) {
105 EXPECT_THAT(request, EqualsProto(expect_request));
106 EXPECT_EQ(received_count, 1);
107 EXPECT_EQ(*status, TransactionStatue::None);
108 is_called = true;
109 }),
110 0);
111 EXPECT_TRUE(is_called);
112 }
113 {
114 std::unique_ptr<Request> request =
115 std::make_unique<Request>(expect_request);
116 SignatureInfo signature;
117 bool is_called = false;
118 EXPECT_EQ(collector.AddRequest(
119 std::move(request), signature,
120 /* is_main_request =*/true,
121 [&](const Request& request, int received_count,
122 TransactionCollector::CollectorDataType* data,
123 std::atomic<TransactionStatue>* status, bool) {
124 EXPECT_THAT(request, EqualsProto(expect_request));
125 EXPECT_EQ(received_count, 1);
126 EXPECT_EQ(*status, TransactionStatue::None);
127 is_called = true;
128 }),
129 -2);
130 EXPECT_FALSE(is_called);
131 }
132}
133
134TEST(TransactionCollectorTest, AddTypeRequest) {
135 int64_t seq = 11111;
136 TransactionCollector collector(seq, nullptr);
137
138 Request expect_request;
139 expect_request.set_seq(seq);
140 expect_request.set_hash("hash_main");
141
142 // Add main request
143 {
144 std::unique_ptr<Request> request =
145 std::make_unique<Request>(expect_request);
146 SignatureInfo signature;
147 bool is_called = false;
148 EXPECT_EQ(collector.AddRequest(
149 std::move(request), signature,
150 /* is_main_request =*/true,
151 [&](const Request& request, int received_count,
152 TransactionCollector::CollectorDataType* data,
153 std::atomic<TransactionStatue>* status, bool) {
154 EXPECT_THAT(request, EqualsProto(expect_request));
155 EXPECT_EQ(received_count, 1);
156 EXPECT_EQ(*status, TransactionStatue::None);
157 is_called = true;
158 }),
159 0);
160 EXPECT_TRUE(is_called);
161 }
162 // Add 1 pre-prepare message.
163 {
164 expect_request.set_type(Request::TYPE_PRE_PREPARE);
165 std::unique_ptr<Request> request =
166 std::make_unique<Request>(expect_request);
167 SignatureInfo signature;
168 bool is_called = false;
169 EXPECT_EQ(collector.AddRequest(
170 std::move(request), signature,
171 /* is_main_request =*/false,
172 [&](const Request& request, int received_count,
173 TransactionCollector::CollectorDataType* data,
174 std::atomic<TransactionStatue>* status, bool) {
175 EXPECT_THAT(request, EqualsProto(expect_request));
176 EXPECT_EQ(received_count, 1);
177 EXPECT_EQ(*status, TransactionStatue::None);
178 is_called = true;
179 }),
180 0);
181 EXPECT_TRUE(is_called);
182 }
183 // Add 1 pre-prepare message with the same sender, should return received
184 // count 1.
185 {
186 expect_request.set_type(Request::TYPE_PRE_PREPARE);
187 std::unique_ptr<Request> request =
188 std::make_unique<Request>(expect_request);
189 SignatureInfo signature;
190 bool is_called = false;
191 EXPECT_EQ(collector.AddRequest(
192 std::move(request), signature,
193 /* is_main_request =*/false,
194 [&](const Request& request, int received_count,
195 TransactionCollector::CollectorDataType* data,
196 std::atomic<TransactionStatue>* status, bool) {
197 EXPECT_THAT(request, EqualsProto(expect_request));
198 EXPECT_EQ(received_count, 1);
199 EXPECT_EQ(*status, TransactionStatue::None);
200 is_called = true;
201 }),
202 0);
203 EXPECT_TRUE(is_called);
204 }
205 // Add 1 pre-prepare message with different sender, should return received
206 // count 2. Set the statue to prepare.
207 {
208 expect_request.set_type(Request::TYPE_PRE_PREPARE);
209 expect_request.set_sender_id(1);
210 std::unique_ptr<Request> request =
211 std::make_unique<Request>(expect_request);
212 SignatureInfo signature;
213 bool is_called = false;
214 EXPECT_EQ(collector.AddRequest(
215 std::move(request), signature,
216 /* is_main_request =*/false,
217 [&](const Request& request, int received_count,
218 TransactionCollector::CollectorDataType* data,
219 std::atomic<TransactionStatue>* status, bool) {
220 EXPECT_THAT(request, EqualsProto(expect_request));
221 EXPECT_EQ(received_count, 2);
222 EXPECT_EQ(*status, TransactionStatue::None);
223 *status = TransactionStatue::Prepare;
224 is_called = true;
225 }),
226 0);
227 EXPECT_TRUE(is_called);
228 }
229 // Add Prepare message.
230 {
231 expect_request.set_type(Request::TYPE_PREPARE);
232 expect_request.set_sender_id(1);
233 std::unique_ptr<Request> request =
234 std::make_unique<Request>(expect_request);
235 SignatureInfo signature;
236 bool is_called = false;
237 EXPECT_EQ(collector.AddRequest(
238 std::move(request), signature,
239 /* is_main_request =*/false,
240 [&](const Request& request, int received_count,
241 TransactionCollector::CollectorDataType* data,
242 std::atomic<TransactionStatue>* status, bool) {
243 EXPECT_THAT(request, EqualsProto(expect_request));
244 EXPECT_EQ(received_count, 1);
245 EXPECT_EQ(*status, TransactionStatue::Prepare);
246 is_called = true;
247 }),
248 0);
249 EXPECT_TRUE(is_called);
250 }
251 // Add old type message, status should not change.
252 {
253 expect_request.set_type(Request::TYPE_PRE_PREPARE);
254 expect_request.set_sender_id(3);
255 std::unique_ptr<Request> request =
256 std::make_unique<Request>(expect_request);
257 SignatureInfo signature;
258 bool is_called = false;
259 EXPECT_EQ(collector.AddRequest(
260 std::move(request), signature,
261 /* is_main_request =*/false,
262 [&](const Request& request, int received_count,
263 TransactionCollector::CollectorDataType* data,
264 std::atomic<TransactionStatue>* status, bool) {
265 EXPECT_THAT(request, EqualsProto(expect_request));
266 EXPECT_EQ(received_count, 3);
267 EXPECT_EQ(*status, TransactionStatue::Prepare);
268 is_called = true;
269 }),
270 0);
271 EXPECT_TRUE(is_called);
272 }
273}
274
275TEST(TransactionCollectorTest, DelayMainRequest) {
276 int64_t seq = 11111;
277 TransactionCollector collector(seq, nullptr);
278
279 Request expect_request;
280 expect_request.set_seq(seq);
281 expect_request.set_hash("hash_main");
282
283 // Add 1 pre-prepare message.
284 {
285 expect_request.set_type(Request::TYPE_PRE_PREPARE);
286 std::unique_ptr<Request> request =
287 std::make_unique<Request>(expect_request);
288 SignatureInfo signature;
289 bool is_called = false;
290 EXPECT_EQ(collector.AddRequest(
291 std::move(request), signature,
292 /* is_main_request =*/false,
293 [&](const Request& request, int received_count,
294 TransactionCollector::CollectorDataType* data,
295 std::atomic<TransactionStatue>* status, bool) {
296 EXPECT_THAT(request, EqualsProto(expect_request));
297 EXPECT_EQ(received_count, 1);
298 EXPECT_EQ(*status, TransactionStatue::None);
299 is_called = true;
300 }),
301 0);
302 EXPECT_TRUE(is_called);
303 }
304 // Add main request
305 {
306 std::unique_ptr<Request> request =
307 std::make_unique<Request>(expect_request);
308 SignatureInfo signature;
309 bool is_called = false;
310 EXPECT_EQ(collector.AddRequest(
311 std::move(request), signature,
312 /* is_main_request =*/true,
313 [&](const Request& request, int received_count,
314 TransactionCollector::CollectorDataType* data,
315 std::atomic<TransactionStatue>* status, bool) {
316 EXPECT_THAT(request, EqualsProto(expect_request));
317 EXPECT_EQ(received_count, 1);
318 EXPECT_EQ(*status, TransactionStatue::None);
319 is_called = true;
320 }),
321 0);
322 EXPECT_TRUE(is_called);
323 }
324
325 // Add 1 pre-prepare message with different sender, should return received
326 // count 2. Set the statue to prepare.
327 {
328 expect_request.set_type(Request::TYPE_PRE_PREPARE);
329 expect_request.set_sender_id(1);
330 std::unique_ptr<Request> request =
331 std::make_unique<Request>(expect_request);
332 SignatureInfo signature;
333 bool is_called = false;
334 EXPECT_EQ(collector.AddRequest(
335 std::move(request), signature,
336 /* is_main_request =*/false,
337 [&](const Request& request, int received_count,
338 TransactionCollector::CollectorDataType* data,
339 std::atomic<TransactionStatue>* status, bool) {
340 EXPECT_THAT(request, EqualsProto(expect_request));
341 EXPECT_EQ(received_count, 2);
342 EXPECT_EQ(*status, TransactionStatue::None);
343 *status = TransactionStatue::Prepare;
344 is_called = true;
345 }),
346 0);
347 EXPECT_TRUE(is_called);
348 }
349 // Add Prepare message.
350 {
351 expect_request.set_type(Request::TYPE_PREPARE);
352 expect_request.set_sender_id(1);
353 std::unique_ptr<Request> request =
354 std::make_unique<Request>(expect_request);
355 SignatureInfo signature;
356 bool is_called = false;
357 EXPECT_EQ(collector.AddRequest(
358 std::move(request), signature,
359 /* is_main_request =*/false,
360 [&](const Request& request, int received_count,
361 TransactionCollector::CollectorDataType* data,
362 std::atomic<TransactionStatue>* status, bool) {
363 EXPECT_THAT(request, EqualsProto(expect_request));
364 EXPECT_EQ(received_count, 1);
365 EXPECT_EQ(*status, TransactionStatue::Prepare);
366 is_called = true;
367 }),
368 0);
369 EXPECT_TRUE(is_called);
370 }
371 // Add old type message, status should not change.
372 {
373 expect_request.set_type(Request::TYPE_PRE_PREPARE);
374 expect_request.set_sender_id(3);
375 std::unique_ptr<Request> request =
376 std::make_unique<Request>(expect_request);
377 SignatureInfo signature;
378 bool is_called = false;
379 EXPECT_EQ(collector.AddRequest(
380 std::move(request), signature,
381 /* is_main_request =*/false,
382 [&](const Request& request, int received_count,
383 TransactionCollector::CollectorDataType* data,
384 std::atomic<TransactionStatue>* status, bool) {
385 EXPECT_THAT(request, EqualsProto(expect_request));
386 EXPECT_EQ(received_count, 3);
387 EXPECT_EQ(*status, TransactionStatue::Prepare);
388 is_called = true;
389 }),
390 0);
391 EXPECT_TRUE(is_called);
392 }
393}
394
395} // namespace
396
397} // namespace resdb
data
std::string data
Definition batch_queue_test.cpp:34
resdb::TransactionCollector::CollectorDataType
std::list< std::unique_ptr< RequestInfo > > CollectorDataType
Definition transaction_collector.h:98
resdb::TEST
TEST(NetworkUtilsTest, GetDNSName)
Definition network_utils_test.cpp:30
test_macros.h
transaction_collector.h