Skip to main content

omni_dev/cli/atlassian/confluence/
mod.rs

1//! Confluence CLI subcommands.
2
3pub(crate) mod create;
4pub(crate) mod delete;
5pub(crate) mod edit;
6pub(crate) mod read;
7pub(crate) mod search;
8pub(crate) mod write;
9
10use anyhow::Result;
11use clap::{Parser, Subcommand};
12
13/// Confluence page management, search, and more.
14#[derive(Parser)]
15pub struct ConfluenceCommand {
16    /// The Confluence subcommand to execute.
17    #[command(subcommand)]
18    pub command: ConfluenceSubcommands,
19}
20
21/// Confluence subcommands.
22#[derive(Subcommand)]
23pub enum ConfluenceSubcommands {
24    /// Fetches a Confluence page and outputs it as JFM markdown or ADF JSON.
25    Read(read::ReadCommand),
26    /// Pushes content to a Confluence page.
27    Write(write::WriteCommand),
28    /// Interactive fetch-edit-push cycle for a Confluence page.
29    Edit(edit::EditCommand),
30    /// Searches Confluence pages using CQL.
31    Search(search::SearchCommand),
32    /// Creates a new Confluence page.
33    Create(create::CreateCommand),
34    /// Deletes a Confluence page.
35    Delete(delete::DeleteCommand),
36}
37
38impl ConfluenceCommand {
39    /// Executes the Confluence command.
40    pub async fn execute(self) -> Result<()> {
41        match self.command {
42            ConfluenceSubcommands::Read(cmd) => cmd.execute().await,
43            ConfluenceSubcommands::Write(cmd) => cmd.execute().await,
44            ConfluenceSubcommands::Edit(cmd) => cmd.execute().await,
45            ConfluenceSubcommands::Search(cmd) => cmd.execute().await,
46            ConfluenceSubcommands::Create(cmd) => cmd.execute().await,
47            ConfluenceSubcommands::Delete(cmd) => cmd.execute().await,
48        }
49    }
50}
51
52#[cfg(test)]
53mod tests {
54    use super::*;
55    use crate::cli::atlassian::format::ContentFormat;
56
57    #[test]
58    fn confluence_subcommands_read_variant() {
59        let cmd = ConfluenceCommand {
60            command: ConfluenceSubcommands::Read(read::ReadCommand {
61                id: "12345".to_string(),
62                output: None,
63                format: ContentFormat::Jfm,
64            }),
65        };
66        assert!(matches!(cmd.command, ConfluenceSubcommands::Read(_)));
67    }
68
69    #[test]
70    fn confluence_subcommands_write_variant() {
71        let cmd = ConfluenceCommand {
72            command: ConfluenceSubcommands::Write(write::WriteCommand {
73                id: "12345".to_string(),
74                file: None,
75                format: ContentFormat::Adf,
76                force: false,
77                dry_run: false,
78            }),
79        };
80        assert!(matches!(cmd.command, ConfluenceSubcommands::Write(_)));
81    }
82
83    #[test]
84    fn confluence_subcommands_edit_variant() {
85        let cmd = ConfluenceCommand {
86            command: ConfluenceSubcommands::Edit(edit::EditCommand {
87                id: "12345".to_string(),
88            }),
89        };
90        assert!(matches!(cmd.command, ConfluenceSubcommands::Edit(_)));
91    }
92
93    #[test]
94    fn confluence_subcommands_search_variant() {
95        let cmd = ConfluenceCommand {
96            command: ConfluenceSubcommands::Search(search::SearchCommand {
97                cql: Some("space = ENG".to_string()),
98                space: None,
99                title: None,
100                limit: 25,
101            }),
102        };
103        assert!(matches!(cmd.command, ConfluenceSubcommands::Search(_)));
104    }
105
106    #[test]
107    fn confluence_subcommands_create_variant() {
108        let cmd = ConfluenceCommand {
109            command: ConfluenceSubcommands::Create(create::CreateCommand {
110                file: None,
111                format: ContentFormat::Jfm,
112                space: Some("ENG".to_string()),
113                title: Some("Test".to_string()),
114                parent: None,
115                dry_run: false,
116            }),
117        };
118        assert!(matches!(cmd.command, ConfluenceSubcommands::Create(_)));
119    }
120
121    #[test]
122    fn confluence_subcommands_delete_variant() {
123        let cmd = ConfluenceCommand {
124            command: ConfluenceSubcommands::Delete(delete::DeleteCommand {
125                id: "12345".to_string(),
126                force: true,
127                purge: false,
128            }),
129        };
130        assert!(matches!(cmd.command, ConfluenceSubcommands::Delete(_)));
131    }
132}