Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

28.5 KB
Raw Blame
use std::collections::{BTreeMap, BTreeSet};

use reqwest::Method;
use serde::{Deserialize, Serialize};

use crate::connection::AppState;

use super::client::{client_for_state, ConsulClient};
use super::config::ConsulConsistency;
use super::response::{decode_json_response, ensure_success, ConsulResponseMetadata, MAX_COLLECTION_ITEMS};

// Consul lists config entries by kind and does not expose a single inventory endpoint.
const NAMESPACE_CONFIG_ENTRY_KINDS: &[&str] = &[
    "api-gateway",
    "bound-api-gateway",
    "file-system-certificate",
    "http-route",
    "ingress-gateway",
    "inline-certificate",
    "jwt-provider",
    "service-defaults",
    "service-intentions",
    "service-resolver",
    "service-router",
    "service-splitter",
    "tcp-route",
    "terminating-gateway",
];

const PARTITION_CONFIG_ENTRY_KINDS: &[&str] = &[
    "control-plane-request-limit",
    "exported-services",
    "mesh",
    "product-usage",
    "proxy-defaults",
    "rate-limit",
    "sameness-group",
];

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum ConsulEnterpriseKind {
    Namespace,
    Partition,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulNamespace {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub partition: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub meta: BTreeMap<String, String>,
    #[serde(rename = "ACLs", default)]
    pub acls: ConsulNamespaceAcls,
    #[serde(default)]
    pub deleted_at: Option<String>,
    #[serde(default)]
    pub create_index: u64,
    #[serde(default)]
    pub modify_index: u64,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulNamespaceAcls {
    #[serde(default)]
    pub policy_defaults: Vec<serde_json::Value>,
    #[serde(default)]
    pub role_defaults: Vec<serde_json::Value>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ConsulPartition {
    #[serde(default)]
    pub name: String,
    #[serde(default)]
    pub description: String,
    #[serde(default)]
    pub meta: BTreeMap<String, String>,
    #[serde(default)]
    pub deleted_at: Option<String>,
    #[serde(default)]
    pub create_index: u64,
    #[serde(default)]
    pub modify_index: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "items", rename_all = "camelCase")]
pub enum ConsulEnterpriseList {
    Namespace(Vec<ConsulNamespace>),
    Partition(Vec<ConsulPartition>),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "item", rename_all = "camelCase")]
pub enum ConsulEnterpriseItem {
    Namespace(ConsulNamespace),
    Partition(ConsulPartition),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind", content = "item", rename_all = "camelCase")]
pub enum ConsulEnterpriseWrite {
    Namespace(ConsulNamespace),
    Partition(ConsulPartition),
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ConsulScopeImpact {
    pub services: usize,
    pub nodes: usize,
    pub kv_keys: usize,
    pub health_checks: usize,
    pub sessions: usize,
    pub config_entries: usize,
    pub intentions: usize,
    pub peerings: usize,
    pub namespaces: usize,
    pub acl_tokens: usize,
    pub acl_policies: usize,
    pub acl_roles: usize,
    pub acl_auth_methods: usize,
    pub acl_binding_rules: usize,
    pub complete: bool,
    pub filtered_by_acls: bool,
    pub unavailable_resources: Vec<String>,
}

#[derive(Debug, Clone, Copy)]
enum ImpactResource {
    Services,
    Nodes,
    KvKeys,
    HealthChecks,
    Sessions,
    ConfigEntries,
    Intentions,
    Peerings,
    Namespaces,
    AclTokens,
    AclPolicies,
    AclRoles,
    AclAuthMethods,
    AclBindingRules,
}

#[derive(Debug)]
struct ImpactInspection {
    count: usize,
    filtered_by_acls: bool,
}

impl ConsulScopeImpact {
    fn record(&mut self, resource: ImpactResource, label: String, result: Result<ImpactInspection, String>) {
        match result {
            Ok(inspection) => {
                let target = match resource {
                    ImpactResource::Services => &mut self.services,
                    ImpactResource::Nodes => &mut self.nodes,
                    ImpactResource::KvKeys => &mut self.kv_keys,
                    ImpactResource::HealthChecks => &mut self.health_checks,
                    ImpactResource::Sessions => &mut self.sessions,
                    ImpactResource::ConfigEntries => &mut self.config_entries,
                    ImpactResource::Intentions => &mut self.intentions,
                    ImpactResource::Peerings => &mut self.peerings,
                    ImpactResource::Namespaces => &mut self.namespaces,
                    ImpactResource::AclTokens => &mut self.acl_tokens,
                    ImpactResource::AclPolicies => &mut self.acl_policies,
                    ImpactResource::AclRoles => &mut self.acl_roles,
                    ImpactResource::AclAuthMethods => &mut self.acl_auth_methods,
                    ImpactResource::AclBindingRules => &mut self.acl_binding_rules,
                };
                if let Some(total) = target.checked_add(inspection.count) {
                    *target = total;
                } else {
                    self.unavailable_resources.push(label);
                }
                self.filtered_by_acls |= inspection.filtered_by_acls;
            }
            Err(_) => self.unavailable_resources.push(label),
        }
    }

    fn finish(mut self) -> Self {
        self.unavailable_resources.sort();
        self.unavailable_resources.dedup();
        self.complete = self.unavailable_resources.is_empty() && !self.filtered_by_acls;
        self
    }
}

pub async fn consul_enterprise_list_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulEnterpriseKind,
) -> Result<ConsulEnterpriseList, String> {
    let client = client_for_state(state, connection_id).await?;
    match kind {
        ConsulEnterpriseKind::Namespace => {
            Ok(ConsulEnterpriseList::Namespace(get_json(&client, "/v1/namespaces", "list namespaces").await?))
        }
        ConsulEnterpriseKind::Partition => {
            Ok(ConsulEnterpriseList::Partition(get_json(&client, "/v1/partitions", "list partitions").await?))
        }
    }
}

pub async fn consul_enterprise_get_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulEnterpriseKind,
    name: &str,
) -> Result<ConsulEnterpriseItem, String> {
    let client = client_for_state(state, connection_id).await?;
    let url = client.api_url(&enterprise_path(kind, name))?;
    match kind {
        ConsulEnterpriseKind::Namespace => Ok(ConsulEnterpriseItem::Namespace(
            client.request_json(Method::GET, url, None::<&()>, true, "read namespace").await?,
        )),
        ConsulEnterpriseKind::Partition => Ok(ConsulEnterpriseItem::Partition(
            client.request_json(Method::GET, url, None::<&()>, true, "read partition").await?,
        )),
    }
}

pub async fn consul_enterprise_apply_core(
    state: &AppState,
    connection_id: &str,
    existing_name: Option<&str>,
    item: ConsulEnterpriseWrite,
) -> Result<ConsulEnterpriseItem, String> {
    super::ensure_writable(state, connection_id, "Enterprise scope write").await?;
    let client = client_for_state(state, connection_id).await?;
    match item {
        ConsulEnterpriseWrite::Namespace(value) => {
            Ok(ConsulEnterpriseItem::Namespace(write_namespace(&client, existing_name, value).await?))
        }
        ConsulEnterpriseWrite::Partition(value) => {
            Ok(ConsulEnterpriseItem::Partition(write_partition(&client, existing_name, value).await?))
        }
    }
}

async fn write_namespace(
    client: &ConsulClient,
    existing_name: Option<&str>,
    mut value: ConsulNamespace,
) -> Result<ConsulNamespace, String> {
    value.partition = target_partition(client.partition()).to_string();
    let (method, path) = write_path(ConsulEnterpriseKind::Namespace, existing_name);
    let mut url = client.api_url(&path)?;
    append_enterprise_target(client, &mut url, ConsulEnterpriseKind::Namespace, false);
    client.request_json_unscoped(method, url, Some(&value), "write namespace").await
}

async fn write_partition(
    client: &ConsulClient,
    existing_name: Option<&str>,
    value: ConsulPartition,
) -> Result<ConsulPartition, String> {
    let (method, path) = write_path(ConsulEnterpriseKind::Partition, existing_name);
    let mut url = client.api_url(&path)?;
    append_enterprise_target(client, &mut url, ConsulEnterpriseKind::Partition, false);
    client.request_json_unscoped(method, url, Some(&value), "write partition").await
}

fn target_partition(partition: &str) -> &str {
    if partition.trim().is_empty() {
        "default"
    } else {
        partition
    }
}

pub async fn consul_enterprise_impact_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulEnterpriseKind,
    name: &str,
) -> Result<ConsulScopeImpact, String> {
    let client = client_for_state(state, connection_id).await?;
    inspect_scope_impact(&client, kind, name).await
}

