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

removed dependency to jansson

Browse Source
This commit is contained in:
Falk Werner
2020-07-12 11:09:50 +02:00
parent 59105c291e
commit df52f1b753
6 changed files with 174 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
test/webfuse_provider/provider/test_client.cc
View File

@@ -2,6 +2,8 @@
#include "webfuse_provider/test_util/webfuse_server.hpp"
#include "webfuse_provider/mocks/mock_provider_client.hpp"
#include "webfuse_provider/test_util/client.hpp"
#include "webfuse_provider/impl/json/parser.h"
#include "webfuse_provider/impl/json/node.h"
#include <gtest/gtest.h>
#include <future>
@@ -146,20 +148,22 @@ TEST(Client, Lookup)
ASSERT_EQ(std::future_status::ready, connected.get_future().wait_for(TIMEOUT));
json_t * response = server.Lookup(1, "foo");
ASSERT_TRUE(json_is_object(response));
json_t * result = json_object_get(response, "result");
std::string response_text = server.Lookup(1, "foo");
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char*>(response_text.data()));
wfp_json const * response = wfp_impl_json_root(doc);
ASSERT_TRUE(wfp_impl_json_is_object(response));
wfp_json const * result = wfp_impl_json_object_get(response, "result");
json_t * inode = json_object_get(result, "inode");
ASSERT_EQ(42, json_integer_value(inode));
wfp_json const * inode = wfp_impl_json_object_get(result, "inode");
ASSERT_EQ(42, wfp_impl_json_get_int(inode));
json_t * mode = json_object_get(result, "mode");
ASSERT_EQ(0644, json_integer_value(mode));
wfp_json const * mode = wfp_impl_json_object_get(result, "mode");
ASSERT_EQ(0644, wfp_impl_json_get_int(mode));
json_t * type = json_object_get(result, "type");
ASSERT_STREQ("file", json_string_value(type));
wfp_json const * type = wfp_impl_json_object_get(result, "type");
ASSERT_STREQ("file", wfp_impl_json_get_string(type));
json_decref(response);
wfp_impl_json_dispose(doc);
client.Disconnect();
ASSERT_EQ(std::future_status::ready, disconnected.get_future().wait_for(TIMEOUT));
@@ -194,14 +198,17 @@ TEST(Client, LookupFail)
ASSERT_EQ(std::future_status::ready, connected.get_future().wait_for(TIMEOUT));
json_t * response = server.Lookup(1, "foo");
ASSERT_TRUE(json_is_object(response));
json_t * error = json_object_get(response, "error");
std::string response_text = server.Lookup(1, "foo");
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char*>(response_text.data()));
wfp_json const * response = wfp_impl_json_root(doc);
json_t * code = json_object_get(error, "code");
ASSERT_NE(0, json_integer_value(code));
ASSERT_TRUE(wfp_impl_json_is_object(response));
wfp_json const * error = wfp_impl_json_object_get(response, "error");
json_decref(response);
wfp_json const * code = wfp_impl_json_object_get(error, "code");
ASSERT_NE(0, wfp_impl_json_get_int(code));
wfp_impl_json_dispose(doc);
client.Disconnect();
ASSERT_EQ(std::future_status::ready, disconnected.get_future().wait_for(TIMEOUT));
@@ -236,14 +243,17 @@ TEST(Client, Open)
ASSERT_EQ(std::future_status::ready, connected.get_future().wait_for(TIMEOUT));
json_t * response = server.Open(1, 0);
ASSERT_TRUE(json_is_object(response));
json_t * result = json_object_get(response, "result");
std::string response_text = server.Open(1, 0);
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char*>(response_text.data()));
wfp_json const * response = wfp_impl_json_root(doc);
json_t * handle = json_object_get(result, "handle");
ASSERT_EQ(4711, json_integer_value(handle));
ASSERT_TRUE(wfp_impl_json_is_object(response));
wfp_json const * result = wfp_impl_json_object_get(response, "result");
json_decref(response);
wfp_json const * handle = wfp_impl_json_object_get(result, "handle");
ASSERT_EQ(4711, wfp_impl_json_get_int(handle));
wfp_impl_json_dispose(doc);
client.Disconnect();
ASSERT_EQ(std::future_status::ready, disconnected.get_future().wait_for(TIMEOUT));
@@ -279,20 +289,23 @@ TEST(Client, Read)
ASSERT_EQ(std::future_status::ready, connected.get_future().wait_for(TIMEOUT));
json_t * response = server.Read(42, 5, 0, 1);
ASSERT_TRUE(json_is_object(response));
json_t * result = json_object_get(response, "result");
std::string response_text = server.Read(42, 5, 0, 1);
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char*>(response_text.data()));
wfp_json const * response = wfp_impl_json_root(doc);
json_t * format = json_object_get(result, "format");
ASSERT_STREQ("base64", json_string_value(format));
ASSERT_TRUE(wfp_impl_json_is_object(response));
wfp_json const * result = wfp_impl_json_object_get(response, "result");
json_t * count = json_object_get(result, "count");
ASSERT_EQ(1, json_integer_value(count));
wfp_json const * format = wfp_impl_json_object_get(result, "format");
ASSERT_STREQ("base64", wfp_impl_json_get_string(format));
json_t * data = json_object_get(result, "data");
ASSERT_STREQ("Kg==", json_string_value(data));
wfp_json const * count = wfp_impl_json_object_get(result, "count");
ASSERT_EQ(1, wfp_impl_json_get_int(count));
json_decref(response);
wfp_json const * data = wfp_impl_json_object_get(result, "data");
ASSERT_STREQ("Kg==", wfp_impl_json_get_string(data));
wfp_impl_json_dispose(doc);
client.Disconnect();
ASSERT_EQ(std::future_status::ready, disconnected.get_future().wait_for(TIMEOUT));
@@ -329,14 +342,17 @@ TEST(Client, ReadDir)
ASSERT_EQ(std::future_status::ready, connected.get_future().wait_for(TIMEOUT));
json_t * response = server.ReadDir(42);
ASSERT_TRUE(json_is_object(response));
json_t * result = json_object_get(response, "result");
std::string response_text = server.ReadDir(42);
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char*>(response_text.data()));
wfp_json const * response = wfp_impl_json_root(doc);
ASSERT_TRUE(json_is_array(result));
ASSERT_EQ(3, json_array_size(result));
ASSERT_TRUE(wfp_impl_json_is_object(response));
wfp_json const * result = wfp_impl_json_object_get(response, "result");
json_decref(response);
ASSERT_TRUE(wfp_impl_json_is_array(result));
ASSERT_EQ(3, wfp_impl_json_array_size(result));
wfp_impl_json_dispose(doc);
client.Disconnect();
ASSERT_EQ(std::future_status::ready, disconnected.get_future().wait_for(TIMEOUT));

