refactored tests

test/config/config.cc

@@ -0,0 +1,107 @@
+#include <gtest/gtest.h>
+#include "webfused/config/config.h"
+#include "webfused/config/config_intern.h"
+#include "mock/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::MockSettings;
+using ::testing::Return;
+using ::testing::StrEq;
+
+TEST(config, server_config)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    wfd_config_set_server_vhostname(config, "localhost");
+    wfd_config_set_server_port(config, 8443);
+    wfd_config_set_server_key(config, "/path/to/key.pem");
+    wfd_config_set_server_cert(config, "/path/to/cert.pem");
+    wfd_config_set_server_document_root(config, "/var/www");
+
+    wf_server_config * server_config = wfd_config_get_server_config(config);
+    ASSERT_NE(nullptr, server_config);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, auth_config)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    MockSettings settings;
+    EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
+
+    bool success = wfd_config_add_auth_provider(config, "file", nullptr);
+    ASSERT_TRUE(success);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, auth_config_failed_to_add_second_provider)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    MockSettings settings;
+    EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
+
+    bool success = wfd_config_add_auth_provider(config, "file", nullptr);
+    ASSERT_TRUE(success);
+
+    success = wfd_config_add_auth_provider(config, "file", nullptr);
+    ASSERT_FALSE(success);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, auth_config_failed_to_add_unknown_provider)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    bool success = wfd_config_add_auth_provider(config, "unknown", nullptr);
+    ASSERT_FALSE(success);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, add_filesystem)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    bool success = wfd_config_add_filesystem(config, "test", "/tmp/test");
+    ASSERT_TRUE(success);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, set_logger)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    bool success = wfd_config_set_logger(config, "stderr", WFD_LOGLEVEL_ALL, nullptr);
+    ASSERT_TRUE(success);
+
+    wfd_config_dispose(config);
+}
+
+TEST(config, do_set_user)
+{
+    wfd_config * config = wfd_config_create();
+    ASSERT_NE(nullptr, config);
+
+    wfd_config_set_user(config, "some.user", "some.group");
+    ASSERT_STREQ("some.user", wfd_config_get_user(config));
+    ASSERT_STREQ("some.group", wfd_config_get_group(config));
+
+    wfd_config_dispose(config);
+}

test/config/factory.cc