pub async fn consul_enterprise_delete_core(
    state: &AppState,
    connection_id: &str,
    kind: ConsulEnterpriseKind,
    name: &str,
) -> Result<ConsulScopeImpact, String> {
    super::ensure_writable(state, connection_id, "Enterprise scope delete").await?;
    let impact = consul_enterprise_impact_core(state, connection_id, kind, name).await?;
    if !impact.complete {
        return Err(
            "CONSUL_IMPACT_INCOMPLETE: scoped resources could not be enumerated completely; delete blocked".to_string()
        );
    }
    let client = client_for_state(state, connection_id).await?;
    let mut url = client.api_url(&enterprise_path(kind, name))?;
    append_enterprise_target(&client, &mut url, kind, false);
    ensure_success(client.send(Method::DELETE, url, None).await?, "delete Enterprise scope", client.token()).await?;
    Ok(impact)
}

async fn get_json<T: serde::de::DeserializeOwned>(
    client: &ConsulClient,
    path: &str,
    action: &str,
) -> Result<T, String> {
    let url = client.api_url(path)?;
    client.request_json(Method::GET, url, None::<&()>, true, action).await
}

async fn inspect_scope_impact(
    client: &ConsulClient,
    kind: ConsulEnterpriseKind,
    name: &str,
) -> Result<ConsulScopeImpact, String> {
    if name.trim().is_empty() {
        return Err("CONSUL_INVALID_REQUEST: Enterprise scope name is required".to_string());
    }

    let mut impact = ConsulScopeImpact::default();
    match kind {
        ConsulEnterpriseKind::Namespace => {
            inspect_namespace_resources(client, name, client.partition(), &mut impact).await;
        }
        ConsulEnterpriseKind::Partition => {
            match inspect_partition_namespaces(client, name).await {
                Ok((namespaces, filtered)) => {
                    impact.record(
                        ImpactResource::Namespaces,
                        "namespaces".to_string(),
                        Ok(ImpactInspection { count: namespaces.len(), filtered_by_acls: filtered }),
                    );
                    // Every partition owns a default namespace. Its absence means the list cannot prove completeness,
                    // even if an older Consul version omitted the ACL-filtered response header.
                    if !namespaces.contains("default") {
                        impact.unavailable_resources.push("namespaces:default".to_string());
                    }
                    for namespace in namespaces {
                        inspect_namespace_resources(client, &namespace, name, &mut impact).await;
                    }
                }
                Err(_) => impact.unavailable_resources.push("namespaces".to_string()),
            }

            record_inspection(
                client,
                &mut impact,
                ImpactResource::Nodes,
                "nodes",
                "/v1/catalog/nodes",
                name,
                None,
                &[],
                false,
            )
            .await;
            record_inspection(
                client,
                &mut impact,
                ImpactResource::Peerings,
                "peerings",
                "/v1/peerings",
                name,
                None,
                &[],
                false,
            )
            .await;
            for config_kind in PARTITION_CONFIG_ENTRY_KINDS {
                record_inspection(
                    client,
                    &mut impact,
                    ImpactResource::ConfigEntries,
                    &format!("configEntries:{config_kind}"),
                    &format!("/v1/config/{config_kind}"),
                    name,
                    Some("default"),
                    &[],
                    false,
                )
                .await;
            }
        }
    }
    Ok(impact.finish())
}

