From 547cd0d7a66b001841a194b82e7f7686eaa9509f Mon Sep 17 00:00:00 2001 From: Falk Werner Date: Mon, 13 Jul 2020 22:41:19 +0200 Subject: [PATCH] use json_writer to write json data --- lib/webfuse/impl/client_protocol.c | 19 +++--- lib/webfuse/impl/credentials.c | 17 ++++++ lib/webfuse/impl/credentials.h | 7 +++ lib/webfuse/impl/json/writer.c | 2 +- lib/webfuse/impl/jsonrpc/proxy.c | 61 ++++++++++---------- lib/webfuse/impl/jsonrpc/proxy.h | 6 ++ lib/webfuse/impl/jsonrpc/request.c | 41 +++++++++---- lib/webfuse/impl/jsonrpc/request.h | 8 ++- lib/webfuse/impl/jsonrpc/response_writer.c | 67 ++++++++++++++++++++++ lib/webfuse/impl/jsonrpc/response_writer.h | 40 +++++++++++++ lib/webfuse/impl/jsonrpc/send_fn.h | 5 +- lib/webfuse/impl/message.c | 25 ++++---- lib/webfuse/impl/message.h | 10 ++-- lib/webfuse/impl/server_protocol.c | 10 ++-- lib/webfuse/impl/session.c | 8 +-- meson.build | 1 + test/webfuse/jsonrpc/test_proxy.cc | 27 ++++----- test/webfuse/jsonrpc/test_request.cc | 30 ++++------ test/webfuse/jsonrpc/test_server.cc | 18 +++--- test/webfuse/test_message.cc | 20 +++---- test/webfuse/test_message_queue.cc | 15 +++-- 21 files changed, 298 insertions(+), 139 deletions(-) create mode 100644 lib/webfuse/impl/jsonrpc/response_writer.c create mode 100644 lib/webfuse/impl/jsonrpc/response_writer.h diff --git a/lib/webfuse/impl/client_protocol.c b/lib/webfuse/impl/client_protocol.c index 1d9370d..2eac597 100644 --- a/lib/webfuse/impl/client_protocol.c +++ b/lib/webfuse/impl/client_protocol.c @@ -77,7 +77,7 @@ wf_impl_client_protocol_receive( static bool wf_impl_client_protocol_send( - json_t * request, + struct wf_message * message, void * user_data) { bool result = false; @@ -85,13 +85,13 @@ wf_impl_client_protocol_send( if (NULL != protocol->wsi) { - struct wf_message * message = wf_impl_message_create(request); - if (NULL != message) - { - wf_impl_slist_append(&protocol->messages, &message->item); - lws_callback_on_writable(protocol->wsi); - result = true; - } + wf_impl_slist_append(&protocol->messages, &message->item); + lws_callback_on_writable(protocol->wsi); + result = true; + } + else + { + wf_impl_message_dispose(message); } return result; @@ -330,14 +330,13 @@ wf_impl_client_protocol_authenticate( wf_impl_credentials_init_default(&creds); protocol->callback(protocol->user_data, WF_CLIENT_AUTHENTICATE_GET_CREDENTIALS, &creds); - json_incref(creds.data); wf_impl_jsonrpc_proxy_invoke( protocol->proxy, &wf_impl_client_protocol_on_authenticate_finished, protocol, "authenticate", "sj", - creds.type, creds.data); + creds.type, &wf_impl_credentials_write, &creds); wf_impl_credentials_cleanup(&creds); } diff --git a/lib/webfuse/impl/credentials.c b/lib/webfuse/impl/credentials.c index ab72731..7986099 100644 --- a/lib/webfuse/impl/credentials.c +++ b/lib/webfuse/impl/credentials.c @@ -1,4 +1,5 @@ #include "webfuse/impl/credentials.h" +#include "webfuse/impl/json/writer.h" #include void wf_impl_credentials_init_default( @@ -62,3 +63,19 @@ void wf_impl_credentials_add( json_object_set_new(credentials->data, key, json_string(value)); } +void +wf_impl_credentials_write( + struct wf_json_writer * writer, + void * data) +{ + struct wf_credentials * credentials = data; + char const * key; + json_t * value; + + wf_impl_json_write_object_begin(writer); + json_object_foreach(credentials->data, key, value) + { + wf_impl_json_write_object_string(writer, key, json_string_value(value)); + } + wf_impl_json_write_object_end(writer); +} diff --git a/lib/webfuse/impl/credentials.h b/lib/webfuse/impl/credentials.h index 59b4c0c..92760ee 100644 --- a/lib/webfuse/impl/credentials.h +++ b/lib/webfuse/impl/credentials.h @@ -8,6 +8,8 @@ extern "C" { #endif +struct wf_json_writer; + struct wf_credentials { char * type; @@ -41,6 +43,11 @@ extern void wf_impl_credentials_add( char const * key, char const * value); +extern void +wf_impl_credentials_write( + struct wf_json_writer * writer, + void * data); + #ifdef __cplusplus } #endif diff --git a/lib/webfuse/impl/json/writer.c b/lib/webfuse/impl/json/writer.c index 40834da..3ad4739 100644 --- a/lib/webfuse/impl/json/writer.c +++ b/lib/webfuse/impl/json/writer.c @@ -412,7 +412,7 @@ wf_impl_json_write_object_begin_object( char const * key) { wf_impl_json_write_object_key(writer, key); - wf_impl_json_write_array_end(writer); + wf_impl_json_write_object_begin(writer); } // -- diff --git a/lib/webfuse/impl/jsonrpc/proxy.c b/lib/webfuse/impl/jsonrpc/proxy.c index c3d1235..f431e29 100644 --- a/lib/webfuse/impl/jsonrpc/proxy.c +++ b/lib/webfuse/impl/jsonrpc/proxy.c @@ -2,12 +2,17 @@ #include "webfuse/impl/jsonrpc/proxy_request_manager.h" #include "webfuse/impl/jsonrpc/response_intern.h" #include "webfuse/impl/jsonrpc/error.h" +#include "webfuse/impl/json/writer.h" +#include "webfuse/impl/message.h" #include "webfuse/status.h" +#include #include #include +#define WF_JSONRPC_PROXY_DEFAULT_MESSAGE_SIZE 1024 + struct wf_jsonrpc_proxy * wf_impl_jsonrpc_proxy_create( struct wf_timer_manager * manager, @@ -29,15 +34,17 @@ void wf_impl_jsonrpc_proxy_dispose( } -static json_t * wf_impl_jsonrpc_request_create( +static struct wf_message * +wf_impl_jsonrpc_request_create( char const * method, int id, char const * param_info, va_list args) { - json_t * request = json_object(); - json_object_set_new(request, "method", json_string(method)); - json_t * params = json_array(); + struct wf_json_writer * writer = wf_impl_json_writer_create(WF_JSONRPC_PROXY_DEFAULT_MESSAGE_SIZE, LWS_PRE); + wf_impl_json_write_object_begin(writer); + wf_impl_json_write_object_string(writer, "method", method); + wf_impl_json_write_object_begin_array(writer, "params"); for (char const * param_type = param_info; '\0' != *param_type; param_type++) { @@ -46,37 +53,41 @@ static json_t * wf_impl_jsonrpc_request_create( case 's': { char const * const value = va_arg(args, char const *); - json_array_append_new(params, json_string(value)); + wf_impl_json_write_string(writer, value); } break; case 'i': { int const value = va_arg(args, int); - json_array_append_new(params, json_integer(value)); + wf_impl_json_write_int(writer, value); } break; case 'j': { - json_t * const value = va_arg(args, json_t *); - json_array_append_new(params, value); + wf_jsonrpc_custom_write_fn * write = va_arg(args, wf_jsonrpc_custom_write_fn *); + void * data = va_arg(args, void *); + write(writer, data); } break; default: - fprintf(stderr, "fatal: unknown param_type '%c'\n", *param_type); - json_decref(params); - json_decref(request); - return NULL; + fprintf(stderr, "fatal: unknown param_type '%c'\n", *param_type); + break; } } - + wf_impl_json_write_array_end(writer); - json_object_set_new(request, "params", params); if (0 != id) { - json_object_set_new(request, "id", json_integer(id)); + wf_impl_json_write_object_int(writer, "id", id); } + + wf_impl_json_write_object_end(writer); - return request; + size_t length; + char * message = wf_impl_json_writer_take(writer, &length); + wf_impl_json_writer_dispose(writer); + + return wf_impl_message_create(message, length); } void wf_impl_jsonrpc_proxy_init( @@ -110,18 +121,13 @@ void wf_impl_jsonrpc_proxy_vinvoke( int id = wf_impl_jsonrpc_proxy_request_manager_add_request( proxy->request_manager, finished, user_data); - json_t * request = wf_impl_jsonrpc_request_create(method_name, id, param_info, args); - bool const is_send = ((NULL != request) && (proxy->send(request, proxy->user_data))); + struct wf_message * request = wf_impl_jsonrpc_request_create(method_name, id, param_info, args); + bool const is_send = proxy->send(request, proxy->user_data); if (!is_send) { wf_impl_jsonrpc_proxy_request_manager_cancel_request( proxy->request_manager, id, WF_BAD, "Bad: failed to send request"); } - - if (NULL != request) - { - json_decref(request); - } } extern void wf_impl_jsonrpc_proxy_vnotify( @@ -130,13 +136,8 @@ extern void wf_impl_jsonrpc_proxy_vnotify( char const * param_info, va_list args) { - json_t * request = wf_impl_jsonrpc_request_create(method_name, 0, param_info, args); - - if (NULL != request) - { - proxy->send(request, proxy->user_data); - json_decref(request); - } + struct wf_message * request = wf_impl_jsonrpc_request_create(method_name, 0, param_info, args); + proxy->send(request, proxy->user_data); } diff --git a/lib/webfuse/impl/jsonrpc/proxy.h b/lib/webfuse/impl/jsonrpc/proxy.h index dd5a73e..a56675f 100644 --- a/lib/webfuse/impl/jsonrpc/proxy.h +++ b/lib/webfuse/impl/jsonrpc/proxy.h @@ -21,6 +21,12 @@ extern "C" { struct wf_jsonrpc_proxy; struct wf_timer_manager; +struct wf_json_writer; + +typedef void +wf_jsonrpc_custom_write_fn( + struct wf_json_writer * writer, + void * data); extern struct wf_jsonrpc_proxy * wf_impl_jsonrpc_proxy_create( diff --git a/lib/webfuse/impl/jsonrpc/request.c b/lib/webfuse/impl/jsonrpc/request.c index 93e2e70..60323e8 100644 --- a/lib/webfuse/impl/jsonrpc/request.c +++ b/lib/webfuse/impl/jsonrpc/request.c @@ -1,9 +1,15 @@ #include "webfuse/impl/jsonrpc/request.h" #include "webfuse/impl/jsonrpc/error.h" +#include "webfuse/impl/json/writer.h" +#include "webfuse/impl/jsonrpc/response_writer.h" +#include "webfuse/impl/message.h" + +#include #include struct wf_jsonrpc_request { + struct wf_jsonrpc_response_writer * writer; int id; wf_jsonrpc_send_fn * send; void * user_data; @@ -29,6 +35,7 @@ wf_impl_jsonrpc_request_create( void * user_data) { struct wf_jsonrpc_request * request = malloc(sizeof(struct wf_jsonrpc_request)); + request->writer = wf_impl_jsonrpc_response_writer_create(id); request->id = id; request->send = send; request->user_data = user_data; @@ -40,6 +47,7 @@ void wf_impl_jsonrpc_request_dispose( struct wf_jsonrpc_request * request) { + wf_impl_jsonrpc_response_writer_dispose(request->writer); free(request); } @@ -50,18 +58,21 @@ wf_impl_jsonrpc_request_get_userdata( return request->user_data; } +struct wf_jsonrpc_response_writer * +wf_impl_jsonrpc_request_get_response_writer( + struct wf_jsonrpc_request * request) +{ + return request->writer; +} + void wf_impl_jsonrpc_respond( - struct wf_jsonrpc_request * request, - json_t * result) + struct wf_jsonrpc_request * request) { - json_t * response = json_object(); - json_object_set_new(response, "result", result); - json_object_set_new(response, "id", json_integer(request->id)); + struct wf_message * response = wf_impl_jsonrpc_response_writer_take_message(request->writer); request->send(response, request->user_data); - json_decref(response); wf_impl_jsonrpc_request_dispose(request); } @@ -70,11 +81,21 @@ void wf_impl_jsonrpc_respond_error( int code, char const * message) { - json_t * response = json_object(); - json_object_set_new(response, "error", wf_impl_jsonrpc_error(code, message)); - json_object_set_new(response, "id", json_integer(request->id)); + struct wf_json_writer * writer = wf_impl_json_writer_create(128, LWS_PRE); + wf_impl_json_write_object_begin(writer); + wf_impl_json_write_object_begin_object(writer, "error"); + wf_impl_json_write_object_int(writer, "code", code); + wf_impl_json_write_object_string(writer, "message", message); + wf_impl_json_write_object_end(writer); + wf_impl_json_write_object_int(writer, "id", request->id); + wf_impl_json_write_object_end(writer); + size_t length; + char * data = wf_impl_json_writer_take(writer, &length); + wf_impl_json_writer_dispose(writer); + + struct wf_message * response = wf_impl_message_create(data, length); request->send(response, request->user_data); - json_decref(response); + wf_impl_jsonrpc_request_dispose(request); } diff --git a/lib/webfuse/impl/jsonrpc/request.h b/lib/webfuse/impl/jsonrpc/request.h index 747c480..7161edc 100644 --- a/lib/webfuse/impl/jsonrpc/request.h +++ b/lib/webfuse/impl/jsonrpc/request.h @@ -20,6 +20,7 @@ extern "C" #endif struct wf_jsonrpc_request; +struct wf_jsonrpc_response_writer; extern bool wf_impl_jsonrpc_is_request( json_t * message); @@ -36,9 +37,12 @@ extern void wf_impl_jsonrpc_request_dispose( extern void * wf_impl_jsonrpc_request_get_userdata( struct wf_jsonrpc_request * request); +extern struct wf_jsonrpc_response_writer * +wf_impl_jsonrpc_request_get_response_writer( + struct wf_jsonrpc_request * request); + extern void wf_impl_jsonrpc_respond( - struct wf_jsonrpc_request * request, - json_t * result); + struct wf_jsonrpc_request * request); extern void wf_impl_jsonrpc_respond_error( struct wf_jsonrpc_request * request, diff --git a/lib/webfuse/impl/jsonrpc/response_writer.c b/lib/webfuse/impl/jsonrpc/response_writer.c new file mode 100644 index 0000000..67248a0 --- /dev/null +++ b/lib/webfuse/impl/jsonrpc/response_writer.c @@ -0,0 +1,67 @@ +#include "webfuse/impl/jsonrpc/response_writer.h" +#include "webfuse/impl/message.h" +#include "webfuse/impl/json/writer.h" + +#include +#include + +#define WF_RESPONSE_WRITER_DEFAULT_MESSAGE_SIZE 1024 + +struct wf_jsonrpc_response_writer +{ + struct wf_json_writer * json_writer; + int id; +}; + +struct wf_jsonrpc_response_writer * +wf_impl_jsonrpc_response_writer_create(int id) +{ + struct wf_jsonrpc_response_writer * writer = malloc(sizeof(struct wf_jsonrpc_response_writer)); + writer->json_writer = wf_impl_json_writer_create(WF_RESPONSE_WRITER_DEFAULT_MESSAGE_SIZE, LWS_PRE); + writer->id = id; + + wf_impl_json_write_object_begin(writer->json_writer); + wf_impl_json_write_object_begin_object(writer->json_writer, "result"); + + return writer; +} + +void +wf_impl_jsonrpc_response_writer_dispose( + struct wf_jsonrpc_response_writer * writer) +{ + wf_impl_json_writer_dispose(writer->json_writer); + free(writer); +} + +struct wf_message * +wf_impl_jsonrpc_response_writer_take_message( + struct wf_jsonrpc_response_writer * writer) +{ + wf_impl_json_write_object_end(writer->json_writer); + wf_impl_json_write_object_int(writer->json_writer, "id", writer->id); + wf_impl_json_write_object_end(writer->json_writer); + + size_t length; + char * data = wf_impl_json_writer_take(writer->json_writer, &length); + + return wf_impl_message_create(data, length); +} + +void +wf_impl_jsonrpc_response_add_int( + struct wf_jsonrpc_response_writer * writer, + char const * key, + int value) +{ + wf_impl_json_write_object_int(writer->json_writer, key, value); +} + +void +wf_impl_jsonrpc_response_add_string( + struct wf_jsonrpc_response_writer * writer, + char const * key, + char const * value) +{ + wf_impl_json_write_object_string(writer->json_writer, key, value); +} diff --git a/lib/webfuse/impl/jsonrpc/response_writer.h b/lib/webfuse/impl/jsonrpc/response_writer.h new file mode 100644 index 0000000..95fb8b8 --- /dev/null +++ b/lib/webfuse/impl/jsonrpc/response_writer.h @@ -0,0 +1,40 @@ +#ifndef WF_IMPL_JSONRPC_RESPONSE_WRITER_H +#define WF_IMPL_JSONRPC_RESPONSE_WRITER_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +struct wf_jsonrpc_response_writer; +struct wf_messge; + +extern struct wf_jsonrpc_response_writer * +wf_impl_jsonrpc_response_writer_create(int id); + +extern void +wf_impl_jsonrpc_response_writer_dispose( + struct wf_jsonrpc_response_writer * writer); + +extern struct wf_message * +wf_impl_jsonrpc_response_writer_take_message( + struct wf_jsonrpc_response_writer * writer); + +extern void +wf_impl_jsonrpc_response_add_int( + struct wf_jsonrpc_response_writer * writer, + char const * key, + int value); + +extern void +wf_impl_jsonrpc_response_add_string( + struct wf_jsonrpc_response_writer * writer, + char const * key, + char const * value); + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/webfuse/impl/jsonrpc/send_fn.h b/lib/webfuse/impl/jsonrpc/send_fn.h index 3c448fd..3074d96 100644 --- a/lib/webfuse/impl/jsonrpc/send_fn.h +++ b/lib/webfuse/impl/jsonrpc/send_fn.h @@ -5,15 +5,16 @@ #include #endif -#include #ifdef __cplusplus extern "C" { #endif +struct wf_message; + typedef bool wf_jsonrpc_send_fn( - json_t * request, + struct wf_message * request, void * user_data); #ifdef __cplusplus diff --git a/lib/webfuse/impl/message.c b/lib/webfuse/impl/message.c index 8df799d..c5bf0a7 100644 --- a/lib/webfuse/impl/message.c +++ b/lib/webfuse/impl/message.c @@ -3,26 +3,23 @@ #include #include -extern struct wf_message * wf_impl_message_create(json_t const * value) +extern struct wf_message * +wf_impl_message_create( + char * data, + size_t length) { - struct wf_message * message = NULL; - size_t const length = json_dumpb(value, NULL, 0, JSON_COMPACT); - - if (0 < length) - { - char * data = malloc(sizeof(struct wf_message) + LWS_PRE + length); - message = (struct wf_message *) data; - message->data = &data[sizeof(struct wf_message) + LWS_PRE]; - message->length = length; - - json_dumpb(value, message->data, length, JSON_COMPACT); - } + struct wf_message * message = malloc(sizeof(struct wf_message)); + message->data = data; + message->length = length; return message; } -void wf_impl_message_dispose( +void +wf_impl_message_dispose( struct wf_message * message) { + char * raw_data = message->data - LWS_PRE; + free(raw_data); free(message); } diff --git a/lib/webfuse/impl/message.h b/lib/webfuse/impl/message.h index 8e75437..1cefdf7 100644 --- a/lib/webfuse/impl/message.h +++ b/lib/webfuse/impl/message.h @@ -8,7 +8,6 @@ using std::size_t; #endif -#include #include "webfuse/impl/util/slist.h" struct wf_message @@ -23,10 +22,13 @@ extern "C" { #endif -extern struct wf_message * wf_impl_message_create( - json_t const * value); +extern struct wf_message * +wf_impl_message_create( + char * value, + size_t length); -extern void wf_impl_message_dispose( +extern void +wf_impl_message_dispose( struct wf_message * message); #ifdef __cplusplus diff --git a/lib/webfuse/impl/server_protocol.c b/lib/webfuse/impl/server_protocol.c index 48792c0..422fcf1 100644 --- a/lib/webfuse/impl/server_protocol.c +++ b/lib/webfuse/impl/server_protocol.c @@ -12,6 +12,7 @@ #include "webfuse/impl/status.h" #include "webfuse/impl/jsonrpc/request.h" +#include "webfuse/impl/jsonrpc/response_writer.h" #include "webfuse/impl/timer/manager.h" #include "webfuse/impl/timer/timer.h" @@ -136,8 +137,7 @@ static void wf_impl_server_protocol_authenticate( if (result) { - json_t * result = json_object(); - wf_impl_jsonrpc_respond(request, result); + wf_impl_jsonrpc_respond(request); } else { @@ -198,9 +198,9 @@ static void wf_impl_server_protocol_add_filesystem( if (WF_GOOD == status) { - json_t * result = json_object(); - json_object_set_new(result, "id", json_string(name)); - wf_impl_jsonrpc_respond(request, result); + struct wf_jsonrpc_response_writer * writer = wf_impl_jsonrpc_request_get_response_writer(request); + wf_impl_jsonrpc_response_add_string(writer, "id", name); + wf_impl_jsonrpc_respond(request); } else { diff --git a/lib/webfuse/impl/session.c b/lib/webfuse/impl/session.c index 5d3d078..1086d0e 100644 --- a/lib/webfuse/impl/session.c +++ b/lib/webfuse/impl/session.c @@ -20,15 +20,13 @@ #define WF_DEFAULT_MESSAGE_SIZE (8 * 1024) static bool wf_impl_session_send( - json_t * request, + struct wf_message * message, void * user_data) { struct wf_impl_session * session = user_data; - struct wf_message * message = wf_impl_message_create(request); + bool result = false; - bool result = (session->is_authenticated || wf_impl_jsonrpc_is_response(request)) && (NULL != session->wsi); - - if (result) + if (NULL != session->wsi) { wf_impl_slist_append(&session->messages, &message->item); lws_callback_on_writable(session->wsi); diff --git a/meson.build b/meson.build index 1a04770..1838a89 100644 --- a/meson.build +++ b/meson.build @@ -36,6 +36,7 @@ webfuse_static = static_library('webfuse', 'lib/webfuse/impl/jsonrpc/method.c', 'lib/webfuse/impl/jsonrpc/request.c', 'lib/webfuse/impl/jsonrpc/response.c', + 'lib/webfuse/impl/jsonrpc/response_writer.c', 'lib/webfuse/impl/jsonrpc/error.c', 'lib/webfuse/impl/message.c', 'lib/webfuse/impl/message_queue.c', diff --git a/test/webfuse/jsonrpc/test_proxy.cc b/test/webfuse/jsonrpc/test_proxy.cc index f5368d0..acaf720 100644 --- a/test/webfuse/jsonrpc/test_proxy.cc +++ b/test/webfuse/jsonrpc/test_proxy.cc @@ -1,5 +1,6 @@ #include #include "webfuse/impl/jsonrpc/proxy.h" +#include "webfuse/impl/message.h" #include "webfuse/status.h" #include "webfuse/impl/timer/manager.h" @@ -40,22 +41,23 @@ namespace ~SendContext() { - if (nullptr != response) - { - json_decref(response); - } + json_decref(response); } }; bool jsonrpc_send( - json_t * request, + wf_message * request, void * user_data) { SendContext * context = reinterpret_cast(user_data); context->is_called = true; - context->response = request; - json_incref(request); + if (nullptr != context->response) + { + json_decref(context->response); + } + context->response = json_loadb(request->data, request->length, 0, nullptr); + wf_impl_message_dispose(request); return context->result; } @@ -199,7 +201,7 @@ TEST(wf_jsonrpc_proxy, invoke_if_another_request_is_pending) wf_impl_timer_manager_dispose(timer_manager); } -TEST(wf_jsonrpc_proxy, invoke_fails_if_request_is_invalid) +TEST(wf_jsonrpc_proxy, invoke_invalid_request) { struct wf_timer_manager * timer_manager = wf_impl_timer_manager_create(); @@ -211,10 +213,9 @@ TEST(wf_jsonrpc_proxy, invoke_fails_if_request_is_invalid) void * finished_data = reinterpret_cast(&finished_context); wf_impl_jsonrpc_proxy_invoke(proxy, &jsonrpc_finished, finished_data, "foo", "?", "error"); - ASSERT_FALSE(send_context.is_called); + ASSERT_TRUE(send_context.is_called); - ASSERT_TRUE(finished_context.is_called); - ASSERT_EQ(WF_BAD, jsonrpc_get_status(finished_context.error)); + ASSERT_FALSE(finished_context.is_called); wf_impl_jsonrpc_proxy_dispose(proxy); wf_impl_timer_manager_dispose(timer_manager); @@ -368,7 +369,7 @@ TEST(wf_jsonrpc_proxy, notify) wf_impl_timer_manager_dispose(timer_manager); } -TEST(wf_jsonrpc_proxy, notify_dont_send_invalid_request) +TEST(wf_jsonrpc_proxy, notify_send_invalid_request) { struct wf_timer_manager * timer_manager = wf_impl_timer_manager_create(); @@ -378,7 +379,7 @@ TEST(wf_jsonrpc_proxy, notify_dont_send_invalid_request) wf_impl_jsonrpc_proxy_notify(proxy, "foo", "?"); - ASSERT_FALSE(send_context.is_called); + ASSERT_TRUE(send_context.is_called); wf_impl_jsonrpc_proxy_dispose(proxy); wf_impl_timer_manager_dispose(timer_manager); diff --git a/test/webfuse/jsonrpc/test_request.cc b/test/webfuse/jsonrpc/test_request.cc index 6152ecb..dc2cab0 100644 --- a/test/webfuse/jsonrpc/test_request.cc +++ b/test/webfuse/jsonrpc/test_request.cc @@ -1,5 +1,6 @@ #include #include "webfuse/impl/jsonrpc/request.h" +#include "webfuse/impl/message.h" #include "webfuse/status.h" namespace @@ -7,17 +8,17 @@ namespace struct Context { - json_t * response; + std::string response; }; bool jsonrpc_send( - json_t * request, + wf_message * request, void * user_data) { Context * context = reinterpret_cast(user_data); - context->response = request; - json_incref(request); + context->response = std::string(request->data, request->length); + wf_impl_message_dispose(request); return true; } @@ -25,7 +26,7 @@ bool jsonrpc_send( TEST(wf_jsonrpc_request, create_dispose) { - Context context{nullptr}; + Context context; void * user_data = reinterpret_cast(&context); struct wf_jsonrpc_request * request = @@ -39,18 +40,15 @@ TEST(wf_jsonrpc_request, create_dispose) TEST(wf_jsonrpc_request, respond) { - Context context{nullptr}; + Context context; void * user_data = reinterpret_cast(&context); struct wf_jsonrpc_request * request = wf_impl_jsonrpc_request_create(42, &jsonrpc_send, user_data); - wf_impl_jsonrpc_respond(request, json_string("okay")); + wf_impl_jsonrpc_respond(request); - ASSERT_NE(nullptr, context.response); - - - json_t * response = reinterpret_cast(context.response); + json_t * response = json_loads(context.response.c_str(), 0, nullptr); ASSERT_TRUE(json_is_object(response)); json_t * id = json_object_get(response, "id"); @@ -58,8 +56,7 @@ TEST(wf_jsonrpc_request, respond) ASSERT_EQ(42, json_integer_value(id)); json_t * result = json_object_get(response, "result"); - ASSERT_TRUE(json_is_string(result)); - ASSERT_STREQ("okay", json_string_value(result)); + ASSERT_TRUE(json_is_object(result)); ASSERT_EQ(nullptr, json_object_get(response, "error")); @@ -68,7 +65,7 @@ TEST(wf_jsonrpc_request, respond) TEST(wf_jsonrpc_request, respond_error) { - Context context{nullptr}; + Context context; void * user_data = reinterpret_cast(&context); struct wf_jsonrpc_request * request = @@ -76,10 +73,7 @@ TEST(wf_jsonrpc_request, respond_error) wf_impl_jsonrpc_respond_error(request, WF_BAD, "Bad"); - ASSERT_NE(nullptr, context.response); - - - json_t * response = reinterpret_cast(context.response); + json_t * response = json_loads(context.response.c_str(), 0, nullptr); ASSERT_TRUE(json_is_object(response)); json_t * id = json_object_get(response, "id"); diff --git a/test/webfuse/jsonrpc/test_server.cc b/test/webfuse/jsonrpc/test_server.cc index c9425d5..98da7bd 100644 --- a/test/webfuse/jsonrpc/test_server.cc +++ b/test/webfuse/jsonrpc/test_server.cc @@ -1,6 +1,7 @@ #include #include "webfuse/impl/jsonrpc/server.h" #include "webfuse/impl/jsonrpc/request.h" +#include "webfuse/impl/message.h" #include "webfuse/status.h" namespace @@ -12,14 +13,14 @@ namespace }; bool jsonrpc_send( - json_t * request, + wf_message * request, void * user_data) { Context * context = reinterpret_cast(user_data); context->is_called = true; - context->response = request; - json_incref(request); + context->response = json_loadb(request->data, request->length, 0, nullptr); + wf_impl_message_dispose(request); return true; } @@ -33,8 +34,7 @@ namespace (void) params; (void) user_data; - json_t * result = json_string("Hello"); - wf_impl_jsonrpc_respond(request, result); + wf_impl_jsonrpc_respond(request); } } @@ -61,15 +61,14 @@ TEST(wf_jsonrpc_server, process_request) ASSERT_EQ(23, json_integer_value(id)); json_t * result = json_object_get(context.response, "result"); - ASSERT_TRUE(json_is_string(result)); - ASSERT_STREQ("Hello", json_string_value(result)); + ASSERT_TRUE(json_is_object(result)); json_decref(context.response); json_decref(request); wf_impl_jsonrpc_server_dispose(server); } -TEST(wf_jsonrpc_server, process_request_with_oject_params) +TEST(wf_jsonrpc_server, process_request_with_object_params) { struct wf_jsonrpc_server * server = wf_impl_jsonrpc_server_create(); wf_impl_jsonrpc_server_add(server, "sayHello", &sayHello, nullptr); @@ -91,8 +90,7 @@ TEST(wf_jsonrpc_server, process_request_with_oject_params) ASSERT_EQ(23, json_integer_value(id)); json_t * result = json_object_get(context.response, "result"); - ASSERT_TRUE(json_is_string(result)); - ASSERT_STREQ("Hello", json_string_value(result)); + ASSERT_TRUE(json_is_object(result)); json_decref(context.response); json_decref(request); diff --git a/test/webfuse/test_message.cc b/test/webfuse/test_message.cc index 0e262fe..a0aafe0 100644 --- a/test/webfuse/test_message.cc +++ b/test/webfuse/test_message.cc @@ -1,22 +1,22 @@ -#include -#include #include "webfuse/impl/message.h" +#include +#include +#include + +#include + TEST(wf_message, create) { - json_t * value = json_object(); + char * data = (char*) malloc(LWS_PRE + 2); + data[LWS_PRE ] = '{'; + data[LWS_PRE + 1] = '}'; - struct wf_message * message = wf_impl_message_create(value); + struct wf_message * message = wf_impl_message_create(&(data[LWS_PRE]), 2); ASSERT_NE(nullptr, message); ASSERT_EQ(2, message->length); ASSERT_TRUE(0 == strncmp("{}", message->data, 2)); wf_impl_message_dispose(message); - json_decref(value); } -TEST(wf_message, fail_to_create) -{ - struct wf_message * message = wf_impl_message_create(nullptr); - ASSERT_EQ(nullptr, message); -} \ No newline at end of file diff --git a/test/webfuse/test_message_queue.cc b/test/webfuse/test_message_queue.cc index 4560cee..b79890d 100644 --- a/test/webfuse/test_message_queue.cc +++ b/test/webfuse/test_message_queue.cc @@ -1,18 +1,23 @@ -#include #include "webfuse/impl/message_queue.h" #include "webfuse/impl/message.h" #include "webfuse/impl/util/slist.h" +#include + +#include +#include +#include + namespace { struct wf_slist_item * create_message(char const * content) { - json_t * value = json_object(); - json_object_set_new(value, "content", json_string(content)); - struct wf_message * message = wf_impl_message_create(value); + std::string json = std::string("{\"content\": \"") + content + "\"}"; + char * data = (char*) malloc(LWS_PRE + json.size()); + memcpy(&(data[LWS_PRE]), json.c_str(), json.size()); + struct wf_message * message = wf_impl_message_create(&(data[LWS_PRE]), json.size()); - json_decref(value); return &message->item; }