shimmy 1.3.4

Lightweight 5MB Ollama alternative with native SafeTensors support. No Python dependencies, 2x faster loading.
Documentation 
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

// PUNCH-generated tests for workflow module
use shimmy::tools::ToolRegistry;
use shimmy::workflow::{WorkflowEngine, WorkflowStep, WorkflowStepType};
use std::collections::HashMap;

#[cfg(test)]
mod tests {
    use super::*;

    // Rule: rust_result_err - Functions returning Result need Err case tests
    #[test]
    fn execute_workflow_error_case() {
        // Test error case handling with invalid workflow
        let engine = WorkflowEngine::new(ToolRegistry::new());
        let request = shimmy::workflow::WorkflowRequest {
            workflow: shimmy::workflow::Workflow {
                id: "test".to_string(),
                name: "test".to_string(),
                description: "test".to_string(),
                steps: vec![], // Empty workflow should cause error
                inputs: HashMap::new(),
                outputs: vec!["nonexistent".to_string()], // Reference non-existent step
            },
            context: HashMap::new(),
        };

        let rt = tokio::runtime::Runtime::new().unwrap();
        let result = rt.block_on(engine.execute_workflow(request));
        // Empty workflow might succeed but requesting output from non-existent step should fail
        if result.is_ok() {
            let workflow_result = result.unwrap();
            assert!(
                !workflow_result.success,
                "Workflow should fail with non-existent output step"
            );
        }
    }

    // Rule: rust_result_err - Functions returning Result need Err case tests
    #[test]
    fn calculate_execution_order_error_case() {
        let engine = WorkflowEngine::new(ToolRegistry::new());
        // Test circular dependencies - same as in the main module tests
        let steps = vec![
            WorkflowStep {
                id: "step1".to_string(),
                step_type: WorkflowStepType::DataTransform {
                    operation: "extract".to_string(),
                    expression: "test".to_string(),
                },
                depends_on: vec!["step2".to_string()],
                parameters: serde_json::Value::Null,
            },
            WorkflowStep {
                id: "step2".to_string(),
                step_type: WorkflowStepType::DataTransform {
                    operation: "extract".to_string(),
                    expression: "test".to_string(),
                },
                depends_on: vec!["step1".to_string()],
                parameters: serde_json::Value::Null,
            },
        ];
        let result = engine.calculate_execution_order(&steps);
        assert!(
            result.is_err(),
            "Function should return Err for circular dependencies"
        );
    }

    // Rule: rust_result_err - Functions returning Result need Err case tests
    #[test]
    fn substitute_variables_error_case() {
        let engine = WorkflowEngine::new(ToolRegistry::new());
        // Test with undefined variables - current implementation doesn't actually error on this
        // but we can test the behavior
        let template = "Hello {{undefined_var}}";
        let variables = HashMap::new();
        let result = engine.substitute_variables(template, &variables);
        // Current implementation just leaves undefined variables as-is
        assert!(
            result.is_ok(),
            "Current implementation handles undefined variables gracefully"
        );
        let output = result.unwrap();
        assert!(
            output.contains("{{undefined_var}}"),
            "Undefined variables should remain in output"
        );
    }

    // Rule: rust_empty_str - Functions accepting &str need empty string tests
    #[test]
    fn substitute_variables_empty_template() {
        let engine = WorkflowEngine::new(ToolRegistry::new());
        let variables = HashMap::new();
        let result = engine.substitute_variables("", &variables);
        match result {
            Ok(output) => assert_eq!(output, "", "Empty template should return empty string"),
            Err(_) => panic!("Empty template should not fail"),
        }
    }

    #[test]
    fn substitute_variables_no_variables() {
        let engine = WorkflowEngine::new(ToolRegistry::new());
        let variables = HashMap::new();
        let template = "Hello World";
        let result = engine.substitute_variables(template, &variables);
        match result {
            Ok(output) => assert_eq!(
                output, "Hello World",
                "Template without variables should pass through"
            ),
            Err(_) => panic!("Template without variables should not fail"),
        }
    }
}