my_task 1.3.0

A simple CLI task manager powered by SQLite
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

use assert_cmd::Command;
use predicates::prelude::*;
use tempfile::TempDir;

fn cmd(db_path: &std::path::Path) -> Command {
    let mut c = Command::cargo_bin("my-task").unwrap();
    c.env("MY_TASK_DATA_FILE", db_path);
    c
}

#[test]
fn test_done_basic() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path).args(["add", "Finish me"]).assert().success();

    cmd(&db_path)
        .args(["done", "1"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Done: #1 Finish me"));

    let output = cmd(&db_path).args(["list"]).assert().success();
    let stdout = String::from_utf8(output.get_output().stdout.clone()).unwrap();
    assert!(!stdout.contains("Finish me"));
}

#[test]
fn test_done_not_found() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path).args(["add", "Exists"]).assert().success();

    cmd(&db_path)
        .args(["done", "999"])
        .assert()
        .failure()
        .stderr(predicate::str::contains("Error: task #999 not found"));
}

#[test]
fn test_done_already_done() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path)
        .args(["add", "Double done"])
        .assert()
        .success();
    cmd(&db_path).args(["done", "1"]).assert().success();

    cmd(&db_path)
        .args(["done", "1"])
        .assert()
        .failure()
        .stderr(predicate::str::contains("Error: task #1 is already done"));
}

#[test]
fn test_done_multiple_ids() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path).args(["add", "Task A"]).assert().success();
    cmd(&db_path).args(["add", "Task B"]).assert().success();
    cmd(&db_path).args(["add", "Task C"]).assert().success();

    cmd(&db_path)
        .args(["done", "1", "2", "3"])
        .assert()
        .success()
        .stdout(predicate::str::contains("Done: #1 Task A"))
        .stdout(predicate::str::contains("Done: #2 Task B"))
        .stdout(predicate::str::contains("Done: #3 Task C"));

    let output = cmd(&db_path).args(["list"]).assert().success();
    let stdout = String::from_utf8(output.get_output().stdout.clone()).unwrap();
    assert!(!stdout.contains("Task A"));
    assert!(!stdout.contains("Task B"));
    assert!(!stdout.contains("Task C"));
}

#[test]
fn test_done_multiple_ids_partial_failure() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path).args(["add", "Real task"]).assert().success();
    cmd(&db_path)
        .args(["add", "Another real task"])
        .assert()
        .success();

    cmd(&db_path)
        .args(["done", "1", "999", "2"])
        .assert()
        .failure()
        .stdout(predicate::str::contains("Done: #1 Real task"))
        .stdout(predicate::str::contains("Done: #2 Another real task"))
        .stderr(predicate::str::contains("Error: task #999 not found"));

    // Verify successful ones are actually done
    let output = cmd(&db_path).args(["list"]).assert().success();
    let stdout = String::from_utf8(output.get_output().stdout.clone()).unwrap();
    assert!(!stdout.contains("Real task"));
    assert!(!stdout.contains("Another real task"));
}

#[test]
fn test_done_multiple_ids_no_args() {
    let tmp = TempDir::new().unwrap();
    let db_path = tmp.path().join("tasks.db");

    cmd(&db_path).args(["done"]).assert().failure();
}