cpplogging/test/cpplogging/cpplogging_tests.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <cpplogging/manager.h>

using namespace ::testing;
using namespace ::cpplogging;

struct LoggingReset
{
    ~LoggingReset()
        { manager::reset(); }
};

struct consumer_mock
    : public consumer
{
    MOCK_CONST_METHOD1(write_entry, void (const log_entry_ptr_s& entry));

    consumer_mock(const std::string& n) :
        consumer(n)
    {
        manager::register_consumer(*this);
    }
};

MATCHER_P5(MatchLogData, level, sender, thread, name, message, "")
{
    if (!arg)
        return false;

    auto& d = *arg;
    return d.level   == level
        && d.sender  == sender
        && d.thread  == thread
        && d.name    == name
        && d.message == message;
}

TEST(LoggingTests, matcher_all)
{
    LoggingReset loggingReset;
    consumer_stream c0("TestConsumer1", std::cout);
    consumer_stream c1("TestConsumer2", std::cout);

    auto& l0 = logger::get();
    auto& l1 = logger::get("TestLogger");

    matcher_all matcher;

    EXPECT_TRUE(matcher.match(c0));
    EXPECT_TRUE(matcher.match(c1));
    EXPECT_TRUE(matcher.match(l0));
    EXPECT_TRUE(matcher.match(l1));
}

TEST(LoggingTests, matcher_default)
{
    LoggingReset loggingReset;
    consumer_stream c0("TestConsumer1", std::cout);
    consumer_stream c1("TestConsumer2", std::cout);

    auto& l0 = logger::get();
    auto& l1 = logger::get("TestLogger");

    matcher_default_logger matcher;

    EXPECT_FALSE(matcher.match(c0));
    EXPECT_FALSE(matcher.match(c1));
    EXPECT_TRUE (matcher.match(l0));
    EXPECT_FALSE(matcher.match(l1));
}

TEST(LoggingTests, matcher_regex)
{
    LoggingReset loggingReset;
    consumer_stream c0("TestConsumer1", std::cout);
    consumer_stream c1("TestConsumer2", std::cout);

    auto& l0 = logger::get();
    auto& l1 = logger::get("TestLogger");

    matcher_regex matcher0("TestConsumer1");
    matcher_regex matcher1("ASEF", true);

    EXPECT_TRUE (matcher0.match(c0));
    EXPECT_FALSE(matcher0.match(c1));
    EXPECT_FALSE(matcher1.match(l0));
    EXPECT_TRUE (matcher1.match(l1));
}

TEST(LoggingTests, log_base)
{
    LoggingReset loggingReset;
    StrictMock<consumer_mock> c0("consumer0");
    StrictMock<consumer_mock> c1("Consumer1");

    EXPECT_CALL(c0, write_entry(MatchLogData(
        log_level::info,
        (void*)0x12,
        std::this_thread::get_id(),
        std::string("logger0"),
        std::string("test1 info"))));

    EXPECT_CALL(c0, write_entry(MatchLogData(
        log_level::warn,
        (void*)0x13,
        std::this_thread::get_id(),
        std::string("logger0"),
        std::string("test1 warn"))));

    manager::define_rule(
        std::make_unique<matcher_regex>("logger0"),
        std::make_unique<matcher_regex>("consumer0"),
        log_level::info,
        log_level::warn);

    auto& l0 = logger::get("logger0");
    auto& l1 = logger::get("logger1");

    cpplogging_log(l0, debug).sender((void*)0x11).message("test1") << " debug";
    cpplogging_log(l0, info ).sender((void*)0x12).message("test1") << " info";
    cpplogging_log(l0, warn ).sender((void*)0x13).message("test1") << " warn";
    cpplogging_log(l0, error).sender((void*)0x14).message("test1") << " error";

    cpplogging_log(l1, debug).sender((void*)0x21).message("test2") << " debug";
    cpplogging_log(l1, info ).sender((void*)0x22).message("test2") << " info";
    cpplogging_log(l1, warn ).sender((void*)0x23).message("test2") << " warn";
    cpplogging_log(l1, error).sender((void*)0x24).message("test2") << " error";
}

TEST(LoggingTests, log_inverted_regex)
{
    LoggingReset loggingReset;
    StrictMock<consumer_mock> c0("consumer0");

    EXPECT_CALL(c0, write_entry(MatchLogData(
        log_level::debug,
        (void*)0x12,
        std::this_thread::get_id(),
        std::string("logger2"),
        std::string("test2"))));

    manager::define_rule(
        std::make_unique<matcher_regex>("^logger[0-1]+$", true),
        std::make_unique<matcher_regex>("consumer0"),
        log_level::debug,
        log_level::error);

    auto& l0 = logger::get("logger0");
    auto& l1 = logger::get("logger1");
    auto& l2 = logger::get("logger2");

    cpplogging_log(l0, debug).sender((void*)0x10) << "test0";
    cpplogging_log(l1, debug).sender((void*)0x11) << "test1";
    cpplogging_log(l2, debug).sender((void*)0x12) << "test2";
}

#ifdef CPPLOGGING_HAS_LOAD_CONFIG
TEST(LoggingTests, load)
{
    manager::load("./cpplogging/test_config.json");
}
#endif