test(cli): unit-test looks_like_uuid + parse_with_uuid_fallback

Add inline #[cfg(test)] coverage for the bare-UUID fallback in
src/lib.rs — case-insensitive shape predicate, the get-rewrite
shortcut, no-double-rewrite invariant, and original-error
preservation when the rewrite parse also fails. Add a new
tests/cli_parse_main.rs integration suite that locks down the
top-level Cli parser: --help / --version / no-subcommand /
unknown-subcommand error kinds, every subcommand name, and the
download/gc visible aliases.

Assisted-by: Claude Code:claude-opus-4-7

Author: mikolalysenko

crates/socket-patch-cli/src/lib.rs

@@ -94,3 +94,162 @@ pub fn parse_with_uuid_fallback(argv: Vec<String>) -> Result<Cli, clap::Error> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    //! Unit tests for the bare-UUID fallback. These tests lock in the
+    //! `socket-patch <UUID>` rewrite shortcut and the shape predicate it
+    //! uses — both of which are part of the CLI contract (see
+    //! `CLI_CONTRACT.md`).
+    use super::*;
+
+    // ---------- looks_like_uuid ----------
+
+    #[test]
+    fn looks_like_uuid_accepts_canonical_lowercase() {
+        assert!(looks_like_uuid("80630680-4da6-45f9-bba8-b888e0ffd58c"));
+    }
+
+    #[test]
+    fn looks_like_uuid_accepts_uppercase() {
+        // `is_ascii_hexdigit` accepts A-F as well as a-f, so all-uppercase
+        // UUIDs must still pass the shape check.
+        assert!(looks_like_uuid("80630680-4DA6-45F9-BBA8-B888E0FFD58C"));
+    }
+
+    #[test]
+    fn looks_like_uuid_accepts_mixed_case() {
+        assert!(looks_like_uuid("80630680-4Da6-45F9-bBa8-B888e0FfD58c"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_four_groups() {
+        // 8-4-4-4 — missing the final 12-char group.
+        assert!(!looks_like_uuid("80630680-4da6-45f9-bba8"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_six_groups() {
+        // One too many groups — the split count must be exactly 5.
+        assert!(!looks_like_uuid(
+            "80630680-4da6-45f9-bba8-b888e0ffd58c-extra"
+        ));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_8_4_4_4_13_group_lengths() {
+        // Final group has 13 chars instead of 12.
+        assert!(!looks_like_uuid("80630680-4da6-45f9-bba8-b888e0ffd58cc"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_7_4_4_4_12_group_lengths() {
+        // First group has 7 chars instead of 8.
+        assert!(!looks_like_uuid("8063068-4da6-45f9-bba8-b888e0ffd58c0"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_non_hex_chars() {
+        // `g` is not a hex digit — must fail even though the shape is right.
+        assert!(!looks_like_uuid("g0630680-4da6-45f9-bba8-b888e0ffd58c"));
+        assert!(!looks_like_uuid("80630680-4dz6-45f9-bba8-b888e0ffd58c"));
+        assert!(!looks_like_uuid("80630680-4da6-45f9-bba8-b888e0ffd58z"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_empty_string() {
+        assert!(!looks_like_uuid(""));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_string_with_no_dashes() {
+        // 32 hex chars, no dashes — close to a UUID but not the right shape.
+        assert!(!looks_like_uuid("806306804da645f9bba8b888e0ffd58c"));
+    }
+
+    #[test]
+    fn looks_like_uuid_rejects_bare_dashes() {
+        // Five empty groups — split count is right, group lengths aren't.
+        assert!(!looks_like_uuid("----"));
+    }
+
+    // ---------- parse_with_uuid_fallback ----------
+
+    const UUID: &str = "80630680-4da6-45f9-bba8-b888e0ffd58c";
+
+    fn argv(items: &[&str]) -> Vec<String> {
+        items.iter().map(|s| (*s).to_string()).collect()
+    }
+
+    #[test]
+    fn fallback_rewrites_bare_uuid_to_get() {
+        let cli = parse_with_uuid_fallback(argv(&["socket-patch", UUID])).unwrap();
+        match cli.command {
+            Commands::Get(args) => assert_eq!(args.identifier, UUID),
+            _ => panic!("expected Commands::Get"),
+        }
+    }
+
+    #[test]
+    fn fallback_preserves_trailing_flags() {
+        // Flags after the UUID must be forwarded to the synthesized `get`.
+        let cli = parse_with_uuid_fallback(argv(&["socket-patch", UUID, "--json"])).unwrap();
+        match cli.command {
+            Commands::Get(args) => {
+                assert_eq!(args.identifier, UUID);
+                assert!(args.json, "--json should be forwarded to get");
+            }
+            _ => panic!("expected Commands::Get"),
+        }
+    }
+
+    #[test]
+    fn fallback_returns_original_error_when_first_arg_is_not_uuid() {
+        // No rewrite should happen; the original clap error must surface.
+        // `Cli` doesn't derive `Debug`, so `unwrap_err()` doesn't compile —
+        // pull the error out via `match` instead.
+        let err = match parse_with_uuid_fallback(argv(&["socket-patch", "not-a-uuid"])) {
+            Ok(_) => panic!("expected parse to fail"),
+            Err(e) => e,
+        };
+        assert_eq!(err.kind(), clap::error::ErrorKind::InvalidSubcommand);
+    }
+
+    #[test]
+    fn fallback_is_skipped_when_normal_parse_succeeds() {
+        // `list` parses normally — fallback should not engage.
+        let cli = parse_with_uuid_fallback(argv(&["socket-patch", "list"])).unwrap();
+        assert!(matches!(cli.command, Commands::List(_)));
+    }
+
+    #[test]
+    fn fallback_does_not_double_rewrite_explicit_get() {
+        // `socket-patch get <UUID>` already parses; fallback never runs.
+        let cli = parse_with_uuid_fallback(argv(&["socket-patch", "get", UUID])).unwrap();
+        match cli.command {
+            Commands::Get(args) => assert_eq!(args.identifier, UUID),
+            _ => panic!("expected Commands::Get"),
+        }
+    }
+
+    #[test]
+    fn fallback_surfaces_original_error_when_rewrite_also_fails() {
+        // UUID is valid-shaped so a rewrite is attempted, but `get` doesn't
+        // accept this flag — the rewrite parse fails and we must return the
+        // ORIGINAL error (the one from the un-rewritten parse), not the
+        // rewrite's error.
+        let err = match parse_with_uuid_fallback(argv(&[
+            "socket-patch",
+            UUID,
+            "--invalid-flag-that-get-does-not-accept",
+        ])) {
+            Ok(_) => panic!("expected parse to fail"),
+            Err(e) => e,
+        };
+        // The original parse failed because `<UUID>` isn't a known
+        // subcommand, so the surfaced error must be InvalidSubcommand —
+        // NOT UnknownArgument (which is what the rewrite parse would have
+        // produced).
+        assert_eq!(err.kind(), clap::error::ErrorKind::InvalidSubcommand);
+    }
+}

crates/socket-patch-cli/tests/cli_parse_main.rs

@@ -0,0 +1,138 @@
+//! Top-level `Cli::try_parse_from` behavior tests.
+//!
+//! These tests cover the parser surface that doesn't fit in
+//! `src/lib.rs::tests` — clap's auto-generated help/version handling, the
+//! "no subcommand" error kind, every subcommand name, and the
+//! visible_alias values (`download` for `get`, `gc` for `repair`).
+//!
+//! Each subcommand name and alias here is part of the CLI contract
+//! defined in `crates/socket-patch-cli/CLI_CONTRACT.md`.
+
+use clap::Parser;
+use socket_patch_cli::{Cli, Commands};
+
+fn parse(argv: &[&str]) -> Result<Cli, clap::Error> {
+    Cli::try_parse_from(argv)
+}
+
+/// Pull the error out of a parse result. `Cli` doesn't derive `Debug`,
+/// so `Result::unwrap_err` won't compile — this helper sidesteps that.
+fn expect_err(result: Result<Cli, clap::Error>) -> clap::Error {
+    match result {
+        Ok(_) => panic!("expected parse to fail"),
+        Err(e) => e,
+    }
+}
+
+// ---------- top-level error kinds ----------
+
+#[test]
+fn no_subcommand_returns_display_help_on_missing() {
+    // clap v4 returns `DisplayHelpOnMissingArgumentOrSubcommand` (not
+    // `MissingSubcommand`) for `socket-patch` with no args when a
+    // subcommand is required — this is the kind the binary's main.rs
+    // handler branches on.
+    let err = expect_err(parse(&["socket-patch"]));
+    assert_eq!(
+        err.kind(),
+        clap::error::ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
+    );
+}
+
+#[test]
+fn version_flag_triggers_display_version() {
+    let err = expect_err(parse(&["socket-patch", "--version"]));
+    assert_eq!(err.kind(), clap::error::ErrorKind::DisplayVersion);
+}
+
+#[test]
+fn help_flag_triggers_display_help() {
+    let err = expect_err(parse(&["socket-patch", "--help"]));
+    assert_eq!(err.kind(), clap::error::ErrorKind::DisplayHelp);
+}
+
+#[test]
+fn unknown_subcommand_returns_invalid_subcommand() {
+    let err = expect_err(parse(&["socket-patch", "bogus"]));
+    assert_eq!(err.kind(), clap::error::ErrorKind::InvalidSubcommand);
+}
+
+// ---------- every subcommand name parses ----------
+
+#[test]
+fn apply_subcommand_parses() {
+    let cli = parse(&["socket-patch", "apply"]).expect("apply must parse with no positional");
+    assert!(matches!(cli.command, Commands::Apply(_)));
+}
+
+#[test]
+fn rollback_subcommand_parses_without_identifier() {
+    // rollback's identifier is optional — bare `rollback` must succeed.
+    let cli =
+        parse(&["socket-patch", "rollback"]).expect("rollback must parse with no positional");
+    assert!(matches!(cli.command, Commands::Rollback(_)));
+}
+
+#[test]
+fn get_subcommand_parses_with_identifier() {
+    let cli = parse(&["socket-patch", "get", "some-id"]).expect("get must parse with identifier");
+    match cli.command {
+        Commands::Get(args) => assert_eq!(args.identifier, "some-id"),
+        _ => panic!("expected Commands::Get"),
+    }
+}
+
+#[test]
+fn scan_subcommand_parses() {
+    let cli = parse(&["socket-patch", "scan"]).expect("scan must parse with no positional");
+    assert!(matches!(cli.command, Commands::Scan(_)));
+}
+
+#[test]
+fn list_subcommand_parses() {
+    let cli = parse(&["socket-patch", "list"]).expect("list must parse with no positional");
+    assert!(matches!(cli.command, Commands::List(_)));
+}
+
+#[test]
+fn remove_subcommand_parses_with_identifier() {
+    let cli =
+        parse(&["socket-patch", "remove", "some-id"]).expect("remove must parse with identifier");
+    match cli.command {
+        Commands::Remove(args) => assert_eq!(args.identifier, "some-id"),
+        _ => panic!("expected Commands::Remove"),
+    }
+}
+
+#[test]
+fn setup_subcommand_parses() {
+    let cli = parse(&["socket-patch", "setup"]).expect("setup must parse with no positional");
+    assert!(matches!(cli.command, Commands::Setup(_)));
+}
+
+#[test]
+fn repair_subcommand_parses() {
+    let cli = parse(&["socket-patch", "repair"]).expect("repair must parse with no positional");
+    assert!(matches!(cli.command, Commands::Repair(_)));
+}
+
+// ---------- visible aliases ----------
+
+#[test]
+fn download_alias_parses_as_get() {
+    // `download` is the visible_alias for `get` — wrappers in the wild
+    // call this name directly, so it has to keep working.
+    let cli = parse(&["socket-patch", "download", "some-id"])
+        .expect("`download` alias must parse as Get");
+    match cli.command {
+        Commands::Get(args) => assert_eq!(args.identifier, "some-id"),
+        _ => panic!("expected Commands::Get via `download` alias"),
+    }
+}
+
+#[test]
+fn gc_alias_parses_as_repair() {
+    // `gc` is the visible_alias for `repair`.
+    let cli = parse(&["socket-patch", "gc"]).expect("`gc` alias must parse as Repair");
+    assert!(matches!(cli.command, Commands::Repair(_)));
+}