augent 0.6.6

Lean package manager for various AI coding platforms
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

//! Integration tests for end-to-end platform workflows

use std::fs;
use tempfile::TempDir;

use crate::platform::{default_platforms, detection::detect_platforms};

#[test]
fn test_all_platforms_defined() {
    let platforms = default_platforms();

    assert_eq!(platforms.len(), 17);

    let expected_ids = vec![
        "antigravity",
        "augment",
        "claude",
        "claude-plugin",
        "codex",
        "copilot",
        "cursor",
        "factory",
        "gemini",
        "junie",
        "kilo",
        "kiro",
        "opencode",
        "qwen",
        "roo",
        "warp",
        "windsurf",
    ];

    for id in expected_ids {
        assert!(
            platforms.iter().any(|p| p.id == id),
            "Platform {} is missing from default platforms",
            id
        );
    }
}

#[test]
fn test_detect_all_platforms_integration() {
    let temp = TempDir::new_in(crate::temp::temp_dir_base()).unwrap();

    fs::create_dir(temp.path().join(".agent")).unwrap();
    fs::create_dir(temp.path().join(".augment")).unwrap();
    fs::create_dir(temp.path().join(".claude")).unwrap();
    fs::create_dir_all(temp.path().join(".claude-plugin")).unwrap();
    fs::write(temp.path().join(".claude-plugin/plugin.json"), "{}").unwrap();
    fs::create_dir(temp.path().join(".codex")).unwrap();
    fs::create_dir(temp.path().join(".cursor")).unwrap();
    fs::create_dir(temp.path().join(".factory")).unwrap();
    fs::create_dir(temp.path().join(".kilocode")).unwrap();
    fs::create_dir(temp.path().join(".kiro")).unwrap();
    fs::create_dir(temp.path().join(".opencode")).unwrap();
    fs::create_dir(temp.path().join(".qwen")).unwrap();
    fs::create_dir(temp.path().join(".roo")).unwrap();
    fs::create_dir(temp.path().join(".warp")).unwrap();
    fs::create_dir(temp.path().join(".windsurf")).unwrap();

    let detected = detect_platforms(temp.path()).unwrap();
    assert_eq!(detected.len(), 14);
}

#[test]
fn test_platform_transform_completeness() {
    let platforms = default_platforms();

    for platform in platforms {
        assert!(
            !platform.transforms.is_empty(),
            "Platform {} has no transform rules",
            platform.id
        );
        assert!(
            !platform.detection.is_empty(),
            "Platform {} has no detection patterns",
            platform.id
        );
    }
}

#[test]
fn test_platform_ids_are_unique() {
    let platforms = default_platforms();

    let mut ids = Vec::new();
    for platform in &platforms {
        assert!(
            !ids.contains(&platform.id),
            "Duplicate platform ID: {}",
            platform.id
        );
        ids.push(platform.id.clone());
    }
}

#[test]
fn test_platform_directories_are_unique() {
    let platforms = default_platforms();

    let mut dirs = Vec::new();
    for platform in &platforms {
        assert!(
            !dirs.contains(&platform.directory),
            "Duplicate platform directory: {}",
            platform.directory
        );
        dirs.push(platform.directory.clone());
    }
}