tests: rework the actually useful tests to live in the integration crate

crates/irtt-app/src/shared/client/targets.rs

@@ -322,170 +322,3 @@ pub fn parse_stdin_target_set(
     let args = elements.into_iter().map(TargetArg::new).collect::<Vec<_>>();
     prepare_managed_targets(target_specs_with_empty(&args, true)?)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn target(input: &str) -> TargetArg {
-        TargetArg::new(input)
-    }
-
-    fn specs(inputs: &[&str]) -> Result<Vec<TargetSpec>, String> {
-        target_specs(&inputs.iter().map(|input| target(input)).collect::<Vec<_>>())
-    }
-
-    #[test]
-    fn legacy_target_syntax_and_ipv6_remain_supported() {
-        let parsed = specs(&[
-            "host.example",
-            "host.example:2112",
-            "[::1]:2112",
-            "eu=host.example",
-        ])
-        .unwrap();
-        assert_eq!(parsed[0].label, "host.example");
-        assert_eq!(parsed[1].label, "host.example:2112");
-        assert_eq!(parsed[2].label, "[::1]:2112");
-        assert_eq!(parsed[3].label, "eu");
-        assert!(parsed
-            .iter()
-            .all(|target| matches!(target.auth, TargetAuth::Inherit)));
-    }
-
-    #[test]
-    fn target_hmac_supports_inherit_override_disable_and_base64_padding() {
-        let parsed = specs(&[
-            "default=default.example",
-            "private=private.example@hmac=YWJjZA==",
-            "public=public.example@hmac=",
-        ])
-        .unwrap();
-        assert!(matches!(parsed[0].auth, TargetAuth::Inherit));
-        assert_eq!(parsed[1].auth, TargetAuth::Override(b"YWJjZA==".to_vec()));
-        assert!(matches!(parsed[2].auth, TargetAuth::Disable));
-    }
-
-    #[test]
-    fn target_delimiters_are_escaped_contextually() {
-        let parsed = specs(&["eu\\=west=host\\@hmac=literal@hmac=a\\@b\\,c\\=d\\\\e"]).unwrap();
-        assert_eq!(parsed[0].label, "eu=west");
-        assert_eq!(parsed[0].addr, "host@hmac=literal");
-        assert_eq!(parsed[0].auth, TargetAuth::Override(b"a@b,c=d\\e".to_vec()));
-    }
-
-    #[test]
-    fn positional_commas_are_not_reserved() {
-        let parsed = specs(&["edge=host,region@hmac=key,part"]).unwrap();
-        assert_eq!(parsed[0].addr, "host,region");
-        assert_eq!(parsed[0].auth, TargetAuth::Override(b"key,part".to_vec()));
-    }
-
-    #[test]
-    fn parser_diagnostics_and_debug_do_not_reveal_hmac_values() {
-        let secret = "very-secret-value";
-        let error = specs(&[&format!("target=host@hmac={secret}\\q")]).unwrap_err();
-        assert!(!error.contains(secret));
-        assert!(!format!("{:?}", target(&format!("target=host@hmac={secret}"))).contains(secret));
-        assert!(
-            !format!("{:?}", TargetAuth::Override(secret.as_bytes().to_vec())).contains(secret)
-        );
-    }
-
-    #[test]
-    fn target_specs_suffix_repeated_unlabeled_and_reject_duplicate_labels() {
-        let parsed = specs(&["host-a:2112", "host-a:2112"]).unwrap();
-        assert_eq!(parsed[0].label, "host-a:2112");
-        assert_eq!(parsed[1].label, "host-a:2112#2");
-        assert_eq!(
-            specs(&["host-a:2112", "host-a:2112=host-b:2112"]).unwrap_err(),
-            "duplicate target label"
-        );
-    }
-
-    #[test]
-    fn target_specs_preserve_argument_order_and_unlabeled_counts() {
-        let parsed = specs(&["local", "eu=eu.example", "foo", "us=us.example", "foo"]).unwrap();
-        let labels: Vec<_> = parsed.iter().map(|target| target.label.as_str()).collect();
-        assert_eq!(labels, ["local", "eu", "foo", "us", "foo#2"]);
-        let addresses: Vec<_> = parsed.iter().map(|target| target.addr.as_str()).collect();
-        assert_eq!(
-            addresses,
-            ["local", "eu.example", "foo", "us.example", "foo"]
-        );
-    }
-
-    #[test]
-    fn target_specs_reject_generated_suffix_collisions() {
-        assert_eq!(
-            specs(&[
-                "host.example",
-                "host.example",
-                "host.example#2=other.example"
-            ])
-            .unwrap_err(),
-            "duplicate target label"
-        );
-    }
-
-    #[test]
-    fn malformed_target_syntax_is_rejected_without_echoing_input() {
-        for input in ["=host", "label=", "host@hmac=value\\q", "host\\x"] {
-            assert!(specs(&[input]).is_err(), "{input}");
-        }
-    }
-
-    #[test]
-    fn target_preparation_maps_auth_to_managed_config() {
-        let prepared =
-            prepare_managed_targets(specs(&["a=one@hmac=key", "b=two@hmac="]).unwrap()).unwrap();
-        assert_eq!(
-            prepared[0]
-                .managed
-                .auth
-                .as_ref()
-                .unwrap()
-                .hmac_key
-                .as_deref(),
-            Some(b"key".as_slice())
-        );
-        assert_eq!(prepared[1].managed.auth.as_ref().unwrap().hmac_key, None);
-    }
-
-    #[test]
-    fn target_preparation_preserves_duplicate_endpoints() {
-        let prepared =
-            prepare_managed_targets(specs(&["a=example.test", "b=example.test"]).unwrap()).unwrap();
-        assert_eq!(prepared[0].managed.server_addr, "example.test");
-        assert_eq!(prepared[1].managed.server_addr, "example.test");
-    }
-
-    #[test]
-    fn stdin_target_sets_frame_commas_without_trimming_payload() {
-        let parsed = parse_stdin_target_set("a=one@hmac=x\\,y,b=two", 128).unwrap();
-        assert_eq!(
-            parsed[0].managed.auth.as_ref().unwrap().hmac_key.as_deref(),
-            Some(b"x,y".as_slice())
-        );
-        assert_eq!(parsed[1].label, "b");
-        assert_eq!(
-            parse_stdin_target_set(" []", 128).unwrap()[0]
-                .managed
-                .server_addr,
-            " []"
-        );
-        assert_eq!(
-            parse_stdin_target_set("[] ", 128).unwrap()[0]
-                .managed
-                .server_addr,
-            "[] "
-        );
-        assert!(parse_stdin_target_set("", 128).is_err());
-        assert!(parse_stdin_target_set("a=one,b=two", 1).is_err());
-    }
-
-    #[test]
-    fn stdin_empty_set_is_exactly_bracket_pair() {
-        assert!(parse_stdin_target_set("[]", 128).unwrap().is_empty());
-    }
-}