Archives/falk-werner_webfused
1
0
Fork 0
mirror of https://github.com/falk-werner/webfused synced 2026-03-02 04:09:19 +00:00
Code Issues Releases Wiki Activity

read log config from config file

Browse Source
This commit is contained in:
Falk Werner
2020-03-18 17:33:31 +01:00
parent 1625869696
commit adbfd45951
29 changed files with 772 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
test/mock_config_builder.cc
View File

@@ -69,6 +69,17 @@ wfd_MockConfigBuilder_add_filesystem(
return builder->addFilesystem(name, mountpoint);
}
static bool
wfd_MockConfigBuilder_set_logger(
void * data,
char const * provider,
int level,
struct wfd_settings * settings)
{
auto * builder = reinterpret_cast<IConfigBuilder*>(data);
return builder->setLogger(provider, level, settings);
}
static const wfd_config_builder_vtable wfd_MockConfigBuilder_vtable =
{
@@ -78,7 +89,8 @@ static const wfd_config_builder_vtable wfd_MockConfigBuilder_vtable =
&wfd_MockConfigBuilder_set_server_cert,
&wfd_MockConfigBuilder_set_server_document_root,
&wfd_MockConfigBuilder_add_auth_provider,
&wfd_MockConfigBuilder_add_filesystem
&wfd_MockConfigBuilder_add_filesystem,
&wfd_MockConfigBuilder_set_logger
};
}

2
test/mock_config_builder.hpp
View File

@@ -18,6 +18,7 @@ public:
virtual void setServerDocumentRoot(char const * document_root) = 0;
virtual bool addAuthProvider(char const * provider, wfd_settings * settings) = 0;
virtual bool addFilesystem(char const * name, char const * mountpoint) = 0;
virtual bool setLogger(char const * provider, int level, wfd_settings * settings) = 0;
};
class MockConfigBuilder: public IConfigBuilder
@@ -31,6 +32,7 @@ public:
MOCK_METHOD1(setServerDocumentRoot, void (char const * document_root));
MOCK_METHOD2(addAuthProvider, bool (char const * provider, wfd_settings * settings));
MOCK_METHOD2(addFilesystem, bool (char const * name, char const * mountpoint));
MOCK_METHOD3(setLogger, bool (char const * provider, int level, wfd_settings * settings));
struct wfd_config_builder getBuilder();
};

50
test/mock_settings.cc
View File

@@ -7,25 +7,67 @@ using webfused_test::ISettings;
static ISettings * wfd_mock_settings = nullptr;
extern char const *
__real_wfd_settings_get(
__real_wfd_settings_get_string(
struct wfd_settings * settings,
char const * key);
extern char const *
__real_wfd_settings_get_string_or_default(
struct wfd_settings * settings,
char const * key,
char const * default_value);
extern bool
__real_wfd_settings_get_bool(
struct wfd_settings * settings,
char const * key);
char const *
__wrap_wfd_settings_get(
__wrap_wfd_settings_get_string(
struct wfd_settings * settings,
char const * key)
{
if (nullptr == wfd_mock_settings)
{
return __real_wfd_settings_get(settings, key);
return __real_wfd_settings_get_string(settings, key);
}
else
{
return wfd_mock_settings->get(key);
return wfd_mock_settings->getString(key);
}
}
char const *
__wrap_wfd_settings_get_string_or_default(
struct wfd_settings * settings,
char const * key,
char const * default_value)
{
if (nullptr == wfd_mock_settings)
{
return __real_wfd_settings_get_string_or_default(
settings, key, default_value);
}
else
{
return wfd_mock_settings->getStringOrDefault(key, default_value);
}
}
bool
__wrap_wfd_settings_get_bool(
struct wfd_settings * settings,
char const * key)
{
if (nullptr == wfd_mock_settings)
{
return __real_wfd_settings_get_bool(settings, key);
}
else
{
return wfd_mock_settings->getBool(key);
}
}
}

8
test/mock_settings.hpp
View File

@@ -11,7 +11,9 @@ class ISettings
{
public:
virtual ~ISettings() = default;
virtual char const * get(char const * key) = 0;
virtual char const * getString(char const * key) = 0;
virtual char const * getStringOrDefault(char const * key, char const * default_value) = 0;
virtual bool getBool(char const * key) = 0;
};
class MockSettings: public ISettings
@@ -19,7 +21,9 @@ class MockSettings: public ISettings
public:
MockSettings();
~MockSettings() override;
MOCK_METHOD1(get, char const * (char const * key));
MOCK_METHOD1(getString, char const * (char const * key));
MOCK_METHOD2(getStringOrDefault, char const * (char const * key, char const * default_value));
MOCK_METHOD1(getBool, bool (char const * key));
};
}

