Merge pull request #1195 from shm11C3/chore/add-backend-test

Add unit tests for hardware monitoring and language services

Author: shm11C3

src-tauri/src/infrastructure/providers/windows/wmi_provider.rs

@@ -365,3 +365,154 @@ fn describe_memory_type_with_fallback(
     None => "Unknown".to_string(),
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  // ── format_wmi_datetime ──
+
+  #[test]
+  fn format_wmi_datetime_typical() {
+    let result = format_wmi_datetime("20230101000000.000000+000");
+    assert_eq!(result, Some("2023-01-01".to_string()));
+  }
+
+  #[test]
+  fn format_wmi_datetime_exact_8_chars() {
+    let result = format_wmi_datetime("20240315");
+    assert_eq!(result, Some("2024-03-15".to_string()));
+  }
+
+  #[test]
+  fn format_wmi_datetime_too_short() {
+    let result = format_wmi_datetime("2023");
+    assert!(result.is_none());
+  }
+
+  #[test]
+  fn format_wmi_datetime_empty() {
+    let result = format_wmi_datetime("");
+    assert!(result.is_none());
+  }
+
+  // ── describe_memory_type ──
+
+  #[test]
+  fn describe_memory_type_ddr4() {
+    assert_eq!(describe_memory_type(Some(26)), "DDR4");
+  }
+
+  #[test]
+  fn describe_memory_type_ddr3() {
+    assert_eq!(describe_memory_type(Some(24)), "DDR3");
+  }
+
+  #[test]
+  fn describe_memory_type_ddr2() {
+    assert_eq!(describe_memory_type(Some(21)), "DDR2");
+  }
+
+  #[test]
+  fn describe_memory_type_ddr() {
+    assert_eq!(describe_memory_type(Some(20)), "DDR");
+  }
+
+  #[test]
+  fn describe_memory_type_sdram() {
+    assert_eq!(describe_memory_type(Some(17)), "SDRAM");
+  }
+
+  #[test]
+  fn describe_memory_type_unknown_zero() {
+    assert_eq!(describe_memory_type(Some(0)), "Unknown or Unsupported");
+  }
+
+  #[test]
+  fn describe_memory_type_none() {
+    assert_eq!(describe_memory_type(None), "Unknown");
+  }
+
+  #[test]
+  fn describe_memory_type_unrecognized_value() {
+    assert_eq!(
+      describe_memory_type(Some(99)),
+      "Other or Unknown Memory Type (99)"
+    );
+  }
+
+  // ── describe_memory_type_with_fallback ──
+
+  #[test]
+  fn fallback_memory_type_none_returns_unknown() {
+    assert_eq!(describe_memory_type_with_fallback(None, None), "Unknown");
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_smbios_ddr5() {
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(0), Some(34)),
+      "DDR5"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_smbios_ddr4() {
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(0), Some(26)),
+      "DDR4"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_smbios_ddr3() {
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(0), Some(24)),
+      "DDR3"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_smbios_ddr2() {
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(0), Some(21)),
+      "DDR2"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_smbios_ddr() {
+    assert_eq!(describe_memory_type_with_fallback(Some(0), Some(20)), "DDR");
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_unknown_smbios() {
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(0), Some(50)),
+      "Other SMBIOS Memory Type (50)"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_zero_with_no_smbios() {
+    assert_eq!(describe_memory_type_with_fallback(Some(0), None), "Unknown");
+  }
+
+  #[test]
+  fn fallback_memory_type_nonzero_uses_primary() {
+    // When memory_type is non-zero, it should use describe_memory_type directly
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(26), Some(34)),
+      "DDR4"
+    );
+  }
+
+  #[test]
+  fn fallback_memory_type_nonzero_ignores_smbios() {
+    // memory_type=24 (DDR3) should be used, not smbios_memory_type=34 (DDR5)
+    assert_eq!(
+      describe_memory_type_with_fallback(Some(24), Some(34)),
+      "DDR3"
+    );
+  }
+}