121
test/webfuse_provider/provider/test_client_protocol.cc
View File

@@ -7,12 +7,14 @@
#include "webfuse_provider/mocks/mock_provider_client.hpp"
#include "webfuse_provider/protocol_names.h"
#include "webfuse_provider/test_util/timeout_watcher.hpp"
#include "webfuse_provider/impl/json/parser.h"
#include "webfuse_provider/impl/json/node.h"
#include <libwebsockets.h>
#include <cstring>
#include <sstream>
#include <thread>
#include <atomic>
using webfuse_test::WsServer;
using webfuse_test::MockProviderClient;
@@ -77,16 +79,16 @@ public:
wfp_client_protocol_disconnect(protocol);
}
void SendToClient(json_t * request)
void SendToClient(std::string const & request)
{
server->SendMessage(request);
}
json_t * ReceiveMessageFromClient()
std::string ReceiveMessageFromClient()
{
TimeoutWatcher watcher(DEFAULT_TIMEOUT);
json_t * result = server->ReceiveMessage();
while (nullptr == result)
std::string result = server->ReceiveMessage();
while (result.empty())
{
watcher.check();
lws_service(context, 0);
@@ -100,73 +102,71 @@ public:
std::string const & expected_username,
std::string const & expected_password)
{
json_t * request = ReceiveMessageFromClient();
ASSERT_TRUE(json_is_object(request));
std::string request_text = ReceiveMessageFromClient();
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char *>(request_text.data()));
wfp_json const * request = wfp_impl_json_root(doc);
ASSERT_TRUE(wfp_impl_json_is_object(request));
json_t * method = json_object_get(request, "method");
ASSERT_TRUE(json_is_string(method));
ASSERT_STREQ("authenticate", json_string_value(method));
wfp_json const * method = wfp_impl_json_object_get(request, "method");
ASSERT_TRUE(wfp_impl_json_is_string(method));
ASSERT_STREQ("authenticate", wfp_impl_json_get_string(method));
json_t * id = json_object_get(request, "id");
ASSERT_TRUE(json_is_integer(id));
wfp_json const * id = wfp_impl_json_object_get(request, "id");
ASSERT_TRUE(wfp_impl_json_is_int(id));
json_t * params = json_object_get(request, "params");
ASSERT_TRUE(json_is_array(params));
ASSERT_EQ(2, json_array_size(params));
wfp_json const * params = wfp_impl_json_object_get(request, "params");
ASSERT_TRUE(wfp_impl_json_is_array(params));
ASSERT_EQ(2, wfp_impl_json_array_size(params));
json_t * type = json_array_get(params, 0);
ASSERT_TRUE(json_is_string(type));
ASSERT_STREQ("username", json_string_value(type));
wfp_json const * type = wfp_impl_json_array_get(params, 0);
ASSERT_TRUE(wfp_impl_json_is_string(type));
ASSERT_STREQ("username", wfp_impl_json_get_string(type));
json_t * credentials = json_array_get(params, 1);
ASSERT_TRUE(json_is_object(credentials));
wfp_json const * credentials = wfp_impl_json_array_get(params, 1);
ASSERT_TRUE(wfp_impl_json_is_object(credentials));
json_t * username = json_object_get(credentials, "username");
ASSERT_TRUE(json_is_string(username));
ASSERT_STREQ(expected_username.c_str(), json_string_value(username));
wfp_json const * username = wfp_impl_json_object_get(credentials, "username");
ASSERT_TRUE(wfp_impl_json_is_string(username));
ASSERT_STREQ(expected_username.c_str(), wfp_impl_json_get_string(username));
json_t * password = json_object_get(credentials, "password");
ASSERT_TRUE(json_is_string(password));
ASSERT_STREQ(expected_password.c_str(), json_string_value(password));
wfp_json const * password = wfp_impl_json_object_get(credentials, "password");
ASSERT_TRUE(wfp_impl_json_is_string(password));
ASSERT_STREQ(expected_password.c_str(), wfp_impl_json_get_string(password));
json_t * response = json_object();
json_object_set_new(response, "result", json_object());
json_object_set(response, "id", id);
SendToClient(response);
std::ostringstream response;
response << "{\"result\": {}, \"id\": " << wfp_impl_json_get_int(id) << "}";
SendToClient(response.str());
json_decref(request);
wfp_impl_json_dispose(doc);
}
void AwaitAddFilesystem(std::string& filesystemName)
{
json_t * addFilesystemRequest = ReceiveMessageFromClient();
ASSERT_NE(nullptr, addFilesystemRequest);
ASSERT_TRUE(json_is_object(addFilesystemRequest));
std::string request_text = ReceiveMessageFromClient();
wfp_json_doc * doc = wfp_impl_json_parse(const_cast<char *>(request_text.data()));
wfp_json const * request = wfp_impl_json_root(doc);
ASSERT_TRUE(wfp_impl_json_is_object(request));
json_t * method = json_object_get(addFilesystemRequest, "method");
ASSERT_TRUE(json_is_string(method));
ASSERT_STREQ("add_filesystem", json_string_value(method));
wfp_json const * method = wfp_impl_json_object_get(request, "method");
ASSERT_TRUE(wfp_impl_json_is_string(method));
ASSERT_STREQ("add_filesystem", wfp_impl_json_get_string(method));
json_t * params = json_object_get(addFilesystemRequest, "params");
ASSERT_TRUE(json_is_array(params));
ASSERT_EQ(1, json_array_size(params));
wfp_json const * params = wfp_impl_json_object_get(request, "params");
ASSERT_TRUE(wfp_impl_json_is_array(params));
ASSERT_EQ(1, wfp_impl_json_array_size(params));
json_t * filesystem = json_array_get(params, 0);
ASSERT_TRUE(json_is_string(filesystem));
filesystemName = json_string_value(filesystem);
wfp_json const * filesystem = wfp_impl_json_array_get(params, 0);
ASSERT_TRUE(wfp_impl_json_is_string(filesystem));
json_t * id = json_object_get(addFilesystemRequest, "id");
ASSERT_TRUE(json_is_integer(id));
wfp_json const * id = wfp_impl_json_object_get(request, "id");
ASSERT_TRUE(wfp_impl_json_is_int(id));
json_t * response = json_object();
json_t * result = json_object();
json_object_set(result, "id", filesystem);
json_object_set_new(response, "result", result);
json_object_set(response, "id", id);
std::ostringstream response;
response << "{\"result\": {\"id\": \"" << wfp_impl_json_get_string(filesystem) << "\"}, \"id\": " << wfp_impl_json_get_int(id) << "}";
SendToClient(response);
SendToClient(response.str());
json_decref(addFilesystemRequest);
wfp_impl_json_dispose(doc);
}
private:
@@ -250,19 +250,12 @@ TEST(client_protocol, getattr)
fixture.AwaitAddFilesystem(filesystem);
if (HasFatalFailure()) { return; }
json_t * params = json_array();
json_array_append_new(params, json_string(filesystem.c_str()));
json_array_append_new(params, json_integer(1));
json_t * request = json_object();
json_object_set_new(request, "method", json_string("getattr"));
json_object_set_new(request, "params", params);
json_object_set_new(request, "id", json_integer(42));
std::ostringstream request;
request << "{\"method\": \"getattr\", \"params\": [\"" << filesystem << "\", 1], \"id\": 42}";
fixture.SendToClient(request);
json_t * response = fixture.ReceiveMessageFromClient();
ASSERT_TRUE(json_is_object(response));
json_decref(response);
fixture.SendToClient(request.str());
std::string response = fixture.ReceiveMessageFromClient();
ASSERT_FALSE(response.empty());
fixture.Disconnect();
}