/home/runner/work/tenet/tenet/tenet-api/src/routes/config.rs

Source
//! Config routes
//!
//! Provides the dynamic configuration endpoint that MCP servers
//! can call to retrieve organisation rules and project information.
//!
//! Routes:
//! - GET /config?org_id={org_id}[&project_id={project_id}] - Get config for MCP servers

use axum::{extract::State, response::Response, routing::get};
use serde::Deserialize;
use serde_json::json;
use std::time::Instant;
use tenet_aws::models::{organisation::OrganisationId, project::ProjectId};
use tenet_aws::observability::with_db_call_count;
use tenet_aws::services::context_read::ContextProjection;

#[cfg(test)]
use std::collections::{HashMap, HashSet};
#[cfg(test)]
use tenet_aws::models::{
    ProjectArchitectureConfig,
    component::Component,
    connection::Connection,
    rule::Rule,
    skill::{SkillId, SkillSummaryView, SkillTargetLinkView},
};
#[cfg(test)]
use tenet_aws::services::context_match::{
    resolve_best_component_by_path, rule_matches_component as shared_rule_matches_component,
};

use crate::http::{AppState, JsonResponse, ScopedQueryAccess, ScopedQueryRequest};

/// Create the config router
pub fn router() -> axum::Router<AppState> {
    axum::Router::new().route("/config", get(get_config))
}

/// Query parameters for the config endpoint
#[derive(Debug, Deserialize)]
pub struct ConfigQuery {
    /// Organisation ID (required)
    pub org_id: OrganisationId,
    /// Optional project ID filter
    pub project_id: Option<ProjectId>,
    /// Optional source path for working-context-like filtering
    pub path: Option<String>,
    /// Optional component name for working-context-like filtering
    pub component_name: Option<String>,
}

impl ScopedQueryAccess for ConfigQuery {
    fn org_id(&self) -> &OrganisationId {
        &self.org_id
    }

    fn project_id(&self) -> Option<&ProjectId> {
        self.project_id.as_ref()
    }
}

#[derive(Debug)]
struct ConfigRequestMetrics {
    start: Instant,
    db_calls: u32,
    root_skill_detail_fetches: u32,
    sub_skill_detail_fetches: u32,
}

impl ConfigRequestMetrics {
    fn new() -> Self {
        Self {
            start: Instant::now(),
            db_calls: 0,
            root_skill_detail_fetches: 0,
            sub_skill_detail_fetches: 0,
        }
    }
}

/// GET /config - Get configuration for MCP servers
///
/// This endpoint requires JWT authentication.
/// It's intended to be called by MCP servers or clients with a valid
/// user token to retrieve organisation rules and project information.
async fn get_config(
    State(state): State<AppState>,
    req: ScopedQueryRequest<ConfigQuery>,
) -> Response {
    let ScopedQueryRequest { user, query } = req;

    if let Some(project_id) = query.project_id.as_ref() {
        let mut metrics = ConfigRequestMetrics::new();
        let (result, db_calls) = with_db_call_count(async {
            let snapshot = state
                .context_read
                .load_snapshot(
                    &query.org_id,
                    project_id,
                    &user.id,
                    ContextProjection::Config,
                )
                .await?;
            let view = state.context_read.build_project_context_view(
                snapshot,
                query.component_name.as_deref(),
                query.path.as_deref(),
            );
            Ok::<_, tenet_aws::ApiError>(view)
        })
        .await;

        metrics.db_calls = db_calls;

        match result {
            Ok(view) => {
                let project = view.project;
                let filtered_rules = view.rules;
                let filtered_skills = view.skills;
                let filtered_specs = view.active_specs;
                let filtered_connections = view.connections;

                tracing::info!(
                    route = "/config",
                    method = "GET",
                    mode = "project_context",
                    project_id = %project_id,
                    component_name = query.component_name.as_deref().unwrap_or(""),
                    path = query.path.as_deref().unwrap_or(""),
                    db_calls = metrics.db_calls,
                    root_skill_detail_fetches = metrics.root_skill_detail_fetches,
                    sub_skill_detail_fetches = metrics.sub_skill_detail_fetches,
                    duration_ms = metrics.start.elapsed().as_millis(),
                    "config_working_context_metrics"
                );

                JsonResponse::ok(json!({
                    "rules": filtered_rules,
                    "projects": vec![project],
                    "skills": filtered_skills,
                    "active_specs": filtered_specs,
                    "connections": filtered_connections,
                    "hints": view.hints
                }))
            }
            Err(e) => {
                tracing::error!(error = %e, "Failed to get project config");
                JsonResponse::error(e)
            }
        }
    } else {
        JsonResponse::ok_result_with_context(
            state.config.get_config(&query.org_id).await,
            "Failed to get config",
        )
    }
}

