use chrono::{Datelike, NaiveDate, Timelike};
use regex::Regex;
use super::severity::detect_severity_from_text;
use crate::models::log_entry::{LogEntry, LogFormat, Severity};
use std::sync::OnceLock;
fn engine_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(
r"^MSI\s+\(([csaN])\)\s+\(([0-9A-Fa-f]+):([0-9A-Fa-f]+)\)\s+\[(\d{2}):(\d{2}):(\d{2}):(\d{3})\]:\s+(.*)$",
)
.expect("MSI engine regex must compile")
})
}
fn header_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(
r"^===\s+(?:Verbose\s+)?[Ll]ogging\s+started:\s+(\d{1,2}/\d{1,2}/\d{4})\s+(\d{1,2}:\d{2}:\d{2})\s+(.*)===\s*$",
)
.expect("MSI header regex must compile")
})
}
fn footer_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^===\s+(?:Verbose\s+)?[Ll]ogging\s+stopped:\s+.*===\s*$")
.expect("MSI footer regex must compile")
})
}
fn action_start_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^Action start (\d{1,2}):(\d{2}):(\d{2}):\s+(\w+)\.\s*$")
.expect("MSI action start regex must compile")
})
}
fn action_ended_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^Action ended (\d{1,2}):(\d{2}):(\d{2}):\s+(\w+)\.\s+Return value (\d+)\.\s*$")
.expect("MSI action ended regex must compile")
})
}
fn action_top_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^Action (\d{1,2}):(\d{2}):(\d{2}):\s+(\w+)\.\s*$")
.expect("MSI top-level action regex must compile")
})
}
fn property_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^Property\([CScs]\):\s+(.*)$").expect("MSI property regex must compile")
})
}
fn main_engine_return_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"^MainEngineThread is returning (\d+)")
.expect("MSI MainEngineThread regex must compile")
})
}
fn note_error_re() -> &'static Regex {
static CELL: OnceLock<Regex> = OnceLock::new();
CELL.get_or_init(|| {
Regex::new(r"Note:\s+1:\s+(\d+)").expect("MSI note error regex must compile")
})
}
pub fn matches_msi_content(line: &str) -> u32 {
let trimmed = line.trim();
if trimmed.starts_with("=== Verbose logging started:")
|| trimmed.starts_with("=== Logging started:")
|| trimmed.starts_with("=== verbose logging started:")
|| trimmed.starts_with("=== logging started:")
{
return 3;
}
if trimmed.starts_with("MSI (c)")
|| trimmed.starts_with("MSI (s)")
|| trimmed.starts_with("MSI (a)")
|| trimmed.starts_with("MSI (N)")
{
return 2;
}
if trimmed.starts_with("MainEngineThread is returning") {
return 2;
}
if action_start_re().is_match(trimmed) || action_ended_re().is_match(trimmed) {
return 1;
}
if trimmed.starts_with("Property(S):") || trimmed.starts_with("Property(C):") {
return 1;
}
0
}
struct MsiParserState {
current_date: Option<NaiveDate>,
prev_time_secs: Option<u32>,
}
impl MsiParserState {
fn new() -> Self {
Self {
current_date: None,
prev_time_secs: None,
}
}
fn advance_time(&mut self, h: u32, m: u32, s: u32) -> Option<NaiveDate> {
let current_secs = h * 3600 + m * 60 + s;
if let Some(prev_secs) = self.prev_time_secs {
if current_secs < prev_secs && (prev_secs - current_secs) > 82800 {
if let Some(date) = self.current_date {
self.current_date = date.succ_opt();
}
}
}
self.prev_time_secs = Some(current_secs);
self.current_date
}
}
pub fn parse_lines(lines: &[&str], file_path: &str) -> (Vec<LogEntry>, u32) {
let mut entries = Vec::with_capacity(lines.len());
let mut errors = 0u32;
let mut id_counter = 0u64;
let mut state = MsiParserState::new();
for (i, line) in lines.iter().enumerate() {
if line.trim().is_empty() {
continue;
}
let entry = parse_msi_line(line, file_path, &mut state, id_counter, (i + 1) as u32);
let is_fallback = entry.component.is_none()
&& entry.timestamp.is_none()
&& !footer_re().is_match(line.trim());
entries.push(entry);
if is_fallback {
errors += 1;
}
id_counter += 1;
}
(entries, errors)
}
fn parse_msi_line(
line: &str,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
) -> LogEntry {
let trimmed = line.trim_end();
if let Some(caps) = header_re().captures(trimmed) {
return parse_header(caps, file_path, state, id, line_number, trimmed);
}
if footer_re().is_match(trimmed) {
return make_entry(
id,
line_number,
trimmed.to_string(),
Some("MSI-header".to_string()),
None,
None,
Severity::Info,
None,
None,
file_path,
);
}
if let Some(caps) = engine_re().captures(trimmed) {
return parse_engine(caps, file_path, state, id, line_number);
}
if let Some(caps) = action_ended_re().captures(trimmed) {
return parse_action_ended(caps, file_path, state, id, line_number, trimmed);
}
if let Some(caps) = action_start_re().captures(trimmed) {
return parse_action_start(caps, file_path, state, id, line_number, trimmed);
}
if let Some(caps) = action_top_re().captures(trimmed) {
return parse_action_top(caps, file_path, state, id, line_number, trimmed);
}
if let Some(caps) = property_re().captures(trimmed) {
return make_entry(
id,
line_number,
caps.get(1).map_or("", |m| m.as_str()).to_string(),
Some("MSI-properties".to_string()),
None,
None,
Severity::Info,
None,
None,
file_path,
);
}
if let Some(caps) = main_engine_return_re().captures(trimmed) {
let code: u32 = caps
.get(1)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let severity = severity_from_msi_exit_code(code);
return make_entry(
id,
line_number,
trimmed.to_string(),
Some("MSI-engine".to_string()),
None,
None,
severity,
None,
None,
file_path,
);
}
let severity = msi_text_severity(trimmed);
make_entry(
id,
line_number,
trimmed.to_string(),
None,
None,
None,
severity,
None,
None,
file_path,
)
}
fn parse_header(
caps: regex::Captures,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
raw: &str,
) -> LogEntry {
let date_str = caps.get(1).map(|m| m.as_str()).unwrap_or("");
let time_str = caps.get(2).map(|m| m.as_str()).unwrap_or("");
let parsed_date = parse_us_date(date_str);
if let Some(d) = parsed_date {
state.current_date = Some(d);
}
let time_parts: Vec<u32> = time_str.split(':').filter_map(|p| p.parse().ok()).collect();
let (h, m, s) = if time_parts.len() == 3 {
(time_parts[0], time_parts[1], time_parts[2])
} else {
(0, 0, 0)
};
let (timestamp, timestamp_display) = if let Some(date) = parsed_date {
build_timestamp(date, h, m, s, 0)
} else {
(None, None)
};
if time_parts.len() == 3 {
state.prev_time_secs = Some(h * 3600 + m * 60 + s);
}
make_entry(
id,
line_number,
raw.to_string(),
Some("MSI-header".to_string()),
timestamp,
timestamp_display,
Severity::Info,
None,
None,
file_path,
)
}
fn parse_engine(
caps: regex::Captures,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
) -> LogEntry {
let context_char = caps.get(1).map(|m| m.as_str()).unwrap_or("c");
let pid_hex = caps.get(2).map(|m| m.as_str()).unwrap_or("0");
let tid_hex = caps.get(3).map(|m| m.as_str()).unwrap_or("0");
let h: u32 = caps
.get(4)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let m: u32 = caps
.get(5)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let s: u32 = caps
.get(6)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let ms: u32 = caps
.get(7)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let message = caps.get(8).map(|m| m.as_str()).unwrap_or("").to_string();
let component = match context_char {
"c" => "MSI-client",
"s" => "MSI-server",
"a" => "MSI-action",
"N" => "MSI-nested",
_ => "MSI-client",
}
.to_string();
let thread_num = u32::from_str_radix(tid_hex, 16).ok();
let thread_display = Some(format!("{}:{}", pid_hex, tid_hex));
let date = state.advance_time(h, m, s);
let (timestamp, timestamp_display) = if let Some(d) = date {
build_timestamp(d, h, m, s, ms)
} else {
(None, Some(format!("{:02}:{:02}:{:02}.{:03}", h, m, s, ms)))
};
let severity = determine_engine_severity(&message);
make_entry(
id,
line_number,
message,
Some(component),
timestamp,
timestamp_display,
severity,
thread_num,
thread_display,
file_path,
)
}
fn parse_action_start(
caps: regex::Captures,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
raw: &str,
) -> LogEntry {
let h: u32 = caps
.get(1)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let m: u32 = caps
.get(2)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let s: u32 = caps
.get(3)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let action = caps.get(4).map(|m| m.as_str()).unwrap_or("Unknown");
let date = state.advance_time(h, m, s);
let (timestamp, timestamp_display) = if let Some(d) = date {
build_timestamp(d, h, m, s, 0)
} else {
(None, Some(format!("{:02}:{:02}:{:02}.000", h, m, s)))
};
make_entry(
id,
line_number,
raw.to_string(),
Some(action.to_string()),
timestamp,
timestamp_display,
Severity::Info,
None,
None,
file_path,
)
}
fn parse_action_ended(
caps: regex::Captures,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
raw: &str,
) -> LogEntry {
let h: u32 = caps
.get(1)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let m: u32 = caps
.get(2)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let s: u32 = caps
.get(3)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let action = caps.get(4).map(|m| m.as_str()).unwrap_or("Unknown");
let return_val: u32 = caps
.get(5)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let date = state.advance_time(h, m, s);
let (timestamp, timestamp_display) = if let Some(d) = date {
build_timestamp(d, h, m, s, 0)
} else {
(None, Some(format!("{:02}:{:02}:{:02}.000", h, m, s)))
};
let severity = severity_from_action_return(return_val);
make_entry(
id,
line_number,
raw.to_string(),
Some(action.to_string()),
timestamp,
timestamp_display,
severity,
None,
None,
file_path,
)
}
fn parse_action_top(
caps: regex::Captures,
file_path: &str,
state: &mut MsiParserState,
id: u64,
line_number: u32,
raw: &str,
) -> LogEntry {
let h: u32 = caps
.get(1)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let m: u32 = caps
.get(2)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let s: u32 = caps
.get(3)
.and_then(|m| m.as_str().parse().ok())
.unwrap_or(0);
let action = caps.get(4).map(|m| m.as_str()).unwrap_or("Unknown");
let date = state.advance_time(h, m, s);
let (timestamp, timestamp_display) = if let Some(d) = date {
build_timestamp(d, h, m, s, 0)
} else {
(None, Some(format!("{:02}:{:02}:{:02}.000", h, m, s)))
};
make_entry(
id,
line_number,
raw.to_string(),
Some(action.to_string()),
timestamp,
timestamp_display,
Severity::Info,
None,
None,
file_path,
)
}
fn determine_engine_severity(message: &str) -> Severity {
if let Some(caps) = main_engine_return_re().captures(message) {
if let Some(code) = caps.get(1).and_then(|m| m.as_str().parse::<u32>().ok()) {
return severity_from_msi_exit_code(code);
}
}
if let Some(caps) = note_error_re().captures(message) {
if let Some(code) = caps.get(1).and_then(|m| m.as_str().parse::<u32>().ok()) {
if matches!(
code,
2318 | 2329
| 2331
| 2335
| 2337
| 2343
| 2345
| 2350
| 2351
| 2352
| 2355
| 2356
| 2357
| 2358
| 2359
| 2360
| 2361
| 2362
| 2371
| 2372
| 2373
| 2374
| 2375
| 2379
| 2380
| 2381
| 2382
) {
return Severity::Error;
}
return Severity::Info;
}
}
let lower = message.to_lowercase();
if lower.contains("installation failed")
|| lower.contains("error status: 1603")
|| lower.contains("error status: 1618")
|| lower.contains("product: error")
{
return Severity::Error;
}
detect_severity_from_text(message)
}
fn severity_from_msi_exit_code(code: u32) -> Severity {
match code {
0 => Severity::Info, 1707 => Severity::Info, 3010 => Severity::Info, 1602 => Severity::Warning, 1618 => Severity::Error, 1603 => Severity::Error, 1604 => Severity::Error, 1605 => Severity::Error, 1610 => Severity::Error, 1612 => Severity::Error, 1613 => Severity::Error, 1619 => Severity::Error, 1620 => Severity::Error, 1622 => Severity::Error, 1623 => Severity::Error, 1624 => Severity::Error, 1625 => Severity::Warning, 1638 => Severity::Warning, _ => {
if (1600..1700).contains(&code) {
Severity::Error
} else {
Severity::Info
}
}
}
}
fn severity_from_action_return(code: u32) -> Severity {
match code {
0 => Severity::Info, 1 => Severity::Info, 2 => Severity::Warning, 3 => Severity::Error, 4 => Severity::Warning, _ => Severity::Info,
}
}
fn msi_text_severity(text: &str) -> Severity {
let lower = text.to_lowercase();
if lower.contains("installation failed") || lower.contains("error status: 1603") {
return Severity::Error;
}
detect_severity_from_text(text)
}
fn parse_us_date(s: &str) -> Option<NaiveDate> {
let parts: Vec<&str> = s.split('/').collect();
if parts.len() != 3 {
return None;
}
let month: u32 = parts[0].parse().ok()?;
let day: u32 = parts[1].parse().ok()?;
let year: i32 = parts[2].parse().ok()?;
NaiveDate::from_ymd_opt(year, month, day)
}
fn build_timestamp(
date: NaiveDate,
h: u32,
m: u32,
s: u32,
ms: u32,
) -> (Option<i64>, Option<String>) {
let dt = date.and_hms_milli_opt(h, m, s, ms);
let timestamp = dt.map(|ndt| ndt.and_utc().timestamp_millis());
let display = dt.map(|ndt| {
format!(
"{:02}-{:02}-{:04} {:02}:{:02}:{:02}.{:03}",
date.month(),
date.day(),
date.year(),
ndt.hour(),
ndt.minute(),
ndt.second(),
ms,
)
});
(timestamp, display)
}
#[allow(clippy::too_many_arguments)]
fn make_entry(
id: u64,
line_number: u32,
message: String,
component: Option<String>,
timestamp: Option<i64>,
timestamp_display: Option<String>,
severity: Severity,
thread: Option<u32>,
thread_display: Option<String>,
file_path: &str,
) -> LogEntry {
LogEntry {
id,
line_number,
message,
component,
timestamp,
timestamp_display,
severity,
thread,
thread_display,
source_file: None,
format: LogFormat::Timestamped,
file_path: file_path.to_string(),
timezone_offset: None,
error_code_spans: Vec::new(),
ip_address: None,
host_name: None,
mac_address: None,
result_code: None,
gle_code: None,
setup_phase: None,
operation_name: None,
http_method: None,
uri_stem: None,
uri_query: None,
status_code: None,
sub_status: None,
time_taken_ms: None,
client_ip: None,
server_ip: None,
user_agent: None,
server_port: None,
username: None,
win32_status: None,
query_name: None,
query_type: None,
response_code: None,
dns_direction: None,
dns_protocol: None,
source_ip: None,
dns_flags: None,
dns_event_id: None,
zone_name: None,
entry_kind: None,
whatif: None,
section_name: None,
section_color: None,
iteration: None,
tags: None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_matches_header() {
assert_eq!(
matches_msi_content("=== Verbose logging started: 6/13/2023 9:02:46 Build type: SHIP UNICODE 5.00.10011.00 Calling process: ... ==="),
3
);
}
#[test]
fn test_matches_logging_started_variant() {
assert_eq!(
matches_msi_content("=== Logging started: 1/2/2024 10:00:00 Build type: SHIP ==="),
3
);
}
#[test]
fn test_matches_engine_client() {
assert_eq!(
matches_msi_content("MSI (c) (8C:98) [07:42:28:452]: Resetting cached policy values"),
2
);
}
#[test]
fn test_matches_engine_server() {
assert_eq!(
matches_msi_content("MSI (s) (8C:98) [07:42:28:452]: Running server"),
2
);
}
#[test]
fn test_matches_main_engine_thread() {
assert_eq!(matches_msi_content("MainEngineThread is returning 0"), 2);
}
#[test]
fn test_matches_action_start() {
assert_eq!(
matches_msi_content("Action start 16:34:29: InstallFiles."),
1
);
}
#[test]
fn test_matches_action_ended() {
assert_eq!(
matches_msi_content("Action ended 16:34:29: InstallFiles. Return value 1."),
1
);
}
#[test]
fn test_matches_property() {
assert_eq!(
matches_msi_content(
"Property(C): ProductCode = {C64CA371-0000-0000-0000-000000000000}"
),
1
);
}
#[test]
fn test_matches_plain_text_zero() {
assert_eq!(matches_msi_content("Just some random text"), 0);
}
#[test]
fn test_parse_header_extracts_date() {
let lines = [
"=== Verbose logging started: 6/13/2023 9:02:46 Build type: SHIP UNICODE 5.00.10011.00 Calling process: C:\\Windows\\System32\\msiexec.exe ===",
"MSI (c) (8C:98) [09:02:46:452]: Resetting cached policy values",
];
let (entries, errors) = parse_lines(&lines, "install.log");
assert_eq!(errors, 0);
assert_eq!(entries.len(), 2);
assert_eq!(entries[0].component.as_deref(), Some("MSI-header"));
assert_eq!(entries[0].severity, Severity::Info);
assert!(entries[0].timestamp.is_some());
assert_eq!(
entries[0].timestamp_display.as_deref(),
Some("06-13-2023 09:02:46.000")
);
assert_eq!(entries[1].component.as_deref(), Some("MSI-client"));
assert!(entries[1].timestamp.is_some());
assert_eq!(
entries[1].timestamp_display.as_deref(),
Some("06-13-2023 09:02:46.452")
);
}
#[test]
fn test_parse_engine_message() {
let lines = [
"=== Verbose logging started: 1/15/2024 7:42:28 Build type: SHIP ===",
"MSI (c) (8C:98) [07:42:28:452]: Resetting cached policy values",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[1].message, "Resetting cached policy values");
assert_eq!(entries[1].component.as_deref(), Some("MSI-client"));
assert_eq!(entries[1].thread_display.as_deref(), Some("8C:98"));
assert_eq!(entries[1].thread, Some(0x98));
assert_eq!(entries[1].severity, Severity::Info);
}
#[test]
fn test_parse_engine_server_context() {
let lines = ["MSI (s) (4A:B0) [10:00:00:000]: Server running"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].component.as_deref(), Some("MSI-server"));
assert_eq!(entries[0].thread_display.as_deref(), Some("4A:B0"));
assert_eq!(entries[0].thread, Some(0xB0));
}
#[test]
fn test_parse_engine_action_context() {
let lines = ["MSI (a) (4A:B0) [10:00:00:000]: Custom action started"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].component.as_deref(), Some("MSI-action"));
}
#[test]
fn test_parse_action_start() {
let lines = [
"=== Verbose logging started: 1/1/2024 16:34:00 Build type: SHIP ===",
"Action start 16:34:29: InstallFiles.",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[1].component.as_deref(), Some("InstallFiles"));
assert_eq!(entries[1].severity, Severity::Info);
assert!(entries[1].timestamp.is_some());
}
#[test]
fn test_parse_action_ended_success() {
let lines = [
"=== Verbose logging started: 1/1/2024 16:34:00 Build type: SHIP ===",
"Action ended 16:34:29: InstallFiles. Return value 1.",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[1].component.as_deref(), Some("InstallFiles"));
assert_eq!(entries[1].severity, Severity::Info);
}
#[test]
fn test_parse_action_ended_error() {
let lines = [
"=== Verbose logging started: 1/1/2024 16:34:00 Build type: SHIP ===",
"Action ended 16:34:29: InstallFiles. Return value 3.",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[1].severity, Severity::Error);
}
#[test]
fn test_parse_action_ended_warning() {
let lines = ["Action ended 16:34:29: InstallFiles. Return value 2."];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].severity, Severity::Warning);
}
#[test]
fn test_parse_property() {
let lines = ["Property(C): ProductCode = {C64CA371-1234-5678-9ABC-DEF012345678}"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].component.as_deref(), Some("MSI-properties"));
assert_eq!(
entries[0].message,
"ProductCode = {C64CA371-1234-5678-9ABC-DEF012345678}"
);
assert_eq!(entries[0].severity, Severity::Info);
assert!(entries[0].timestamp.is_none());
}
#[test]
fn test_main_engine_thread_success() {
let lines = ["MainEngineThread is returning 0"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].severity, Severity::Info);
assert_eq!(entries[0].component.as_deref(), Some("MSI-engine"));
}
#[test]
fn test_main_engine_thread_error_1603() {
let lines = ["MainEngineThread is returning 1603"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].severity, Severity::Error);
}
#[test]
fn test_main_engine_thread_warning_1602() {
let lines = ["MainEngineThread is returning 1602"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].severity, Severity::Warning);
}
#[test]
fn test_parse_footer() {
let lines = ["=== Verbose logging stopped: 6/13/2023 9:03:15 ==="];
let (entries, errors) = parse_lines(&lines, "test.log");
assert_eq!(errors, 0);
assert_eq!(entries[0].severity, Severity::Info);
assert_eq!(entries[0].component.as_deref(), Some("MSI-header"));
}
#[test]
fn test_plain_text_fallback() {
let lines = ["Some random unstructured text"];
let (entries, errors) = parse_lines(&lines, "test.log");
assert_eq!(errors, 1);
assert_eq!(entries[0].severity, Severity::Info);
assert!(entries[0].component.is_none());
}
#[test]
fn test_engine_error_keyword_severity() {
let lines = ["MSI (c) (8C:98) [10:00:00:000]: Installation failed with error status: 1603"];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].severity, Severity::Error);
}
#[test]
fn test_midnight_rollover() {
let lines = [
"=== Verbose logging started: 1/15/2024 23:59:50 Build type: SHIP ===",
"MSI (c) (8C:98) [23:59:55:000]: Before midnight",
"MSI (c) (8C:98) [00:00:05:000]: After midnight",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert!(entries[2].timestamp.is_some());
assert_eq!(
entries[2].timestamp_display.as_deref(),
Some("01-16-2024 00:00:05.000")
);
}
#[test]
fn test_empty_lines_skipped() {
let lines = ["", " ", "MSI (c) (8C:98) [10:00:00:000]: Hello", ""];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries.len(), 1);
assert_eq!(entries[0].message, "Hello");
}
#[test]
fn test_ids_and_line_numbers() {
let lines = [
"=== Verbose logging started: 1/1/2024 10:00:00 Build type: SHIP ===",
"MSI (c) (8C:98) [10:00:01:000]: First",
"MSI (c) (8C:98) [10:00:02:000]: Second",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(entries[0].id, 0);
assert_eq!(entries[0].line_number, 1);
assert_eq!(entries[1].id, 1);
assert_eq!(entries[1].line_number, 2);
assert_eq!(entries[2].id, 2);
assert_eq!(entries[2].line_number, 3);
}
#[test]
fn test_timestamp_display_format() {
let lines = [
"=== Verbose logging started: 12/25/2023 8:30:15 Build type: SHIP ===",
"MSI (c) (FF:01) [08:30:15:007]: Test message",
];
let (entries, _) = parse_lines(&lines, "test.log");
assert_eq!(
entries[1].timestamp_display.as_deref(),
Some("12-25-2023 08:30:15.007")
);
}
#[test]
fn test_engine_without_header_has_time_only_display() {
let lines = ["MSI (c) (8C:98) [14:30:00:123]: No header yet"];
let (entries, _) = parse_lines(&lines, "test.log");
assert!(entries[0].timestamp.is_none());
assert_eq!(
entries[0].timestamp_display.as_deref(),
Some("14:30:00.123")
);
}
#[test]
fn test_file_path_propagated() {
let lines = ["MSI (c) (8C:98) [10:00:00:000]: Test"];
let (entries, _) = parse_lines(&lines, "C:/Logs/install.log");
assert_eq!(entries[0].file_path, "C:/Logs/install.log");
}
#[test]
fn test_log_format_is_timestamped() {
let lines = [
"MSI (c) (8C:98) [10:00:00:000]: Test",
"Property(C): Foo = Bar",
"Random line",
];
let (entries, _) = parse_lines(&lines, "test.log");
for entry in &entries {
assert_eq!(entry.format, LogFormat::Timestamped);
}
}
}