async fn inspect_namespace_resources(
    client: &ConsulClient,
    namespace: &str,
    partition: &str,
    impact: &mut ConsulScopeImpact,
) {
    let resources = [
        (ImpactResource::Services, "services", "/v1/catalog/services", false),
        (ImpactResource::KvKeys, "kvKeys", "/v1/kv/", true),
        (ImpactResource::HealthChecks, "healthChecks", "/v1/health/state/any", false),
        (ImpactResource::Sessions, "sessions", "/v1/session/list", false),
        (ImpactResource::Intentions, "intentions", "/v1/connect/intentions", false),
        (ImpactResource::AclTokens, "aclTokens", "/v1/acl/tokens", false),
        (ImpactResource::AclPolicies, "aclPolicies", "/v1/acl/policies", false),
        (ImpactResource::AclRoles, "aclRoles", "/v1/acl/roles", false),
        (ImpactResource::AclAuthMethods, "aclAuthMethods", "/v1/acl/auth-methods", false),
        (ImpactResource::AclBindingRules, "aclBindingRules", "/v1/acl/binding-rules", false),
    ];
    for (resource, label, path, empty_on_not_found) in resources {
        let query = if matches!(resource, ImpactResource::KvKeys) { &[("keys", "")][..] } else { &[][..] };
        record_inspection(
            client,
            impact,
            resource,
            &scoped_label(label, namespace),
            path,
            partition,
            Some(namespace),
            query,
            empty_on_not_found,
        )
        .await;
    }
    for config_kind in NAMESPACE_CONFIG_ENTRY_KINDS {
        record_inspection(
            client,
            impact,
            ImpactResource::ConfigEntries,
            &scoped_label(&format!("configEntries:{config_kind}"), namespace),
            &format!("/v1/config/{config_kind}"),
            partition,
            Some(namespace),
            &[],
            false,
        )
        .await;
    }
}

