use std::path::PathBuf;
use clap::{Args, Parser, Subcommand, ValueEnum};
use crate::command::completion::CompletionShell;
use crate::command::graph::GraphFormat;
use crate::command::new::{NewKind, NewLang};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, ValueEnum)]
#[value(rename_all = "lower")]
pub enum ColorMode {
#[default]
Auto,
Always,
Never,
}
#[derive(Debug, Parser)]
#[command(name = "astrs", version, about, long_about = None)]
pub struct Cli {
#[arg(long, global = true)]
pub json: bool,
#[arg(long, global = true, value_enum, default_value_t = ColorMode::Auto)]
pub color: ColorMode,
#[command(subcommand)]
pub command: Command,
}
#[derive(Debug, Subcommand)]
pub enum Command {
Run(RunArgs),
Up(UpArgs),
Down(DownArgs),
Build(BuildArgs),
Start(StartArgs),
Stop(StopArgs),
Restart(RestartArgs),
Destroy(DestroyArgs),
Clean(CleanArgs),
List(ListArgs),
Logs(LogsArgs),
Top(TopArgs),
#[command(subcommand)]
Topic(TopicCommand),
Status(StatusArgs),
Trace(TraceArgs),
Validate(ValidateCliArgs),
Expand(ExpandCliArgs),
Graph(GraphCliArgs),
#[command(subcommand)]
Node(NodeCommand),
#[command(subcommand)]
Param(ParamCommand),
#[command(subcommand)]
Record(RecordCommand),
Replay(ReplayArgs),
#[command(subcommand)]
Bag(BagCommand),
#[command(subcommand)]
Ros2(Ros2Command),
#[command(subcommand)]
New(NewCommand),
#[command(subcommand)]
Migrate(MigrateCommand),
Doctor(DoctorCliArgs),
Completion(CompletionCliArgs),
Schema(SchemaCliArgs),
#[command(subcommand)]
Token(TokenCommand),
#[command(subcommand)]
Hub(HubCommand),
#[command(hide = true)]
Daemon(DaemonArgs),
#[command(hide = true)]
Coordinator(CoordinatorArgs),
#[command(hide = true)]
Runtime(RuntimeArgs),
}
#[derive(Debug, Args, Clone, Default)]
pub struct ConnectArgs {
#[arg(long)]
pub coordinator: Option<String>,
#[arg(long)]
pub token: Option<String>,
#[arg(long)]
pub token_file: Option<PathBuf>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct RunArgs {
pub manifest: PathBuf,
#[arg(long)]
pub deterministic: bool,
#[arg(long, value_name = "PATH")]
pub from_recording: Option<PathBuf>,
#[arg(long, value_name = "FACTOR")]
pub speed: Option<f64>,
#[arg(long)]
pub exit_when_nodes_finish: bool,
#[arg(long)]
pub skip_build: bool,
#[arg(long, value_name = "LEVEL")]
pub level: Option<String>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
#[arg(long, value_name = "SECONDS")]
pub timeout: Option<f64>,
#[arg(long, value_name = "SECONDS")]
pub grace: Option<f64>,
}
#[derive(Debug, Args)]
pub struct UpArgs {
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub port: Option<u16>,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
#[arg(long)]
pub recreate_store: bool,
#[arg(long)]
pub no_daemon: bool,
}
#[derive(Debug, Args)]
pub struct DownArgs {
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct BuildArgs {
pub manifest: PathBuf,
#[arg(long)]
pub release: bool,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct StartArgs {
pub manifest: PathBuf,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub name: Option<String>,
#[arg(long = "machine", value_name = "[NODE=]MACHINE")]
pub machines: Vec<String>,
#[arg(long)]
pub attach: bool,
#[arg(long, value_name = "LEVEL")]
pub level: Option<String>,
}
#[derive(Debug, Args)]
pub struct StopArgs {
pub dataflow: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long, value_name = "SECONDS")]
pub grace: Option<f64>,
}
#[derive(Debug, Args)]
pub struct RestartArgs {
pub dataflow: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub rebuild: bool,
}
#[derive(Debug, Args)]
pub struct DestroyArgs {
pub dataflow: Option<String>,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct CleanArgs {
pub dataflow: Option<String>,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub artifacts: bool,
#[arg(long)]
pub logs: bool,
}
#[derive(Debug, Args)]
pub struct ListArgs {
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(short, long)]
pub all: bool,
}
#[derive(Debug, Args)]
pub struct LogsArgs {
pub dataflow: Option<String>,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(short, long)]
pub follow: bool,
#[arg(long)]
pub level: Option<String>,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub limit: Option<u32>,
}
#[derive(Debug, Args)]
pub struct TopArgs {
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub replay: Option<PathBuf>,
}
#[derive(Debug, Subcommand)]
pub enum TopicCommand {
Echo(TopicEchoArgs),
Hz(TopicHzArgs),
Info(TopicInfoArgs),
Pub(TopicPubArgs),
}
#[derive(Debug, Args)]
pub struct TopicEchoArgs {
pub topic: String,
#[arg(long)]
pub dataflow: Option<String>,
#[arg(long)]
pub count: Option<u32>,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Args)]
pub struct TopicHzArgs {
pub topic: String,
#[arg(long)]
pub dataflow: Option<String>,
#[arg(long, default_value_t = 5.0)]
pub window: f64,
#[arg(long)]
pub count: Option<u32>,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Args)]
pub struct TopicInfoArgs {
pub topic: String,
#[arg(long)]
pub dataflow: Option<String>,
#[arg(long)]
pub manifest: Option<PathBuf>,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Args)]
pub struct TopicPubArgs {
pub topic: String,
pub message: String,
#[arg(long)]
pub dataflow: Option<String>,
#[arg(long)]
pub rate: Option<f64>,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Args)]
pub struct StatusArgs {
pub dataflow: Option<String>,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct TraceArgs {
pub dataflow: Option<String>,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub limit: Option<u32>,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Args)]
pub struct ValidateCliArgs {
pub manifest: PathBuf,
#[arg(long)]
pub prove: bool,
#[arg(long, value_name = "FILE", requires = "prove")]
pub profile: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct ExpandCliArgs {
pub manifest: PathBuf,
}
#[derive(Debug, Args)]
pub struct GraphCliArgs {
pub manifest: PathBuf,
#[arg(long, value_enum, default_value_t = GraphFormatArg::Mermaid)]
pub format: GraphFormatArg,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
#[value(rename_all = "lower")]
pub enum GraphFormatArg {
Mermaid,
Dot,
Html,
}
impl From<GraphFormatArg> for GraphFormat {
fn from(value: GraphFormatArg) -> Self {
match value {
GraphFormatArg::Mermaid => Self::Mermaid,
GraphFormatArg::Dot => Self::Dot,
GraphFormatArg::Html => Self::Html,
}
}
}
#[derive(Debug, Subcommand)]
pub enum NodeCommand {
Add(NodeAddArgs),
Remove(NodeRemoveArgs),
Replace(NodeReplaceArgs),
Connect(NodeConnectArgs),
Disconnect(NodeDisconnectArgs),
}
#[derive(Debug, Args)]
pub struct NodeAddArgs {
pub dataflow: String,
pub node_manifest: PathBuf,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub no_start: bool,
#[arg(long)]
pub json: bool,
}
#[derive(Debug, Args)]
pub struct NodeRemoveArgs {
pub dataflow: String,
pub node_id: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long, value_name = "SECONDS")]
pub grace: Option<f64>,
#[arg(long)]
pub json: bool,
}
#[derive(Debug, Args)]
pub struct NodeReplaceArgs {
pub dataflow: String,
pub node_id: String,
pub node_manifest: PathBuf,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub drain: bool,
#[arg(long)]
pub json: bool,
}
#[derive(Debug, Args)]
pub struct NodeConnectArgs {
pub dataflow: String,
pub node_id: String,
pub input: String,
pub source: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub queue_size: Option<u32>,
#[arg(long, value_enum)]
pub queue_policy: Option<QueuePolicyArg>,
#[arg(long)]
pub json: bool,
}
#[derive(Debug, Args)]
pub struct NodeDisconnectArgs {
pub dataflow: String,
pub node_id: String,
pub input: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub json: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
#[value(rename_all = "kebab-case")]
pub enum QueuePolicyArg {
DropOldest,
Backpressure,
}
#[derive(Debug, Subcommand)]
pub enum ParamCommand {
Get(ParamGetArgs),
Set(ParamSetArgs),
List(ParamListArgs),
Delete(ParamDeleteArgs),
}
#[derive(Debug, Args)]
pub struct ParamGetArgs {
pub dataflow: String,
pub key: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub exact: bool,
#[arg(long)]
pub watch: bool,
#[arg(long)]
pub count: Option<u32>,
}
#[derive(Debug, Args)]
pub struct ParamSetArgs {
pub dataflow: String,
pub key: String,
pub value: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub create_only: bool,
}
#[derive(Debug, Args)]
pub struct ParamListArgs {
pub dataflow: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub node: Option<String>,
#[arg(long)]
pub prefix: Option<String>,
#[arg(long)]
pub inherited: bool,
}
#[derive(Debug, Args)]
pub struct ParamDeleteArgs {
pub dataflow: String,
pub key: String,
#[command(flatten)]
pub connect: ConnectArgs,
#[arg(long)]
pub node: Option<String>,
}
#[derive(Debug, Subcommand)]
pub enum RecordCommand {
Start(RecordStartArgs),
Stop(RecordStopArgs),
}
#[derive(Debug, Args)]
pub struct RecordStartArgs {
#[command(flatten)]
pub connect: ConnectArgs,
pub dataflow: String,
pub output: PathBuf,
#[arg(long = "only")]
pub only: Vec<String>,
#[arg(long)]
pub overwrite: bool,
}
#[derive(Debug, Args)]
pub struct RecordStopArgs {
#[command(flatten)]
pub connect: ConnectArgs,
pub dataflow: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, ValueEnum)]
#[value(rename_all = "kebab-case")]
pub enum ReplayTimingMode {
AsFastAsPossible,
#[default]
RealTime,
FixedRate,
}
impl ReplayTimingMode {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::AsFastAsPossible => "as-fast-as-possible",
Self::RealTime => "real-time",
Self::FixedRate => "fixed-rate",
}
}
}
#[derive(Debug, Args)]
pub struct ReplayArgs {
pub input: PathBuf,
pub dataflow: Option<String>,
#[arg(long, conflicts_with = "dataflow")]
pub into: Option<String>,
#[arg(long)]
pub speed: Option<f64>,
#[arg(long, value_enum, default_value = "real-time")]
pub mode: ReplayTimingMode,
#[arg(long)]
pub rate: Option<f64>,
#[arg(long)]
pub r#loop: bool,
#[arg(long = "replace")]
pub replace: Vec<String>,
#[arg(long, requires = "dataflow")]
pub drain: bool,
#[command(flatten)]
pub connect: ConnectArgs,
}
#[derive(Debug, Subcommand)]
pub enum BagCommand {
Convert(BagConvertArgs),
Info(BagInfoArgs),
}
#[derive(Debug, Args)]
pub struct BagConvertArgs {
pub input: PathBuf,
pub output: PathBuf,
}
#[derive(Debug, Args)]
pub struct BagInfoArgs {
pub input: PathBuf,
}
#[derive(Debug, Subcommand)]
pub enum Ros2Command {
Doctor(Ros2DoctorArgs),
Topics(Ros2TopicsArgs),
}
#[derive(Debug, Args)]
pub struct Ros2DoctorArgs {
#[arg(long)]
pub domain_id: Option<u32>,
#[arg(long, value_name = "MS")]
pub timeout: Option<u64>,
#[arg(long)]
pub hidden: bool,
}
#[derive(Debug, Args)]
pub struct Ros2TopicsArgs {
#[arg(long)]
pub domain_id: Option<u32>,
#[arg(long, value_name = "MS")]
pub timeout: Option<u64>,
#[arg(long)]
pub hidden: bool,
}
#[derive(Debug, Subcommand)]
pub enum NewCommand {
Node(NewNodeArgs),
Operator(NewOperatorArgs),
OperatorDylib(NewOperatorDylibArgs),
Graph(NewGraphArgs),
}
#[derive(Debug, Args)]
pub struct NewNodeArgs {
pub name: String,
#[arg(long, value_enum, default_value_t = NewLang::Rust)]
pub lang: NewLang,
#[arg(long, default_value = ".")]
pub dir: PathBuf,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct NewOperatorArgs {
pub name: String,
#[arg(long, value_enum, default_value_t = NewLang::Rust)]
pub lang: NewLang,
#[arg(long, default_value = ".")]
pub dir: PathBuf,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct NewOperatorDylibArgs {
pub name: String,
#[arg(long, value_enum, default_value_t = NewLang::Rust)]
pub lang: NewLang,
#[arg(long, default_value = ".")]
pub dir: PathBuf,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct NewGraphArgs {
pub name: String,
#[arg(long, default_value = ".")]
pub dir: PathBuf,
#[arg(long)]
pub force: bool,
}
impl NewCommand {
#[must_use]
pub fn into_new_args(self, json: bool) -> crate::command::new::NewArgs {
use crate::command::new::NewArgs;
match self {
Self::Node(a) => NewArgs {
kind: NewKind::Node,
name: a.name,
lang: a.lang,
dir: a.dir,
force: a.force,
json,
},
Self::Operator(a) => NewArgs {
kind: NewKind::Operator,
name: a.name,
lang: a.lang,
dir: a.dir,
force: a.force,
json,
},
Self::OperatorDylib(a) => NewArgs {
kind: NewKind::OperatorDylib,
name: a.name,
lang: a.lang,
dir: a.dir,
force: a.force,
json,
},
Self::Graph(a) => NewArgs {
kind: NewKind::Graph,
name: a.name,
lang: NewLang::Rust,
dir: a.dir,
force: a.force,
json,
},
}
}
}
#[derive(Debug, Subcommand)]
pub enum MigrateCommand {
FromDora(FromDoraCliArgs),
FromRos2(FromRos2CliArgs),
}
#[derive(Debug, Args)]
pub struct FromDoraCliArgs {
pub input: PathBuf,
#[arg(long)]
pub output: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct FromRos2CliArgs {
pub input: PathBuf,
#[arg(long)]
pub output: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct DoctorCliArgs {
#[arg(long, default_value_t = crate::command::doctor::DEFAULT_COORDINATOR_PORT)]
pub coordinator_port: u16,
#[arg(long, default_value_t = crate::command::doctor::DEFAULT_DAEMON_PORT)]
pub daemon_port: u16,
}
#[derive(Debug, Args)]
pub struct CompletionCliArgs {
#[arg(value_enum)]
pub shell: CompletionShell,
}
#[derive(Debug, Args)]
pub struct SchemaCliArgs {
#[arg(long)]
pub output: Option<PathBuf>,
}
#[derive(Debug, Subcommand)]
pub enum TokenCommand {
Mint(TokenMintArgs),
}
#[derive(Debug, Args)]
pub struct TokenMintArgs {
#[arg(long, value_enum)]
pub scope: TokenScopeArg,
#[arg(long)]
pub token: Option<String>,
#[arg(long)]
pub token_file: Option<PathBuf>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
#[arg(long)]
pub out: Option<PathBuf>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum)]
#[value(rename_all = "kebab-case")]
pub enum TokenScopeArg {
Read,
Mutate,
}
#[derive(Debug, Subcommand)]
pub enum HubCommand {
Update(HubUpdateArgs),
Search(HubSearchArgs),
Info(HubInfoArgs),
Init(HubInitArgs),
}
#[derive(Debug, Args)]
pub struct HubUpdateArgs {
#[arg(long)]
pub index: Option<String>,
}
#[derive(Debug, Args)]
pub struct HubSearchArgs {
pub term: String,
}
#[derive(Debug, Args)]
pub struct HubInfoArgs {
pub name: String,
}
#[derive(Debug, Args)]
pub struct HubInitArgs {
pub dir: PathBuf,
#[arg(long)]
pub force: bool,
}
#[derive(Debug, Args)]
pub struct DaemonArgs {
#[arg(long)]
pub coordinator: Option<String>,
#[arg(long)]
pub machine: Option<String>,
#[arg(long)]
pub port: Option<u16>,
#[arg(long, default_value_t = astrs_daemon::peer::DEFAULT_PEER_PORT)]
pub peer_port: u16,
#[arg(long)]
pub peer_bind: Option<String>,
#[arg(long = "label", value_name = "KEY=VALUE")]
pub labels: Vec<String>,
#[arg(long)]
pub runtime_dir: Option<PathBuf>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
#[arg(long)]
pub token: Option<String>,
#[arg(long)]
pub token_file: Option<PathBuf>,
#[arg(long)]
pub pidfile: Option<PathBuf>,
#[arg(long)]
pub announce: bool,
}
#[derive(Debug, Args)]
pub struct CoordinatorArgs {
#[arg(long, default_value_t = crate::command::doctor::DEFAULT_COORDINATOR_PORT)]
pub port: u16,
#[arg(long)]
pub bind: Option<String>,
#[arg(long)]
pub token: Option<String>,
#[arg(long)]
pub token_file: Option<PathBuf>,
#[arg(long)]
pub working_dir: Option<PathBuf>,
#[arg(long)]
pub store: Option<PathBuf>,
#[arg(long)]
pub recreate_store: bool,
#[arg(long)]
pub pidfile: Option<PathBuf>,
#[arg(long)]
pub announce: bool,
#[arg(long)]
pub ha_node_id: Option<u64>,
#[arg(long = "ha-peer")]
pub ha_peers: Vec<String>,
}
#[derive(Debug, Args)]
pub struct RuntimeArgs {
#[arg(long)]
pub node_id: Option<String>,
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use clap::CommandFactory;
#[test]
fn cli_tree_is_valid_per_clap_debug_assert() {
Cli::command().debug_assert();
}
#[test]
fn the_coordinator_takes_a_repeated_ha_peer_flag() {
let cli = Cli::try_parse_from([
"astrs",
"coordinator",
"--ha-node-id",
"2",
"--ha-peer",
"1=10.0.0.1:7601",
"--ha-peer",
"2=10.0.0.2:7601",
"--ha-peer",
"3=10.0.0.3:7601",
])
.unwrap();
let Command::Coordinator(args) = cli.command else {
panic!("expected `coordinator`");
};
assert_eq!(args.ha_node_id, Some(2));
assert_eq!(args.ha_peers.len(), 3);
assert_eq!(args.ha_peers[0], "1=10.0.0.1:7601");
}
#[test]
fn the_coordinator_still_parses_without_any_ha_flags() {
let cli = Cli::try_parse_from(["astrs", "coordinator"]).unwrap();
let Command::Coordinator(args) = cli.command else {
panic!("expected `coordinator`");
};
assert!(args.ha_node_id.is_none());
assert!(args.ha_peers.is_empty());
}
#[test]
fn binary_name_is_astrs() {
assert_eq!(Cli::command().get_name(), "astrs");
}
#[test]
fn json_and_color_are_global_flags() {
let cli = Cli::try_parse_from(["astrs", "--json", "schema"]).unwrap();
assert!(cli.json);
let cli = Cli::try_parse_from(["astrs", "schema", "--json"]).unwrap();
assert!(cli.json, "global flags must also work after the subcommand");
}
#[test]
fn token_mint_parses_its_scope() {
let cli = Cli::try_parse_from(["astrs", "token", "mint", "--scope", "read"]).unwrap();
let Command::Token(TokenCommand::Mint(args)) = cli.command else {
panic!("expected `token mint`");
};
assert_eq!(args.scope, TokenScopeArg::Read);
let cli = Cli::try_parse_from(["astrs", "token", "mint", "--scope", "mutate"]).unwrap();
let Command::Token(TokenCommand::Mint(args)) = cli.command else {
panic!("expected `token mint`");
};
assert_eq!(args.scope, TokenScopeArg::Mutate);
}
#[test]
fn token_mint_requires_a_scope() {
assert!(Cli::try_parse_from(["astrs", "token", "mint"]).is_err());
}
#[test]
fn validate_rejects_a_profile_without_prove() {
assert!(
Cli::try_parse_from(["astrs", "validate", "--profile", "v.yaml", "dataflow.yml"])
.is_err(),
"`--profile` only means something alongside `--prove`"
);
}
#[test]
fn validate_parses_the_profile_flag() {
let cli = Cli::try_parse_from([
"astrs",
"validate",
"--prove",
"--profile",
"verify.yaml",
"dataflow.yml",
])
.unwrap();
match cli.command {
Command::Validate(args) => {
assert!(args.prove);
assert_eq!(
args.profile.as_deref(),
Some(std::path::Path::new("verify.yaml"))
);
}
other => panic!("expected validate, got {other:?}"),
}
}
#[test]
fn validate_parses_prove_flag() {
let cli = Cli::try_parse_from(["astrs", "validate", "--prove", "dataflow.yml"]).unwrap();
match cli.command {
Command::Validate(args) => {
assert!(args.prove);
assert_eq!(args.manifest, PathBuf::from("dataflow.yml"));
}
other => panic!("expected Validate, got {other:?}"),
}
}
#[test]
fn new_node_parses_with_defaults() {
let cli = Cli::try_parse_from(["astrs", "new", "node", "my-node"]).unwrap();
match cli.command {
Command::New(NewCommand::Node(args)) => {
assert_eq!(args.name, "my-node");
assert_eq!(args.lang, NewLang::Rust);
assert_eq!(args.dir, PathBuf::from("."));
assert!(!args.force);
}
other => panic!("expected New(Node), got {other:?}"),
}
}
#[test]
fn new_operator_dylib_parses_as_the_kebab_case_subcommand() {
let cli = Cli::try_parse_from(["astrs", "new", "operator-dylib", "my-dylib-op"]).unwrap();
match cli.command {
Command::New(NewCommand::OperatorDylib(args)) => {
assert_eq!(args.name, "my-dylib-op");
assert_eq!(args.lang, NewLang::Rust);
assert_eq!(args.dir, PathBuf::from("."));
assert!(!args.force);
}
other => panic!("expected New(OperatorDylib), got {other:?}"),
}
}
#[test]
fn migrate_from_dora_parses() {
let cli = Cli::try_parse_from([
"astrs",
"migrate",
"from-dora",
"in.yml",
"--output",
"out.yml",
])
.unwrap();
match cli.command {
Command::Migrate(MigrateCommand::FromDora(args)) => {
assert_eq!(args.input, PathBuf::from("in.yml"));
assert_eq!(args.output, Some(PathBuf::from("out.yml")));
}
other => panic!("expected Migrate(FromDora), got {other:?}"),
}
}
#[test]
fn migrate_from_ros2_parses() {
let cli = Cli::try_parse_from([
"astrs",
"migrate",
"from-ros2",
"in.launch.xml",
"--output",
"out.yml",
])
.unwrap();
match cli.command {
Command::Migrate(MigrateCommand::FromRos2(args)) => {
assert_eq!(args.input, PathBuf::from("in.launch.xml"));
assert_eq!(args.output, Some(PathBuf::from("out.yml")));
}
other => panic!("expected Migrate(FromRos2), got {other:?}"),
}
}
#[test]
fn every_daemon_needing_verb_still_parses() {
let lines: &[&[&str]] = &[
&["astrs", "run", "d.yml"],
&["astrs", "up"],
&["astrs", "down"],
&["astrs", "build", "d.yml"],
&["astrs", "start", "d.yml"],
&["astrs", "stop", "my-flow"],
&["astrs", "restart", "my-flow"],
&["astrs", "destroy", "my-flow"],
&["astrs", "clean"],
&["astrs", "list"],
&["astrs", "logs"],
&["astrs", "top"],
&["astrs", "topic", "echo", "cam/frames"],
&["astrs", "topic", "hz", "cam/frames"],
&["astrs", "topic", "info", "cam/frames"],
&["astrs", "topic", "pub", "cam/frames", "{}"],
&["astrs", "status"],
&["astrs", "trace"],
&["astrs", "node", "remove", "my-flow", "cam"],
&["astrs", "param", "list", "my-flow"],
&["astrs", "record", "stop", "my-flow"],
&["astrs", "replay", "r.arec"],
&["astrs", "bag", "info", "b.mcap"],
&["astrs", "ros2", "doctor"],
&["astrs", "ros2", "topics"],
&["astrs", "daemon"],
&["astrs", "coordinator"],
&["astrs", "runtime", "--node-id", "cam"],
];
for argv in lines {
Cli::try_parse_from(*argv).unwrap_or_else(|e| panic!("{argv:?} failed to parse: {e}"));
}
}
#[test]
fn every_client_verb_takes_the_same_connect_flags() {
for verb in [
&["astrs", "list"][..],
&["astrs", "logs"][..],
&["astrs", "stop", "f"][..],
&["astrs", "restart", "f"][..],
&["astrs", "destroy"][..],
&["astrs", "clean"][..],
&["astrs", "start", "d.yml"][..],
&["astrs", "status"][..],
&["astrs", "up"][..],
&["astrs", "down"][..],
&["astrs", "top"][..],
] {
let mut argv: Vec<&str> = verb.to_vec();
argv.extend(["--coordinator", "127.0.0.1:7407", "--token", "ab"]);
Cli::try_parse_from(&argv).unwrap_or_else(|e| panic!("{argv:?} failed to parse: {e}"));
}
}
#[test]
fn top_parses_the_replay_flag() {
let cli = Cli::try_parse_from(["astrs", "top", "--replay", "session.arec"]).unwrap();
match cli.command {
Command::Top(args) => {
assert_eq!(args.replay, Some(PathBuf::from("session.arec")));
}
other => panic!("expected Command::Top, got {other:?}"),
}
}
#[test]
fn top_without_replay_defaults_to_live() {
let cli = Cli::try_parse_from(["astrs", "top"]).unwrap();
match cli.command {
Command::Top(args) => assert_eq!(args.replay, None),
other => panic!("expected Command::Top, got {other:?}"),
}
}
#[test]
fn run_parses_its_stage_two_flags() {
let cli = Cli::try_parse_from([
"astrs",
"run",
"d.yml",
"--skip-build",
"--level",
"warn",
"--timeout",
"2.5",
"--exit-when-nodes-finish",
])
.unwrap();
match cli.command {
Command::Run(args) => {
assert!(args.skip_build);
assert!(args.exit_when_nodes_finish);
assert_eq!(args.level.as_deref(), Some("warn"));
assert_eq!(args.timeout, Some(2.5));
assert!(!args.deterministic);
assert_eq!(args.from_recording, None);
assert_eq!(args.speed, None);
}
other => panic!("expected Run, got {other:?}"),
}
}
#[test]
fn run_parses_deterministic_replay_flags() {
let cli = Cli::try_parse_from([
"astrs",
"run",
"d.yml",
"--deterministic",
"--from-recording",
"session.arec",
"--speed",
"2.0",
])
.unwrap();
match cli.command {
Command::Run(args) => {
assert!(args.deterministic);
assert_eq!(args.from_recording, Some(PathBuf::from("session.arec")));
assert_eq!(args.speed, Some(2.0));
}
other => panic!("expected Run, got {other:?}"),
}
}
#[test]
fn up_takes_no_manifest_because_it_brings_up_a_cluster() {
assert!(Cli::try_parse_from(["astrs", "up", "d.yml"]).is_err());
let cli = Cli::try_parse_from(["astrs", "up", "--recreate-store", "--port", "0"]).unwrap();
match cli.command {
Command::Up(args) => {
assert!(args.recreate_store);
assert_eq!(args.port, Some(0));
assert!(!args.no_daemon);
}
other => panic!("expected Up, got {other:?}"),
}
}
#[test]
fn hidden_commands_are_marked_hidden() {
let command = Cli::command();
for name in ["daemon", "coordinator", "runtime"] {
let sub = command
.find_subcommand(name)
.unwrap_or_else(|| panic!("missing subcommand {name}"));
assert!(sub.is_hide_set(), "`{name}` should be hidden");
}
assert!(!command.find_subcommand("validate").unwrap().is_hide_set());
}
#[test]
fn graph_format_arg_maps_onto_graph_format() {
assert_eq!(
GraphFormat::from(GraphFormatArg::Mermaid),
GraphFormat::Mermaid
);
assert_eq!(GraphFormat::from(GraphFormatArg::Dot), GraphFormat::Dot);
assert_eq!(GraphFormat::from(GraphFormatArg::Html), GraphFormat::Html);
}
#[test]
fn new_command_flattens_into_new_args() {
let cli = Cli::try_parse_from(["astrs", "new", "graph", "perception"]).unwrap();
let Command::New(new_command) = cli.command else {
panic!("expected New");
};
let args = new_command.into_new_args(false);
assert_eq!(args.kind, NewKind::Graph);
assert_eq!(args.name, "perception");
assert!(!args.json);
}
#[test]
fn new_command_threads_the_global_json_flag_through() {
let cli = Cli::try_parse_from(["astrs", "--json", "new", "node", "cam"]).unwrap();
let Command::New(new_command) = cli.command else {
panic!("expected New");
};
let args = new_command.into_new_args(cli.json);
assert!(args.json);
}
}