finery 0.2.0

Keyboard-first Jira backlog and Composer with optional MCP access
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

use crate::store::composer::{
    ChangeKind, ChangeSet, SubmissionSnapshot, Ticket, TicketChange, TicketKind,
};

use super::{ConditionalSaveChangeSetOutcome, Storage};

mod revisions;
mod ticket_order;

fn ticket(key: &str, title: &str) -> Ticket {
    Ticket {
        key: key.into(),
        project_key: "OPS".into(),
        title: title.into(),
        description: "Description".into(),
        description_safe_to_overwrite: true,
        kind: TicketKind::Story,
        status: "To Do".into(),
        priority: "High".into(),
        assignee: "Ada".into(),
        assignee_account_id: "ada".into(),
        parent_key: None,
        parent_title: None,
        parent_kind: None,
        has_children: false,
    }
}

#[test]
fn change_sets_ticket_snapshots_and_settings_survive_round_trip() {
    tokio::runtime::Runtime::new().unwrap().block_on(async {
        let storage = Storage::connect_for_tests().await.unwrap();
        let set = ChangeSet {
            id: "CS-1".into(),
            name: "Checkout".into(),
            closed: true,
            selected_ticket_ids: vec!["OPS-1".into()],
            submission_attempt: None,
            tickets: vec![TicketChange {
                id: "OPS-1".into(),
                original: Some(ticket("OPS-1", "Original")),
                updated: Some(ticket("OPS-1", "Updated")),
                kind: ChangeKind::Modified,
                submitted: Some(SubmissionSnapshot {
                    original: Some(ticket("OPS-1", "Original")),
                    updated: Some(ticket("OPS-1", "Updated")),
                }),
                retry_blocked: false,
                create_attempt: true,
                sibling_order: 0,
            }],
        };

        storage.save_change_set(&set).await.unwrap();
        storage
            .set_settings(&[("reader.wpm", "450".into())])
            .await
            .unwrap();
        storage
            .set_settings(&[("reader.wpm", "500".into())])
            .await
            .unwrap();
        storage
            .set_settings(&[
                ("jira.story_points_board_id", "42".into()),
                ("jira.story_points_field_id", "customfield_10016".into()),
            ])
            .await
            .unwrap();

        assert_eq!(storage.load_change_sets().await.unwrap(), vec![set]);
        assert_eq!(
            storage.load_settings().await.unwrap().get("reader.wpm"),
            Some(&"500".to_string())
        );
        assert_eq!(
            storage
                .load_settings()
                .await
                .unwrap()
                .get("jira.story_points_field_id"),
            Some(&"customfield_10016".to_string())
        );
    });
}

#[test]
fn deleting_change_set_cascades_ticket_changes() {
    tokio::runtime::Runtime::new().unwrap().block_on(async {
        let storage = Storage::connect_for_tests().await.unwrap();
        let set = ChangeSet {
            id: "CS-2".into(),
            name: "Disposable".into(),
            closed: false,
            selected_ticket_ids: vec!["NEW-1".into()],
            submission_attempt: None,
            tickets: vec![TicketChange {
                id: "NEW-1".into(),
                original: None,
                updated: Some(ticket("NEW-1", "Local")),
                kind: ChangeKind::Added,
                submitted: None,
                retry_blocked: false,
                create_attempt: false,
                sibling_order: 0,
            }],
        };
        storage.save_change_set(&set).await.unwrap();

        storage.delete_change_set(&set.id).await.unwrap();

        assert!(storage.load_change_sets().await.unwrap().is_empty());
    });
}

#[test]
fn recent_ticket_stack_keeps_unique_keys_in_open_order() {
    tokio::runtime::Runtime::new().unwrap().block_on(async {
        let storage = Storage::connect_for_tests().await.unwrap();

        storage.record_recent_ticket("OPS-1", 1, 2).await.unwrap();
        storage.record_recent_ticket("OPS-2", 2, 2).await.unwrap();
        storage.record_recent_ticket("OPS-1", 3, 2).await.unwrap();
        storage.record_recent_ticket("OPS-3", 4, 2).await.unwrap();

        assert_eq!(
            storage.load_recent_ticket_keys(15).await.unwrap(),
            vec!["OPS-3", "OPS-1"]
        );
    });
}