#[allow(clippy::too_many_arguments)]
async fn record_inspection(
    client: &ConsulClient,
    impact: &mut ConsulScopeImpact,
    resource: ImpactResource,
    label: &str,
    path: &str,
    partition: &str,
    namespace: Option<&str>,
    query: &[(&str, &str)],
    empty_on_not_found: bool,
) {
    let result = impact_get(client, path, partition, namespace, query, empty_on_not_found).await;
    impact.record(resource, label.to_string(), result);
}

async fn impact_get(
    client: &ConsulClient,
    path: &str,
    partition: &str,
    namespace: Option<&str>,
    extra_query: &[(&str, &str)],
    empty_on_not_found: bool,
) -> Result<ImpactInspection, String> {
    let mut url = client.api_url(path)?;
    append_explicit_scope(client, &mut url, partition, namespace, true);
    for (key, value) in extra_query {
        url.query_pairs_mut().append_pair(key, value);
    }
    let response = client.send(Method::GET, url, None).await?;
    let filtered = ConsulResponseMetadata::from_response(&response).filtered_by_acls.unwrap_or(false);
    if is_empty_not_found(response.status(), empty_on_not_found) {
        return Ok(ImpactInspection { count: 0, filtered_by_acls: filtered });
    }
    let response = ensure_success(response, "inspect scoped resources", client.token()).await?;
    let value = decode_json_response::<serde_json::Value>(response, "inspect scoped resources").await?;
    let count = count_collection(&value)?;
    Ok(ImpactInspection { count, filtered_by_acls: filtered })
}

