pdmt 1.0.1

High-performance, deterministic templating library for Model Context Protocol (MCP) applications with comprehensive todo validation and quality enforcement
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use pdmt::models::content::{ContentFormat, GeneratedContent};
use pdmt::models::quality::QualityReport;
use serde_json::json;
use std::str::FromStr;

#[test]
fn test_content_format_yaml_to_json() {
    let yaml_content = r#"
todos:
  - id: task1
    content: Do something
    priority: high
"#;

    let content = GeneratedContent::new("test".to_string(), yaml_content.to_string(), json!({}));

    let json_content = content.as_format(ContentFormat::Json).unwrap();
    assert!(json_content.contains("\"todos\""));
    assert!(json_content.contains("\"task1\""));
}

#[test]
fn test_content_format_yaml_to_markdown() {
    let yaml_content = r#"
title: Test Document
items:
  - item1
  - item2
metadata:
  author: test
  version: 1.0
"#;

    let content = GeneratedContent::new("test".to_string(), yaml_content.to_string(), json!({}));

    let markdown_content = content.as_format(ContentFormat::Markdown).unwrap();
    assert!(markdown_content.contains("title"));
    assert!(markdown_content.contains("item1"));
}

#[test]
fn test_content_format_yaml_to_text() {
    let yaml_content = r#"
title: Test Document
content: This is the content
"#;

    let content = GeneratedContent::new("test".to_string(), yaml_content.to_string(), json!({}));

    let text_content = content.as_format(ContentFormat::Text).unwrap();
    assert!(text_content.contains("Test Document"));
    assert!(text_content.contains("This is the content"));
}

#[test]
fn test_content_quality_checks() {
    let mut content =
        GeneratedContent::new("test".to_string(), "test content".to_string(), json!({}));

    // Test quality report
    assert!(!content.has_quality_issues());

    content.quality_report = Some(QualityReport {
        passed: false,
        violations: vec![],
        suggestions: vec!["Improve quality".to_string()],
    });

    assert!(content.has_quality_issues());
}

#[test]
fn test_content_processing_duration() {
    let mut content = GeneratedContent::new("test".to_string(), "test".to_string(), json!({}));

    content.metadata.processing_time_ms = 1500;
    let duration = content.processing_duration();
    assert_eq!(duration.as_millis(), 1500);
}

#[test]
fn test_content_format_parsing() {
    assert_eq!(
        ContentFormat::from_str("yaml").unwrap(),
        ContentFormat::Yaml
    );
    assert_eq!(
        ContentFormat::from_str("json").unwrap(),
        ContentFormat::Json
    );
    assert_eq!(
        ContentFormat::from_str("text").unwrap(),
        ContentFormat::Text
    );
    assert_eq!(
        ContentFormat::from_str("markdown").unwrap(),
        ContentFormat::Markdown
    );
    assert!(ContentFormat::from_str("unknown").is_err());

    assert_eq!(ContentFormat::Yaml.to_string(), "yaml");
    assert_eq!(ContentFormat::Json.to_string(), "json");
}

#[test]
fn test_content_with_complex_yaml() {
    let yaml_content = r#"
project:
  name: Test Project
  tasks:
    - id: task1
      dependencies: [task2, task3]
    - id: task2
      dependencies: []
metadata:
  version: 1.0.0
"#;

    let content = GeneratedContent::new("test".to_string(), yaml_content.to_string(), json!({}));

    let json_result = content.as_format(ContentFormat::Json).unwrap();
    assert!(json_result.contains("\"project\""));
    assert!(json_result.contains("\"dependencies\""));
}

#[test]
fn test_content_metadata() {
    let content = GeneratedContent::new(
        "test_template".to_string(),
        "content".to_string(),
        json!({"input": "data"}),
    );

    assert_eq!(content.template_id, "test_template");
    assert_eq!(content.content, "content");
    assert_eq!(content.input_data, json!({"input": "data"}));

    // Check metadata defaults
    assert!(content.metadata.is_deterministic);
    assert_eq!(content.metadata.processing_time_ms, 0);
}