2 * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * @file test_cases_async.cpp
19 * @author Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
21 * @brief Tests for libcynara-client-async
24 #include <cynara_test_admin.h>
25 #include <cynara_test_commons.h>
26 #include <cynara_test_client_async_client.h>
28 #include <service_manager.h>
29 #include <dpl/test/test_runner.h>
31 #include <cynara-client-async.h>
36 using namespace CynaraTestClientAsync;
37 using namespace CynaraTestAdmin;
39 void tca01_initialize_func()
44 void tca02_empty_cache_miss_func()
46 std::string testNo("02");
49 client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
50 client.checkCache({testNo}, CYNARA_API_CACHE_MISS);
53 void tca03_create_max_requests_func()
55 std::string testNo("03");
57 RequestEntity callbackData = {RequestFunction(), 0, CYNARA_CALL_CAUSE_FINISH};
61 for (auto i = 0; i <= UINT16_MAX; ++i) {
62 client.createRequest({testNo, i}, id, callbackData, CYNARA_API_SUCCESS);
63 client.assertStatus(READWRITE);
66 client.createRequest({testNo}, id, callbackData, CYNARA_API_MAX_PENDING_REQUESTS);
67 client.assertStatus(READWRITE);
70 void tca04_request_and_process_func()
72 std::string testNo("04");
74 RequestEntity callbackData = {RequestFunction(),
75 CYNARA_API_ACCESS_DENIED,
76 CYNARA_CALL_CAUSE_ANSWER};
80 client.createRequest({testNo}, id, callbackData);
81 client.assertStatus(READWRITE);
85 client.assertStatus(READ);
88 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
91 void tca05_request_and_cancel1_func()
93 std::string testNo("05");
96 RequestEntity callbackData = {RequestFunction(),
97 CYNARA_API_ACCESS_DENIED,
98 CYNARA_CALL_CAUSE_CANCEL};
102 client.createRequest({testNo, subtest}, id, callbackData);
103 client.assertStatus(READWRITE);
106 client.assertStatus(READWRITE);
108 //send request and cancel
110 client.assertStatus(READ);
113 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
116 void tca05_request_and_cancel2_func()
118 std::string testNo("05");
120 cynara_check_id id1, id2;
123 RequestEntity callbackData1 = {[&]()->void {client.cancel(id2);},
124 CYNARA_API_ACCESS_DENIED,
125 CYNARA_CALL_CAUSE_ANSWER};
126 RequestEntity callbackData2 = {RequestFunction(),
127 CYNARA_API_ACCESS_DENIED,
128 CYNARA_CALL_CAUSE_CANCEL};
130 client.createRequest({testNo, subtest}, id1, callbackData1);
131 client.createRequest({testNo, subtest}, id2, callbackData2);
132 client.assertStatus(READWRITE);
136 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
137 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
140 void tca05_request_and_cancel3_func()
142 std::string testNo("05");
145 RequestEntity callbackData = {RequestFunction(),
146 CYNARA_API_ACCESS_DENIED,
147 CYNARA_CALL_CAUSE_ANSWER};
151 client.createRequest({testNo, subtest}, id, callbackData);
152 client.assertStatus(READWRITE);
156 client.assertStatus(READ);
159 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
160 client.assertStatus(READ);
162 client.cancel(id, CYNARA_API_INVALID_PARAM);
165 void tca06_cancel_fail_func()
167 cynara_check_id id = 0xDEAD;
171 client.cancel(id, CYNARA_API_INVALID_PARAM);
174 void tca07_request_with_data_insertion_func()
176 std::string testNo("07");
178 const char *bucket = CYNARA_ADMIN_DEFAULT_BUCKET;
179 const int resultAllow = CYNARA_ADMIN_ALLOW;
180 CheckData data[2] = {{testNo, 1}, {testNo, 2}};
181 RequestEntity callbackAllow = {RequestFunction(),
182 CYNARA_API_ACCESS_ALLOWED,
183 CYNARA_CALL_CAUSE_ANSWER};
184 RequestEntity callbackDeny = {RequestFunction(),
185 CYNARA_API_ACCESS_DENIED,
186 CYNARA_CALL_CAUSE_ANSWER};
190 client.checkCache(data[0], CYNARA_API_CACHE_MISS);
191 client.checkCache(data[1], CYNARA_API_CACHE_MISS);
193 client.createRequest(data[0], id, callbackDeny);
194 client.assertStatus(READWRITE);
196 client.assertStatus(READ);
197 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
198 client.assertStatus(READ);
200 client.checkCache(data[0], CYNARA_API_ACCESS_DENIED);
201 client.checkCache(data[1], CYNARA_API_CACHE_MISS);
204 CynaraPoliciesContainer cp;
205 cp.add(bucket, data[0].toAdminPolicy(), resultAllow);
206 admin.setPolicies(cp);
209 client.checkCache(data[0], CYNARA_API_CACHE_MISS);
210 client.checkCache(data[1], CYNARA_API_CACHE_MISS);
212 client.createRequest(data[0], id, callbackAllow);
213 client.assertStatus(READWRITE);
215 client.assertStatus(READ);
216 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
217 client.assertStatus(READ);
219 client.checkCache(data[0], CYNARA_API_ACCESS_ALLOWED);
220 client.checkCache(data[1], CYNARA_API_CACHE_MISS);
223 void tca08_disconnect1_func()
225 std::string testNo("08");
227 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
229 RequestEntity callbackData = {RequestFunction(),
230 CYNARA_API_ACCESS_DENIED,
231 CYNARA_CALL_CAUSE_ANSWER};
234 client.createRequest({testNo, subtest}, id, callbackData);
235 client.assertStatus(READWRITE);
237 serviceManager.restartService();
240 client.assertStatus(READ);
241 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
244 void tca08_disconnect2_func()
246 std::string testNo("08");
248 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
250 RequestEntity callbackData = {RequestFunction(),
251 CYNARA_API_ACCESS_DENIED,
252 CYNARA_CALL_CAUSE_ANSWER};
255 client.createRequest({testNo, subtest}, id, callbackData);
256 client.assertStatus(READWRITE);
258 serviceManager.restartService();
261 client.assertStatus(READ);
263 serviceManager.restartService();
266 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
269 void tca08_disconnect3_func()
271 std::string testNo("08");
274 RequestEntity callbackData = {[&](){
275 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
276 serviceManager.restartService();
278 CYNARA_API_ACCESS_DENIED,
279 CYNARA_CALL_CAUSE_ANSWER};
282 client.createRequest({testNo, subtest}, id, callbackData);
283 client.assertStatus(READWRITE);
286 client.assertStatus(READ);
288 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
289 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
292 void tca09_disconnect_and_cancel1_func()
294 std::string testNo("09");
296 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
298 RequestEntity callbackData = {RequestFunction(),
299 CYNARA_API_ACCESS_DENIED,
300 CYNARA_CALL_CAUSE_CANCEL};
304 client.createRequest({testNo, subtest}, id, callbackData);
305 client.assertStatus(READWRITE);
309 client.assertStatus(READ);
311 serviceManager.restartService();
314 client.assertStatus(READWRITE);
318 client.assertStatus(READ);
321 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
322 client.assertStatus(READ);
325 void tca09_disconnect_and_cancel2_func()
327 std::string testNo("09");
329 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
331 RequestEntity callbackData = {RequestFunction(),
332 CYNARA_API_ACCESS_DENIED,
333 CYNARA_CALL_CAUSE_CANCEL};
337 client.createRequest({testNo, subtest}, id, callbackData);
338 client.assertStatus(READWRITE);
342 client.assertStatus(READ);
345 client.assertStatus(READWRITE);
347 serviceManager.restartService();
351 client.assertStatus(READ);
354 client.process(CYNARA_API_SUCCESS, Client::EXPECT_TIMEOUT);
355 client.assertStatus(READ);
358 void tca10_double_request_func()
360 std::string testNo("10");
361 cynara_check_id id, id2;
364 RequestEntity callbackData2 = {RequestFunction(),
365 CYNARA_API_ACCESS_DENIED,
366 CYNARA_CALL_CAUSE_ANSWER};
368 RequestEntity callbackData = {[&](){client.createRequest({testNo}, id2, callbackData2);},
369 CYNARA_API_ACCESS_DENIED,
370 CYNARA_CALL_CAUSE_ANSWER};
373 client.createRequest({testNo}, id, callbackData);
374 client.assertStatus(READWRITE);
378 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
379 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
382 void tca11_double_request_with_restart_func()
384 std::string testNo("11");
385 cynara_check_id id, id2;
388 RequestEntity callbackData2 = {RequestFunction(),
389 CYNARA_API_ACCESS_DENIED,
390 CYNARA_CALL_CAUSE_ANSWER};
392 RequestEntity callbackData = {[&](){
393 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
394 serviceManager.restartService();
395 client.createRequest({testNo}, id2, callbackData2);
397 CYNARA_API_ACCESS_DENIED,
398 CYNARA_CALL_CAUSE_ANSWER};
401 client.createRequest({testNo}, id, callbackData);
402 client.assertStatus(READWRITE);
406 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
407 client.process(CYNARA_API_SUCCESS, Client::IGNORE_TIMEOUT);
410 void tca12_multiple_connections_without_requests_func()
412 std::string testNo("12");
415 RequestEntity callbackData = {RequestFunction(),
416 CYNARA_API_ACCESS_DENIED,
417 CYNARA_CALL_CAUSE_FINISH};
419 ServiceManager serviceManager(CynaraTestConsts::SERVICE);
420 pid_t before = serviceManager.getServicePid();
421 timeval beforeTimestamp = serviceManager.getServiceStartTimestamp();
423 for (int i = 0; i < 10; ++i)
426 client.createRequest({testNo}, id, callbackData);
427 client.assertStatus(READWRITE);
430 //wait until cynara possibly restarts
433 pid_t after = serviceManager.getServicePid();
434 timeval afterTimestamp = serviceManager.getServiceStartTimestamp();
435 RUNNER_ASSERT_MSG(after != 0,
436 "cynara service not running. After = " << after << ".");
437 RUNNER_ASSERT_MSG(before == after
438 && beforeTimestamp.tv_sec == afterTimestamp.tv_sec
439 && beforeTimestamp.tv_usec == afterTimestamp.tv_usec,
440 "cynara service was restarted during the test. Before pid / timestamp = "
441 << before << " / " << beforeTimestamp.tv_sec << "."
442 << beforeTimestamp.tv_usec << " and after pid / timestamp = "
443 << after << " / " << afterTimestamp.tv_sec << "."
444 << afterTimestamp.tv_usec);
447 RUNNER_TEST_GROUP_INIT(cynara_async_tests)
449 RUN_CYNARA_TEST(tca01_initialize)
450 RUN_CYNARA_TEST(tca02_empty_cache_miss)
451 RUN_CYNARA_TEST(tca03_create_max_requests)
452 RUN_CYNARA_TEST(tca04_request_and_process)
453 RUN_CYNARA_TEST(tca05_request_and_cancel1)
454 RUN_CYNARA_TEST(tca05_request_and_cancel2)
455 RUN_CYNARA_TEST(tca05_request_and_cancel3)
456 RUN_CYNARA_TEST(tca06_cancel_fail)
457 RUN_CYNARA_TEST(tca07_request_with_data_insertion)
458 RUN_CYNARA_TEST(tca08_disconnect1)
459 RUN_CYNARA_TEST(tca08_disconnect2)
460 RUN_CYNARA_TEST(tca08_disconnect3)
461 RUN_CYNARA_TEST(tca09_disconnect_and_cancel1)
462 RUN_CYNARA_TEST(tca09_disconnect_and_cancel2)
463 RUN_CYNARA_TEST(tca10_double_request)
464 RUN_CYNARA_TEST(tca11_double_request_with_restart)
465 RUN_CYNARA_TEST(tca12_multiple_connections_without_requests)