async fn inspect_partition_namespaces(
    client: &ConsulClient,
    partition: &str,
) -> Result<(BTreeSet<String>, bool), String> {
    let mut url = client.api_url("/v1/namespaces")?;
    append_explicit_scope(client, &mut url, partition, None, true);
    let response = ensure_success(
        client.send(Method::GET, url, None).await?,
        "list namespaces for partition impact",
        client.token(),
    )
    .await?;
    let filtered = ConsulResponseMetadata::from_response(&response).filtered_by_acls.unwrap_or(false);
    let value = decode_json_response::<serde_json::Value>(response, "list namespaces for partition impact").await?;
    let items = value
        .as_array()
        .ok_or_else(|| "CONSUL_INVALID_RESPONSE: namespace impact response must be an array".to_string())?;
    if items.len() > MAX_COLLECTION_ITEMS {
        return Err(format!("CONSUL_RESPONSE_TOO_LARGE: impact response exceeds {MAX_COLLECTION_ITEMS} items"));
    }
    let mut namespaces = BTreeSet::new();
    for item in items {
        let name = item
            .get("Name")
            .and_then(serde_json::Value::as_str)
            .filter(|name| !name.is_empty())
            .ok_or_else(|| "CONSUL_INVALID_RESPONSE: namespace impact item is missing Name".to_string())?;
        if !namespaces.insert(name.to_string()) {
            return Err(format!("CONSUL_INVALID_RESPONSE: duplicate namespace {name:?} in impact response"));
        }
    }
    Ok((namespaces, filtered))
}

fn count_collection(value: &serde_json::Value) -> Result<usize, String> {
    let count = match value {
        serde_json::Value::Array(items) => items.len(),
        serde_json::Value::Object(items) => items.len(),
        _ => return Err("CONSUL_INVALID_RESPONSE: impact response must be an array or object".to_string()),
    };
    if count > MAX_COLLECTION_ITEMS {
        return Err(format!("CONSUL_RESPONSE_TOO_LARGE: impact response exceeds {MAX_COLLECTION_ITEMS} items"));
    }
    Ok(count)
}

fn is_empty_not_found(status: reqwest::StatusCode, empty_on_not_found: bool) -> bool {
    empty_on_not_found && status == reqwest::StatusCode::NOT_FOUND
}

fn append_explicit_scope(
    client: &ConsulClient,
    url: &mut reqwest::Url,
    partition: &str,
    namespace: Option<&str>,
    read: bool,
) {
    let mut query = url.query_pairs_mut();
    if !client.datacenter().is_empty() {
        query.append_pair("dc", client.datacenter());
    }
    if !partition.is_empty() {
        query.append_pair("partition", partition);
    }
    if let Some(namespace) = namespace.filter(|namespace| !namespace.is_empty()) {
        query.append_pair("ns", namespace);
    }
    if read {
        match client.config().consistency {
            ConsulConsistency::Default => {}
            ConsulConsistency::Stale => {
                query.append_pair("stale", "");
            }
            ConsulConsistency::Consistent => {
                query.append_pair("consistent", "");
            }
        }
    }
}

fn append_enterprise_target(client: &ConsulClient, url: &mut reqwest::Url, kind: ConsulEnterpriseKind, read: bool) {
    let partition = match kind {
        ConsulEnterpriseKind::Namespace => client.partition(),
        ConsulEnterpriseKind::Partition => "",
    };
    append_explicit_scope(client, url, partition, None, read);
}

fn scoped_label(label: &str, namespace: &str) -> String {
    format!("{label}@namespace:{namespace}")
}

fn enterprise_path(kind: ConsulEnterpriseKind, name: &str) -> String {
    let name = percent_encoding::utf8_percent_encode(name, percent_encoding::NON_ALPHANUMERIC);
    match kind {
        ConsulEnterpriseKind::Namespace => format!("/v1/namespace/{name}"),
        ConsulEnterpriseKind::Partition => format!("/v1/partition/{name}"),
    }
}

fn write_path(kind: ConsulEnterpriseKind, existing_name: Option<&str>) -> (Method, String) {
    match existing_name {
        Some(name) => (Method::PUT, enterprise_path(kind, name)),
        None => (
            Method::PUT,
            match kind {
                ConsulEnterpriseKind::Namespace => "/v1/namespace",
                ConsulEnterpriseKind::Partition => "/v1/partition",
            }
            .to_string(),
        ),
    }
}

#[cfg(test)]
mod tests {
    use super::super::test_support::{serve_once, test_client as fixture_client};
    use super::*;
    use reqwest::Url;

