1use std::fmt::Write as _;
4use std::path::PathBuf;
5
6use sapphire_backend::protocol as proto;
7use sapphire_bridge_api::{
8 DevicePrioritySetParams, DeviceRetireParams, InviteParams, JoinParams, WorkgroupCreateParams,
9};
10use sapphire_bridge_client::BridgeClient;
11use sapphire_framework_service::{Environment, ServiceCommand, SystemManager};
12use sapphire_ipc::{ClientInfo, Endpoint};
13
14use crate::AppServer;
15use crate::error::{Error, Result};
16
17pub use sapphire_backend::protocol::{StatusReport, StatusRow};
18
19#[derive(Debug, Default, clap::Subcommand)]
25pub enum FrameworkCommand {
26 #[default]
28 Serve,
29 Status,
31 #[command(subcommand)]
33 Service(ServiceCommand),
34 #[command(subcommand)]
37 Workspace(WorkspaceCommand),
38 #[command(subcommand)]
40 Workgroup(WorkgroupCommand),
41 #[command(subcommand)]
43 Device(DeviceCommand),
44 #[command(subcommand)]
47 Embedding(sapphire_bridge_api::EmbeddingCommand),
48 #[command(subcommand)]
52 ExternalDevice(sapphire_bridge_api::ExternalDeviceCommand),
53 #[cfg(feature = "mcp")]
56 Mcp,
57}
58
59impl FrameworkCommand {
60 pub async fn dispatch(self, server: AppServer, version: &'static str) -> Result<i32> {
65 match self {
66 FrameworkCommand::Serve => {
67 server.run().await?;
68 Ok(0)
69 }
70 FrameworkCommand::Status => crate::command::status(&server, version).await,
71 FrameworkCommand::Service(command) => {
72 let spec = server.service_spec();
73 command
74 .run(&spec, &Environment::detect(), &SystemManager)
75 .map_err(Error::from)
76 }
77 FrameworkCommand::Workspace(command) => {
78 command.dispatch(server.app_name(), version).await
79 }
80 FrameworkCommand::Workgroup(command) => command.dispatch(version).await,
81 FrameworkCommand::Device(command) => command.dispatch(version).await,
82 FrameworkCommand::Embedding(command) => embedding(command, version).await,
83 FrameworkCommand::ExternalDevice(command) => {
84 external_device(command, server.app_name(), version).await
85 }
86 #[cfg(feature = "mcp")]
87 FrameworkCommand::Mcp => {
88 server.serve_mcp_stdio(version).await?;
89 Ok(0)
90 }
91 }
92 }
93}
94
95#[derive(Debug, clap::Subcommand)]
104pub enum WorkspaceCommand {
105 Init {
107 dir: Option<PathBuf>,
109 #[arg(long)]
111 sync: bool,
112 },
113 Select {
115 dir: Option<PathBuf>,
117 },
118 Show,
120 Move {
122 dir: PathBuf,
124 },
125 Remove {
127 #[arg(long)]
129 delete: bool,
130 },
131 Map {
133 selector: String,
135 dir: Option<PathBuf>,
137 },
138}
139
140impl WorkspaceCommand {
141 pub async fn dispatch(self, app: &'static str, version: &'static str) -> Result<i32> {
146 match self {
147 WorkspaceCommand::Init { dir, sync } => workspace_init(app, version, dir, sync).await,
148 WorkspaceCommand::Select { dir } => workspace_select(app, version, dir).await,
149 WorkspaceCommand::Show => workspace_show(app, version).await,
150 WorkspaceCommand::Move { dir } => workspace_move(app, version, dir).await,
151 WorkspaceCommand::Remove { delete } => workspace_remove(app, version, delete).await,
152 WorkspaceCommand::Map { selector, dir } => {
153 workspace_map(app, version, &selector, dir).await
154 }
155 }
156 }
157}
158
159#[derive(Debug, clap::Subcommand)]
164pub enum WorkgroupCommand {
165 Create {
167 name: String,
169 #[arg(long)]
171 device_name: String,
172 },
173 List,
175 Join {
177 ticket: String,
179 #[arg(long)]
181 device_name: Option<String>,
182 },
183}
184
185impl WorkgroupCommand {
186 pub async fn dispatch(self, version: &'static str) -> Result<i32> {
188 match self {
189 WorkgroupCommand::Create { name, device_name } => {
190 let client = connect_running(version).await?;
191 let created = client
192 .workgroup_create(WorkgroupCreateParams { name, device_name })
193 .await?;
194 println!(
195 "created workgroup {} ({}); this device is {}",
196 created.name, created.workgroup_id, created.device_id
197 );
198 Ok(0)
199 }
200 WorkgroupCommand::List => {
201 let client = connect_running(version).await?;
202 match client.status().await?.workgroup {
203 Some(workgroup) => {
204 println!("{} ({})", workgroup.name, workgroup.workgroup_id);
205 Ok(0)
206 }
207 None => {
208 println!("this host has not joined a workgroup");
209 Ok(1)
210 }
211 }
212 }
213 WorkgroupCommand::Join {
214 ticket,
215 device_name,
216 } => {
217 let client = connect_running(version).await?;
218 let joined = client
219 .join(JoinParams {
220 ticket,
221 device_name,
222 })
223 .await?;
224 println!(
225 "joined workgroup {} ({}); this device is {}",
226 joined.workgroup_name, joined.workgroup_id, joined.device_id
227 );
228 Ok(0)
229 }
230 }
231 }
232}
233
234#[derive(Debug, clap::Subcommand)]
240pub enum DeviceCommand {
241 List,
243 Invite {
245 #[arg(long)]
247 name: String,
248 #[arg(long)]
250 ttl: Option<u64>,
251 #[arg(long)]
253 workgroup: Option<String>,
254 },
255 Retire {
257 selector: String,
259 },
260 Priority {
263 selector: String,
265 priority: Option<u8>,
267 },
268}
269
270impl DeviceCommand {
271 pub async fn dispatch(self, version: &'static str) -> Result<i32> {
273 match self {
274 DeviceCommand::List => {
275 let client = connect_running(version).await?;
276 let peers = client.peers().await?;
277 if peers.peers.is_empty() {
278 println!("no devices");
279 return Ok(0);
280 }
281 for peer in peers.peers {
282 println!(
283 "{} {} p{}{}{}",
284 peer.name,
285 peer.device_id,
286 peer.priority,
287 peer.availability
288 .map(|a| format!(" a{a}"))
289 .unwrap_or_default(),
290 if peer.connected { " (online)" } else { "" }
291 );
292 }
293 Ok(0)
294 }
295 DeviceCommand::Invite {
296 name,
297 ttl,
298 workgroup,
299 } => {
300 let client = connect_running(version).await?;
301 let invite = client
302 .invite(InviteParams {
303 name,
304 ttl,
305 workgroup,
306 })
307 .await?;
308 println!("{}", invite.ticket);
311 Ok(0)
312 }
313 DeviceCommand::Retire { selector } => {
314 let client = connect_running(version).await?;
315 let retired = client
316 .device_retire(DeviceRetireParams { selector })
317 .await?;
318 println!("retired device {} ({})", retired.name, retired.device_id);
319 Ok(0)
320 }
321 DeviceCommand::Priority { selector, priority } => {
322 let client = connect_running(version).await?;
323 match priority {
324 Some(priority) => {
325 let set = client
326 .device_priority_set(DevicePrioritySetParams { selector, priority })
327 .await?;
328 println!("{} ({}) priority {}", set.name, set.device_id, set.priority);
329 }
330 None => {
331 let peers = client.peers().await?;
332 match peers
333 .peers
334 .iter()
335 .find(|p| p.name == selector || p.device_id.to_string() == selector)
336 {
337 Some(p) => {
338 println!("{} ({}) priority {}", p.name, p.device_id, p.priority)
339 }
340 None => {
341 println!("no device {selector:?}");
342 return Ok(1);
343 }
344 }
345 }
346 }
347 Ok(0)
348 }
349 }
350 }
351}
352
353async fn connect_running(version: &str) -> Result<BridgeClient> {
359 BridgeClient::connect_running("cli", version)
360 .await
361 .map_err(Error::from)
362}
363
364async fn embedding(command: sapphire_bridge_api::EmbeddingCommand, version: &str) -> Result<i32> {
366 let client = connect_running(version).await?;
368 let request = command.request()?;
369 let report = client.embed_request(request).await?;
370 for line in sapphire_bridge_api::describe(&report) {
371 println!("{line}");
372 }
373 Ok(0)
374}
375
376async fn external_device(
378 command: sapphire_bridge_api::ExternalDeviceCommand,
379 app: &str,
380 version: &str,
381) -> Result<i32> {
382 let client = connect_running(version).await?;
383 let outcome = client
384 .external_device_request(command.request(Some(app)))
385 .await?;
386 for line in sapphire_bridge_api::describe_external_outcome(&outcome) {
387 println!("{line}");
388 }
389 Ok(0)
390}
391
392async fn workspace_init(
401 app: &'static str,
402 version: &'static str,
403 dir: Option<PathBuf>,
404 sync: bool,
405) -> Result<i32> {
406 let endpoint = Endpoint::for_app(app)?;
407 let client_info = ClientInfo {
408 kind: "cli".to_owned(),
409 version: version.to_owned(),
410 api: proto::API_VERSION,
411 app_api: None,
412 pid: std::process::id(),
413 };
414 let Some((client, _)) = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?
415 else {
416 println!("no {app} server is running");
417 return Ok(1);
418 };
419
420 let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
422 let result: proto::WorkspaceInitResult = client
423 .call(proto::WORKSPACE_INIT, proto::WorkspaceInitParams { dir })
424 .await?;
425 if result.created {
426 println!("initialized {app} workspace in {}", result.root.display());
427 } else {
428 println!(
429 "{} already exists (workspace {})",
430 result.root.display(),
431 result.workspace_id
432 );
433 }
434 println!("the {app} server now serves {}", result.root.display());
435
436 if sync {
437 let enabled: proto::SyncEnableResult = client
438 .call(proto::SYNC_ENABLE, serde_json::json!({}))
439 .await?;
440 let status: proto::SyncStatusResult = client
443 .call(proto::SYNC_STATUS, serde_json::json!({}))
444 .await
445 .unwrap_or(proto::SyncStatusResult {
446 enabled: true,
447 workspace_id: Some(enabled.workspace_id),
448 ..proto::SyncStatusResult::not_synced()
449 });
450 println!(
451 "syncing as {} ({} peer{})",
452 enabled.workspace_id,
453 status.peers,
454 if status.peers == 1 { "" } else { "s" }
455 );
456 }
457 Ok(0)
458}
459
460pub async fn render_workspace(client: &sapphire_ipc::Client, out: &mut String) -> Result<i32> {
465 let current: proto::WorkspaceCurrentResult = client
466 .call(proto::WORKSPACE_CURRENT, serde_json::json!({}))
467 .await?;
468 let Some(ws) = current.workspace else {
469 writeln!(
470 out,
471 "no workspace yet; run `workspace init <dir>` or `workspace select <dir>`"
472 )
473 .expect("writing to a String cannot fail");
474 return Ok(1);
475 };
476 writeln!(out, "{} {}", ws.root.display(), describe_state(&ws))
477 .expect("writing to a String cannot fail");
478 Ok(0)
479}
480
481fn describe_state(ws: &proto::CurrentWorkspace) -> String {
483 let state = if !ws.reachable {
484 "unreachable"
485 } else if ws.sync.enabled {
486 "synced"
487 } else {
488 "not synced"
489 };
490 let star = if matches!(ws.sync.topology, proto::Topology::Star { .. }) {
491 " (star)"
492 } else {
493 ""
494 };
495 let pending = match &ws.sync.embedding {
496 Some(e) if e.pending > 0 => format!(", embedding {} pending", e.pending),
497 _ => String::new(),
498 };
499 format!("{state}{star}{pending}")
500}
501
502async fn connect_app(app: &str, version: &str) -> Result<Option<sapphire_ipc::Client>> {
504 let endpoint = Endpoint::for_app(app)?;
505 let client_info = ClientInfo {
506 kind: "cli".to_owned(),
507 version: version.to_owned(),
508 api: proto::API_VERSION,
509 app_api: None,
510 pid: std::process::id(),
511 };
512 let client = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?;
513 if client.is_none() {
514 println!("no {app} server is running");
515 }
516 Ok(client.map(|(c, _)| c))
517}
518
519async fn workspace_select(
521 app: &'static str,
522 version: &'static str,
523 dir: Option<PathBuf>,
524) -> Result<i32> {
525 let Some(client) = connect_app(app, version).await? else {
526 return Ok(1);
527 };
528 let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
530 let ws: proto::CurrentWorkspace = client
531 .call(
532 proto::WORKSPACE_SELECT,
533 proto::WorkspaceSelectParams { dir },
534 )
535 .await?;
536 println!("{} {}", ws.root.display(), describe_state(&ws));
537 Ok(0)
538}
539
540async fn workspace_move(app: &'static str, version: &'static str, dir: PathBuf) -> Result<i32> {
542 let Some(client) = connect_app(app, version).await? else {
543 return Ok(1);
544 };
545 let dir = std::env::current_dir()?.join(dir);
547 let ws: proto::CurrentWorkspace = client
548 .call(proto::WORKSPACE_MOVE, proto::WorkspaceMoveParams { dir })
549 .await?;
550 println!("{} {}", ws.root.display(), describe_state(&ws));
551 Ok(0)
552}
553
554async fn workspace_remove(app: &'static str, version: &'static str, delete: bool) -> Result<i32> {
556 let Some(client) = connect_app(app, version).await? else {
557 return Ok(1);
558 };
559 let _: proto::Ack = client
560 .call(
561 proto::WORKSPACE_REMOVE,
562 proto::WorkspaceRemoveParams { delete },
563 )
564 .await?;
565 println!(
566 "{}",
567 if delete {
568 "removed and deleted"
569 } else {
570 "removed; the files stay"
571 }
572 );
573 Ok(0)
574}
575
576async fn workspace_show(app: &'static str, version: &'static str) -> Result<i32> {
582 let Some(client) = connect_app(app, version).await? else {
583 return Ok(1);
584 };
585 let mut out = String::new();
586 let code = render_workspace(&client, &mut out).await?;
587 for line in out.lines() {
588 println!("{line}");
589 }
590
591 let Some(client) = BridgeClient::connect_running("cli", version).await.ok() else {
592 println!("no sapphire-bridge is running");
593 return Ok(code);
594 };
595 let workspaces = client.workspaces().await.map_err(Error::from)?;
596 let mine: Vec<_> = workspaces
597 .workspaces
598 .into_iter()
599 .filter(|w| w.app_name == app)
600 .collect();
601 if !mine.is_empty() {
602 println!();
603 println!("in the workgroup:");
604 for workspace in mine {
605 println!("{} {}", workspace.name, workspace.workspace_id);
606 }
607 }
608 Ok(code)
609}
610
611async fn workspace_map(
618 app: &'static str,
619 version: &'static str,
620 selector: &str,
621 dir: Option<PathBuf>,
622) -> Result<i32> {
623 let Some(client) = BridgeClient::connect_running("cli", version).await.ok() else {
624 println!("no sapphire-bridge is running");
625 return Ok(1);
626 };
627 let workspaces = client.workspaces().await.map_err(Error::from)?;
628 let wanted = workspaces
629 .workspaces
630 .iter()
631 .find(|w| w.name == selector || w.workspace_id.to_string() == selector)
633 .ok_or_else(|| Error::UnknownWorkspaceName(selector.to_owned()))?;
634
635 let endpoint = Endpoint::for_app(app)?;
636 let client_info = ClientInfo {
637 kind: "cli".to_owned(),
638 version: version.to_owned(),
639 api: proto::API_VERSION,
640 app_api: None,
641 pid: std::process::id(),
642 };
643 let Some((client, _)) = sapphire_ipc::connect_or_absent(&endpoint, app, client_info).await?
644 else {
645 println!("no {app} server is running");
646 return Ok(1);
647 };
648
649 let dir = std::env::current_dir()?.join(dir.unwrap_or_else(|| PathBuf::from(".")));
650 let mapped: proto::SyncEnableResult = client
651 .call(
652 proto::SYNC_MAP,
653 proto::SyncMapParams {
654 workspace: wanted.workspace_id.to_string(),
655 dir,
656 },
657 )
658 .await?;
659 println!(
660 "mapped {} as {}; the {app} server now serves it",
661 wanted.name, mapped.workspace_id
662 );
663 Ok(0)
664}
665
666async fn status(server: &AppServer, version: &str) -> Result<i32> {
669 let endpoint = Endpoint::for_app(server.app_name())?;
670 run_status(&endpoint, server.app_name(), version).await
671}
672
673async fn run_status(endpoint: &Endpoint, app: &str, version: &str) -> Result<i32> {
682 let mut out = String::new();
683 let code = run_status_into(endpoint, app, version, &mut out).await?;
684 for line in out.lines() {
685 println!("{line}");
686 }
687 Ok(code)
688}
689
690async fn run_status_into(
693 endpoint: &Endpoint,
694 app: &str,
695 version: &str,
696 out: &mut String,
697) -> Result<i32> {
698 let client_info = ClientInfo {
699 kind: "cli".to_owned(),
700 version: version.to_owned(),
701 api: proto::API_VERSION,
702 app_api: None,
703 pid: std::process::id(),
704 };
705 let Some((client, _)) = sapphire_ipc::connect_or_absent(endpoint, app, client_info).await?
706 else {
707 writeln!(out, "no {app} server is running").expect("writing to a String cannot fail");
710 return Ok(1);
711 };
712 let report: StatusReport = client
713 .call(
714 sapphire_backend::protocol::SERVER_INFO,
715 serde_json::json!({}),
716 )
717 .await?;
718 writeln!(out, "running: {}", report.running).expect("writing to a String cannot fail");
719 if let Some(version) = &report.version {
720 writeln!(out, "version: {version}").expect("writing to a String cannot fail");
721 }
722 if let Some(pid) = report.pid {
723 writeln!(out, "pid: {pid}").expect("writing to a String cannot fail");
724 }
725 if let Some(managed_by) = &report.managed_by {
726 writeln!(out, "managed_by: {managed_by:?}").expect("writing to a String cannot fail");
727 }
728 for row in &report.app {
729 writeln!(out, "{}: {}", row.name, row.value).expect("writing to a String cannot fail");
730 }
731 Ok(0)
732}
733#[cfg(test)]
734mod tests {
735 use super::*;
736 use clap::Parser;
737
738 #[derive(Parser)]
747 struct Probe {
748 #[command(subcommand)]
749 command: Command,
750 }
751
752 #[derive(Debug, clap::Subcommand)]
753 enum Command {
754 Greet,
756 #[command(flatten)]
757 Framework(FrameworkCommand),
758 }
759
760 #[test]
761 fn app_and_framework_commands_parse_side_by_side() {
762 let probe = Probe::try_parse_from(["app", "greet"]).unwrap();
763 assert!(matches!(probe.command, Command::Greet));
764 let probe = Probe::try_parse_from(["app", "serve"]).unwrap();
765 assert!(matches!(
766 probe.command,
767 Command::Framework(FrameworkCommand::Serve)
768 ));
769 let probe = Probe::try_parse_from(["app", "status"]).unwrap();
770 assert!(matches!(
771 probe.command,
772 Command::Framework(FrameworkCommand::Status)
773 ));
774 }
775
776 #[cfg(feature = "mcp")]
777 #[test]
778 fn the_mcp_command_parses_beside_the_apps() {
779 let probe = Probe::try_parse_from(["app", "mcp"]).unwrap();
780 assert!(matches!(
781 probe.command,
782 Command::Framework(FrameworkCommand::Mcp)
783 ));
784 }
785
786 #[test]
787 fn the_service_subcommands_parse() {
788 for args in [
789 vec!["app", "service", "install"],
790 vec!["app", "service", "uninstall"],
791 vec!["app", "service", "status"],
792 ] {
793 assert!(Probe::try_parse_from(&args).is_ok(), "{args:?}");
794 }
795 }
796
797 #[test]
798 fn the_workspace_and_bridge_commands_parse() {
799 for args in [
800 vec!["app", "workspace", "init"],
801 vec!["app", "workspace", "init", "papers"],
802 vec!["app", "workspace", "init", "--sync"],
803 vec!["app", "workspace", "show"],
804 vec!["app", "workspace", "select", "papers"],
805 vec!["app", "workspace", "map", "papers", "papers-remote"],
806 vec!["app", "workspace", "move", "../papers"],
807 vec!["app", "workspace", "remove"],
808 vec!["app", "workspace", "remove", "--delete"],
809 vec![
810 "app",
811 "workgroup",
812 "create",
813 "--device-name",
814 "laptop",
815 "home",
816 ],
817 vec!["app", "workgroup", "list"],
818 vec![
819 "app",
820 "workgroup",
821 "join",
822 "--device-name",
823 "laptop",
824 "TICKET",
825 ],
826 vec!["app", "device", "list"],
827 vec!["app", "device", "invite", "--name", "phone"],
828 vec!["app", "device", "retire", "phone"],
829 ] {
830 assert!(Probe::try_parse_from(&args).is_ok(), "{args:?}");
831 }
832 }
833
834 #[test]
835 fn bare_invocation_defaults_to_serve() {
836 #[derive(Parser)]
840 struct Bare {
841 #[command(subcommand)]
842 command: Option<Command>,
843 }
844 let bare = Bare::try_parse_from(["app"]).unwrap();
845 assert!(bare.command.is_none());
846 assert!(matches!(
847 FrameworkCommand::default(),
848 FrameworkCommand::Serve
849 ));
850 }
851}
852
853#[cfg(test)]
854mod status_tests {
855 use super::*;
856 use sapphire_workspace::AppContext;
857
858 static CTX: AppContext = AppContext::new("sapphire-statustest");
859
860 async fn wait_until_listening(endpoint: &Endpoint) {
866 let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(5);
867 while !sapphire_ipc::probe(endpoint).await.unwrap() {
868 assert!(
869 tokio::time::Instant::now() < deadline,
870 "the server never started listening"
871 );
872 tokio::time::sleep(std::time::Duration::from_millis(10)).await;
873 }
874 }
875
876 #[tokio::test]
877 async fn status_reports_no_server_when_none_is_running() {
878 let tmp = tempfile::tempdir().unwrap();
879 let endpoint = sapphire_ipc::Endpoint::in_dir("status-test", tmp.path().to_path_buf());
880 let code = run_status(&endpoint, "status-test", "0.0.0").await.unwrap();
881 assert_eq!(code, 1, "no server is a non-zero exit");
882 }
883
884 #[tokio::test(flavor = "multi_thread")]
885 async fn status_shows_the_extension_rows_of_a_running_server() {
886 let tmp = tempfile::tempdir().unwrap();
887 let endpoint = sapphire_ipc::Endpoint::in_dir("status-test", tmp.path().to_path_buf());
888 let server = AppServer::new(&CTX, "0.0.0")
889 .endpoint(endpoint.clone())
890 .selection_file(tmp.path().join("workspace.toml"))
892 .status_rows(std::sync::Arc::new(|| {
893 vec![StatusRow {
894 name: "sync".into(),
895 value: "on".into(),
896 }]
897 }));
898 let handle = tokio::spawn(async move { server.run().await });
899 wait_until_listening(&endpoint).await;
900
901 let mut out = String::new();
904 let code = run_status_into(&endpoint, CTX.app_name, "0.0.0", &mut out)
905 .await
906 .unwrap();
907 assert_eq!(code, 0);
908 assert!(out.contains("running: true"), "output was: {out}");
909 assert!(out.contains("sync: on"), "output was: {out}");
910
911 let (client, _) = sapphire_ipc::connect_or_absent(
912 &endpoint,
913 CTX.app_name,
914 sapphire_ipc::ClientInfo {
915 kind: "test".into(),
916 version: "0.0.0".into(),
917 api: sapphire_backend::protocol::API_VERSION,
918 app_api: None,
919 pid: std::process::id(),
920 },
921 )
922 .await
923 .unwrap()
924 .expect("the server is listening");
925 let _: serde_json::Value = client
926 .call(sapphire_ipc::SHUTDOWN_METHOD, serde_json::json!({}))
927 .await
928 .unwrap();
929 handle.await.unwrap().unwrap();
930 }
931}
932
933#[cfg(test)]
934mod service_spec_tests {
935 use super::*;
936 use sapphire_workspace::AppContext;
937
938 static CTX: AppContext = AppContext::new("sapphire-servicetest");
939
940 #[test]
941 fn the_generated_spec_runs_the_server_not_the_cli() {
942 let spec = AppServer::new(&CTX, "0.0.0").service_spec();
946 assert_eq!(spec.args, vec!["serve".to_owned()]);
947 }
948
949 #[test]
950 fn the_generated_spec_names_this_application() {
951 let spec = AppServer::new(&CTX, "0.0.0").service_spec();
952 assert_eq!(spec.app_name, CTX.app_name);
953 }
954
955 #[test]
956 fn the_generated_spec_describes_the_server() {
957 let spec = AppServer::new(&CTX, "0.0.0").service_spec();
958 assert!(
959 spec.description.contains(CTX.app_name),
960 "the unit's description should name the application: {:?}",
961 spec.description
962 );
963 assert!(spec.description.contains("0.0.0"));
964 }
965}