parse filesystem info

test/mock_config_builder.cc

@@ -55,7 +55,17 @@ wfd_MockConfigBuilder_add_auth_provider(
     struct wfd_auth_settings * settings)
 {
     auto * builder = reinterpret_cast<IConfigBuilder*>(data);
-    builder->addAuthProvider(settings);
+    return builder->addAuthProvider(settings);
+}
+
+static bool
+wfd_MockConfigBuilder_add_filesystem(
+    void * data,
+    char const * name,
+    char const * mountpoint)
+{
+    auto * builder = reinterpret_cast<IConfigBuilder*>(data);
+    return builder->addFilesystem(name, mountpoint);
 }
 
 
@@ -66,7 +76,8 @@ static const wfd_config_builder_vtable wfd_MockConfigBuilder_vtable =
     &wfd_MockConfigBuilder_set_server_key,
     &wfd_MockConfigBuilder_set_server_cert,
     &wfd_MockConfigBuilder_set_server_document_root,
-    &wfd_MockConfigBuilder_add_auth_provider
+    &wfd_MockConfigBuilder_add_auth_provider,
+    &wfd_MockConfigBuilder_add_filesystem
 };
 
 }

test/mock_config_builder.hpp

@@ -17,6 +17,7 @@ public:
     virtual void setServerCert(char const * cert_path) = 0;
     virtual void setServerDocumentRoot(char const * document_root) = 0;
     virtual bool addAuthProvider(wfd_auth_settings * settings) = 0;
+    virtual bool addFilesystem(char const * name, char const * mountpoint) = 0;
 };
 
 class MockConfigBuilder: public IConfigBuilder
@@ -29,6 +30,7 @@ public:
     MOCK_METHOD1(setServerCert, void (char const * cert_path));
     MOCK_METHOD1(setServerDocumentRoot, void (char const * document_root));
     MOCK_METHOD1(addAuthProvider, bool (wfd_auth_settings * settings));
+    MOCK_METHOD2(addFilesystem, bool (char const * name, char const * mountpoint));
 
     struct wfd_config_builder getBuilder();
 };

test/test_config.cc

@@ -2,6 +2,12 @@
 #include "webfused/config/config.h"
 #include "mock_auth_settings.hpp"
 
+#include "webfused/log/logger.h"
+#include "webfused/log/log.h"
+#include "mock_logger.hpp"
+using ::webfused_test::MockLogger;
+using ::testing::_;
+
 using ::webfused_test::MockAuthSettings;
 using ::testing::Return;
 using ::testing::StrEq;
@@ -74,5 +80,18 @@ TEST(config, auth_config_failed_to_add_unknown_provider)
     bool success = wfd_config_builder_add_auth_provider(builder, nullptr);
     ASSERT_FALSE(success);
 
+    wfd_config_dispose(config);
+}
+
+TEST(config, add_filesystem)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    wfd_config_builder builder = wfd_config_get_builder(config);
+
+    bool success = wfd_config_builder_add_filesystem(builder, "test", "/tmp/test");
+    ASSERT_TRUE(success);
+
     wfd_config_dispose(config);
 }

test/test_config_factory.cc

@@ -20,6 +20,7 @@ TEST(config, is_loadable)
     EXPECT_CALL(builder, setServerVhostname(StrEq("localhost"))).Times(1);
     EXPECT_CALL(builder, setServerPort(8080)).Times(1);
     EXPECT_CALL(builder, addAuthProvider(_)).Times(1).WillOnce(Return(true));
+    EXPECT_CALL(builder, addFilesystem(_,_)).Times(1).WillOnce(Return(true));
 
     bool result = wfd_config_load_file(builder.getBuilder(), "webfused.conf");
     ASSERT_TRUE(result);
@@ -333,3 +334,102 @@ TEST(config, failed_missing_auth_settings)
     bool result = wfd_config_load_string(builder.getBuilder(), config_text);
     ASSERT_FALSE(result);
 }
+
+TEST(config, filesystems)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(1).WillOnce(Return(true));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
+        ")\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_TRUE(result);
+}
+
+TEST(config, filesystems_empty)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        ")\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_TRUE(result);
+}
+
+TEST(config, filesystems_failed_add)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(1).WillOnce(Return(false));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
+        ")\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}
+
+TEST(config, filesystems_failed_missing_name)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {mount_point = \"/tmp/test\" }\n"
+        ")\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}
+
+TEST(config, filesystems_failed_missing_mountpoint)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\"}\n"
+        ")\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}

test/test_mountpoint_factory.cc

@@ -0,0 +1,135 @@
+#include <gtest/gtest.h>
+#include "webfused/mountpoint_factory.h"
+#include <webfuse/adapter/mountpoint.h>
+
+#include <cstring>
+
+TEST(mountpoint_factory, create)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, add_filesystem)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    ASSERT_TRUE(success);
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, add_filesystem_fail_to_add_twice)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    ASSERT_TRUE(success);
+
+    success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfused_test");
+    ASSERT_FALSE(success);
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, add_filesystem_multi)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+
+    for (size_t i = 0; i < 24; i++)
+    {
+        char name[10];
+        snprintf(name, 10, "test_%zu", i);
+        bool success = wfd_mountpoint_factory_add_filesystem(factory, name, "/tmp/webfused_test");
+        ASSERT_TRUE(success) << i;
+    }
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, add_filesystem_fail_invalid_path)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/do/not/allow/nested/paths");
+    ASSERT_FALSE(success);
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, create_mountpoint)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    ASSERT_TRUE(success);
+
+    wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
+    ASSERT_NE(nullptr, mountpoint);
+    ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint));
+
+    wf_mountpoint_dispose(mountpoint);
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, create_mountpoint_fail_already_in_use)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    ASSERT_TRUE(success);
+
+    wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
+    ASSERT_NE(nullptr, mountpoint);
+    ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint));
+
+    wf_mountpoint * mountpoint2 = wfd_mountpoint_factory_create_mountpoint("test", factory);
+    ASSERT_EQ(nullptr, mountpoint2);
+
+    wf_mountpoint_dispose(mountpoint);
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, create_mountpoint_fail_unknown_filesystem)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    ASSERT_TRUE(success);
+
+    wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("unkown", factory);
+    ASSERT_EQ(nullptr, mountpoint);
+
+    wfd_mountpoint_factory_dispose(factory);
+}
+
+TEST(mountpiont_factory, create_mountpoint_multi)
+{
+    wfd_mountpoint_factory * factory = wfd_mountpoint_factory_create();
+    ASSERT_NE(nullptr, factory);
+
+    bool success = wfd_mountpoint_factory_add_filesystem(factory, "test", "/tmp/webfuse_test");
+    ASSERT_TRUE(success);
+
+    for(int i = 0; i < 5; i++)
+    {
+        wf_mountpoint * mountpoint = wfd_mountpoint_factory_create_mountpoint("test", factory);
+        ASSERT_NE(nullptr, mountpoint) << i;
+        ASSERT_STREQ("/tmp/webfuse_test", wf_mountpoint_get_path(mountpoint)) << i;
+
+        wf_mountpoint_dispose(mountpoint);
+    }
+ 
+    wfd_mountpoint_factory_dispose(factory);
+}