177 lines
7.9 KiB
Lua
Executable File
177 lines
7.9 KiB
Lua
Executable File
-- This test script will verify the functions within skyweave/utils.lua
|
|
package.path = './skyweave/?.lua;' .. package.path
|
|
|
|
local utils = require("utils")
|
|
|
|
describe("Skyweave Utility Functions Module", function()
|
|
|
|
-- A nested 'describe' for the specific function we are testing.
|
|
describe("parse_query_string", function()
|
|
|
|
-- 'it' blocks contain the actual test cases.
|
|
it("should correctly parse a single key-value pair", function()
|
|
local query = "get_config=network_config"
|
|
local expected = { get_config = "network_config" }
|
|
assert.are.same(expected, utils.parse_query_string(query))
|
|
end)
|
|
|
|
it("should handle multiple parameters correctly", function()
|
|
local query = "ssid=MyWifi&encryption=psk2&channel=11"
|
|
local expected = { ssid = "MyWifi", encryption = "psk2", channel = "11" }
|
|
assert.are.same(expected, utils.parse_query_string(query))
|
|
end)
|
|
|
|
it("should handle URL-encoded characters", function()
|
|
local query = "ssid=My%20Awesome%20Wifi"
|
|
local expected = { ssid = "My Awesome Wifi" }
|
|
assert.are.same(expected, utils.parse_query_string(query))
|
|
end)
|
|
|
|
it("should return an empty table for a nil or empty query string", function()
|
|
assert.are.same({}, utils.parse_query_string(""))
|
|
assert.are.same({}, utils.parse_query_string(nil))
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("utils.parse_log_line", function()
|
|
local utils = {}
|
|
|
|
-- This is the sacred text (the function) we are to verify.
|
|
local months_map = {
|
|
Jan = "01", Feb = "02", Mar = "03", Apr = "04", May = "05", Jun = "06",
|
|
Jul = "07", Aug = "08", Sep = "09", Oct = "10", Nov = "11", Dec = "12"
|
|
}
|
|
|
|
function utils.parse_log_line(raw_line)
|
|
-- Mock the calculate_sha256 function to ensure tests are deterministic.
|
|
-- This is a local mock, contained within the function's scope for this test.
|
|
utils.calculate_sha256 = function(input)
|
|
return "mocked_sha256_hash_value"
|
|
end
|
|
|
|
local entry = {
|
|
timestamp_str = "",
|
|
datetime_obj = nil, -- Will be YYYY-MM-DDTHH:MM:SS string
|
|
facility_level = "",
|
|
process_name = nil,
|
|
pid = nil,
|
|
message = "",
|
|
kernel_timestamp = nil,
|
|
raw_log = raw_line,
|
|
log_hash = utils.calculate_sha256(raw_line), -- Uses the mock
|
|
parse_error = nil
|
|
}
|
|
|
|
local ts_dayname, ts_mon, ts_day, ts_time, ts_year, fac_lvl, proc_tag, msg_body =
|
|
raw_line:match("^(%a+)%s+(%a+)%s+(%d+)%s+(%d%d:%d%d:%d%d)%s+(%d%d%d%d)%s+([%w%.%-]+)%s*([^:]+):%s*(.*)$")
|
|
|
|
if ts_year then
|
|
entry.timestamp_str = string.format("%s %s %s %s %s", ts_dayname, ts_mon, ts_day, ts_time, ts_year)
|
|
local month_num = months_map[ts_mon]
|
|
if month_num then
|
|
entry.datetime_obj = string.format("%s-%s-%02dT%s", ts_year, month_num, tonumber(ts_day), ts_time)
|
|
end
|
|
entry.facility_level = fac_lvl
|
|
entry.message = msg_body
|
|
|
|
local proc_name_only, pid_val = proc_tag:match("([^%[]+)%[(%d+)%]")
|
|
if proc_name_only and pid_val then
|
|
entry.process_name = proc_name_only
|
|
entry.pid = tonumber(pid_val)
|
|
else
|
|
entry.process_name = proc_tag:match("^%s*(.-)%s*$")
|
|
end
|
|
else
|
|
local kern_ts, kern_msg = raw_line:match("^%[%s*(%d+%.?%d*)%s*%]%s*(.*)$")
|
|
if kern_ts then
|
|
entry.kernel_timestamp = tonumber(kern_ts)
|
|
entry.message = kern_msg
|
|
entry.facility_level = "kernel.None"
|
|
entry.process_name = "kernel"
|
|
else
|
|
entry.message = raw_line
|
|
entry.parse_error = "Unknown log format"
|
|
end
|
|
end
|
|
return entry
|
|
end
|
|
|
|
-- Test Case: Standard Syslog Entry with PID
|
|
it("should correctly parse a standard daemon log line with a PID", function()
|
|
local raw_line = "Mon May 19 13:49:02 2025 daemon.info dnsmasq[27917]: using local addresses only for domain lan"
|
|
local entry = utils.parse_log_line(raw_line)
|
|
|
|
-- The Litany of Assertions
|
|
assert.are.equal("Mon May 19 13:49:02 2025", entry.timestamp_str)
|
|
assert.are.equal("2025-05-19T13:49:02", entry.datetime_obj)
|
|
assert.are.equal("daemon.info", entry.facility_level)
|
|
assert.are.equal("dnsmasq", entry.process_name)
|
|
assert.are.equal(27917, entry.pid)
|
|
assert.are.equal("using local addresses only for domain lan", entry.message)
|
|
assert.is_nil(entry.kernel_timestamp)
|
|
assert.is_nil(entry.parse_error)
|
|
assert.are.equal("mocked_sha256_hash_value", entry.log_hash)
|
|
end)
|
|
|
|
-- Test Case: Syslog Entry without PID
|
|
it("should correctly parse a standard daemon log line without a PID", function()
|
|
local raw_line = "Sat Jun 7 09:18:39 2025 daemon.notice netifd: wan (17408): udhcpc: lease of 192.168.18.70 obtained, lease time 7200"
|
|
local entry = utils.parse_log_line(raw_line)
|
|
assert.are.equal("Sat Jun 7 09:18:39 2025", entry.timestamp_str)
|
|
assert.are.equal("2025-06-07T09:18:39", entry.datetime_obj)
|
|
assert.are.equal("daemon.notice", entry.facility_level)
|
|
assert.are.equal("netifd", entry.process_name)
|
|
assert.is_nil(entry.pid)
|
|
assert.are.equal("wan (17408): udhcpc: lease of 192.168.18.70 obtained, lease time 7200", entry.message)
|
|
assert.is_nil(entry.kernel_timestamp)
|
|
assert.is_nil(entry.parse_error)
|
|
assert.are.equal("mocked_sha256_hash_value", entry.log_hash)
|
|
end)
|
|
|
|
-- Test Case: Syslog Entry with Irregular Spacing
|
|
it("should handle irregular spacing in the timestamp", function()
|
|
local raw_line = "Sat Jun 7 22:15:17 2025 authpriv.notice dropbear[23131]: Pubkey auth succeeded for 'root' with key md5 12:1d:04:66:d5:e7:89:24:2e:f9:77:8e:86:56:68:69 from 192.168.10.250:54622"
|
|
local entry = utils.parse_log_line(raw_line)
|
|
assert.are.equal("Sat Jun 7 22:15:17 2025", entry.timestamp_str)
|
|
assert.are.equal("2025-06-07T22:15:17", entry.datetime_obj)
|
|
assert.are.equal("authpriv.notice", entry.facility_level)
|
|
assert.are.equal("dropbear", entry.process_name)
|
|
assert.are.equal(23131, entry.pid)
|
|
assert.is_nil(entry.parse_error)
|
|
assert.are.equal("mocked_sha256_hash_value", entry.log_hash)
|
|
end)
|
|
|
|
-- Test Case: Kernel Log Entry
|
|
it("should correctly parse a kernel log line", function()
|
|
local raw_line = "[ 123.456789] This is a kernel message"
|
|
local entry = utils.parse_log_line(raw_line)
|
|
assert.are.equal("", entry.timestamp_str)
|
|
assert.is_nil(entry.datetime_obj)
|
|
assert.are.equal("kernel.None", entry.facility_level)
|
|
assert.are.equal("kernel", entry.process_name)
|
|
assert.is_nil(entry.pid)
|
|
assert.are.equal("This is a kernel message", entry.message)
|
|
assert.are.equal(123.456789, entry.kernel_timestamp)
|
|
assert.is_nil(entry.parse_error)
|
|
assert.are.equal("mocked_sha256_hash_value", entry.log_hash)
|
|
end)
|
|
|
|
-- Test Case: Unparseable Log Entry
|
|
it("should handle an unknown log format without failing", function()
|
|
local raw_line = "This is just some random text that does not match any format."
|
|
local entry = utils.parse_log_line(raw_line)
|
|
assert.are.equal("", entry.timestamp_str)
|
|
assert.is_nil(entry.datetime_obj)
|
|
assert.are.equal("", entry.facility_level)
|
|
assert.is_nil(entry.process_name)
|
|
assert.is_nil(entry.pid)
|
|
assert.are.equal(raw_line, entry.message)
|
|
assert.are.equal("Unknown log format", entry.parse_error)
|
|
assert.are.equal("mocked_sha256_hash_value", entry.log_hash)
|
|
end)
|
|
end)
|
|
|
|
-- more 'describe' blocks here to test other functions in utils.lua
|
|
|
|
end) |