parse authentication settings

test/invalid.conf

@@ -0,0 +1,4 @@
+# This config file is invalid,
+# since "." is not allowed as separator
+
+version.major = 1

test/mock_config_builder.cc

@@ -5,7 +5,7 @@ extern "C"
 using webfused_test::IConfigBuilder;
 
 static void
-wfd_MockConifigBuilder_set_server_vhostname(
+wfd_MockConfigBuilder_set_server_vhostname(
     void * data,
     char const * vhost_name)
 {
@@ -14,7 +14,7 @@ wfd_MockConifigBuilder_set_server_vhostname(
 }
 
 static void
-wfd_MockConifigBuilder_set_server_port(
+wfd_MockConfigBuilder_set_server_port(
     void * data,
     int port)
 {
@@ -23,7 +23,7 @@ wfd_MockConifigBuilder_set_server_port(
 }
 
 static void
-wfd_MockConifigBuilder_set_server_key(
+wfd_MockConfigBuilder_set_server_key(
     void * data,
     char const * key_path)
 {
@@ -32,7 +32,7 @@ wfd_MockConifigBuilder_set_server_key(
 }
 
 static void
-wfd_MockConifigBuilder_set_server_cert(
+wfd_MockConfigBuilder_set_server_cert(
     void * data,
     char const * cert_path)
 {
@@ -41,7 +41,7 @@ wfd_MockConifigBuilder_set_server_cert(
 }
 
 static void
-wfd_MockConifigBuilder_set_server_document_root(
+wfd_MockConfigBuilder_set_server_document_root(
     void * data,
     char const * document_root)
 {
@@ -49,13 +49,24 @@ wfd_MockConifigBuilder_set_server_document_root(
     builder->setServerDocumentRoot(document_root);
 }
 
+static bool
+wfd_MockConfigBuilder_add_auth_provider(
+    void * data,
+    struct wfd_auth_settings * settings)
+{
+    auto * builder = reinterpret_cast<IConfigBuilder*>(data);
+    builder->addAuthProvider(settings);
+}
+
+
 static const wfd_config_builder_vtable wfd_MockConfigBuilder_vtable =
 {
-    &wfd_MockConifigBuilder_set_server_vhostname,
-    &wfd_MockConifigBuilder_set_server_port,
-    &wfd_MockConifigBuilder_set_server_key,
-    &wfd_MockConifigBuilder_set_server_cert,
-    &wfd_MockConifigBuilder_set_server_document_root
+    &wfd_MockConfigBuilder_set_server_vhostname,
+    &wfd_MockConfigBuilder_set_server_port,
+    &wfd_MockConfigBuilder_set_server_key,
+    &wfd_MockConfigBuilder_set_server_cert,
+    &wfd_MockConfigBuilder_set_server_document_root,
+    &wfd_MockConfigBuilder_add_auth_provider
 };
 
 }

test/mock_config_builder.hpp

@@ -16,6 +16,7 @@ public:
     virtual void setServerKey(char const * key_path) = 0;
     virtual void setServerCert(char const * cert_path) = 0;
     virtual void setServerDocumentRoot(char const * document_root) = 0;
+    virtual bool addAuthProvider(wfd_auth_settings * settings) = 0;
 };
 
 class MockConfigBuilder: public IConfigBuilder
@@ -27,6 +28,7 @@ public:
     MOCK_METHOD1(setServerKey, void (char const * key_path));
     MOCK_METHOD1(setServerCert, void (char const * cert_path));
     MOCK_METHOD1(setServerDocumentRoot, void (char const * document_root));
+    MOCK_METHOD1(addAuthProvider, bool (wfd_auth_settings * settings));
 
     struct wfd_config_builder getBuilder();
 };

test/test_auth_factory.cc

@@ -0,0 +1,26 @@
+#include <gtest/gtest.h>
+#include "webfused/auth/factory.h"
+#include "webfused/auth/authenticator.h"
+#include "webfused/config/auth_settings.h"
+#include "webfused/log/log.h"
+#include "mock_logger.hpp"
+
+using ::testing::_;
+using ::webfused_test::MockLogger;
+
+
+TEST(auth_factory, fail_unknown_provider)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(WFD_LOGLEVEL_ERROR, _, _)).Times(1);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    wfd_auth_settings * auth_settings = wfd_auth_settings_create(
+        "unknown", NULL);
+
+    wfd_authenticator authenticator;
+    bool result = wfd_authenticator_create(auth_settings, &authenticator);
+    ASSERT_FALSE(result);
+
+    wfd_auth_settings_dispose(auth_settings);
+}

test/test_auth_settings.cc

@@ -0,0 +1,31 @@
+#include <gtest/gtest.h>
+#include "webfused/auth/settings.h"
+#include "webfused/config/auth_settings.h"
+#include <libconfig.h>
+
+TEST(auth_settings, auth_settings)
+{
+    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 * settings = config_lookup(&config, "settings");
+    ASSERT_NE(nullptr, settings);
+
+    wfd_auth_settings * auth_settings = wfd_auth_settings_create("test_provider", settings);
+    ASSERT_STREQ("test_provider", wfd_auth_settings_get_provider(auth_settings));
+    ASSERT_STREQ("some.string", wfd_auth_settings_get(auth_settings, "string_value"));
+    ASSERT_EQ(nullptr, wfd_auth_settings_get(auth_settings, "int_value"));
+    ASSERT_EQ(nullptr, wfd_auth_settings_get(auth_settings, "invalid_value"));
+
+    wfd_auth_settings_dispose(auth_settings);
+    config_destroy(&config);
+}

test/test_config_factory.cc

@@ -8,6 +8,7 @@
 
 
 using ::testing::_;
+using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::StrEq;
 using ::webfused_test::MockLogger;
@@ -18,6 +19,7 @@ TEST(config, is_loadable)
     StrictMock<MockConfigBuilder> builder;
     EXPECT_CALL(builder, setServerVhostname(StrEq("localhost"))).Times(1);
     EXPECT_CALL(builder, setServerPort(8080)).Times(1);
+    EXPECT_CALL(builder, addAuthProvider(_)).Times(1).WillOnce(Return(true));
 
     bool result = wfd_config_load_file(builder.getBuilder(), "webfused.conf");
     ASSERT_TRUE(result);
@@ -50,6 +52,18 @@ TEST(config, invalid_config)
     ASSERT_FALSE(result);    
 }
 
+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;    
+
+    bool result = wfd_config_load_file(builder.getBuilder(), "invalid.conf");
+    ASSERT_FALSE(result);    
+}
+
 TEST(config, invalid_major_version_too_low)
 {
     MockLogger logger;
@@ -239,3 +253,83 @@ TEST(config, document_root)
     bool result = wfd_config_load_string(builder.getBuilder(), config_text);
     ASSERT_TRUE(result);
 }
+
+TEST(config, authentication)
+{
+    MockLogger logger;
+    EXPECT_CALL(logger, log(_, _, _)).Times(0);
+    EXPECT_CALL(logger, onclose()).Times(1);
+
+    StrictMock<MockConfigBuilder> builder;
+    EXPECT_CALL(builder, addAuthProvider(_)).Times(1).WillOnce(Return(true));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "{\n"
+        "  provider = \"test\"\n"
+        "  settings: { }\n"
+        "}\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_TRUE(result);
+}
+
+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, addAuthProvider(_)).Times(1).WillOnce(Return(false));    
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "{\n"
+        "  provider = \"test\"\n"
+        "  settings: { }\n"
+        "}\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}
+
+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;
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "{\n"
+        "  settings: { }\n"
+        "}\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}
+
+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;
+
+    char const config_text[] = 
+        "version = { major = 1, minor = 0 }\n"
+        "authentication:\n"
+        "{\n"
+        "  provider = \"test\"\n"
+        "}\n"
+        ;
+    bool result = wfd_config_load_string(builder.getBuilder(), config_text);
+    ASSERT_FALSE(result);
+}