Archives/falk-werner_webfuse-provider
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse-provider synced 2026-03-02 04:09:18 +00:00
Code Issues Releases Wiki Activity

refactor: made jsonrpc an independent library

Browse Source
This commit is contained in:
Falk Werner
2020-02-28 23:17:41 +01:00
parent c6ca2e14bd
commit e3a3427ca8
54 changed files with 882 additions and 707 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
test/webfuse/tests/adapter/jsonrpc/test_is_request.cc → test/jsonrpc/test_is_request.cc
View File

@@ -1,5 +1,5 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "jsonrpc/request.h"
TEST(jsonrpc_is_request, request_with_object_params)
{
@@ -8,7 +8,7 @@ TEST(jsonrpc_is_request, request_with_object_params)
json_object_set_new(request, "params", json_object());
json_object_set_new(request, "id", json_integer(42));
ASSERT_TRUE(wf_impl_jsonrpc_is_request(request));
ASSERT_TRUE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -20,14 +20,14 @@ TEST(jsonrpc_is_request, request_with_array_params)
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(42));
ASSERT_TRUE(wf_impl_jsonrpc_is_request(request));
ASSERT_TRUE(jsonrpc_is_request(request));
json_decref(request);
}
TEST(jsonrpc_is_request, null_request)
{
ASSERT_FALSE(wf_impl_jsonrpc_is_request(nullptr));
ASSERT_FALSE(jsonrpc_is_request(nullptr));
}
TEST(jsonrpc_is_request, invalid_request)
@@ -37,7 +37,7 @@ TEST(jsonrpc_is_request, invalid_request)
json_array_append_new(request, json_object());
json_array_append_new(request, json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -48,7 +48,7 @@ TEST(jsonrpc_is_request, invalid_request_without_id)
json_object_set_new(request, "method", json_string("method"));
json_object_set_new(request, "params", json_object());
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -60,7 +60,7 @@ TEST(jsonrpc_is_request, invalid_request_due_to_invalid_id)
json_object_set_new(request, "params", json_object());
json_object_set_new(request, "id", json_string("42"));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -71,7 +71,7 @@ TEST(jsonrpc_is_request, invalid_request_without_method)
json_object_set_new(request, "params", json_object());
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -83,7 +83,7 @@ TEST(jsonrpc_is_request, invalid_request_due_to_invalid_method)
json_object_set_new(request, "params", json_object());
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -94,7 +94,7 @@ TEST(jsonrpc_is_request, invalid_request_without_params)
json_object_set_new(request, "method", json_string("method"));
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}
@@ -106,7 +106,7 @@ TEST(jsonrpc_is_request, invalid_request_due_to_invalid_params)
json_object_set_new(request, "params", json_string("params"));
json_object_set_new(request, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_request(request));
ASSERT_FALSE(jsonrpc_is_request(request));
json_decref(request);
}

20
test/webfuse/tests/adapter/jsonrpc/test_is_response.cc → test/jsonrpc/test_is_response.cc
View File

