fallow-types 3.43.0

Shared types and serde paths for fallow codebase intelligence
Documentation
use std::collections::BTreeSet;

use crate::results::TOTAL_ISSUE_RESULT_KEYS;

use super::*;

#[test]
fn fixable_codes_are_canonical_issue_codes() {
    for code in FIXABLE_ISSUE_CODES {
        assert!(
            issue_meta_by_code(code).is_some(),
            "fixable code {code} is not a canonical ISSUE_KIND_META code"
        );
    }
    assert!(issue_is_fixable("unused-export"));
    assert!(!issue_is_fixable("unused-file"));
}

#[test]
fn known_names_round_trip_through_metadata() {
    for name in KNOWN_ISSUE_KIND_NAMES.iter() {
        let meta = issue_meta_for_token(name)
            .unwrap_or_else(|| panic!("known issue name {name} missing metadata row"));
        assert!(
            meta.kind.is_some(),
            "known issue name {name} maps to non-IssueKind metadata"
        );
    }
}

#[test]
fn issue_kind_variants_have_metadata() {
    for &kind in IssueKind::ALL {
        assert!(
            issue_meta_by_kind(kind).is_some(),
            "IssueKind {kind:?} has no metadata row"
        );
    }
}

#[test]
fn dead_code_filter_flags_match_metadata() {
    let from_constants: BTreeSet<&str> = DEAD_CODE_FILTER_FLAGS.iter().copied().collect();
    let from_meta: BTreeSet<&str> = ISSUE_KIND_META
        .iter()
        .filter_map(|meta| meta.filter_flag)
        .collect();
    assert_eq!(from_constants, from_meta);
}

#[test]
fn mcp_issue_type_flags_match_metadata() {
    let from_constants: BTreeSet<(&str, &str)> = MCP_ISSUE_TYPE_FLAGS.iter().copied().collect();
    let from_meta: BTreeSet<(&str, &str)> = ISSUE_KIND_META
        .iter()
        .filter_map(|meta| meta.mcp_pair())
        .collect();
    assert_eq!(from_constants, from_meta);
}

#[test]
fn lsp_exposes_only_actual_diagnostic_codes() {
    let codes: BTreeSet<&str> = diagnostic_issue_metas().map(|meta| meta.code).collect();
    assert!(codes.contains("boundary-violation"));
    assert!(!codes.contains("boundary-coverage"));
    assert!(!codes.contains("boundary-call-violation"));
}

#[test]
fn issue_codes_are_unique() {
    let mut seen = BTreeSet::new();
    for meta in ISSUE_KIND_META {
        assert!(seen.insert(meta.code), "duplicate issue code {}", meta.code);
    }
}

#[test]
#[cfg_attr(
    miri,
    ignore = "too slow under Miri: loops over every issue kind in safe code"
)]
fn contract_tokens_resolve_through_metadata() {
    for meta in ISSUE_KIND_META {
        assert_eq!(
            issue_meta_for_contract_token(meta.code).map(|resolved| resolved.code),
            Some(meta.code),
            "canonical issue code {} should resolve through contract token lookup",
            meta.code
        );
        for token in meta.aliases {
            assert!(
                issue_meta_matches_contract_token(meta, token),
                "alias {token} should match {}",
                meta.code
            );
        }
        for token in [
            meta.config_key,
            meta.mcp_issue_type,
            meta.suppress_token,
            meta.filter_flag,
        ]
        .into_iter()
        .flatten()
        {
            assert!(
                issue_meta_for_contract_token(token).is_some(),
                "contract token {token} should resolve through metadata"
            );
            assert!(
                issue_meta_matches_contract_token(meta, token),
                "contract token {token} should match {}",
                meta.code
            );
        }
    }
}

#[test]
fn sarif_rule_descriptions_cover_result_metadata() {
    for meta in result_issue_metas() {
        for rule_id in issue_sarif_rule_ids(meta.code) {
            assert!(
                issue_sarif_rule_description(&rule_id).is_some(),
                "SARIF rule {rule_id} for {} needs a central description",
                meta.code
            );
        }
    }
}

#[test]
fn result_meta_codes_have_issue_metadata() {
    for meta in ISSUE_RESULT_META {
        assert!(
            issue_meta_by_code(meta.code).is_some(),
            "result metadata code {} has no issue metadata row",
            meta.code
        );
    }
}

#[test]
fn result_meta_codes_have_docs_anchors() {
    for meta in ISSUE_RESULT_META {
        let issue = issue_meta_by_code(meta.code)
            .unwrap_or_else(|| panic!("result metadata code {} has no issue row", meta.code));
        assert_eq!(
            issue.docs_anchor(),
            Some(meta.docs_anchor),
            "result metadata code {} has mismatched docs anchor",
            meta.code
        );
    }
}

#[test]
fn result_meta_codes_have_summary_labels() {
    for meta in ISSUE_RESULT_META {
        assert!(
            !meta.summary_label.is_empty(),
            "result metadata code {} has no summary label",
            meta.code
        );
    }
}

#[test]
fn result_meta_codes_have_meta_names() {
    for meta in ISSUE_RESULT_META {
        assert!(
            !meta.meta_name.is_empty(),
            "result metadata code {} has no meta name",
            meta.code
        );
    }
}

#[test]
fn result_meta_codes_have_meta_docs_paths() {
    for meta in ISSUE_RESULT_META {
        assert!(
            meta.meta_docs_path.starts_with("explanations/dead-code#"),
            "result metadata code {} has invalid meta docs path",
            meta.code
        );
    }
}