17
test/test_config.cc
View File

@@ -38,7 +38,7 @@ TEST(config, auth_config)
wfd_config_builder builder = wfd_config_get_builder(config);
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
bool success = wfd_config_builder_add_auth_provider(builder, "file", nullptr);
ASSERT_TRUE(success);
@@ -54,7 +54,7 @@ TEST(config, auth_config_failed_to_add_second_provider)
wfd_config_builder builder = wfd_config_get_builder(config);
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
bool success = wfd_config_builder_add_auth_provider(builder, "file", nullptr);
ASSERT_TRUE(success);
@@ -88,5 +88,18 @@ TEST(config, add_filesystem)
bool success = wfd_config_builder_add_filesystem(builder, "test", "/tmp/test");
ASSERT_TRUE(success);
wfd_config_dispose(config);
}
TEST(config, set_logger)
{
wfd_config * config = wfd_config_create();
ASSERT_NE(nullptr, config);
wfd_config_builder builder = wfd_config_get_builder(config);
bool success = wfd_config_builder_set_logger(builder, "stderr", WFD_LOGLEVEL_ALL, nullptr);
ASSERT_TRUE(success);
wfd_config_dispose(config);
}

105
test/test_config_factory.cc
View File

@@ -17,6 +17,7 @@ using ::webfused_test::MockConfigBuilder;
TEST(config, is_loadable)
{
StrictMock<MockConfigBuilder> builder;
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));
@@ -433,3 +434,107 @@ TEST(config, filesystems_failed_missing_mountpoint)
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_FALSE(result);
}
TEST(config, log)
{
MockLogger logger;
EXPECT_CALL(logger, log(_, _, _)).Times(0);
EXPECT_CALL(logger, onclose()).Times(1);
StrictMock<MockConfigBuilder> builder;
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"
;
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_TRUE(result);
}
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, 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"
;
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_FALSE(result);
}
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, setLogger(_, _, _)).Times(0);
char const config_text[] =
"version = { major = 1, minor = 0 }\n"
"log:\n"
"{\n"
" level = \"all\"\n"
"}\n"
;
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_FALSE(result);
}
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, setLogger(_, _, _)).Times(0);
char const config_text[] =
"version = { major = 1, minor = 0 }\n"
"log:\n"
"{\n"
" provider = \"stderr\"\n"
" level = \"fancy\"\n"
"}\n"
;
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_FALSE(result);
}
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, setLogger(_, _, _)).Times(0);
char const config_text[] =
"version = { major = 1, minor = 0 }\n"
"log:\n"
"{\n"
" provider = \"stderr\"\n"
"}\n"
;
bool result = wfd_config_load_string(builder.getBuilder(), config_text);
ASSERT_FALSE(result);
}

18
test/test_file_authenticator.cc
View File

