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

chore: re-enabled unit tests

Browse Source
This commit is contained in:
Falk Werner
2020-07-12 13:06:00 +02:00
parent df52f1b753
commit 7d4f6a3d55
10 changed files with 190 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
test/webfuse_provider/mocks/mock_request.cc
View File

@@ -1,33 +1,61 @@
#include "webfuse_provider/mocks/mock_request.hpp"
#include "webfuse_provider/impl/json/parser.h"
#include "webfuse_provider/impl/message.h"
#include "webfuse_provider/impl/message_writer.h"
#include "webfuse_provider/status.h"
#include <cstdlib>
extern "C"
{
static void webfuse_test_MockRequest_respond(
json_t * response,
struct wfp_message * response,
void * user_data)
{
auto * request = reinterpret_cast<webfuse_test::MockRequest*>(user_data);
json_t * result = json_object_get(response, "result");
json_t * error = json_object_get(response, "error");
json_t * id_holder = json_object_get(response, "id");
int error_code = WFP_BAD;
int id = -1;
if (json_is_integer(id_holder))
wfp_json_doc * doc = wfp_impl_json_parse_buffer(response->data, response->length);
if (NULL != doc)
{
id = json_integer_value(id_holder);
wfp_json const * response = wfp_impl_json_root(doc);
wfp_json const * result = wfp_impl_json_object_get(response, "result");
wfp_json const * id_holder = wfp_impl_json_object_get(response, "id");
if (wfp_impl_json_is_int(id_holder))
{
id = wfp_impl_json_get_int(id_holder);
}
if (nullptr != result)
{
error_code = WFP_GOOD;
request->respond(result, id);
}
else
{
wfp_json const * error = wfp_impl_json_object_get(response, "error");
if (wfp_impl_json_is_object(error))
{
wfp_json const * error_code_holder = wfp_impl_json_object_get(response, "error");
if (wfp_impl_json_is_int(error_code_holder))
{
error_code = wfp_impl_json_get_int(error_code_holder);
}
}
}
wfp_impl_json_dispose(doc);
}
if (nullptr != result)
if (WFP_GOOD != error_code)
{
request->respond(result, id);
}
else
{
request->respond_error(error, id);
request->respond_error(error_code, id);
}
wfp_message_dispose(response);
}
}
@@ -41,6 +69,7 @@ struct wfp_request * MockRequest::create_request(int id)
request->respond = &webfuse_test_MockRequest_respond;
request->user_data = reinterpret_cast<void*>(this);
request->id = id;
request->writer = wfp_impl_message_writer_create(id);
return request;
}

69
test/webfuse_provider/mocks/mock_request.hpp
View File

