github-copilot-sdk 1.0.17-preview.5

Rust SDK for programmatic control of the GitHub Copilot CLI via JSON-RPC.
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *--------------------------------------------------------------------------------------------*/

#![cfg(test)]

use super::*;

fn data() -> PermissionRequestData {
    PermissionRequestData {
        extra: serde_json::json!({ "tool": "shell" }),
        ..Default::default()
    }
}

#[tokio::test]
async fn approve_all_approves() {
    let h = approve_all();
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), data())
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::ApproveOnce(_),
            ..
        }
    ));
}

#[tokio::test]
async fn approve_all_fails_when_managed_settings_enabled() {
    let h = approve_all();
    let mut request = data();
    request.managed_settings_enabled = true;
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), request)
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::UserNotAvailable(_),
            ..
        }
    ));
}

#[tokio::test]
async fn deny_all_denies() {
    let h = deny_all();
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), data())
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::Reject(_),
            ..
        }
    ));
}

#[tokio::test]
async fn approve_if_consults_predicate() {
    let h = approve_if(|d| d.extra.get("tool").and_then(|v| v.as_str()) != Some("shell"));
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), data())
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::Reject(_),
            ..
        }
    ));
}

#[tokio::test]
async fn approve_if_leaves_managed_approval_pending_when_predicate_approves() {
    let h = approve_if(|_| true);
    let mut request = data();
    request.managed_approval_required = Some(true);
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), request)
            .await,
        PermissionResult::NoResult
    ));
}

#[tokio::test]
async fn approve_if_still_rejects_managed_request_when_predicate_denies() {
    let h = approve_if(|_| false);
    let mut request = data();
    request.managed_approval_required = Some(true);
    assert!(matches!(
        h.handle(SessionId::from("s"), RequestId::new("1"), request)
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::Reject(_),
            ..
        }
    ));
}

#[tokio::test]
async fn resolve_handler_policy_wins() {
    struct AlwaysApprove;
    #[async_trait]
    impl PermissionHandler for AlwaysApprove {
        async fn handle(
            &self,
            _: SessionId,
            _: RequestId,
            _: PermissionRequestData,
        ) -> PermissionResult {
            PermissionResult::approve_once()
        }
    }
    let resolved = resolve_handler(Some(Arc::new(AlwaysApprove)), Some(Policy::DenyAll)).unwrap();
    // Policy wins -- the AlwaysApprove handler is discarded.
    assert!(matches!(
        resolved
            .handle(SessionId::from("s"), RequestId::new("1"), data())
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::Reject(_),
            ..
        }
    ));
}

#[tokio::test]
async fn resolve_handler_with_only_handler() {
    struct H;
    #[async_trait]
    impl PermissionHandler for H {
        async fn handle(
            &self,
            _: SessionId,
            _: RequestId,
            _: PermissionRequestData,
        ) -> PermissionResult {
            PermissionResult::approve_once()
        }
    }
    let resolved = resolve_handler(Some(Arc::new(H)), None).unwrap();
    assert!(matches!(
        resolved
            .handle(SessionId::from("s"), RequestId::new("1"), data())
            .await,
        PermissionResult::Decision {
            decision: crate::types::PermissionDecision::ApproveOnce(_),
            ..
        }
    ));
}

#[test]
fn resolve_handler_with_neither_returns_none() {
    assert!(resolve_handler(None, None).is_none());
}