src-tauri/src/models/hardware.rs

@@ -151,3 +151,113 @@ where
     s.serialize_str(&format!("{x:.1}")) // Up to 1 decimal place
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  fn make_process_info(cpu: f32, mem: f32) -> ProcessInfo {
+    ProcessInfo {
+      pid: 1,
+      name: "test".to_string(),
+      cpu_usage: cpu,
+      memory_usage: mem,
+    }
+  }
+
+  // ── serialize_usage via ProcessInfo JSON serialization ──
+
+  #[test]
+  fn serialize_usage_integer_values() {
+    let info = make_process_info(50.0, 100.0);
+    let json = serde_json::to_value(&info).unwrap();
+    assert_eq!(json["cpuUsage"], "50");
+    assert_eq!(json["memoryUsage"], "100");
+  }
+
+  #[test]
+  fn serialize_usage_fractional_values() {
+    let info = make_process_info(12.5, 33.3);
+    let json = serde_json::to_value(&info).unwrap();
+    assert_eq!(json["cpuUsage"], "12.5");
+    assert_eq!(json["memoryUsage"], "33.3");
+  }
+
+  #[test]
+  fn serialize_usage_zero() {
+    let info = make_process_info(0.0, 0.0);
+    let json = serde_json::to_value(&info).unwrap();
+    assert_eq!(json["cpuUsage"], "0");
+    assert_eq!(json["memoryUsage"], "0");
+  }
+
+  #[test]
+  fn serialize_usage_small_fraction() {
+    let info = make_process_info(0.1, 0.9);
+    let json = serde_json::to_value(&info).unwrap();
+    assert_eq!(json["cpuUsage"], "0.1");
+    assert_eq!(json["memoryUsage"], "0.9");
+  }
+
+  // ── ProcessInfo camelCase serialization ──
+
+  #[test]
+  fn process_info_camel_case_keys() {
+    let info = make_process_info(1.0, 2.0);
+    let json = serde_json::to_value(&info).unwrap();
+    assert!(json.get("cpuUsage").is_some());
+    assert!(json.get("memoryUsage").is_some());
+    assert!(json.get("pid").is_some());
+    assert!(json.get("name").is_some());
+  }
+
+  // ── NameValue serialization ──
+
+  #[test]
+  fn name_value_serialization() {
+    let nv = NameValue {
+      name: "GPU0".to_string(),
+      value: 72,
+    };
+    let json = serde_json::to_value(&nv).unwrap();
+    assert_eq!(json["name"], "GPU0");
+    assert_eq!(json["value"], 72);
+  }
+
+  // ── GpuUsageResult serialization ──
+
+  #[test]
+  fn gpu_usage_result_serialization() {
+    let result = GpuUsageResult {
+      usage: 85,
+      source: "NVAPI".to_string(),
+    };
+    let json = serde_json::to_value(&result).unwrap();
+    assert_eq!(json["usage"], 85);
+    assert_eq!(json["source"], "NVAPI");
+  }
+
+  // ── GpuMemoryUsage serialization ──
+
+  #[test]
+  fn gpu_memory_usage_with_none_fields() {
+    let mem = GpuMemoryUsage {
+      in_use_bytes: None,
+      alloc_bytes: None,
+    };
+    let json = serde_json::to_value(&mem).unwrap();
+    assert!(json["inUseBytes"].is_null());
+    assert!(json["allocBytes"].is_null());
+  }
+
+  #[test]
+  fn gpu_memory_usage_with_values() {
+    let mem = GpuMemoryUsage {
+      in_use_bytes: Some("1048576".to_string()),
+      alloc_bytes: Some("2097152".to_string()),
+    };
+    let json = serde_json::to_value(&mem).unwrap();
+    assert_eq!(json["inUseBytes"], "1048576");
+    assert_eq!(json["allocBytes"], "2097152");
+  }
+}