@@ -1,5 +1,5 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/response.h"
#include "jsonrpc/response.h"
TEST(jsonrpc_is_response, valid_result)
{
@@ -7,7 +7,7 @@ TEST(jsonrpc_is_response, valid_result)
json_object_set_new(message, "result", json_object());
json_object_set_new(message, "id", json_integer(42));
ASSERT_TRUE(wf_impl_jsonrpc_is_response(message));
ASSERT_TRUE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -18,7 +18,7 @@ TEST(jsonrpc_is_response, valid_result_string)
json_object_set_new(message, "result", json_string("also valid"));
json_object_set_new(message, "id", json_integer(42));
ASSERT_TRUE(wf_impl_jsonrpc_is_response(message));
ASSERT_TRUE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -29,14 +29,14 @@ TEST(jsonrpc_is_response, valid_error)
json_object_set_new(message, "error", json_object());
json_object_set_new(message, "id", json_integer(42));
ASSERT_TRUE(wf_impl_jsonrpc_is_response(message));
ASSERT_TRUE(jsonrpc_is_response(message));
json_decref(message);
}
TEST(jsonrpc_is_response, invalid_null)
{
ASSERT_FALSE(wf_impl_jsonrpc_is_response(nullptr));
ASSERT_FALSE(jsonrpc_is_response(nullptr));
}
TEST(jsonrpc_is_response, invalid_message)
@@ -45,7 +45,7 @@ TEST(jsonrpc_is_response, invalid_message)
json_array_append_new(message, json_object());
json_array_append_new(message, json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_response(message));
ASSERT_FALSE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -55,7 +55,7 @@ TEST(jsonrpc_is_response, invalid_missing_id)
json_t * message = json_object();
json_object_set_new(message, "result", json_object());
ASSERT_FALSE(wf_impl_jsonrpc_is_response(message));
ASSERT_FALSE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -66,7 +66,7 @@ TEST(jsonrpc_is_response, invalid_id_wrong_type)
json_object_set_new(message, "result", json_object());
json_object_set_new(message, "id", json_string("42"));
ASSERT_FALSE(wf_impl_jsonrpc_is_response(message));
ASSERT_FALSE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -77,7 +77,7 @@ TEST(jsonrpc_is_response, invalid_missing_result_and_error)
json_t * message = json_object();
json_object_set_new(message, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_response(message));
ASSERT_FALSE(jsonrpc_is_response(message));
json_decref(message);
}
@@ -88,7 +88,7 @@ TEST(jsonrpc_is_response, invalid_error_wrong_type)
json_object_set_new(message, "error", json_array());
json_object_set_new(message, "id", json_integer(42));
ASSERT_FALSE(wf_impl_jsonrpc_is_response(message));
ASSERT_FALSE(jsonrpc_is_response(message));
json_decref(message);
}

122
test/webfuse/tests/adapter/jsonrpc/test_proxy.cc → test/jsonrpc/test_proxy.cc
View File

