bb-cli 0.1.0

bb — a Bitbucket CLI, a gh for Bitbucket.
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

//! Test-only support: scripted fakes and a `Context` builder, so command tests
//! are hermetic (the analog of `gh`'s `runCommand` helper + prompt stubber).
//!
//! Available only under `cfg(test)`.
#![allow(dead_code)]

use std::collections::VecDeque;
use std::sync::{Arc, Mutex};

use crate::core::{
    Browser, ConfigProvider, Context, GitClient, IoStreams, PromptError, Prompter, TestBuffers,
    Transport,
};

/// A [`Prompter`] that returns pre-scripted answers, panicking on an unexpected
/// prompt (the analog of `gh`'s `AskStubber`).
#[derive(Default)]
pub struct ScriptedPrompter {
    confirms: Mutex<VecDeque<bool>>,
    inputs: Mutex<VecDeque<String>>,
    passwords: Mutex<VecDeque<String>>,
    selects: Mutex<VecDeque<usize>>,
    editors: Mutex<VecDeque<String>>,
}

impl ScriptedPrompter {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn confirm(self, v: bool) -> Self {
        self.confirms.lock().unwrap().push_back(v);
        self
    }

    #[must_use]
    pub fn input(self, v: &str) -> Self {
        self.inputs.lock().unwrap().push_back(v.to_owned());
        self
    }

    #[must_use]
    pub fn password(self, v: &str) -> Self {
        self.passwords.lock().unwrap().push_back(v.to_owned());
        self
    }

    #[must_use]
    pub fn select(self, v: usize) -> Self {
        self.selects.lock().unwrap().push_back(v);
        self
    }

    #[must_use]
    pub fn editor(self, v: &str) -> Self {
        self.editors.lock().unwrap().push_back(v.to_owned());
        self
    }
}

fn pop<T>(q: &Mutex<VecDeque<T>>, what: &str) -> Result<T, PromptError> {
    q.lock()
        .unwrap()
        .pop_front()
        .ok_or_else(|| PromptError::Other(format!("unexpected {what} prompt")))
}

impl Prompter for ScriptedPrompter {
    fn confirm(&self, _message: &str, _default: bool) -> Result<bool, PromptError> {
        pop(&self.confirms, "confirm")
    }

    fn input(&self, _message: &str, _default: Option<&str>) -> Result<String, PromptError> {
        pop(&self.inputs, "input")
    }

    fn password(&self, _message: &str) -> Result<String, PromptError> {
        pop(&self.passwords, "password")
    }

    fn select(&self, _message: &str, _options: &[String]) -> Result<usize, PromptError> {
        pop(&self.selects, "select")
    }

    fn editor(&self, _message: &str, _initial: &str) -> Result<String, PromptError> {
        pop(&self.editors, "editor")
    }
}

/// A [`Browser`] that records the last URL "opened" instead of launching one.
#[derive(Default)]
pub struct RecordingBrowser {
    pub urls: Mutex<Vec<String>>,
}

impl Browser for RecordingBrowser {
    fn browse(&self, url: &str) -> Result<(), std::io::Error> {
        self.urls.lock().unwrap().push(url.to_owned());
        Ok(())
    }
}

/// Build a test [`Context`] from injected fakes, returning the captured
/// stdout/stderr buffers. TTY state defaults to `tty`.
pub fn test_context(
    transport: Arc<dyn Transport>,
    git: Arc<dyn GitClient>,
    config: Arc<dyn ConfigProvider>,
    prompter: Arc<dyn Prompter>,
    tty: bool,
) -> (Context, TestBuffers) {
    let (mut io, bufs) = IoStreams::test();
    io.set_stdout_tty(tty);
    io.set_stderr_tty(tty);
    io.set_stdin_tty(tty);
    let ctx = Context {
        io: Arc::new(io),
        prompter,
        browser: Arc::new(RecordingBrowser::default()),
        git,
        config,
        transport,
        app_version: "test".to_owned(),
        repo_override: None,
    };
    (ctx, bufs)
}