@@ -1,10 +1,10 @@
#ifndef WFP_MOCK_REQUEST_HPP
#define WFP_MOCK_REQUEST_HPP
#include <gmock/gmock.h>
#include <jansson.h>
#include <cstring>
#include "webfuse_provider/impl/request.h"
#include "webfuse_provider/impl/json/node.h"
#include <gmock/gmock.h>
#include <cstring>
namespace webfuse_test
@@ -14,28 +14,28 @@ class MockRequest
{
public:
struct wfp_request * create_request(int id);
MOCK_METHOD2(respond, void(json_t * result, int id));
MOCK_METHOD2(respond_error, void(json_t * error, int id));
MOCK_METHOD2(respond, void(wfp_json const * result, int id));
MOCK_METHOD2(respond_error, void(int error_code, int id));
};
MATCHER_P3(StatMatcher, inode, mode, file_type, "")
{
json_t * inode_holder = json_object_get(arg, "inode");
if ((!json_is_integer(inode_holder)) || (inode != json_integer_value(inode_holder)))
wfp_json const * inode_holder = wfp_impl_json_object_get(arg, "inode");
if ((!wfp_impl_json_is_int(inode_holder)) || (inode != wfp_impl_json_get_int(inode_holder)))
{
*result_listener << "missing inode";
return false;
}
json_t * mode_holder = json_object_get(arg, "mode");
if ((!json_is_integer(mode_holder)) || (mode != json_integer_value(mode_holder)))
wfp_json const * mode_holder = wfp_impl_json_object_get(arg, "mode");
if ((!wfp_impl_json_is_int(mode_holder)) || (mode != wfp_impl_json_get_int(mode_holder)))
{
*result_listener << "missing mode";
return false;
}
json_t * type_holder = json_object_get(arg, "type");
if ((!json_is_string(type_holder)) || (0 != strcmp(file_type, json_string_value(type_holder))))
wfp_json const * type_holder = wfp_impl_json_object_get(arg, "type");
if ((!wfp_impl_json_is_string(type_holder)) || (0 != strcmp(file_type, wfp_impl_json_get_string(type_holder))))
{
*result_listener << "missing type";
return false;
@@ -46,8 +46,8 @@ MATCHER_P3(StatMatcher, inode, mode, file_type, "")
MATCHER_P(OpenMatcher, handle, "")
{
json_t * handle_holder = json_object_get(arg, "handle");
if ((!json_is_integer(handle_holder)) || (handle != json_integer_value(handle_holder)))
wfp_json const * handle_holder = wfp_impl_json_object_get(arg, "handle");
if ((!wfp_impl_json_is_int(handle_holder)) || (handle != wfp_impl_json_get_int(handle_holder)))
{
*result_listener << "missing handle";
return false;
@@ -58,24 +58,24 @@ MATCHER_P(OpenMatcher, handle, "")
MATCHER_P3(ReadResultMatcher, data, format, count, "")
{
json_t * format_holder = json_object_get(arg, "format");
if ((!json_is_string(format_holder)) || (0 != strcmp(format, json_string_value(format_holder))))
wfp_json const * format_holder = wfp_impl_json_object_get(arg, "format");
if ((!wfp_impl_json_is_string(format_holder)) || (0 != strcmp(format, wfp_impl_json_get_string(format_holder))))
{
*result_listener << "invalid or missing format: " << json_string_value(format_holder);
*result_listener << "invalid or missing format: " << wfp_impl_json_get_string(format_holder);
return false;
}
json_t * count_holder = json_object_get(arg, "count");
if ((!json_is_integer(count_holder)) || (count != json_integer_value(count_holder)))
wfp_json const * count_holder = wfp_impl_json_object_get(arg, "count");
if ((!wfp_impl_json_is_int(count_holder)) || (count != wfp_impl_json_get_int(count_holder)))
{
*result_listener << "invalid or missing count: " << json_integer_value(count_holder);
*result_listener << "invalid or missing count: " << wfp_impl_json_get_int(count_holder);
return false;
}
json_t * data_holder = json_object_get(arg, "data");
if ((!json_is_string(data_holder)) || (0 != strcmp(data, json_string_value(data_holder))))
wfp_json const * data_holder = wfp_impl_json_object_get(arg, "data");
if ((!wfp_impl_json_is_string(data_holder)) || (0 != strcmp(data, wfp_impl_json_get_string(data_holder))))
{
*result_listener << "invalid or missing data: " << json_string_value(data_holder);
*result_listener << "invalid or missing data: " << wfp_impl_json_get_string(data_holder);
return false;
}
@@ -84,28 +84,26 @@ MATCHER_P3(ReadResultMatcher, data, format, count, "")
MATCHER_P(ReaddirMatcher, contained_elements , "")
{
if (!json_is_array(arg))
if (!wfp_impl_json_is_array(arg))
{
*result_listener << "result is not array";
return false;
}
{
size_t i;
json_t * value;
json_array_foreach(arg, i, value)
for(size_t i = 0; i < wfp_impl_json_array_size(arg); i++)
{
json_t * inode = json_object_get(value, "inode");
json_t * name = json_object_get(value, "name");
wfp_json const * value = wfp_impl_json_array_get(arg, i);
wfp_json const * inode = wfp_impl_json_object_get(value, "inode");
wfp_json const * name = wfp_impl_json_object_get(value, "name");
if(!json_is_integer(inode))
if(!wfp_impl_json_is_int(inode))
{
*result_listener << "invalid result: missing inode";
return false;
}
if (!json_is_string(name))
if (!wfp_impl_json_is_string(name))
{
*result_listener << "invalid result: missing name";
return false;
@@ -117,14 +115,13 @@ MATCHER_P(ReaddirMatcher, contained_elements , "")
{
char const * element = contained_elements[i];
bool found = false;
size_t j;
json_t * value;
json_array_foreach(arg, j, value)
for(size_t j = 0; j < wfp_impl_json_array_size(arg); j++)
{
json_t * name = json_object_get(value, "name");
wfp_json const * value = wfp_impl_json_array_get(arg, j);
wfp_json const * name = wfp_impl_json_object_get(value, "name");
found = (0 == strcmp(element, json_string_value(name)));
found = (0 == strcmp(element, wfp_impl_json_get_string(name)));
if (found)
{
break;