@@ -1,7 +1,8 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/proxy.h"
#include "jsonrpc/proxy.h"
#include "webfuse/adapter/impl/time/timeout_manager.h"
#include "webfuse/utils/msleep.hpp"
#include "webfuse/core/json_util.h"
using webfuse_test::msleep;
@@ -47,13 +48,13 @@ namespace
struct FinishedContext
{
bool is_called;
wf_status status;
json_t * result;
json_t * error;
FinishedContext()
: is_called(false)
, status(WF_BAD)
, result(nullptr)
, error(nullptr)
{
}
@@ -64,18 +65,23 @@ namespace
{
json_decref(result);
}
if (nullptr != error)
{
json_decref(error);
}
}
};
void jsonrpc_finished(
void * user_data,
wf_status status,
struct json_t const * result)
json_t const * result,
json_t const * error)
{
FinishedContext * context = reinterpret_cast<FinishedContext*>(user_data);
context->is_called = true;
context->status = status;
context->result = json_deep_copy(result);
context->error = json_deep_copy(error);
}
}
@@ -86,10 +92,10 @@ TEST(jsonrpc_proxy, init)
SendContext context;
void * user_data = reinterpret_cast<void*>(&context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, user_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, user_data);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
ASSERT_FALSE(context.is_called);
@@ -102,12 +108,12 @@ TEST(jsonrpc_proxy, invoke)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -129,11 +135,11 @@ TEST(jsonrpc_proxy, invoke)
ASSERT_FALSE(finished_context.is_called);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
ASSERT_TRUE(finished_context.is_called);
ASSERT_FALSE(WF_GOOD == finished_context.status);
ASSERT_FALSE(nullptr == finished_context.error);
}
TEST(jsonrpc_proxy, invoke_calls_finish_if_send_fails)
@@ -143,20 +149,20 @@ TEST(jsonrpc_proxy, invoke_calls_finish_if_send_fails)
SendContext send_context(false);
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
ASSERT_TRUE(finished_context.is_called);
ASSERT_FALSE(WF_GOOD == finished_context.status);
ASSERT_FALSE(nullptr == finished_context.error);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -167,16 +173,16 @@ TEST(jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
FinishedContext finished_context2;
void * finished_data2 = reinterpret_cast<void*>(&finished_context2);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data2, "foo", "");
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data2, "foo", "");
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -184,9 +190,9 @@ TEST(jsonrpc_proxy, invoke_fails_if_another_request_is_pending)
ASSERT_FALSE(finished_context.is_called);
ASSERT_TRUE(finished_context2.is_called);
ASSERT_EQ(WF_BAD_BUSY, finished_context2.status);
ASSERT_EQ(WF_BAD_BUSY, wf_impl_jsonrpc_get_status(finished_context2.error));
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -197,19 +203,19 @@ TEST(jsonrpc_proxy, invoke_fails_if_request_is_invalid)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "?", "error");
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "?", "error");
ASSERT_FALSE(send_context.is_called);
ASSERT_TRUE(finished_context.is_called);
ASSERT_EQ(WF_BAD, finished_context.status);
ASSERT_EQ(WF_BAD, wf_impl_jsonrpc_get_status(finished_context.error));
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -220,12 +226,12 @@ TEST(jsonrpc_proxy, on_result)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -237,15 +243,15 @@ TEST(jsonrpc_proxy, on_result)
json_object_set_new(response, "result", json_string("okay"));
json_object_set(response, "id", id);
wf_impl_jsonrpc_proxy_onresult(&proxy, response);
jsonrpc_proxy_onresult(&proxy, response);
json_decref(response);
ASSERT_TRUE(finished_context.is_called);
ASSERT_EQ(WF_GOOD, finished_context.status);
ASSERT_EQ(nullptr, finished_context.error);
ASSERT_TRUE(json_is_string(finished_context.result));
ASSERT_STREQ("okay", json_string_value(finished_context.result));
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -256,12 +262,12 @@ TEST(jsonrpc_proxy, on_result_reject_response_with_unknown_id)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -273,12 +279,12 @@ TEST(jsonrpc_proxy, on_result_reject_response_with_unknown_id)
json_object_set_new(response, "result", json_string("okay"));
json_object_set_new(response, "id", json_integer(1 + json_integer_value(id)));
wf_impl_jsonrpc_proxy_onresult(&proxy, response);
jsonrpc_proxy_onresult(&proxy, response);
json_decref(response);
ASSERT_FALSE(finished_context.is_called);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -289,12 +295,12 @@ TEST(jsonrpc_proxy, timeout)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, 0, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, 0, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -303,9 +309,9 @@ TEST(jsonrpc_proxy, timeout)
wf_impl_timeout_manager_check(&timeout_manager);
ASSERT_TRUE(finished_context.is_called);
ASSERT_EQ(WF_BAD_TIMEOUT, finished_context.status);
ASSERT_EQ(WF_BAD_TIMEOUT, wf_impl_jsonrpc_get_status(finished_context.error));
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -316,12 +322,12 @@ TEST(jsonrpc_proxy, cleanup_pending_request)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, 10, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, 10, &jsonrpc_send, send_data);
FinishedContext finished_context;
void * finished_data = reinterpret_cast<void*>(&finished_context);
wf_impl_jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
jsonrpc_proxy_invoke(&proxy, &jsonrpc_finished, finished_data, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -329,7 +335,7 @@ TEST(jsonrpc_proxy, cleanup_pending_request)
ASSERT_FALSE(finished_context.is_called);
ASSERT_NE(nullptr, timeout_manager.timers);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
ASSERT_TRUE(finished_context.is_called);
ASSERT_EQ(nullptr, timeout_manager.timers);
@@ -346,10 +352,10 @@ TEST(jsonrpc_proxy, notify)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
wf_impl_jsonrpc_proxy_notify(&proxy, "foo", "si", "bar", 42);
jsonrpc_proxy_notify(&proxy, "foo", "si", "bar", 42);
ASSERT_TRUE(send_context.is_called);
ASSERT_TRUE(json_is_object(send_context.response));
@@ -370,7 +376,7 @@ TEST(jsonrpc_proxy, notify)
ASSERT_EQ(nullptr, id);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}
@@ -381,13 +387,13 @@ TEST(jsonrpc_proxy, notify_dont_send_invalid_request)
SendContext send_context;
void * send_data = reinterpret_cast<void*>(&send_context);
struct wf_impl_jsonrpc_proxy proxy;
wf_impl_jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
struct jsonrpc_proxy proxy;
jsonrpc_proxy_init(&proxy, &timeout_manager, WF_DEFAULT_TIMEOUT, &jsonrpc_send, send_data);
wf_impl_jsonrpc_proxy_notify(&proxy, "foo", "?");
jsonrpc_proxy_notify(&proxy, "foo", "?");
ASSERT_FALSE(send_context.is_called);
wf_impl_jsonrpc_proxy_cleanup(&proxy);
jsonrpc_proxy_cleanup(&proxy);
wf_impl_timeout_manager_cleanup(&timeout_manager);
}

