chore(webfuse) Increase test coverage (#34)

* removes unnecessary code

* adds test of wf_status

* adds tests of wf_message

* adds tests of wf_message_queue

* changed branch of coverage badge to display correct results

* moves core tests into separate subdirectory

* increases coverage of timer test

* moves adapter specific tests into separate directory

* moves provider specific tests into separate directory

* adds tests of jsonrpc utilities

* adds tests of jsonrpc request

* adds test of jsonrpc response

* adds tests of jsonrpc server

* adds tests of jsonrpc proxy

* adds integration test (found some issues)

* disables problematic tests

* fixes resource leak: pending timer after cleanup proxy

* fixes order of cleanup to prevent processing pending requests after filesystem shut down

* fixes some memcheck and helgrind errors: initialization of lws_log; setup of client and server

* disabled a test

* fixes error in msleep utility

* fixes deadlock at IntegrationTest using valgrind

* removes unit test code from coverage report

* adds some integration tests

* makes badge show coverage of master

* fixes some coding style issues

* fixes eary trigger of is_connected (provider)

* fixes read error in 32 bit environments\n\ninode is always 64 bit, but variadic wf_impl_jsonrpc_proxy_invoke expects int

test/integration/provider.cc

@@ -0,0 +1,85 @@
+#include "integration/provider.hpp"
+#include "webfuse_provider.h"
+#include "webfuse/provider/impl/client.h"
+#include <thread>
+#include <mutex>
+#include <string>
+#include "msleep.hpp"
+
+namespace webfuse_test
+{
+
+class Provider::Private
+{
+public:
+    explicit Private(char const * url)
+    : is_shutdown_requested(false)
+    {
+        config = wfp_client_config_create();
+
+        fs = wfp_static_filesystem_create(config);
+        wfp_static_filesystem_add_text(fs, "hello.txt", 0444, "Hello, World");
+
+        client = wfp_client_create(config);
+        wfp_client_connect(client, url);
+        while (!wfp_impl_client_is_connected(client))
+        {
+            wfp_client_service(client, 100);
+        }
+       
+        thread = std::thread(Run, this);
+        webfuse_test::msleep(200);
+    }
+
+    ~Private()
+    {
+        RequestShutdown();
+        thread.join();
+
+        wfp_client_dispose(client);
+
+        wfp_static_filesystem_dispose(fs);
+        wfp_client_config_dispose(config);
+    }
+
+    bool IsShutdownRequested()
+    {
+        std::lock_guard<std::mutex> lock(shutdown_lock);
+        return is_shutdown_requested;
+    }
+private:
+    void RequestShutdown()
+    {
+        std::lock_guard<std::mutex> lock(shutdown_lock);
+        is_shutdown_requested = true;
+    }
+
+    static void Run(Provider::Private * context)
+    {
+        while (!context->IsShutdownRequested())
+        {
+            wfp_client_service(context->client, 100);
+        }
+    }
+
+    std::mutex shutdown_lock;
+    std::thread thread;
+    bool is_shutdown_requested;
+
+    wfp_client_config * config;
+    wfp_static_filesystem * fs;
+public:
+    wfp_client * client;
+};
+
+Provider::Provider(char const * url)
+: d(new Provider::Private(url))
+{
+}
+
+Provider::~Provider()
+{
+    delete d;
+}
+
+}

test/integration/provider.hpp

@@ -0,0 +1,19 @@
+#ifndef WF_TEST_INTEGRATION_PROVIDER
+#define WF_TEST_INTEGRATION_PROVIDER
+
+namespace webfuse_test
+{
+
+class Provider
+{
+public:
+    explicit Provider(char const * url);
+    ~Provider();
+private:
+    class Private;
+    Private * d;
+};
+
+}
+
+#endif

test/integration/server.cc

@@ -0,0 +1,99 @@
+#include "integration/server.hpp"
+#include <thread>
+#include <mutex>
+#include <cstdlib>
+#include <cstring>
+#include <unistd.h>
+#include "webfuse_adapter.h"
+#include "webfuse/adapter/impl/server.h"
+#include "msleep.hpp"
+
+#define WF_PATH_MAX (100)
+
+namespace webfuse_test
+{
+
+class Server::Private
+{
+public:
+    Private()
+    : is_shutdown_requested(false)
+    {
+        snprintf(base_dir, WF_PATH_MAX, "%s", "/tmp/webfuse_test_integration_XXXXXX");
+        mkdtemp(base_dir);
+
+        config = wf_server_config_create();
+        wf_server_config_set_port(config, 8080);
+        wf_server_config_set_mountpoint(config, base_dir);
+
+        server = wf_server_create(config);
+
+        while (!wf_impl_server_is_operational(server))
+        {
+            wf_server_service(server, 100);
+        }
+
+        thread = std::thread(Run, this);
+
+    }
+
+    ~Private()
+    {
+        RequestShutdown();
+        thread.join();
+        rmdir(base_dir);
+        wf_server_dispose(server);
+        wf_server_config_dispose(config);
+    }
+
+    bool IsShutdownRequested()
+    {
+        std::lock_guard<std::mutex> lock(shutdown_lock);
+        return is_shutdown_requested;
+    }
+
+private:
+    void RequestShutdown()
+    {
+        std::lock_guard<std::mutex> lock(shutdown_lock);
+        is_shutdown_requested = true;
+    }
+
+    static void Run(Server::Private * context)
+    {
+        while (!context->IsShutdownRequested())
+        {
+            wf_server_service(context->server, 100);
+        }
+    }
+
+
+    std::mutex shutdown_lock;
+    std::thread thread;
+    bool is_shutdown_requested;
+
+
+public:
+    char base_dir[WF_PATH_MAX];
+    wf_server_config * config;
+    wf_server * server;
+};
+
+Server::Server()
+: d(new Server::Private())
+{
+
+}
+
+Server::~Server()
+{
+    delete d;
+}
+
+char const * Server::GetBaseDir(void) const
+{
+    return d->base_dir;
+}
+
+
+}

test/integration/server.hpp

@@ -0,0 +1,22 @@
+#ifndef WF_TEST_INTEGRATION_SERVER_HPP
+#define WF_TEST_INTEGRATION_SERVER_HPP
+
+namespace webfuse_test
+{
+
+class Server
+{
+public:
+    Server();
+    ~Server();
+    void Start(void);
+    void Stop(void);
+    char const * GetBaseDir(void) const;
+private:
+    class Private;
+    Private * d;
+};
+
+}
+
+#endif

test/integration/test_integration.cc

@@ -0,0 +1,156 @@
+#include <gtest/gtest.h>
+#include "integration/server.hpp"
+#include "integration/provider.hpp"
+
+#include <cstdio>
+#include <csignal>
+#include <cstring>
+
+#include <string>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <dirent.h>
+
+#include <jansson.h>
+#include "webfuse/core/lws_log.h"
+#include "die_if.hpp"
+
+using webfuse_test::Server;
+using webfuse_test::Provider;
+using webfuse_test::die_if;
+
+namespace
+{
+    class IntegrationTest: public ::testing::Test
+    {
+        public:
+            IntegrationTest()
+            : server(nullptr)
+            , provider(nullptr)
+            {
+                json_object_seed(0);
+                wf_lwslog_disable();
+            }
+
+        protected:
+            void SetUp()
+            {
+                server = new Server();
+                provider = new Provider("ws://localhost:8080/");
+            }
+
+            void TearDown()
+            {
+                delete provider;
+                delete server;
+            }
+
+            char const * GetBaseDir() const
+            {
+                return server->GetBaseDir();
+            }
+        private:
+            Server * server;
+            Provider * provider;
+    };
+}
+
+TEST_F(IntegrationTest, HasMountpoint)
+{
+    struct stat buffer;
+    int rc = stat(GetBaseDir(), &buffer);
+
+    ASSERT_EQ(0, rc);
+    ASSERT_TRUE(S_ISDIR(buffer.st_mode));
+}
+
+TEST_F(IntegrationTest, ProvidesTextFile)
+{
+    std::string file_name = std::string(GetBaseDir()) + "/cprovider/default/hello.txt";
+
+    ASSERT_EXIT({
+        struct stat buffer;
+        int rc = stat(file_name.c_str(), &buffer);
+
+        die_if(0 != rc);
+        die_if(!S_ISREG(buffer.st_mode));
+        die_if(0444 != (buffer.st_mode & 0777));
+        die_if(12 != buffer.st_size);
+
+        exit(0);
+    }, ::testing::ExitedWithCode(0), ".*");      
+}
+
+TEST_F(IntegrationTest, ReadTextFile)
+{
+    std::string file_name = std::string(GetBaseDir()) + "/cprovider/default/hello.txt";
+
+    ASSERT_EXIT({
+        FILE * file = fopen(file_name.c_str(), "rb");
+        die_if(nullptr == file);
+
+        char buffer[13];
+        ssize_t count = fread(buffer, 1, 12, file);
+        int rc = fclose(file);
+
+        die_if(12 != count);
+        die_if(0 != strncmp("Hello, World", buffer, 12));
+        die_if(0 != rc);
+
+        exit(0);
+    }, ::testing::ExitedWithCode(0), ".*");      
+
+}
+
+TEST_F(IntegrationTest, ReadDir)
+{    
+    std::string dir_name = std::string(GetBaseDir()) + "/cprovider/default";
+
+    ASSERT_EXIT({
+
+        DIR * dir = opendir(dir_name.c_str());
+        die_if(nullptr == dir);
+
+        bool found_self = false;
+        bool found_parent = false;
+        bool found_hello_txt = false;
+        bool found_other = false;
+
+        dirent * entry = readdir(dir);
+        while (NULL != entry)
+        {
+            if (0 == strcmp(".", entry->d_name))
+            {
+                found_self = true;
+            }
+            else if (0 == strcmp("..", entry->d_name))
+            {
+                found_parent = true;
+            }
+            else if (0 == strcmp("hello.txt", entry->d_name))
+            {
+                found_hello_txt = true;
+            }
+            else
+            {
+                found_other = true;
+            }
+            
+
+            entry = readdir(dir);
+        }
+
+        closedir(dir);
+
+        die_if(!found_self);
+        die_if(!found_parent);
+        die_if(!found_hello_txt);
+
+        die_if(found_other);
+
+        exit(0);
+    }, ::testing::ExitedWithCode(0), ".*");      
+
+}