test_parser.cpp

#include <gtest/gtest.h>
#include "LogParser.h"
#include "LogFilter.h"
#include "LogReport.h"

// ── LogEntry Tests ────────────────────────────────────────────

TEST(LogEntryTest, LevelFromStringCaseInsensitive) {
    EXPECT_EQ(LogEntry::levelFromString("ERROR"),    LogLevel::ERROR);
    EXPECT_EQ(LogEntry::levelFromString("error"),    LogLevel::ERROR);
    EXPECT_EQ(LogEntry::levelFromString("WARNING"),  LogLevel::WARNING);
    EXPECT_EQ(LogEntry::levelFromString("WARN"),     LogLevel::WARNING);
    EXPECT_EQ(LogEntry::levelFromString("CRITICAL"), LogLevel::CRITICAL);
    EXPECT_EQ(LogEntry::levelFromString("FATAL"),    LogLevel::CRITICAL);
    EXPECT_EQ(LogEntry::levelFromString("UNKNOWN"),  LogLevel::UNKNOWN);
}

TEST(LogEntryTest, LevelToString) {
    LogEntry e;
    e.level = LogLevel::ERROR;
    EXPECT_EQ(e.levelToString(), "ERROR");
    e.level = LogLevel::WARNING;
    EXPECT_EQ(e.levelToString(), "WARNING");
    e.level = LogLevel::INFO;
    EXPECT_EQ(e.levelToString(), "INFO");
}

// ── LogParser Tests ───────────────────────────────────────────

TEST(LogParserTest, ParseStandardFormatLine) {
    LogParser parser;
    LogEntry entry = parser.parseLine(
        "[2024-01-15 10:30:45] [ERROR] [database] Connection refused", 1);

    EXPECT_EQ(entry.level, LogLevel::ERROR);
    EXPECT_EQ(entry.timestamp, "2024-01-15 10:30:45");
    EXPECT_EQ(entry.source, "database");
    EXPECT_EQ(entry.message, "Connection refused");
}

TEST(LogParserTest, ParseSimpleFormatLine) {
    LogParser parser;
    LogEntry entry = parser.parseLine("ERROR: Something went wrong", 1);

    EXPECT_EQ(entry.level, LogLevel::ERROR);
    EXPECT_EQ(entry.message, "Something went wrong");
}

TEST(LogParserTest, ParseInfoLine) {
    LogParser parser;
    LogEntry entry = parser.parseLine(
        "2024-03-01 08:00:00 INFO app: Server started on port 8080", 1);

    EXPECT_EQ(entry.level, LogLevel::INFO);
    EXPECT_FALSE(entry.message.empty());
}

TEST(LogParserTest, UnknownLineReturnsUnknown) {
    LogParser parser;
    LogEntry entry = parser.parseLine("this is not a log line at all", 1);
    EXPECT_EQ(entry.level, LogLevel::UNKNOWN);
}

// ── LogFilter Tests ───────────────────────────────────────────

class LogFilterTest : public ::testing::Test {
protected:
    std::vector<LogEntry> makeEntries() {
        std::vector<LogEntry> entries;
        auto make = [](LogLevel lvl, const std::string& msg, const std::string& src) {
            LogEntry e;
            e.level = lvl;
            e.message = msg;
            e.source = src;
            e.timestamp = "2024-01-15 10:00:00";
            e.lineNumber = 1;
            return e;
        };
        entries.push_back(make(LogLevel::ERROR,   "Connection refused",    "database"));
        entries.push_back(make(LogLevel::INFO,    "Server started",        "server"));
        entries.push_back(make(LogLevel::WARNING, "Disk usage high",       "monitor"));
        entries.push_back(make(LogLevel::ERROR,   "Null pointer exception","app"));
        entries.push_back(make(LogLevel::DEBUG,   "Query executed",        "database"));
        return entries;
    }
};

TEST_F(LogFilterTest, FilterByLevel) {
    auto entries = makeEntries();
    auto errors  = LogFilter::byLevel(entries, LogLevel::ERROR);
    EXPECT_EQ(errors.size(), 2u);
    for (const auto& e : errors)
        EXPECT_EQ(e.level, LogLevel::ERROR);
}

TEST_F(LogFilterTest, FilterByKeyword) {
    auto entries  = makeEntries();
    auto filtered = LogFilter::byKeyword(entries, "database");
    EXPECT_EQ(filtered.size(), 2u);  // "Connection refused" source=database + "Query executed" source=database
}

TEST_F(LogFilterTest, FilterBySource) {
    auto entries  = makeEntries();
    auto filtered = LogFilter::bySource(entries, "server");
    EXPECT_EQ(filtered.size(), 1u);
    EXPECT_EQ(filtered[0].message, "Server started");
}

TEST_F(LogFilterTest, EmptyFilterReturnsAll) {
    auto entries = makeEntries();
    FilterOptions opts;
    auto filtered = LogFilter::apply(entries, opts);
    EXPECT_EQ(filtered.size(), entries.size());
}

TEST_F(LogFilterTest, CombinedFilter) {
    auto entries = makeEntries();
    FilterOptions opts;
    opts.level  = "ERROR";
    opts.source = "database";
    auto filtered = LogFilter::apply(entries, opts);
    EXPECT_EQ(filtered.size(), 1u);
    EXPECT_EQ(filtered[0].message, "Connection refused");
}

// ── LogReport Tests ───────────────────────────────────────────

TEST(LogReportTest, TopErrorsReturnsCorrectCount) {
    std::vector<LogEntry> entries;
    for (int i = 0; i < 10; i++) {
        LogEntry e;
        e.level   = LogLevel::ERROR;
        e.message = "Error type " + std::to_string(i % 3);
        entries.push_back(e);
    }
    auto top = LogReport::getTopErrors(entries, 2);
    EXPECT_LE((int)top.size(), 2);
}

TEST(LogReportTest, ExportToFileCreatesFile) {
    std::vector<LogEntry> entries;
    LogEntry e;
    e.level = LogLevel::INFO;
    e.message = "Test message";
    e.timestamp = "2024-01-01 00:00:00";
    e.source = "test";
    entries.push_back(e);

    bool result = LogReport::exportToFile(entries, "/tmp/test_export.log");
    EXPECT_TRUE(result);
}