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;
}
