start-command 0.15.1

Gamification of coding, execute any command with ability to auto-report issues on GitHub
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! Tests for cleanup_stale and lock functionality in ExecutionStore

use start_command::execution_store::{
    CleanupOptions, ExecutionRecord, ExecutionStatus, ExecutionStore, ExecutionStoreOptions,
};
use tempfile::TempDir;

/// Create a test store with temporary directory
fn create_test_store() -> (ExecutionStore, TempDir) {
    let temp_dir = TempDir::new().unwrap();
    let store = ExecutionStore::with_options(ExecutionStoreOptions {
        app_folder: Some(temp_dir.path().to_path_buf()),
        verbose: false,
        ..ExecutionStoreOptions::default()
    });
    (store, temp_dir)
}

#[test]
fn test_cleanup_stale_no_stale_records() {
    let (store, _temp) = create_test_store();

    // Create a record that just started (not stale)
    let record = ExecutionRecord::new("echo hello");
    store.save(&record).unwrap();

    let result = store.cleanup_stale(CleanupOptions {
        dry_run: false,
        ..Default::default()
    });

    assert_eq!(result.cleaned, 0);
    assert_eq!(result.records.len(), 0);
    assert!(result.errors.is_empty());
}

#[test]
fn test_cleanup_stale_dry_run() {
    let (store, _temp) = create_test_store();

    // Create a record with an old start time
    let mut record = ExecutionRecord::new("echo old");
    // Set start time to 25 hours ago
    let old_time = chrono::Utc::now() - chrono::Duration::hours(25);
    record.start_time = old_time.to_rfc3339();
    store.save(&record).unwrap();

    // Dry run should find the stale record but not clean it
    let result = store.cleanup_stale(CleanupOptions {
        dry_run: true,
        ..Default::default()
    });

    assert_eq!(result.cleaned, 1);
    assert_eq!(result.records.len(), 1);
    assert_eq!(result.records[0].uuid, record.uuid);

    // Record should still be executing
    let retrieved = store.get(&record.uuid).unwrap();
    assert_eq!(retrieved.status, ExecutionStatus::Executing);
}

#[test]
fn test_cleanup_stale_actual_cleanup() {
    let (store, _temp) = create_test_store();

    // Create a record with an old start time
    let mut record = ExecutionRecord::new("echo old");
    // Set start time to 25 hours ago
    let old_time = chrono::Utc::now() - chrono::Duration::hours(25);
    record.start_time = old_time.to_rfc3339();
    store.save(&record).unwrap();

    // Actual cleanup should mark the record as executed with exit code -1
    let result = store.cleanup_stale(CleanupOptions {
        dry_run: false,
        ..Default::default()
    });

    assert_eq!(result.cleaned, 1);
    assert_eq!(result.records.len(), 1);

    // Record should now be executed with exit code -1
    let retrieved = store.get(&record.uuid).unwrap();
    assert_eq!(retrieved.status, ExecutionStatus::Executed);
    assert_eq!(retrieved.exit_code, Some(-1));
    assert!(retrieved.end_time.is_some());
}

#[test]
fn test_cleanup_stale_custom_max_age() {
    let (store, _temp) = create_test_store();

    // Create a record with a 2 hour old start time
    let mut record = ExecutionRecord::new("echo recent");
    let old_time = chrono::Utc::now() - chrono::Duration::hours(2);
    record.start_time = old_time.to_rfc3339();
    store.save(&record).unwrap();

    // With default 24 hour max age, should not be stale
    let result = store.cleanup_stale(CleanupOptions {
        dry_run: true,
        ..Default::default()
    });
    assert_eq!(result.cleaned, 0);

    // With 1 hour max age, should be stale
    let result = store.cleanup_stale(CleanupOptions {
        dry_run: true,
        max_age_ms: Some(60 * 60 * 1000), // 1 hour
    });
    assert_eq!(result.cleaned, 1);
}

#[test]
fn test_cleanup_stale_only_executing_records() {
    let (store, _temp) = create_test_store();

    // Create an old executed record
    let mut executed_record = ExecutionRecord::new("echo done");
    let old_time = chrono::Utc::now() - chrono::Duration::hours(25);
    executed_record.start_time = old_time.to_rfc3339();
    executed_record.complete(0);
    store.save(&executed_record).unwrap();

    // Create an old executing record
    let mut executing_record = ExecutionRecord::new("echo running");
    executing_record.start_time = old_time.to_rfc3339();
    store.save(&executing_record).unwrap();

    let result = store.cleanup_stale(CleanupOptions {
        dry_run: true,
        ..Default::default()
    });

    // Only the executing record should be found as stale
    assert_eq!(result.cleaned, 1);
    assert_eq!(result.records[0].uuid, executing_record.uuid);
}