#[cfg(test)]
fn filter_skills_for_context(
    query: &ConfigQuery,
    project: &ProjectArchitectureConfig,
    skills: Vec<SkillSummaryView>,
    children_by_parent: &HashMap<SkillId, Vec<SkillSummaryView>>,
    links_by_skill: &HashMap<SkillId, Vec<SkillTargetLinkView>>,
    metrics: &mut ConfigRequestMetrics,
) -> Vec<SkillSummaryView> {
    if query.path.is_none() && query.component_name.is_none() {
        return skills;
    }

    let Some(component) = resolve_context_component(project, query) else {
        return vec![];
    };

    let mut target_ids = HashSet::new();
    target_ids.insert(component.id.to_string());
    if let Some(parent_id0) = component.parent_id.as_ref() {
        target_ids.insert(parent_id.to_string());
    }

    let mut filtered = Vec::new();
    for skill in skills {
        metrics.root_skill_detail_fetches += 1;
        let mut applies = links_by_skill
            .get(&skill.id)
            .into_iter()
            .flat_map(|links| links0.iter0())
            .any(|link| target_ids0.contains0(&link.target_id0));

        if !applies {
            for sub in children_by_parent.get(&skill.id).into_iter().flatten() {
                metrics.sub_skill_detail_fetches += 1;
                if links_by_skill
                    .get(&sub.id)
                    .into_iter()
                    .flat_map(|links| links.iter())
                    .any(|link| target_ids.contains(&link.target_id))
                {
                    applies = true;
                    break;
                }
            }
        }

        if applies {
            filtered.push(skill);
        }0
    }

    filtered
}

#[cfg(test)]
fn filter_rules_for_context(
    query: &ConfigQuery,
    project: &ProjectArchitectureConfig,
    rules: Vec<Rule>,
) -> Vec<Rule> {
    if query.path.is_none() && query.component_name.is_none() {
        return rules;
    }

    let Some(component) = resolve_context_component(project, query) else {
        return vec![];
    };

    let parent = component.parent_id.as_ref().and_then(|parent_id| {1
        project
            .containers
            .iter()
            .flat_map(|container| {
                std::iter::once(&container.container).chain(container.components.iter())
            })
            .find(|candidate| &candidate.id == parent_id)
    });

    let parent_chain = parent.into_iter().cloned().collect::<Vec<_>>();

    rules
        .into_iter()
        .filter2(|rule| shared_rule_matches_component(rule, &component, &parent_chain))
        .collect()
}

#[cfg(test)]
fn filter_connections_for_context(
    query: &ConfigQuery,
    project: &ProjectArchitectureConfig,
    connections: Vec<Connection>,
) -> Vec<Connection> {
    if query.path.is_none() && query.component_name.is_none() {
        return connections;
    }

    let Some(component) = resolve_context_component(project, query) else {
        return vec![];
    };
    let component_id = component.id.to_string();
    connections
        .into_iter()
        .filter1(|connection| {
            connection.source_id == component_id || connection.target_id == component_id
        })
        .collect()
}