@@ -17,7 +17,7 @@ using ::testing::StrEq;
TEST(file_authenticator, create)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -29,7 +29,7 @@ TEST(file_authenticator, create)
TEST(file_authenticator, create_fail_missing_file)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return(nullptr));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return(nullptr));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -39,7 +39,7 @@ TEST(file_authenticator, create_fail_missing_file)
TEST(file_authenticator, create_via_factory)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_authenticator_create("file", nullptr, &authenticator);
@@ -51,7 +51,7 @@ TEST(file_authenticator, create_via_factory)
TEST(file_authenticator, authenticate)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -70,7 +70,7 @@ TEST(file_authenticator, authenticate)
TEST(file_authenticator, authenticate_fail_wrong_passwd)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -89,7 +89,7 @@ TEST(file_authenticator, authenticate_fail_wrong_passwd)
TEST(file_authenticator, authenticate_fail_no_passwd_file)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("unknown_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("unknown_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -108,7 +108,7 @@ TEST(file_authenticator, authenticate_fail_no_passwd_file)
TEST(file_authenticator, authenticate_fail_missing_username)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -127,7 +127,7 @@ TEST(file_authenticator, authenticate_fail_missing_username)
TEST(file_authenticator, authenticate_fail_missing_password)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("test_passwd.json"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);
@@ -146,7 +146,7 @@ TEST(file_authenticator, authenticate_fail_missing_password)
TEST(file_authenticator, get_type)
{
MockSettings settings;
EXPECT_CALL(settings, get(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
EXPECT_CALL(settings, getString(StrEq("file"))).Times(1).WillOnce(Return("/any/path"));
wfd_authenticator authenticator;
bool success = wfd_file_authenticator_create(nullptr, &authenticator);

59
test/test_log.cc
View File

@@ -108,4 +108,63 @@ TEST(log, omit_onclose_if_nullptr)
TEST(log, default_log)
{
WFD_ERROR("trigger log");
}
TEST(log, loglevel_parse)
{
int level;
ASSERT_TRUE(wfd_log_level_parse("fatal", &level));
ASSERT_EQ(WFD_LOGLEVEL_FATAL, level);
ASSERT_TRUE(wfd_log_level_parse("FATAL", &level));
ASSERT_EQ(WFD_LOGLEVEL_FATAL, level);
ASSERT_TRUE(wfd_log_level_parse("error", &level));
ASSERT_EQ(WFD_LOGLEVEL_ERROR, level);
ASSERT_TRUE(wfd_log_level_parse("ERROR", &level));
ASSERT_EQ(WFD_LOGLEVEL_ERROR, level);
ASSERT_TRUE(wfd_log_level_parse("warn", &level));
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
ASSERT_TRUE(wfd_log_level_parse("WARN", &level));
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
ASSERT_TRUE(wfd_log_level_parse("warning", &level));
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
ASSERT_TRUE(wfd_log_level_parse("WARNING", &level));
ASSERT_EQ(WFD_LOGLEVEL_WARN, level);
ASSERT_TRUE(wfd_log_level_parse("info", &level));
ASSERT_EQ(WFD_LOGLEVEL_INFO, level);
ASSERT_TRUE(wfd_log_level_parse("INFO", &level));
ASSERT_EQ(WFD_LOGLEVEL_INFO, level);
ASSERT_TRUE(wfd_log_level_parse("debug", &level));
ASSERT_EQ(WFD_LOGLEVEL_DEBUG, level);
ASSERT_TRUE(wfd_log_level_parse("DEBUG", &level));
ASSERT_EQ(WFD_LOGLEVEL_DEBUG, level);
ASSERT_FALSE(wfd_log_level_parse("<invalid>", &level));
ASSERT_TRUE(wfd_log_level_parse("all", &level));
ASSERT_EQ(WFD_LOGLEVEL_ALL, level);
ASSERT_TRUE(wfd_log_level_parse("ALL", &level));
ASSERT_EQ(WFD_LOGLEVEL_ALL, level);
ASSERT_TRUE(wfd_log_level_parse("none", &level));
ASSERT_EQ(WFD_LOGLEVEL_NONE, level);
ASSERT_TRUE(wfd_log_level_parse("NONE", &level));
ASSERT_EQ(WFD_LOGLEVEL_NONE, level);
}
TEST(log, log_level_tostring)
{
ASSERT_STREQ("none", wfd_log_level_tostring(WFD_LOGLEVEL_NONE));
ASSERT_STREQ("fatal", wfd_log_level_tostring(WFD_LOGLEVEL_FATAL));
ASSERT_STREQ("error", wfd_log_level_tostring(WFD_LOGLEVEL_ERROR));
ASSERT_STREQ("warn", wfd_log_level_tostring(WFD_LOGLEVEL_WARN));
ASSERT_STREQ("info", wfd_log_level_tostring(WFD_LOGLEVEL_INFO));
ASSERT_STREQ("debug", wfd_log_level_tostring(WFD_LOGLEVEL_DEBUG));
ASSERT_STREQ("all", wfd_log_level_tostring(WFD_LOGLEVEL_ALL));
ASSERT_STREQ("<unknown>", wfd_log_level_tostring(42));
}

10
test/test_log_manager.cc Normal file
View File

@@ -0,0 +1,10 @@
#include "webfused/log/manager.h"
#include "webfused/log/log.h"
#include <gtest/gtest.h>
#include <stddef.h>
TEST(log_manager, set_logger_fail_unknown_provider)
{
ASSERT_FALSE(wfd_log_manager_set_logger("unknown", WFD_LOGLEVEL_ALL, NULL));
}

67
test/test_settings.cc
View File

@@ -3,7 +3,7 @@
#include "webfused/config/settings.h"
#include <libconfig.h>
TEST(settings, settings)
TEST(settings, get_string)
{
char const settings_text[] =
"settings:\n"
@@ -22,9 +22,68 @@ TEST(settings, settings)
wfd_settings settings;
wfd_settings_init(&settings, setting);
ASSERT_STREQ("some.string", wfd_settings_get(&settings, "string_value"));
ASSERT_EQ(nullptr, wfd_settings_get(&settings, "int_value"));
ASSERT_EQ(nullptr, wfd_settings_get(&settings, "invalid_value"));
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);

27
test/test_stderr_logger.cc Normal file
View File

@@ -0,0 +1,27 @@
#include "webfused/log/stderr_logger.h"
#include "webfused/log/manager.h"
#include "webfused/log/logger.h"
#include "webfused/log/log.h"
#include <gtest/gtest.h>
#include <stddef.h>
TEST(stderr_logger, init)
{
ASSERT_TRUE(wfd_stderr_logger_init(WFD_LOGLEVEL_ALL, NULL));
wfd_logger_close();
}
TEST(stderr_logger, init_via_manager)
{
ASSERT_TRUE(wfd_log_manager_set_logger("stderr", WFD_LOGLEVEL_ALL, NULL));
wfd_logger_close();
}
TEST(stderr_logger, log)
{
ASSERT_TRUE(wfd_stderr_logger_init(WFD_LOGLEVEL_ALL, NULL));
WFD_INFO("some information");
wfd_logger_close();
}

45
test/test_syslog_logger.cc Normal file
View File

@@ -0,0 +1,45 @@
#include "webfused/log/syslog_logger.h"
#include "webfused/log/manager.h"
#include "webfused/log/logger.h"
#include "webfused/log/log.h"
#include "mock_settings.hpp"
#include <gtest/gtest.h>
#include <stddef.h>
using ::webfused_test::MockSettings;
using ::testing::StrEq;
using ::testing::_;
using ::testing::Return;
TEST(syslog_logger, init)
{
ASSERT_TRUE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, NULL));
wfd_logger_close();
}
TEST(syslog_logger, init_fail_invalid_facility)
{
MockSettings settings;
EXPECT_CALL(settings, getStringOrDefault(StrEq("ident"), _)).Times(1).WillOnce(Return("webfused_test"));
EXPECT_CALL(settings, getStringOrDefault(StrEq("facility"), _)).Times(1).WillOnce(Return("invalid"));
EXPECT_CALL(settings, getBool(StrEq("log_pid"))).Times(1).WillOnce(Return(false));
wfd_settings * fake_settings = reinterpret_cast<wfd_settings*>(0xDEADBEEF);
ASSERT_FALSE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, fake_settings));
}
TEST(syslog_logger, init_via_manager)
{
ASSERT_TRUE(wfd_log_manager_set_logger("syslog", WFD_LOGLEVEL_ALL, NULL));
wfd_logger_close();
}
TEST(syslog_logger, log)
{
ASSERT_TRUE(wfd_syslog_logger_init(WFD_LOGLEVEL_ALL, NULL));
WFD_INFO("some information");
wfd_logger_close();
}