@@ -0,0 +1,711 @@
+#include <gtest/gtest.h>
+
+#include "webfused/config/factory.h"
+#include "webfused/log/logger.h"
+#include "webfused/log/log.h"
+#include "mock/logger.hpp"
+#include "mock/config_builder.hpp"
+#include "mock/libconfig.hpp"
+
+using ::testing::_;
+using ::testing::Return;
+using ::testing::StrictMock;
+using ::testing::StrEq;
+using ::webfused_test::MockLogger;
+using ::webfused_test::MockConfigBuilder;
+using ::webfused_test::MockLibConfig;
+
+TEST(config, is_loadable)
+{
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setLogger(_,_,_)).Times(1).WillOnce(Return(true));
+    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));
+
+    struct wfd_config * config = wfd_config_load_file("webfused.conf");
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, minimal_config)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+
+    char const minimal[] = "version = { major = 1, minor = 0 }\n";
+    struct wfd_config * config = wfd_config_load_string(minimal);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, invalid_config)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(0);
+    EXPECT_CALL(builder, dispose(_)).Times(0);
+
+    char const syntax_error[] = "version.major = 1\n";
+
+    wfd_config * config = wfd_config_load_string(syntax_error);
+    ASSERT_EQ(nullptr, config);    
+}
+
+TEST(config, invalid_config_file)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(0);
+    EXPECT_CALL(builder, dispose(_)).Times(0);
+
+    struct wfd_config * config = wfd_config_load_file("invalid.conf");
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, invalid_major_version_too_low)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const too_low[] = "version = { major = 0, minor = 0 }\n";
+
+    struct wfd_config * config= wfd_config_load_string(too_low);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, invalid_major_version_too_high)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const too_high[] = "version = { major = 2, minor = 0 }\n";
+
+    struct wfd_config * config = wfd_config_load_string(too_high);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, invalid_missing_major_version)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const too_high[] = "version = { minor = 0 }\n";
+
+    struct wfd_config * config = wfd_config_load_string(too_high);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, invalid_missing_minor_version)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const too_high[] = "version = { major = 1 }\n";
+
+    struct wfd_config * config = wfd_config_load_string(too_high);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, valid_older_minor)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_INFO, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+    
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+
+    char const valid[] = "version = { major = 1, minor = -1 }\n";
+
+    struct wfd_config * config = wfd_config_load_string(valid);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, valid_newer_minor)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_WARN, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+
+    char const valid[] = "version = { major = 1, minor = 1 }\n";
+
+    struct wfd_config * config = wfd_config_load_string(valid);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, vhost_name)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setServerVhostname(StrEq("some.host"))).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "server:\n"
+        "{\n"
+        "  vhost_name = \"some.host\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, port)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setServerPort(54321)).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "server:\n"
+        "{\n"
+        "  port = 54321\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, tls_certificate)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;    
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setServerCert(StrEq("/path/to/cert.pem"))).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "server:\n"
+        "{\n"
+        "  tls:\n"
+        "  {\n"
+        "    certificate = \"/path/to/cert.pem\"\n"
+        "  }\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, tls_key)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;    
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setServerKey(StrEq("/path/to/key.pem"))).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "server:\n"
+        "{\n"
+        "  tls:\n"
+        "  {\n"
+        "    key = \"/path/to/key.pem\"\n"
+        "  }\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, document_root)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setServerDocumentRoot(StrEq("/var/www"))).Times(1);    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "server:\n"
+        "{\n"
+        "  document_root = \"/var/www\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, authentication)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, addAuthProvider(_, _)).Times(1).WillOnce(Return(true));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "(\n"
+        "  {\n"
+        "    provider = \"test\"\n"
+        "    settings: { }\n"
+        "  }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, failed_create_authenticator)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, addAuthProvider(_, _)).Times(1).WillOnce(Return(false));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "(\n"
+        "  {\n"
+        "    provider = \"test\"\n"
+        "    settings: { }\n"
+        "  }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, failed_missing_auth_provider)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "(\n"
+        "  {\n"
+        "    settings: { }\n"
+        "  }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, failed_missing_auth_settings)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "(\n"
+        "  {\n"
+        "    provider = \"test\"\n"
+        "  }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, failed_auth_settings_get_elem)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+
+    MockLibConfig libconfig;
+    EXPECT_CALL(libconfig, config_setting_get_elem(_,_)).Times(1).WillOnce(Return(nullptr));
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "(\n"
+        "  {\n"
+        "    provider = \"test\"\n"
+        "    settings: { }\n"
+        "  }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, filesystems)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    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"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, filesystems_empty)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+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, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    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"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+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, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    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"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+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, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\"}\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, filesystems_failed_missing_elem)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, addFilesystem(_, _)).Times(0);
+
+    MockLibConfig libconfig;
+    EXPECT_CALL(libconfig, config_setting_get_elem(_,_)).Times(1).WillOnce(Return(nullptr));
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "filesystems:\n"
+        "(\n"
+        "  {name = \"foo\", mount_point = \"/tmp/test\" }\n"
+        ")\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, log)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setLogger(_, _, _)).Times(1).WillOnce(Return(true));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "log:\n"
+        "{\n"
+        "  provider = \"stderr\"\n"
+        "  level    = \"all\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, log_fail_set_logger)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setLogger(_, _, _)).Times(1).WillOnce(Return(false));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "log:\n"
+        "{\n"
+        "  provider = \"stderr\"\n"
+        "  level    = \"all\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, log_fail_missing_provider)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "log:\n"
+        "{\n"
+        "  level    = \"all\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, log_fail_missing_level)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "log:\n"
+        "{\n"
+        "  provider = \"stderr\"\n"
+        "  level    = \"fancy\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, log_fail_invalid_level)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setLogger(_, _, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "log:\n"
+        "{\n"
+        "  provider = \"stderr\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, set_user)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, setUser(_, _)).Times(1);   
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "user:\n"
+        "{\n"
+        "  name  = \"webfused\"\n"
+        "  group = \"webfused\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_NE(nullptr, config);
+}
+
+TEST(config, set_user_fail_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, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setUser(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "user:\n"
+        "{\n"
+        "  group = \"webfused\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}
+
+TEST(config, set_user_fail_missing_group)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, create).Times(1).WillOnce(Return(builder.getBuilder()));
+    EXPECT_CALL(builder, dispose(_)).Times(1);
+    EXPECT_CALL(builder, setUser(_, _)).Times(0);
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "user:\n"
+        "{\n"
+        "  name = \"webfused\"\n"
+        "}\n"
+        ;
+    struct wfd_config * config = wfd_config_load_string(config_text);
+    ASSERT_EQ(nullptr, config);
+}

test/config/settings.cc

@@ -0,0 +1,90 @@
+#include <gtest/gtest.h>
+#include "webfused/config/settings_intern.h"
+#include "webfused/config/settings.h"
+#include <libconfig.h>
+
+TEST(settings, get_string)
+{
+    char const settings_text[] =
+        "settings:\n"
+        "{\n"
+        "  string_value = \"some.string\"\n"
+        "  int_value    = 42\n"
+        "}\n"
+        ;
+    config_t config;
+    config_init(&config);
+    int rc = config_read_string(&config, settings_text);
+    ASSERT_TRUE(CONFIG_TRUE == rc);
+
+    config_setting_t * setting = config_lookup(&config, "settings");
+    ASSERT_NE(nullptr, setting);
+
+    wfd_settings settings;
+    wfd_settings_init(&settings, setting);
+    ASSERT_STREQ("some.string", wfd_settings_get_string(&settings, "string_value"));
+    ASSERT_EQ(nullptr, wfd_settings_get_string(&settings, "int_value"));
+    ASSERT_EQ(nullptr, wfd_settings_get_string(&settings, "invalid_value"));
+    ASSERT_EQ(nullptr, wfd_settings_get_string(NULL, "invalid_value"));
+
+    wfd_settings_cleanup(&settings);
+    config_destroy(&config);
+}
+
+TEST(settings, get_string_or_default)
+{
+    char const settings_text[] =
+        "settings:\n"
+        "{\n"
+        "  string_value = \"some.string\"\n"
+        "  int_value    = 42\n"
+        "}\n"
+        ;
+    config_t config;
+    config_init(&config);
+    int rc = config_read_string(&config, settings_text);
+    ASSERT_TRUE(CONFIG_TRUE == rc);
+
+    config_setting_t * setting = config_lookup(&config, "settings");
+    ASSERT_NE(nullptr, setting);
+
+    wfd_settings settings;
+    wfd_settings_init(&settings, setting);
+    ASSERT_STREQ("some.string", wfd_settings_get_string_or_default(&settings, "string_value", "default"));
+    ASSERT_STREQ("default", wfd_settings_get_string_or_default(&settings, "int_value", "default"));
+    ASSERT_STREQ("default", wfd_settings_get_string_or_default(&settings, "invalid_value", "default"));
+    ASSERT_STREQ("default", wfd_settings_get_string_or_default(NULL, "invalid_value", "default"));
+
+    wfd_settings_cleanup(&settings);
+    config_destroy(&config);
+}
+
+TEST(settings, get_bool)
+{
+    char const settings_text[] =
+        "settings:\n"
+        "{\n"
+        "  true_value   = true\n"
+        "  false_value  = false\n"
+        "  int_value    = 42\n"
+        "}\n"
+        ;
+    config_t config;
+    config_init(&config);
+    int rc = config_read_string(&config, settings_text);
+    ASSERT_TRUE(CONFIG_TRUE == rc);
+
+    config_setting_t * setting = config_lookup(&config, "settings");
+    ASSERT_NE(nullptr, setting);
+
+    wfd_settings settings;
+    wfd_settings_init(&settings, setting);
+    ASSERT_TRUE(wfd_settings_get_bool(&settings, "true_value"));
+    ASSERT_FALSE(wfd_settings_get_bool(&settings, "false_value"));
+    ASSERT_FALSE(wfd_settings_get_bool(&settings, "int_value"));
+    ASSERT_FALSE(wfd_settings_get_bool(&settings, "invalid_value"));
+    ASSERT_FALSE(wfd_settings_get_bool(NULL, "invalid_value"));
+
+    wfd_settings_cleanup(&settings);
+    config_destroy(&config);
+}