22
test/webfuse/tests/adapter/jsonrpc/test_request.cc → test/jsonrpc/test_request.cc
View File

@@ -1,5 +1,5 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "jsonrpc/request.h"
namespace
{
@@ -27,13 +27,13 @@ TEST(jsonrpc_request, create_dispose)
Context context{nullptr};
void * user_data = reinterpret_cast<void*>(&context);
struct wf_impl_jsonrpc_request * request =
wf_impl_jsonrpc_request_create(42, &jsonrpc_send, user_data);
struct jsonrpc_request * request =
jsonrpc_request_create(42, &jsonrpc_send, user_data);
ASSERT_NE(nullptr, request);
ASSERT_EQ(user_data, wf_impl_jsonrpc_request_get_userdata(request));
ASSERT_EQ(user_data, jsonrpc_request_get_userdata(request));
wf_impl_jsonrpc_request_dispose(request);
jsonrpc_request_dispose(request);
}
TEST(jsonrpc_request, respond)
@@ -41,10 +41,10 @@ TEST(jsonrpc_request, respond)
Context context{nullptr};
void * user_data = reinterpret_cast<void*>(&context);
struct wf_impl_jsonrpc_request * request =
wf_impl_jsonrpc_request_create(42, &jsonrpc_send, user_data);
struct jsonrpc_request * request =
jsonrpc_request_create(42, &jsonrpc_send, user_data);
wf_impl_jsonrpc_respond(request, json_string("okay"));
jsonrpc_respond(request, json_string("okay"));
ASSERT_NE(nullptr, context.response);
@@ -70,10 +70,10 @@ TEST(jsonrpc_request, respond_error)
Context context{nullptr};
void * user_data = reinterpret_cast<void*>(&context);
struct wf_impl_jsonrpc_request * request =
wf_impl_jsonrpc_request_create(42, &jsonrpc_send, user_data);
struct jsonrpc_request * request =
jsonrpc_request_create(42, &jsonrpc_send, user_data);
wf_impl_jsonrpc_respond_error(request, WF_BAD);
jsonrpc_respond_error(request, WF_BAD);
ASSERT_NE(nullptr, context.response);

28
test/webfuse/tests/adapter/jsonrpc/test_response.cc → test/jsonrpc/test_response.cc
View File