    #[test]
    fn enterprise_paths_encode_names() {
        assert_eq!(enterprise_path(ConsulEnterpriseKind::Namespace, "team/a"), "/v1/namespace/team%2Fa");
    }

    #[test]
    fn namespace_acl_defaults_round_trip_with_the_official_nested_shape() {
        let value = serde_json::json!({
            "Name": "team-a",
            "Partition": "payments",
            "ACLs": {
                "PolicyDefaults": [{ "Name": "node-read" }],
                "RoleDefaults": [{ "ID": "role-1" }]
            }
        });
        let namespace: ConsulNamespace = serde_json::from_value(value.clone()).unwrap();
        assert_eq!(namespace.acls.policy_defaults.len(), 1);
        assert_eq!(namespace.acls.role_defaults.len(), 1);
        assert_eq!(namespace.partition, "payments");
        let serialized = serde_json::to_value(namespace).unwrap();
        assert_eq!(serialized["ACLs"], value["ACLs"]);
    }

    #[test]
    fn namespace_write_partition_is_explicit_and_defaults_safely() {
        assert_eq!(target_partition("partition-a"), "partition-a");
        assert_eq!(target_partition(""), "default");
        assert_eq!(target_partition("   "), "default");
        assert_eq!(
            write_path(ConsulEnterpriseKind::Namespace, Some("team/a")),
            (Method::PUT, "/v1/namespace/team%2Fa".to_string())
        );
    }

    #[tokio::test]
    async fn namespace_create_uses_partition_body_and_excludes_current_namespace() {
        let response_body = r#"{"Name":"team-b","Partition":"partition-a","Description":"","Meta":{},"ACLs":{}}"#;
        let response = format!(
            "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{response_body}",
            response_body.len()
        );
        let (url, request_rx) = serve_once(response).await;
        let client = fixture_client(url).await;
        let written =
            write_namespace(&client, None, ConsulNamespace { name: "team-b".to_string(), ..Default::default() })
                .await
                .unwrap();
        assert_eq!(written.partition, "partition-a");

        let request = request_rx.await.unwrap();
        let (headers, body) = request.split_once("\r\n\r\n").unwrap();
        assert!(headers.starts_with("PUT /proxy/v1/namespace?dc=dc1&partition=partition-a HTTP/1.1"));
        assert!(!headers.contains("ns="));
        assert!(headers.to_ascii_lowercase().contains("content-type: application/json"));
        assert!(headers.to_ascii_lowercase().contains("x-consul-token: fixture-token"));
        let body: serde_json::Value = serde_json::from_str(body).unwrap();
        assert_eq!(body["Name"], "team-b");
        assert_eq!(body["Partition"], "partition-a");
    }

    #[tokio::test]
    async fn explicit_impact_scope_uses_the_target_without_wildcards() {
        let client = test_client().await;
        let mut url = client.api_url("/v1/catalog/services").unwrap();
        append_explicit_scope(&client, &mut url, "target-partition", Some("target-namespace"), true);
        let pairs: BTreeMap<_, _> = url.query_pairs().into_owned().collect();
        assert_eq!(pairs.get("dc").map(String::as_str), Some("dc1"));
        assert_eq!(pairs.get("partition").map(String::as_str), Some("target-partition"));
        assert_eq!(pairs.get("ns").map(String::as_str), Some("target-namespace"));
        assert!(pairs.contains_key("consistent"));
        assert!(!url.as_str().contains('*'));
        assert!(!url.as_str().contains("configured-namespace"));
        assert!(!url.as_str().contains("configured-partition"));
    }

    #[tokio::test]
    async fn enterprise_delete_target_does_not_append_the_connection_namespace() {
        let client = test_client().await;
        let mut namespace_url = client.api_url("/v1/namespace/team-a").unwrap();
        append_enterprise_target(&client, &mut namespace_url, ConsulEnterpriseKind::Namespace, false);
        assert_eq!(namespace_url.query(), Some("dc=dc1&partition=configured-partition"));

        let mut partition_url = client.api_url("/v1/partition/team-a").unwrap();
        append_enterprise_target(&client, &mut partition_url, ConsulEnterpriseKind::Partition, false);
        assert_eq!(partition_url.query(), Some("dc=dc1"));
    }

