fix(bindings): declare no Rust test targets for pyo3/napi FFI shims

The pyo3/napi cdylib crates leave their extension symbols undefined for
resolution at import/dlopen time, so an ordinary cargo test executable
can't link against them. Set test = false / doctest = false on both
binding crates and drop their now-dead #[cfg(test)] modules, since
coverage already comes from the real FFI boundary (query.test.cjs,
test_query.py). Update the CI comment to match.

Author: farhan-syah

.github/workflows/test.yml

@@ -73,9 +73,10 @@ jobs:
       - uses: Swatinem/rust-cache@v2
         with:
           prefix-key: test
-      # The pyo3/napi cdylib crates are extension modules that cannot be linked
-      # as cargo test binaries; they are built via maturin/napi in the `bindings`
-      # job below. Everything else is tested across all three OSes.
+      # The pyo3/napi cdylib crates declare no Rust test targets (see their
+      # Cargo.toml `[lib]` notes) and need Python/Node toolchains to build, so
+      # they are built and tested through their real FFI boundary by the
+      # `bindings` job. Everything else is tested across all three OSes.
       - name: Run tests
         run: cargo test --workspace --all-features --exclude code2graph-py --exclude code2graph-node
 

bindings/node/Cargo.toml

@@ -6,9 +6,15 @@ rust-version.workspace = true
 license.workspace = true
 publish = false
 
+# N-API symbols are provided by the host Node process at dlopen time and have no
+# link-time target, so a cargo test harness — an ordinary executable — is
+# unlinkable. This crate therefore declares no Rust test targets: it is a thin
+# FFI shim, verified through the real boundary by `test/query.test.cjs`.
 [lib]
 name = "code2graph_node"
 crate-type = ["cdylib"]
+test = false
+doctest = false
 
 [dependencies]
 code2graph_core = { package = "code2graph", path = "../..", version = "=0.0.0", default-features = false, features = ["serde", "rust", "python", "typescript", "go", "java", "c", "cpp", "ruby", "php", "shell", "swift", "kotlin", "solidity", "sql", "hcl", "csharp", "scala", "dart", "lua", "luau", "pascal", "svelte"] }

bindings/node/src/convert.rs

@@ -99,39 +99,3 @@ pub(crate) fn positive_limit(limit: u32) -> napi::Result<usize> {
     }
     Ok(limit as usize)
 }
-
-#[cfg(test)]
-mod tests {
-    use code2graph_core::{Descriptor, SymbolId};
-    use serde_json::json;
-
-    use super::{code_graph, edge_filter, positive_limit, symbol_id};
-
-    #[test]
-    fn accepts_only_lossless_structural_id_objects() {
-        let id = SymbolId::global("rust", vec![Descriptor::Term("run".into())]);
-        let value = serde_json::to_value(&id).expect("serialize id");
-        assert_eq!(symbol_id(value).expect("object id"), id);
-        assert!(symbol_id(json!(id.to_scip_string())).is_err());
-        assert!(
-            code_graph(json!({"symbols": [{"id": id.to_scip_string()}], "edges": []})).is_err()
-        );
-    }
-
-    #[test]
-    fn filters_are_canonical_and_limits_are_positive() {
-        assert!(edge_filter(Some("call".into()), None, None).is_err());
-        assert!(edge_filter(None, Some("exact".into()), None).is_err());
-        assert!(edge_filter(None, None, Some("scope_graph".into())).is_err());
-        assert!(
-            edge_filter(
-                Some("Call".into()),
-                Some("Exact".into()),
-                Some("ScopeGraph".into()),
-            )
-            .is_ok()
-        );
-        assert!(positive_limit(0).is_err());
-        assert_eq!(positive_limit(1).expect("positive"), 1);
-    }
-}

bindings/node/src/query.rs

@@ -130,66 +130,3 @@ impl GraphIndex {
         }))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use code2graph_core::{
-        CodeGraph, Confidence, Descriptor, Edge, Occurrence, Provenance, RefRole, SymbolId,
-    };
-
-    use super::GraphIndex;
-
-    fn id(name: &str) -> SymbolId {
-        SymbolId::global("rust", vec![Descriptor::Term(name.into())])
-    }
-
-    fn edge(from: SymbolId, to: SymbolId, byte: usize) -> Edge {
-        Edge {
-            from,
-            to,
-            role: RefRole::Call,
-            confidence: Confidence::Exact,
-            provenance: Provenance::ScopeGraph,
-            occ: Occurrence {
-                file: "src/a.rs".into(),
-                line: 1,
-                col: 0,
-                byte,
-            },
-        }
-    }
-
-    #[test]
-    fn preserves_endpoint_ids_direction_and_bounded_impact_output() {
-        let seed = SymbolId::local("vendor/api.rs", "remote");
-        let caller = id("caller");
-        let graph = CodeGraph {
-            symbols: vec![],
-            edges: vec![edge(caller.clone(), seed.clone(), 1)],
-        };
-        let index =
-            GraphIndex::new(serde_json::to_value(graph).expect("graph json")).expect("index");
-        let incoming = index
-            .incoming(
-                serde_json::to_value(&seed).unwrap(),
-                1,
-                Some("Call".into()),
-                None,
-                None,
-            )
-            .expect("incoming");
-        assert_eq!(incoming.as_array().unwrap().len(), 1);
-        let outgoing = index
-            .outgoing(serde_json::to_value(&seed).unwrap(), 1, None, None, None)
-            .expect("outgoing");
-        assert!(outgoing.as_array().unwrap().is_empty());
-        let impact = index
-            .impact(serde_json::to_value(&seed).unwrap(), 1, 1, None, None, None)
-            .expect("impact");
-        assert_eq!(
-            impact["steps"][0]["symbol"],
-            serde_json::to_value(caller).unwrap()
-        );
-        assert!(impact.get("visited").is_none());
-    }
-}

bindings/python/Cargo.toml

@@ -6,9 +6,16 @@ rust-version.workspace = true
 license.workspace = true
 publish = false
 
+# `pyo3/extension-module` deliberately leaves the CPython symbols undefined so
+# the interpreter resolves them at import time. That is correct for the shipped
+# cdylib but makes a cargo test harness — an ordinary executable — unlinkable,
+# so this crate declares no Rust test targets. It is a thin FFI shim; its
+# behaviour is verified through the real boundary by `tests/test_query.py`.
 [lib]
 name = "code2graph"
 crate-type = ["cdylib"]
+test = false
+doctest = false
 
 [dependencies]
 code2graph_core = { package = "code2graph", path = "../..", version = "=0.0.0", default-features = false, features = ["serde", "rust", "python", "typescript", "go", "java", "c", "cpp", "ruby", "php", "shell", "swift", "kotlin", "solidity", "sql", "hcl", "csharp", "scala", "dart", "lua", "luau", "pascal", "svelte"] }

bindings/python/src/convert.rs

@@ -100,18 +100,3 @@ pub(crate) fn positive_limit(limit: u32) -> PyResult<usize> {
     }
     Ok(limit as usize)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::{edge_filter, positive_limit};
-
-    #[test]
-    fn filters_are_canonical_and_limits_are_positive() {
-        assert!(edge_filter(Some("call"), None, None).is_err());
-        assert!(edge_filter(None, Some("exact"), None).is_err());
-        assert!(edge_filter(None, None, Some("scope_graph")).is_err());
-        assert!(edge_filter(Some("Call"), Some("Exact"), Some("ScopeGraph")).is_ok());
-        assert!(positive_limit(0).is_err());
-        assert_eq!(positive_limit(1).expect("positive"), 1);
-    }
-}