@@ -1,5 +1,7 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/response.h"
#include "jsonrpc/response.h"
#include "webfuse/core/status.h"
#include "webfuse/core/json_util.h"
TEST(json_response, init_result)
{
@@ -7,15 +9,15 @@ TEST(json_response, init_result)
json_object_set_new(message, "result", json_integer(47));
json_object_set_new(message, "id", json_integer(11));
struct wf_impl_jsonrpc_response response;
wf_impl_jsonrpc_response_init(&response, message);
struct jsonrpc_response response;
jsonrpc_response_init(&response, message);
ASSERT_EQ(WF_GOOD, response.status);
ASSERT_EQ(nullptr, response.error);
ASSERT_TRUE(json_is_integer(response.result));
ASSERT_EQ(47, json_integer_value(response.result));
ASSERT_EQ(11, response.id);
wf_impl_jsonrpc_response_cleanup(&response);
jsonrpc_response_cleanup(&response);
json_decref(message);
}
@@ -28,14 +30,14 @@ TEST(json_response, init_error)
json_object_set_new(message, "error", err);
json_object_set_new(message, "id", json_integer(23));
struct wf_impl_jsonrpc_response response;
wf_impl_jsonrpc_response_init(&response, message);
struct jsonrpc_response response;
jsonrpc_response_init(&response, message);
ASSERT_EQ(WF_BAD_ACCESS_DENIED, response.status);
ASSERT_EQ(WF_BAD_ACCESS_DENIED, wf_impl_jsonrpc_get_status(response.error)) << json_string_value(json_object_get(response.error, "message"));
ASSERT_EQ(nullptr, response.result);
ASSERT_EQ(23, response.id);
wf_impl_jsonrpc_response_cleanup(&response);
jsonrpc_response_cleanup(&response);
json_decref(message);
}
@@ -44,13 +46,13 @@ TEST(json_response, init_format_error)
json_t * message = json_object();
json_object_set_new(message, "id", json_integer(12));
struct wf_impl_jsonrpc_response response;
wf_impl_jsonrpc_response_init(&response, message);
struct jsonrpc_response response;
jsonrpc_response_init(&response, message);
ASSERT_EQ(WF_BAD_FORMAT, response.status);
ASSERT_EQ(WF_BAD_FORMAT, wf_impl_jsonrpc_get_status(response.error));
ASSERT_EQ(nullptr, response.result);
ASSERT_EQ(12, response.id);
wf_impl_jsonrpc_response_cleanup(&response);
jsonrpc_response_cleanup(&response);
json_decref(message);
}

36
test/webfuse/tests/adapter/jsonrpc/test_server.cc → test/jsonrpc/test_server.cc
View File

@@ -1,6 +1,6 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/server.h"
#include "webfuse/adapter/impl/jsonrpc/request.h"
#include "jsonrpc/server.h"
#include "jsonrpc/request.h"
namespace
{
@@ -23,7 +23,7 @@ namespace
}
void sayHello(
struct wf_impl_jsonrpc_request * request,
struct jsonrpc_request * request,
char const * method_name,
json_t * params,
void * user_data)
@@ -33,16 +33,16 @@ namespace
(void) user_data;
json_t * result = json_string("Hello");
wf_impl_jsonrpc_respond(request, result);
jsonrpc_respond(request, result);
}
}
TEST(jsonrpc_server, process_request)
{
struct wf_impl_jsonrpc_server server;
wf_impl_jsonrpc_server_init(&server);
wf_impl_jsonrpc_server_add(&server, "sayHello", &sayHello, nullptr);
struct jsonrpc_server server;
jsonrpc_server_init(&server);
jsonrpc_server_add(&server, "sayHello", &sayHello, nullptr);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
@@ -50,7 +50,7 @@ TEST(jsonrpc_server, process_request)
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(23));
wf_impl_jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
ASSERT_TRUE(context.is_called);
ASSERT_NE(nullptr, context.response);
@@ -66,14 +66,14 @@ TEST(jsonrpc_server, process_request)
json_decref(context.response);
json_decref(request);
wf_impl_jsonrpc_server_cleanup(&server);
jsonrpc_server_cleanup(&server);
}
TEST(jsonrpc_server, invoke_unknown_method)
{
struct wf_impl_jsonrpc_server server;
wf_impl_jsonrpc_server_init(&server);
wf_impl_jsonrpc_server_add(&server, "sayHello", &sayHello, nullptr);
struct jsonrpc_server server;
jsonrpc_server_init(&server);
jsonrpc_server_add(&server, "sayHello", &sayHello, nullptr);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
@@ -81,7 +81,7 @@ TEST(jsonrpc_server, invoke_unknown_method)
json_object_set_new(request, "method", json_string("greet"));
json_object_set_new(request, "params", json_array());
json_object_set_new(request, "id", json_integer(42));
wf_impl_jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
ASSERT_TRUE(context.is_called);
ASSERT_NE(nullptr, context.response);
@@ -103,23 +103,23 @@ TEST(jsonrpc_server, invoke_unknown_method)
json_decref(context.response);
json_decref(request);
wf_impl_jsonrpc_server_cleanup(&server);
jsonrpc_server_cleanup(&server);
}
TEST(jsonrpc_server, skip_invalid_request)
{
struct wf_impl_jsonrpc_server server;
wf_impl_jsonrpc_server_init(&server);
struct jsonrpc_server server;
jsonrpc_server_init(&server);
Context context{nullptr, false};
void * user_data = reinterpret_cast<void*>(&context);
json_t * request = json_object();
json_object_set_new(request, "method", json_string("sayHello"));
json_object_set_new(request, "params", json_array());
wf_impl_jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
jsonrpc_server_process(&server, request, &jsonrpc_send, user_data);
ASSERT_FALSE(context.is_called);
json_decref(request);
wf_impl_jsonrpc_server_cleanup(&server);
jsonrpc_server_cleanup(&server);
}

