static void _admin_post_read(struct buf_sock *s) { parse_rstatus_t status; admin_request_reset(&req); while (buf_rsize(s->rbuf) > 0) { int n; status = admin_parse_req(&req, s->rbuf); if (status == PARSE_EUNFIN) { goto done; } if (status != PARSE_OK) { log_info("illegal request received on admin port status %d", status); goto error; } /* processing */ if (req.type == REQ_QUIT) { log_info("peer called quit"); s->ch->state = CHANNEL_TERM; goto done; } admin_response_reset(&rsp); admin_process_request(&rsp, &req); n = admin_compose_rsp(&s->wbuf, &rsp); if (n < 0) { log_error("compose response error"); goto error; } } done: if (buf_rsize(s->wbuf) > 0) { _admin_event_write(s); } return; error: s->ch->state = CHANNEL_TERM; }
END_TEST START_TEST(test_nil_bulk) { #define NIL_BULK "$-1\r\n" size_t len = sizeof(NIL_BULK) - 1; struct element el_c, el_p; test_reset(); el_c.type = ELEM_NIL; ck_assert_int_eq(compose_element(&buf, &el_c), len); ck_assert_int_eq(buf_rsize(buf), len); ck_assert_int_eq(cc_bcmp(buf->rpos, NIL_BULK, len), 0); el_p.type = ELEM_UNKNOWN; ck_assert_int_eq(parse_element(&el_p, buf), PARSE_OK); ck_assert_int_eq(el_p.type, ELEM_NIL); #undef NIL_BULK }
END_TEST /* * request */ START_TEST(test_quit) { #define QUIT "quit" #define SERIALIZED "*1\r\n$4\r\n" QUIT "\r\n" #define INVALID "*2\r\n$4\r\n" QUIT "\r\n$3\r\nnow\r\n" int ret; struct element *el; test_reset(); req->type = REQ_QUIT; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(QUIT) - 1, QUIT}; ret = compose_req(&buf, req); ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); el->type = ELEM_UNKNOWN; /* this effectively resets *el */ request_reset(req); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_QUIT); ck_assert_int_eq(req->token->nelem, 1); el = array_first(req->token); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, QUIT, sizeof(QUIT) - 1), 0); /* invalid number of arguments */ test_reset(); buf_write(buf, INVALID, sizeof(INVALID) - 1); ck_assert_int_eq(parse_req(req, buf), PARSE_EINVALID); #undef INVALID #undef SERIALIZED #undef QUIT } END_TEST START_TEST(test_ping) { #define PING "ping" #define VAL "hello" #define S_PING "*1\r\n$4\r\n" PING "\r\n" #define S_ECHO "*2\r\n$4\r\n" PING "\r\n$5\r\nhello\r\n" int ret; struct element *el; test_reset(); /* simple ping */ buf_write(buf, S_PING, sizeof(S_PING) - 1); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_PING); /* ping as echo */ test_reset(); req->type = REQ_PING; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(PING) - 1, PING}; el = array_push(req->token); el->type = ELEM_BULK; el->bstr = (struct bstring){sizeof(VAL) - 1, VAL}; ret = compose_req(&buf, req); ck_assert_int_eq(ret, sizeof(S_ECHO) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, S_ECHO, ret), 0); el->type = ELEM_UNKNOWN; /* resets *el */ request_reset(req); ck_assert_int_eq(parse_req(req, buf), PARSE_OK); ck_assert_int_eq(req->type, REQ_PING); ck_assert_int_eq(req->token->nelem, 2); el = array_first(req->token); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, PING, sizeof(PING) - 1), 0); el = array_get(req->token, 1); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(cc_bcmp(el->bstr.data, VAL, sizeof(VAL) - 1), 0); #undef S_ECHO #undef ECHO #undef S_PING #undef QUIT } END_TEST START_TEST(test_unfin_req) { char *token[4] = { "*2\r\n", "*2\r\n$3\r\n", "*2\r\n$3\r\nfoo\r\n", "*2\r\n$3\r\nfoo\r\n$3\r\n", }; for (int i = 0; i < 4; i++) { char *pos; size_t len; len = strlen(token[i]); buf_reset(buf); buf_write(buf, token[i], len); pos = buf->rpos; ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN); ck_assert(buf->rpos == pos); } } END_TEST /* * response */ START_TEST(test_ok) { #define OK "OK" #define SERIALIZED "+" OK "\r\n" int ret; struct element *el; test_reset(); rsp->type = ELEM_STR; el = array_push(rsp->token); el->type = ELEM_STR; el->bstr = (struct bstring){sizeof(OK) - 1, OK}; ret = compose_rsp(&buf, rsp); ck_assert_int_eq(ret, sizeof(SERIALIZED) - 1); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, ret), 0); el->type = ELEM_UNKNOWN; /* resets *el */ response_reset(rsp); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK); ck_assert_int_eq(rsp->type, ELEM_STR); ck_assert_int_eq(rsp->token->nelem, 1); el = array_first(rsp->token); ck_assert_int_eq(el->type, ELEM_STR); ck_assert_int_eq(cc_bcmp(el->bstr.data, OK, sizeof(OK) - 1), 0); #undef SERIALIZED #undef OK } END_TEST START_TEST(test_array_reply) { #define SERIALIZED "*5\r\n:-10\r\n$-1\r\n-ERR invalid arg\r\n+foo\r\n$5\r\nHELLO\r\n" size_t len = sizeof(SERIALIZED) - 1; struct element *el; test_reset(); buf_write(buf, SERIALIZED, len); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_OK); ck_assert_int_eq(rsp->type, ELEM_ARRAY); ck_assert_int_eq(rsp->token->nelem, 5); el = array_first(rsp->token); ck_assert_int_eq(el->type, ELEM_INT); el = array_get(rsp->token, 1); ck_assert_int_eq(el->type, ELEM_NIL); el = array_get(rsp->token, 2); ck_assert_int_eq(el->type, ELEM_ERR); el = array_get(rsp->token, 3); ck_assert_int_eq(el->type, ELEM_STR); el = array_get(rsp->token, 4); ck_assert_int_eq(el->type, ELEM_BULK); ck_assert_int_eq(el->bstr.len, 5); ck_assert_int_eq(cc_bcmp(el->bstr.data, "HELLO", 5), 0); ck_assert_int_eq(buf_rsize(buf), 0); ck_assert_int_eq(compose_rsp(&buf, rsp), len); ck_assert_int_eq(buf_rsize(buf), len); ck_assert_int_eq(cc_bcmp(buf->rpos, SERIALIZED, len), 0); #undef SERIALIZED } END_TEST /* * edge cases */ START_TEST(test_empty_buf) { struct element el; test_reset(); ck_assert(!token_is_array(buf)); ck_assert_int_eq(parse_element(&el, buf), PARSE_EUNFIN); ck_assert_int_eq(parse_rsp(rsp, buf), PARSE_EUNFIN); ck_assert_int_eq(parse_req(req, buf), PARSE_EUNFIN); } END_TEST /* * request/response pool */ START_TEST(test_req_pool_basic) { #define POOL_SIZE 10 int i; struct request *reqs[POOL_SIZE]; request_options_st options = { .request_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = REQ_NTOKEN}, .request_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}}; request_setup(&options, NULL); for (i = 0; i < POOL_SIZE; i++) { reqs[i] = request_borrow(); ck_assert_msg(reqs[i] != NULL, "expected to borrow a request"); } ck_assert_msg(request_borrow() == NULL, "expected request pool to be depleted"); for (i = 0; i < POOL_SIZE; i++) { request_return(&reqs[i]); ck_assert_msg(reqs[i] == NULL, "expected request to be nulled after return"); } request_teardown(); #undef POOL_SIZE } END_TEST START_TEST(test_rsp_pool_basic) { #define POOL_SIZE 10 int i; struct response *rsps[POOL_SIZE]; response_options_st options = { .response_ntoken = {.type = OPTION_TYPE_UINT, .val.vuint = RSP_NTOKEN}, .response_poolsize = {.type = OPTION_TYPE_UINT, .val.vuint = POOL_SIZE}}; response_setup(&options, NULL); for (i = 0; i < POOL_SIZE; i++) { rsps[i] = response_borrow(); ck_assert_msg(rsps[i] != NULL, "expected to borrow a response"); } ck_assert_msg(response_borrow() == NULL, "expected response pool to be depleted"); for (i = 0; i < POOL_SIZE; i++) { response_return(&rsps[i]); ck_assert_msg(rsps[i] == NULL, "expected response to be nulled after return"); } response_teardown(); #undef POOL_SIZE } END_TEST /* * test suite */ static Suite * redis_suite(void) { Suite *s = suite_create(SUITE_NAME); /* token */ TCase *tc_token = tcase_create("token"); suite_add_tcase(s, tc_token); tcase_add_test(tc_token, test_simple_string); tcase_add_test(tc_token, test_error); tcase_add_test(tc_token, test_integer); tcase_add_test(tc_token, test_bulk_string); tcase_add_test(tc_token, test_array); tcase_add_test(tc_token, test_nil_bulk); tcase_add_test(tc_token, test_unfin_token); /* basic requests */ TCase *tc_request = tcase_create("request"); suite_add_tcase(s, tc_request); tcase_add_test(tc_request, test_quit); tcase_add_test(tc_request, test_ping); tcase_add_test(tc_request, test_unfin_req); /* basic responses */ TCase *tc_response = tcase_create("response"); suite_add_tcase(s, tc_response); tcase_add_test(tc_response, test_ok); tcase_add_test(tc_response, test_array_reply); /* edge cases */ TCase *tc_edge = tcase_create("edge cases"); suite_add_tcase(s, tc_edge); tcase_add_test(tc_edge, test_empty_buf); /* req/rsp objects, pooling */ TCase *tc_pool = tcase_create("request/response pool"); suite_add_tcase(s, tc_pool); tcase_add_test(tc_pool, test_req_pool_basic); tcase_add_test(tc_pool, test_rsp_pool_basic); return s; } /* TODO(yao): move main to a different file, keep most test files main-less */ int main(void) { int nfail; /* setup */ test_setup(); Suite *suite = redis_suite(); SRunner *srunner = srunner_create(suite); srunner_set_log(srunner, DEBUG_LOG); srunner_run_all(srunner, CK_ENV); /* set CK_VEBOSITY in ENV to customize */ nfail = srunner_ntests_failed(srunner); srunner_free(srunner); /* teardown */ test_teardown(); return (nfail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }