Add unit and integration tests for mingling_core

3 files changed, 238 insertions, 0 deletions

diff --git a/mingling_core/src/renderer/general.rs b/mingling_core/src/renderer/general.rs
index 0ea82c1..1a9647b 100644
--- a/mingling_core/src/renderer/general.rs
+++ b/mingling_core/src/renderer/general.rs
@@ -142,3 +142,115 @@ impl GeneralRenderer {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::RenderResult;
+    use serde::Serialize;
+
+    #[derive(Debug, Clone, PartialEq, Serialize)]
+    struct TestData {
+        name: String,
+        value: i32,
+    }
+
+    fn test_data() -> TestData {
+        TestData {
+            name: "hello".into(),
+            value: 42,
+        }
+    }
+
+    #[test]
+    fn test_render_disable_does_nothing() {
+        let mut r = RenderResult::default();
+        let result =
+            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Disable, &mut r);
+        assert!(result.is_ok());
+        assert!(r.is_empty());
+    }
+
+    #[cfg(feature = "json_serde_fmt")]
+    #[test]
+    fn test_render_to_json() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_json(&test_data(), &mut r);
+        assert!(result.is_ok());
+        assert!(!r.is_empty());
+        let output: String = r.into();
+        assert!(output.contains("\"name\""));
+        assert!(output.contains("\"hello\""));
+        assert!(output.contains("\"value\""));
+        assert!(output.contains("42"));
+    }
+
+    #[cfg(feature = "json_serde_fmt")]
+    #[test]
+    fn test_render_to_json_pretty() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_json_pretty(&test_data(), &mut r);
+        assert!(result.is_ok());
+        let output: String = r.into();
+        // Pretty JSON has newlines
+        assert!(output.contains('\n'));
+    }
+
+    #[cfg(feature = "yaml_serde_fmt")]
+    #[test]
+    fn test_render_to_yaml() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_yaml(&test_data(), &mut r);
+        assert!(result.is_ok());
+        assert!(!r.is_empty());
+    }
+
+    #[cfg(feature = "toml_serde_fmt")]
+    #[test]
+    fn test_render_to_toml() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_toml(&test_data(), &mut r);
+        assert!(result.is_ok());
+        assert!(!r.is_empty());
+    }
+
+    #[cfg(feature = "ron_serde_fmt")]
+    #[test]
+    fn test_render_to_ron() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_ron(&test_data(), &mut r);
+        assert!(result.is_ok());
+        assert!(!r.is_empty());
+    }
+
+    #[cfg(feature = "ron_serde_fmt")]
+    #[test]
+    fn test_render_to_ron_pretty() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render_to_ron_pretty(&test_data(), &mut r);
+        assert!(result.is_ok());
+        let output: String = r.into();
+        assert!(output.contains('\n'));
+    }
+
+    #[test]
+    fn test_render_dispatches_correct_format() {
+        // Test that render dispatches to the right format handler
+        let mut r = RenderResult::default();
+
+        // Disable
+        let result =
+            GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Disable, &mut r);
+        assert!(result.is_ok());
+        assert!(r.is_empty());
+    }
+
+    #[cfg(feature = "json_serde_fmt")]
+    #[test]
+    fn test_render_dispatches_json() {
+        let mut r = RenderResult::default();
+        let result = GeneralRenderer::render(&test_data(), &GeneralRendererSetting::Json, &mut r);
+        assert!(result.is_ok());
+        assert!(!r.is_empty());
+    }
+}
diff --git a/mingling_core/src/renderer/general/error.rs b/mingling_core/src/renderer/general/error.rs
index eb76a8b..8c89266 100644
--- a/mingling_core/src/renderer/general/error.rs
+++ b/mingling_core/src/renderer/general/error.rs
@@ -34,3 +34,35 @@ impl From<GeneralRendererSerializeError> for String {
         val.error
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn new_creates_error_with_message() {
+        let msg = "serialization failed".to_string();
+        let err = GeneralRendererSerializeError::new(msg.clone());
+        assert_eq!(err.error, msg);
+    }
+
+    #[test]
+    fn from_str_creates_error_from_string_slice() {
+        let err: GeneralRendererSerializeError = "oops".into();
+        assert_eq!(err.error, "oops");
+    }
+
+    #[test]
+    fn deref_accesses_inner_error_string() {
+        let err = GeneralRendererSerializeError::new("inner message".to_string());
+        let derefed: &String = &*err;
+        assert_eq!(derefed, "inner message");
+    }
+
+    #[test]
+    fn into_string_extracts_message() {
+        let err = GeneralRendererSerializeError::new("extract me".to_string());
+        let s: String = err.into();
+        assert_eq!(s, "extract me");
+    }
+}
diff --git a/mingling_core/src/renderer/render_result.rs b/mingling_core/src/renderer/render_result.rs
index 3eb8929..5ef3120 100644
--- a/mingling_core/src/renderer/render_result.rs
+++ b/mingling_core/src/renderer/render_result.rs
@@ -105,3 +105,97 @@ impl RenderResult {
         self.render_text.clear();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write as IoWrite;
+
+    #[test]
+    fn default_creates_empty_text_with_exit_code_zero() {
+        let result = RenderResult::default();
+        assert!(result.is_empty());
+        assert_eq!(result.exit_code, 0);
+    }
+
+    #[test]
+    fn print_appends_text() {
+        let mut result = RenderResult::default();
+        result.print("Hello");
+        assert_eq!(result.deref(), "Hello");
+    }
+
+    #[test]
+    fn println_appends_text_with_newline() {
+        let mut result = RenderResult::default();
+        result.println("Hello");
+        assert_eq!(result.deref(), "Hello\n");
+    }
+
+    #[test]
+    fn clear_empties_content() {
+        let mut result = RenderResult::default();
+        result.print("something");
+        assert!(!result.is_empty());
+        result.clear();
+        assert!(result.is_empty());
+    }
+
+    #[test]
+    fn is_empty_returns_true_for_new_false_after_print() {
+        let mut result = RenderResult::default();
+        assert!(result.is_empty());
+        result.print("x");
+        assert!(!result.is_empty());
+    }
+
+    #[test]
+    fn write_appends_utf8_bytes() {
+        let mut result = RenderResult::default();
+        let n = IoWrite::write(&mut result, b"hello").unwrap();
+        assert_eq!(n, 5);
+        assert_eq!(result.deref(), "hello");
+    }
+
+    #[test]
+    fn write_with_invalid_utf8_returns_error() {
+        let mut result = RenderResult::default();
+        let err = IoWrite::write(&mut result, &[0xff, 0xfe]).unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
+    }
+
+    #[test]
+    fn display_trims_trailing_whitespace() {
+        let mut result = RenderResult::default();
+        result.print("  hello world  \n");
+        let formatted = format!("{}", result);
+        assert_eq!(formatted, "hello world\n");
+    }
+
+    #[test]
+    fn deref_exposes_inner_text_as_str() {
+        let mut result = RenderResult::default();
+        result.print("test");
+
+        let s: &str = &result;
+        assert_eq!(s, "test");
+    }
+
+    #[test]
+    fn from_render_result_into_string_consumes() {
+        let mut result = RenderResult::default();
+        result.print("content");
+        let s: String = result.into();
+        assert_eq!(s, "content");
+    }
+
+    #[test]
+    fn from_ref_render_result_into_string_clones() {
+        let mut result = RenderResult::default();
+        result.print("content");
+        let s: String = String::from(&result);
+        assert_eq!(s, "content");
+        // original is still usable
+        assert!(!result.is_empty());
+    }
+}