2
test/webfuse/tests/adapter/jsonrpc/test_util.cc → test/jsonrpc/test_util.cc
View File

@@ -1,5 +1,5 @@
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/util.h"
#include "webfuse/core/json_util.h"
TEST(jsonrpc_util, get_int)
{

23
test/webfuse/mocks/mock_provider_client.cc
View File

@@ -167,6 +167,22 @@ static void webfuse_test_iproviderclient_onread(
delete[] data;
}
static void webfuse_test_iproviderclient_get_credentials(
wfp_credentials * credentials,
void * user_data)
{
auto * self = reinterpret_cast<IProviderClient*>(user_data);
try
{
self->GetCredentials(credentials);
}
catch (...)
{
// swallow
}
}
}
namespace webfuse_test
@@ -185,7 +201,7 @@ wf_status ProviderClientException::GetErrorCode()
}
void IProviderClient::AttachTo(wfp_client_config * config)
void IProviderClient::AttachTo(wfp_client_config * config, bool enableAuthentication)
{
void * self = reinterpret_cast<void *>(this);
wfp_client_config_set_userdata(config, self);
@@ -199,6 +215,11 @@ void IProviderClient::AttachTo(wfp_client_config * config)
wfp_client_config_set_onopen(config, &webfuse_test_iproviderclient_onopen);
wfp_client_config_set_onclose(config, &webfuse_test_iproviderclient_onclose);
wfp_client_config_set_onread(config, &webfuse_test_iproviderclient_onread);
if (enableAuthentication)
{
wfp_client_config_enable_authentication(config, &webfuse_test_iproviderclient_get_credentials);
}
}
}

6
test/webfuse/mocks/mock_provider_client.hpp
View File

@@ -16,8 +16,6 @@ namespace webfuse_test
private:
wf_status error_code_;
};
class IProviderClient
{
@@ -32,8 +30,9 @@ namespace webfuse_test
virtual void Open(ino_t inode, int flags, uint32_t * handle) = 0;
virtual void Close(ino_t inode, uint32_t handle, int flags) = 0;
virtual void Read(ino_t inode, uint32_t handle, size_t offset, size_t length, char * buffer, size_t * bytes_read) = 0;
virtual void GetCredentials(wfp_credentials * credentials) = 0;
void AttachTo(wfp_client_config * config);
void AttachTo(wfp_client_config * config, bool enableAuthentication = false);
};
class MockProviderClient: public IProviderClient
@@ -49,6 +48,7 @@ namespace webfuse_test
MOCK_METHOD3( Open, void(ino_t inode, int flags, uint32_t * handle));
MOCK_METHOD3( Close, void(ino_t inode, uint32_t handle, int flags));
MOCK_METHOD6( Read, void(ino_t inode, uint32_t handle, size_t offset, size_t length, char * buffer, size_t * bytes_read));
MOCK_METHOD1( GetCredentials, void (wfp_credentials * credentials));
};
}

27
test/webfuse/tests/adapter/test_response_parser.cc
View File