    #[test]
    fn impact_is_incomplete_when_any_result_is_filtered_or_unavailable() {
        let mut impact = ConsulScopeImpact::default();
        impact.record(
            ImpactResource::Services,
            "services".to_string(),
            Ok(ImpactInspection { count: 2, filtered_by_acls: true }),
        );
        impact.record(ImpactResource::Sessions, "sessions".to_string(), Err("forbidden".to_string()));
        let impact = impact.finish();
        assert_eq!(impact.services, 2);
        assert!(impact.filtered_by_acls);
        assert_eq!(impact.unavailable_resources, vec!["sessions"]);
        assert!(!impact.complete);
    }

    #[test]
    fn impact_is_complete_only_after_all_recorded_results_are_unfiltered() {
        let mut impact = ConsulScopeImpact::default();
        impact.record(
            ImpactResource::KvKeys,
            "kvKeys".to_string(),
            Ok(ImpactInspection { count: 3, filtered_by_acls: false }),
        );
        impact.record(
            ImpactResource::ConfigEntries,
            "configEntries".to_string(),
            Ok(ImpactInspection { count: 4, filtered_by_acls: false }),
        );
        let impact = impact.finish();
        assert_eq!(impact.kv_keys, 3);
        assert_eq!(impact.config_entries, 4);
        assert!(impact.complete);
    }

    #[test]
    fn impact_collection_count_rejects_non_collections_and_excess_items() {
        assert!(count_collection(&serde_json::json!(false)).is_err());
        let oversized = serde_json::Value::Array(vec![serde_json::Value::Null; MAX_COLLECTION_ITEMS + 1]);
        assert!(count_collection(&oversized).is_err());
    }

    #[test]
    fn config_entry_inventory_covers_namespace_and_partition_scopes_without_duplicates() {
        let all = NAMESPACE_CONFIG_ENTRY_KINDS
            .iter()
            .chain(PARTITION_CONFIG_ENTRY_KINDS.iter())
            .copied()
            .collect::<BTreeSet<_>>();
        assert_eq!(all.len(), NAMESPACE_CONFIG_ENTRY_KINDS.len() + PARTITION_CONFIG_ENTRY_KINDS.len());
        for required in [
            "service-defaults",
            "service-intentions",
            "api-gateway",
            "bound-api-gateway",
            "jwt-provider",
            "proxy-defaults",
            "mesh",
            "exported-services",
            "sameness-group",
        ] {
            assert!(all.contains(required), "missing config entry kind {required}");
        }
    }

    #[test]
    fn only_explicitly_empty_collections_treat_not_found_as_zero() {
        assert!(is_empty_not_found(reqwest::StatusCode::NOT_FOUND, true));
        assert!(!is_empty_not_found(reqwest::StatusCode::NOT_FOUND, false));
        assert!(!is_empty_not_found(reqwest::StatusCode::FORBIDDEN, true));
    }

    async fn test_client() -> ConsulClient {
        test_client_at(Url::parse("https://consul.example/proxy").unwrap()).await
    }

    async fn test_client_at(base_url: Url) -> ConsulClient {
        ConsulClient::new(super::super::config::ConsulConfig {
            base_url,
            token: String::new(),
            datacenter: "dc1".to_string(),
            namespace: "configured-namespace".to_string(),
            partition: "configured-partition".to_string(),
            consistency: ConsulConsistency::Consistent,
            tls_skip_verify: false,
            ca_cert_path: String::new(),
            client_cert_path: String::new(),
            client_key_path: String::new(),
            connect_timeout_secs: 5,
            request_timeout_secs: 30,
            connect_override: None,
            operator_snapshot_restore_enabled: false,
            operator_autopilot_write_enabled: false,
            operator_raft_write_enabled: false,
            operator_keyring_write_enabled: false,
            operator_license_write_enabled: false,
            agent_target: None,
        })
        .await
        .unwrap()
    }
}