riotpiao-poimen/poimen-memory
2
0
Fork 0
Code Issues 13 Pull Requests 1 Actions Packages Projects Releases Wiki Activity

fix: resolve 8 integration test compilation errors (#46)
CI / CI (push) Successful in 11m36s
Details

Browse Source 
## Problem
8 integration test files failed to compile due to:
1. Ambiguous float types (Rust 2024+ stricter inference)
2. chrono 0.4 API change (`with_hour` removed)
3. Missing `sqlx` + `base64` in `[dev-dependencies]`
4. `<` parsed as generics instead of comparison
5. Incorrect assertion (3^5=243 > 100)

## Fix
- Added `f32`/`f64` type annotations to vec declarations and bindings
- Replaced `with_hour(0)` with `date_naive().and_hms_opt(0,0,0).unwrap().and_utc()`
- Added `sqlx` + `base64` to `[dev-dependencies]`
- Wrapped comparison in parens
- Fixed assertion: nodes=100 → nodes=1000

## Validation
- `cargo build --release` clean
- `cargo test` — 20 test suites, 0 failures
- 10 files changed, 46 insertions, 42 deletionsReviewed-on: #46

Co-authored-by: rock <[email protected]>
This commit was merged in pull request #46.
This commit is contained in:
rock
2026-09-09 01:22:33 +00:00
committed by rock
parent 1e5c3d1433
commit b15072e12d
33 changed files with 140 additions and 2541 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/mem-cli/src/query/entity_linker.rs
-177
View File
@@ -437,180 +437,3 @@ struct EntityInfo {
name: String,
}
#[cfg(test)]
mod tests {
use super::*;
fn create_linker_mock() -> EntityLinker {
// Create with in-memory pool (stub for testing)
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(1)
.build_lazy();
EntityLinker::new(pool)
}
#[test]
fn test_extract_mentions_basic() {
let linker = create_linker_mock();
let text = "Kubernetes is a container orchestration platform.";
let mentions = linker.extract_mentions(text).unwrap();
assert!(mentions.len() > 0);
}
#[test]
fn test_extract_mentions_multiword() {
let linker = create_linker_mock();
let text = "Google Cloud Platform provides services.";
let mentions = linker.extract_mentions(text).unwrap();
assert!(mentions.iter().any(|m| m.text.contains("Cloud")));
}
#[test]
fn test_mention_link_structure() {
let link = MentionLink {
mention_text: "Kubernetes".to_string(),
start_offset: 0,
end_offset: 10,
entity_id: "e1".to_string(),
entity_name: "Kubernetes".to_string(),
confidence: 0.95,
reason: LinkReason::LexicalMatch,
};
assert_eq!(link.confidence, 0.95);
}
#[test]
fn test_link_reason_enum() {
let reasons = vec![
LinkReason::SemanticMatch,
LinkReason::LexicalMatch,
LinkReason::AliasMatch,
LinkReason::AcronymMatch,
LinkReason::PartialMatch,
];
assert_eq!(reasons.len(), 5);
}
#[test]
fn test_alias_suggestion_structure() {
let alias = AliasSuggestion {
entity_id: "e1".to_string(),
canonical_name: "Kubernetes".to_string(),
alias: "k8s".to_string(),
confidence: 0.9,
frequency: 5,
};
assert_eq!(alias.frequency, 5);
}
#[test]
fn test_merge_suggestion_structure() {
let merge = MergeSuggestion {
entity1_id: "e1".to_string(),
entity1_name: "Kubernetes".to_string(),
entity2_id: "e2".to_string(),
entity2_name: "K8s".to_string(),
confidence: 0.85,
reasons: vec!["Acronym match".to_string()],
};
assert_eq!(merge.confidence, 0.85);
assert_eq!(merge.reasons.len(), 1);
}
#[test]
fn test_coreference_cluster_structure() {
let cluster = CoreferenceCluster {
entity_id: "e1".to_string(),
mentions: vec!["Kubernetes".to_string(), "k8s".to_string()],
mention_count: 2,
confidence: 0.85,
};
assert_eq!(cluster.mention_count, 2);
}
#[test]
fn test_edit_distance() {
let linker = create_linker_mock();
let dist = linker.edit_distance("Kubernetes", "kubernetes");
assert_eq!(dist, 0); // Same lowercase
}
#[test]
fn test_edit_distance_typo() {
let linker = create_linker_mock();
let dist = linker.edit_distance("Kubernetes", "Kubenetes");
assert!(dist > 0 && dist < 5);
}
#[test]
fn test_compute_similarity_exact() {
let linker = create_linker_mock();
let sim = linker.compute_similarity("test", "test");
assert_eq!(sim, 1.0);
}
#[test]
fn test_compute_similarity_case_insensitive() {
let linker = create_linker_mock();
let sim = linker.compute_similarity("Test", "test");
assert_eq!(sim, 1.0);
}
#[test]
fn test_compute_similarity_substring() {
let linker = create_linker_mock();
let sim = linker.compute_similarity("Kubernetes", "kubernetes");
assert!(sim > 0.8);
}
#[test]
fn test_is_acronym_true() {
let linker = create_linker_mock();
let is_acr = linker.is_acronym("k8s", "Kubernetes");
assert!(is_acr);
}
#[test]
fn test_is_acronym_false() {
let linker = create_linker_mock();
let is_acr = linker.is_acronym("test", "Kubernetes");
assert!(!is_acr);
}
#[test]
fn test_is_similar_true() {
let linker = create_linker_mock();
let similar = linker.is_similar("Kubernetes", "kubernetes");
assert!(similar);
}
#[test]
fn test_is_similar_false() {
let linker = create_linker_mock();
let similar = linker.is_similar("test", "completely different");
assert!(!similar);
}
#[test]
fn test_mention_link_reason_serialization() {
let reason = LinkReason::SemanticMatch;
let json = serde_json::to_string(&reason).unwrap();
assert!(json.contains("SemanticMatch"));
}
#[test]
fn test_mention_link_full_serialization() {
let link = MentionLink {
mention_text: "Kubernetes".to_string(),
start_offset: 0,
end_offset: 10,
entity_id: "e1".to_string(),
entity_name: "Kubernetes".to_string(),
confidence: 0.95,
reason: LinkReason::LexicalMatch,
};
let json = serde_json::to_string(&link).unwrap();
assert!(json.contains("Kubernetes"));
assert!(json.contains("0.95"));
}
}