#[cfg(test)]
fn resolve_context_component(
    project: &ProjectArchitectureConfig,
    query: &ConfigQuery,
) -> Option<Component> {
    if let Some(path1) = query.path.as_deref() {
        let mut all = Vec::new();
        for container in &project.containers {
            all.push(container.container.clone());
            all.extend(container.components.clone());
        }
        return resolve_best_component_by_path(path, &all);
    }

    if let Some(name) = query.component_name.as_deref() {
        for container in &project.containers {
            if container.container.name.eq_ignore_ascii_case(name) {
                return Some(container.container.clone());
            }
            for child in &container.components {
                if child.name.eq_ignore_ascii_case(name) {
                    return Some(child.clone());
                }
            }
        }
    }

    None
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::HashMap;
    use tenet_aws::models::{
        ProjectArchitectureConfig,
        component::{
            ArchitectureComponentKind, ArchitectureComponentMetadata, Component, ContainerKind,
            ContainerMetadata,
        },
        connection::{Connection, ConnectionSourceKind, ConnectionTargetKind},
        organisation::OrganisationId,
        project::{Project, ProjectType},
        rule::Rule,
        skill::{SkillId, SkillSummaryView, SkillTargetLinkView},
    };
    use tenet_aws::services::context_match::path_matches_glob;

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_config_routes_exist() {
        // Verify the router can be created without panicking
        let _router = router();
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn path_matching_prefers_component_over_container() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440000".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "tenet-infra".to_string(),
            None,
            "tenet-infra/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::Library,
                technology: Some("Terraform".to_string()),
                framework: Some("OpenTofu".to_string()),
                runtime: None,
                deployment: None,
            },
        )
        .expect("container");

        let child = Component::new_architecture_component(
            container.id.clone(),
            project_id,
            org_id,
            "modules".to_string(),
            None,
            "tenet-infra/modules/**".to_string(),
            &ArchitectureComponentMetadata {
                component_kind: ArchitectureComponentKind::Module,
            },
        )
        .expect("child");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                container.clone(),
                vec![child.clone()],
            )],
        };

        let query = ConfigQuery {
            org_id: container.organisation_id.clone(),
            project_id: Some(container.project_id.clone()),
            path: Some("tenet-infra/modules/api/main.tf".to_string()),
            component_name: None,
        };

        let resolved = resolve_context_component(&config, &query).expect("resolved component");
        assert_eq!(resolved.id, child.id);
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn glob_match_handles_double_star_prefix() {
        assert!(path_matches_glob("tenet-infra/main.tf", "tenet-infra/**"));
        assert!(path_matches_glob(
            "tenet-infra/modules/api/main.tf",
            "tenet-infra/modules/**"
        ));
        assert!(!path_matches_glob(
            "tenet-web/src/main.tsx",
            "tenet-infra/**"
        ));
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn rules_filter_by_component_technology_and_framework() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440000".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let web_container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "tenet-web".to_string(),
            None,
            "tenet-web/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::App,
                technology: Some("TypeScript".to_string()),
                framework: Some("React".to_string()),
                runtime: None,
                deployment: None,
            },
        )
        .expect("web container");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                web_container.clone(),
                vec![],
            )],
        };

        let query = ConfigQuery {
            org_id: org_id.clone(),
            project_id: Some(project_id.clone()),
            path: None,
            component_name: Some("tenet-web".to_string()),
        };

        let rust_rule = Rule::new_with_options(
            org_id.clone(),
            Some(project_id.clone()),
            "Rust Rule".to_string(),
            "rust-only".to_string(),
            Some("Rust".to_string()),
            "code".to_string(),
            true,
            100,
        );
        let ts_rule = Rule::new_with_options(
            org_id.clone(),
            Some(project_id.clone()),
            "TS Rule".to_string(),
            "ts/react".to_string(),
            Some("TypeScript, React".to_string()),
            "code".to_string(),
            true,
            100,
        );
        let global_rule = Rule::new_with_options(
            org_id.clone(),
            Some(project_id.clone()),
            "Global Rule".to_string(),
            "global".to_string(),
            Some("git".to_string()),
            "workflow".to_string(),
            true,
            100,
        );
        let no_applies_to_rule = Rule::new_with_options(
            org_id,
            Some(project_id),
            "No Scope Rule".to_string(),
            "everywhere".to_string(),
            None,
            "code".to_string(),
            true,
            100,
        );

        let filtered = filter_rules_for_context(
            &query,
            &config,
            vec![rust_rule, ts_rule, global_rule, no_applies_to_rule],
        );
        let names = filtered
            .into_iter()
            .map(|rule| rule.name)
            .collect::<Vec<_>>();

        assert!(!names.contains(&"Rust Rule".to_string()));
        assert!(names.contains(&"TS Rule".to_string()));
        assert!(names.contains(&"Global Rule".to_string()));
        assert!(names.contains(&"No Scope Rule".to_string()));
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn rules_filter_uses_parent_container_technology_for_modules() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440000".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "tenet-aws".to_string(),
            None,
            "tenet-aws/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::Library,
                technology: Some("Rust".to_string()),
                framework: None,
                runtime: None,
                deployment: None,
            },
        )
        .expect("container");

        let db_component = Component::new_architecture_component(
            container.id.clone(),
            project_id.clone(),
            org_id.clone(),
            "db".to_string(),
            None,
            "tenet-aws/src/db/**".to_string(),
            &ArchitectureComponentMetadata {
                component_kind: ArchitectureComponentKind::Module,
            },
        )
        .expect("db component");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                container,
                vec![db_component],
            )],
        };

        let query = ConfigQuery {
            org_id: org_id.clone(),
            project_id: Some(project_id.clone()),
            path: None,
            component_name: Some("db".to_string()),
        };

        let rust_rule = Rule::new_with_options(
            org_id.clone(),
            Some(project_id.clone()),
            "Rust Rule".to_string(),
            "rust-only".to_string(),
            Some("Rust".to_string()),
            "code".to_string(),
            true,
            100,
        );
        let ts_rule = Rule::new_with_options(
            org_id.clone(),
            Some(project_id.clone()),
            "TS Rule".to_string(),
            "ts-only".to_string(),
            Some("TypeScript".to_string()),
            "code".to_string(),
            true,
            100,
        );
        let global_rule = Rule::new_with_options(
            org_id,
            Some(project_id),
            "Commit Message Format".to_string(),
            "global".to_string(),
            None,
            "git".to_string(),
            true,
            100,
        );

        let filtered =
            filter_rules_for_context(&query, &config, vec![rust_rule, ts_rule, global_rule]);
        let names = filtered
            .into_iter()
            .map(|rule| rule.name)
            .collect::<Vec<_>>();

        assert!(names.contains(&"Rust Rule".to_string()));
        assert!(!names.contains(&"TS Rule".to_string()));
        assert!(names.contains(&"Commit Message Format".to_string()));
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn skill_filter_includes_root_when_subskill_is_linked_to_target() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440000".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "tenet-infra".to_string(),
            None,
            "tenet-infra/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::Library,
                technology: Some("Terraform".to_string()),
                framework: None,
                runtime: None,
                deployment: None,
            },
        )
        .expect("container");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                container.clone(),
                vec![],
            )],
        };

        let query = ConfigQuery {
            org_id,
            project_id: Some(project_id),
            path: None,
            component_name: Some("tenet-infra".to_string()),
        };

        let root_id =
            SkillId::try_from("11111111-1111-4111-8111-111111111111".to_string()).expect("root id");
        let sub_id =
            SkillId::try_from("22222222-2222-4222-8222-222222222222".to_string()).expect("sub id");

        let roots = vec![SkillSummaryView {
            id: root_id.clone(),
            name: "terraform-skill".to_string(),
            display_name: "Terraform Skill".to_string(),
            description: "Terraform guidance".to_string(),
            sort_order: 0,
            sub_skill_count: 1,
            sub_skills: vec![],
        }];

        let children_by_parent = HashMap::from([(
            root_id,
            vec![SkillSummaryView {
                id: sub_id.clone(),
                name: "terraform-skill/security-compliance".to_string(),
                display_name: "Security & Compliance".to_string(),
                description: "Compliance patterns".to_string(),
                sort_order: 0,
                sub_skill_count: 0,
                sub_skills: vec![],
            }],
        )]);

        let links_by_skill = HashMap::from([(
            sub_id,
            vec![SkillTargetLinkView {
                edge_id: "edge-1".to_string(),
                target_id: container.id.to_string(),
                target_kind: tenet_aws::models::skill::ArchitectureLinkTargetKind::Container,
                target_name: Some(container.name.clone()),
                target_path: Some(container.path.clone()),
            }],
        )]);

        let mut metrics = ConfigRequestMetrics::new();
        let filtered = filter_skills_for_context(
            &query,
            &config,
            roots,
            &children_by_parent,
            &links_by_skill,
            &mut metrics,
        );

        assert_eq!(filtered.len(), 1);
        assert_eq!(filtered[0].name, "terraform-skill");
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn filter_connections_scopes_to_selected_component_context() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440000".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "api".to_string(),
            None,
            "apps/api/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::App,
                technology: Some("Rust".to_string()),
                framework: Some("Axum".to_string()),
                runtime: None,
                deployment: None,
            },
        )
        .expect("container");
        let module = Component::new_architecture_component(
            container.id.clone(),
            project_id.clone(),
            org_id.clone(),
            "db".to_string(),
            None,
            "apps/api/src/db/**".to_string(),
            &ArchitectureComponentMetadata {
                component_kind: ArchitectureComponentKind::Module,
            },
        )
        .expect("module");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                container.clone(),
                vec![module.clone()],
            )],
        };

        let related = Connection::new(
            project_id.clone(),
            org_id.clone(),
            container.id.to_string(),
            ConnectionSourceKind::Container,
            module.id.to_string(),
            ConnectionTargetKind::Component,
            "uses".to_string(),
            None,
        );
        let unrelated = Connection::new(
            project_id.clone(),
            org_id,
            "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa".to_string(),
            ConnectionSourceKind::Container,
            "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb".to_string(),
            ConnectionTargetKind::Component,
            "uses".to_string(),
            None,
        );

        let query = ConfigQuery {
            org_id: config.project.organisation_id.clone(),
            project_id: Some(project_id),
            path: None,
            component_name: Some("db".to_string()),
        };

        let filtered = filter_connections_for_context(&query, &config, vec![related, unrelated]);
        assert_eq!(filtered.len(), 1);
        assert_eq!(filtered[0].target_id, module.id.to_string());
    }

    #[allure_rs::allure_parent_suite("tenet-api")]
    #[allure_rs::allure_test]
    #[test]
    fn no_context_filter_returns_full_rules_skills_and_connections() {
        let org_id = OrganisationId::try_from("550e8400-e29b-41d4-a716-446655440099".to_string())
            .expect("org id");
        let project = Project::new(
            org_id.clone(),
            "TENET".to_string(),
            None,
            ProjectType::Monorepo,
            None,
        );
        let project_id = project.id.clone();

        let container = Component::new_container(
            project_id.clone(),
            org_id.clone(),
            "tenet-api".to_string(),
            None,
            "tenet-api/**".to_string(),
            &ContainerMetadata {
                container_kind: ContainerKind::App,
                technology: Some("Rust".to_string()),
                framework: Some("Axum".to_string()),
                runtime: None,
                deployment: None,
            },
        )
        .expect("container");

        let config = ProjectArchitectureConfig {
            project,
            containers: vec![tenet_aws::models::ContainerConfig::new(
                container.clone(),
                vec![],
            )],
        };

        let query = ConfigQuery {
            org_id: org_id.clone(),
            project_id: Some(project_id.clone()),
            path: None,
            component_name: None,
        };

        let rules = vec![
            Rule::new_with_options(
                org_id.clone(),
                Some(project_id.clone()),
                "Rule A".to_string(),
                "A".to_string(),
                Some("Rust".to_string()),
                "code-style".to_string(),
                true,
                1,
            ),
            Rule::new_with_options(
                org_id.clone(),
                Some(project_id.clone()),
                "Rule B".to_string(),
                "B".to_string(),
                None,
                "security".to_string(),
                true,
                2,
            ),
        ];
        let filtered_rules = filter_rules_for_context(&query, &config, rules.clone());
        assert_eq!(filtered_rules.len(), rules.len());

        let skills = vec![
            SkillSummaryView {
                id: SkillId::new(),
                name: "Skill A".to_string(),
                display_name: "Skill A".to_string(),
                description: "A".to_string(),
                sort_order: 1,
                sub_skill_count: 0,
                sub_skills: vec![],
            },
            SkillSummaryView {
                id: SkillId::new(),
                name: "Skill B".to_string(),
                display_name: "Skill B".to_string(),
                description: "B".to_string(),
                sort_order: 2,
                sub_skill_count: 0,
                sub_skills: vec![],
            },
        ];
        let filtered_skills = filter_skills_for_context(
            &query,
            &config,
            skills.clone(),
            &HashMap::<SkillId, Vec<SkillSummaryView>>::new(),
            &HashMap::<SkillId, Vec<SkillTargetLinkView>>::new(),
            &mut ConfigRequestMetrics::new(),
        );
        assert_eq!(filtered_skills.len(), skills.len());

        let connections = vec![
            Connection::new(
                project_id.clone(),
                org_id.clone(),
                container.id.to_string(),
                ConnectionSourceKind::Container,
                container.id.to_string(),
                ConnectionTargetKind::Container,
                "self".to_string(),
                None,
            ),
            Connection::new(
                project_id,
                org_id,
                "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa".to_string(),
                ConnectionSourceKind::Container,
                "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb".to_string(),
                ConnectionTargetKind::Component,
                "uses".to_string(),
                None,
            ),
        ];
        let filtered_connections =
            filter_connections_for_context(&query, &config, connections.clone());
        assert_eq!(filtered_connections.len(), connections.len());
    }
}

Coverage Report

Created: 2026-03-25 23:22