@@ -1,54 +1,59 @@
#include <string>
#include <gtest/gtest.h>
#include "webfuse/adapter/impl/jsonrpc/response.h"
#include "jsonrpc/response.h"
#include "webfuse/core/json_util.h"
static void response_parse_str(
std::string const & buffer,
struct wf_impl_jsonrpc_response * response)
struct jsonrpc_response * response)
{
json_t * message = json_loadb(buffer.c_str(), buffer.size(), 0, nullptr);
if (nullptr != message)
{
wf_impl_jsonrpc_response_init(response, message);
jsonrpc_response_init(response, message);
json_decref(message);
}
}
TEST(response_parser, test)
{
struct wf_impl_jsonrpc_response response;
struct jsonrpc_response response;
// no object
response_parse_str("[]", &response);
ASSERT_NE(WF_GOOD, response.status);
ASSERT_NE(nullptr, response.error);
ASSERT_EQ(-1, response.id);
ASSERT_EQ(nullptr, response.result);
jsonrpc_response_cleanup(&response);
// empty
response_parse_str("{}", &response);
ASSERT_NE(WF_GOOD, response.status);
ASSERT_NE(nullptr, response.error);
ASSERT_EQ(-1, response.id);
ASSERT_EQ(nullptr, response.result);
jsonrpc_response_cleanup(&response);
// no data
response_parse_str("{\"id\":42}", &response);
ASSERT_NE(WF_GOOD, response.status);
ASSERT_NE(nullptr, response.error);
ASSERT_EQ(42, response.id);
ASSERT_EQ(nullptr, response.result);
jsonrpc_response_cleanup(&response);
// custom error code
response_parse_str("{\"error\":{\"code\": 42}, \"id\": 42}", &response);
ASSERT_NE(WF_GOOD, response.status);
ASSERT_EQ(42, response.status);
ASSERT_NE(nullptr, response.error);
ASSERT_EQ(42, json_integer_value(json_object_get(response.error, "code")));
ASSERT_EQ(42, response.id);
ASSERT_EQ(nullptr, response.result);
jsonrpc_response_cleanup(&response);
// valid response
response_parse_str("{\"result\": true, \"id\": 42}", &response);
ASSERT_EQ(WF_GOOD, response.status);
ASSERT_EQ(WF_GOOD, response.error);
ASSERT_EQ(42, response.id);
ASSERT_NE(nullptr, response.result);
json_decref(response.result);
jsonrpc_response_cleanup(&response);
}

16
test/webfuse/tests/provider/test_client_protocol.cc
View File

@@ -15,6 +15,7 @@ using webfuse_test::MockProviderClient;
using webfuse_test::IProviderClient;
using testing::_;
using testing::AtMost;
using testing::Invoke;
namespace
{
@@ -24,10 +25,10 @@ class ClientProtocolFixture
ClientProtocolFixture(ClientProtocolFixture const &) = delete;
ClientProtocolFixture& operator=(ClientProtocolFixture const &) = delete;
public:
explicit ClientProtocolFixture(IProviderClient& client)
explicit ClientProtocolFixture(IProviderClient& client, bool enableAuthentication = false)
{
config = wfp_client_config_create();
client.AttachTo(config);
client.AttachTo(config, enableAuthentication);
protocol = wfp_client_protocol_create(config);
@@ -140,6 +141,13 @@ private:
wfp_client_protocol * protocol;
};
void GetCredentials(wfp_credentials * credentials)
{
wfp_credentials_set_type(credentials, "username");
wfp_credentials_add(credentials, "username", "bob");
wfp_credentials_add(credentials, "password", "secret");
}
}
TEST(client_protocol, connect)
@@ -161,11 +169,11 @@ TEST(client_protocol, connect)
TEST(client_protocol, connect_with_username_authentication)
{
MockProviderClient provider;
ClientProtocolFixture fixture(provider);
// ToDo: enable authentication
ClientProtocolFixture fixture(provider, true);
EXPECT_CALL(provider, OnConnected()).Times(AtMost(1));
EXPECT_CALL(provider, OnDisconnected()).Times(1);
EXPECT_CALL(provider, GetCredentials(_)).WillOnce(Invoke(GetCredentials)).Times(1);
fixture.Connect();
if (HasFatalFailure()) { return; }