#[test]
fn result_meta_codes_have_meta_descriptions() {
    for meta in ISSUE_RESULT_META {
        assert!(
            !meta.meta_description.is_empty(),
            "result metadata code {} has no meta description",
            meta.code
        );
    }
}

#[test]
fn ci_format_ids_are_prefixed_and_known() {
    let result_codes: BTreeSet<&str> = result_issue_metas().map(|meta| meta.code).collect();
    let codeclimate_codes: BTreeSet<&str> = CODECLIMATE_RESULT_CODES.iter().copied().collect();
    assert!(codeclimate_codes.is_subset(&result_codes));

    for meta in result_issue_metas() {
        let issue = issue_meta_by_code(meta.code)
            .unwrap_or_else(|| panic!("result metadata code {} has no issue row", meta.code));
        assert!(issue.has_result_contract());
        let sarif_ids = issue.sarif_rule_ids();
        assert!(sarif_ids.contains(&format!("fallow/{}", meta.code)));
        for rule_id in sarif_ids {
            assert!(
                rule_id.starts_with("fallow/"),
                "result metadata code {} has unprefixed SARIF rule id {rule_id}",
                meta.code
            );
        }
        for check_name in issue.codeclimate_check_names() {
            assert!(
                check_name.starts_with("fallow/"),
                "result metadata code {} has unprefixed CodeClimate check name {check_name}",
                meta.code
            );
        }
    }
}

#[test]
fn ts_alias_policy_is_explicit() {
    let aliases: BTreeSet<(&str, &str)> = ISSUE_TS_ALIAS_META
        .iter()
        .map(|meta| (meta.alias.name, meta.alias.parent))
        .collect();

    assert_eq!(
        BTreeSet::from([
            ("BoundaryViolation", "BoundaryViolationFinding"),
            ("CircularDependency", "CircularDependencyFinding"),
            ("DeprecatedExportInUse", "DeprecatedExportInUseFinding"),
            (
                "DevDependencyInProduction",
                "DevDependencyInProductionFinding",
            ),
            ("DuplicateExport", "DuplicateExportFinding"),
            ("DuplicateExportAlias", "DuplicateExportAliasFinding"),
            ("EmptyCatalogGroup", "EmptyCatalogGroupFinding"),
            (
                "MisconfiguredDependencyOverride",
                "MisconfiguredDependencyOverrideFinding",
            ),
            ("PrivateTypeLeak", "PrivateTypeLeakFinding"),
            ("PackageCycle", "PackageCycleFinding"),
            ("ReExportCycle", "ReExportCycleFinding"),
            ("TestOnlyDependency", "TestOnlyDependencyFinding"),
            ("TypeOnlyDependency", "TypeOnlyDependencyFinding"),
            (
                "UnresolvedCatalogReference",
                "UnresolvedCatalogReferenceFinding",
            ),
            ("UnresolvedImport", "UnresolvedImportFinding"),
            ("UnlistedDependency", "UnlistedDependencyFinding"),
            ("UnlistedBinary", "UnlistedBinaryFinding"),
            ("UnusedCatalogEntry", "UnusedCatalogEntryFinding"),
            ("UnusedDependency", "UnusedDependencyFinding"),
            ("UnusedDependency", "UnusedDevDependencyFinding"),
            ("UnusedDependency", "UnusedOptionalDependencyFinding"),
            (
                "UnusedDependencyOverride",
                "UnusedDependencyOverrideFinding",
            ),
            ("UnusedExport", "UnusedExportFinding"),
            ("UnusedFile", "UnusedFileFinding"),
            ("UnusedMember", "UnusedClassMemberFinding"),
            ("UnusedMember", "UnusedEnumMemberFinding"),
            ("UnusedMember", "UnusedNamespaceMemberFinding"),
            ("UnusedMember", "UnusedStoreMemberFinding"),
        ]),
        aliases
    );
}

#[test]
fn ts_alias_registry_rows_match_result_metadata() {
    let result_codes: BTreeSet<&str> = result_issue_metas().map(|meta| meta.code).collect();
    let mut seen_codes = BTreeSet::new();
    for meta in ISSUE_TS_ALIAS_META {
        assert!(
            seen_codes.insert(meta.code),
            "duplicate TypeScript alias row for {}",
            meta.code
        );
        assert!(
            result_codes.contains(meta.code),
            "TypeScript alias row {} has no result metadata",
            meta.code
        );
        assert!(
            meta.alias.parent.ends_with("Finding"),
            "TypeScript alias row {} must point at a generated Finding wrapper",
            meta.code
        );
        assert_eq!(
            Some(meta.alias),
            issue_meta_by_code(meta.code).and_then(|issue| issue.ts_alias()),
            "IssueKindMeta helper must resolve TypeScript alias row {} through the registry",
            meta.code
        );
    }
}

#[test]
fn result_keys_are_unique() {
    let mut seen = BTreeSet::new();
    for meta in ISSUE_RESULT_META {
        assert!(
            seen.insert(meta.result_key),
            "duplicate result key {}",
            meta.result_key
        );
    }
}

#[test]
fn counted_result_keys_match_total_issue_fields() {
    let from_total: BTreeSet<&str> = TOTAL_ISSUE_RESULT_KEYS.iter().copied().collect();
    let from_meta: BTreeSet<&str> = counted_result_issue_metas()
        .map(|meta| meta.result_key)
        .collect();
    assert_eq!(from_total, from_meta);
}