Skip to content

Commit cbf9813

Browse files
omoshola-oomoshola-o
committed
fix(ci): resolve strict warnings and test compile failures
1 parent 362f886 commit cbf9813

15 files changed

Lines changed: 115 additions & 148 deletions

File tree

‎crates/agentic-memory-mcp/src/daemon/mod.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -458,25 +458,25 @@ mod tests {
458458

459459
#[test]
460460
fn status_roundtrip() {
461-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
461+
let dir = tempfile::tempdir().expect("test fixture");
462462
let path = dir.path().join("daemon.status");
463463
let mut status = DaemonStatus::new();
464464
status.state = DaemonRunState::Running;
465465
status.entries_extracted = 3;
466-
status.save(&path).unwrap_or_else(|_| Default::default());
466+
status.save(&path).expect("test fixture");
467467
let loaded = DaemonStatus::load(&path)
468-
.unwrap_or_else(|_| Default::default())
469-
.unwrap_or_else(|_| Default::default());
468+
.expect("test fixture")
469+
.expect("test fixture");
470470
assert_eq!(loaded.state, DaemonRunState::Running);
471471
assert_eq!(loaded.entries_extracted, 3);
472472
}
473473

474474
#[test]
475475
fn tail_lines_returns_last_n() {
476-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
476+
let dir = tempfile::tempdir().expect("test fixture");
477477
let path = dir.path().join("daemon.log");
478-
fs::write(&path, "a\nb\nc\nd\n").unwrap_or_else(|_| Default::default());
479-
let lines = read_last_lines(&path, 2).unwrap_or_else(|_| Default::default());
478+
fs::write(&path, "a\nb\nc\nd\n").expect("test fixture");
479+
let lines = read_last_lines(&path, 2).expect("test fixture");
480480
assert_eq!(lines, vec!["c".to_string(), "d".to_string()]);
481481
}
482482
}

‎crates/agentic-memory-mcp/src/session/manager.rs‎

Lines changed: 36 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -1832,27 +1832,24 @@ mod tests {
18321832

18331833
#[test]
18341834
fn budget_projection_available_with_timeline() {
1835-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1835+
let dir = tempfile::tempdir().expect("test fixture");
18361836
let brain = dir.path().join("projection.amem");
18371837
let mut manager =
1838-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1839-
.unwrap_or_else(|_| Default::default());
1838+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
18401839

18411840
let (id_a, _) = manager
18421841
.add_event(EventType::Fact, "old fact", 0.9, vec![])
1843-
.unwrap_or_else(|_| Default::default());
1842+
.expect("test fixture");
18441843
let (_id_b, _) = manager
18451844
.add_event(EventType::Fact, "new fact", 0.9, vec![])
1846-
.unwrap_or_else(|_| Default::default());
1845+
.expect("test fixture");
18471846

18481847
{
18491848
let graph = manager.graph_mut();
1850-
let old = graph
1851-
.get_node_mut(id_a)
1852-
.unwrap_or_else(|_| Default::default());
1849+
let old = graph.get_node_mut(id_a).expect("test fixture");
18531850
old.created_at = old.created_at.saturating_sub(15 * 24 * 3600 * 1_000_000);
18541851
}
1855-
manager.save().unwrap_or_else(|_| Default::default());
1852+
manager.save().expect("test fixture");
18561853
let size = manager.current_file_size_bytes();
18571854
let projected = manager.projected_file_size_bytes(size);
18581855
assert!(size > 0);
@@ -1861,23 +1858,20 @@ mod tests {
18611858

18621859
#[test]
18631860
fn budget_auto_rollup_archives_completed_session() {
1864-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1861+
let dir = tempfile::tempdir().expect("test fixture");
18651862
let brain = dir.path().join("rollup.amem");
18661863
let mut manager =
1867-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1868-
.unwrap_or_else(|_| Default::default());
1864+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
18691865

18701866
// Build current session with enough content, then advance so it becomes completed.
18711867
let _ = manager
18721868
.add_event(EventType::Fact, "alpha", 0.8, vec![])
1873-
.unwrap_or_else(|_| Default::default());
1869+
.expect("test fixture");
18741870
let _ = manager
18751871
.add_event(EventType::Decision, "beta", 0.9, vec![])
1876-
.unwrap_or_else(|_| Default::default());
1877-
manager
1878-
.start_session(None)
1879-
.unwrap_or_else(|_| Default::default());
1880-
manager.save().unwrap_or_else(|_| Default::default());
1872+
.expect("test fixture");
1873+
manager.start_session(None).expect("test fixture");
1874+
manager.save().expect("test fixture");
18811875

18821876
// Force tiny budget to trigger rollup.
18831877
manager.storage_budget_mode = StorageBudgetMode::AutoRollup;
@@ -1886,7 +1880,7 @@ mod tests {
18861880

18871881
manager
18881882
.maybe_enforce_storage_budget()
1889-
.unwrap_or_else(|_| Default::default());
1883+
.expect("test fixture");
18901884

18911885
let episode_count = manager
18921886
.graph()
@@ -1900,30 +1894,28 @@ mod tests {
19001894

19011895
#[test]
19021896
fn auto_capture_off_noop() {
1903-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1897+
let dir = tempfile::tempdir().expect("test fixture");
19041898
let brain = dir.path().join("capture-off.amem");
19051899
let mut manager =
1906-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1907-
.unwrap_or_else(|_| Default::default());
1900+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
19081901
manager.auto_capture_mode = AutoCaptureMode::Off;
19091902

19101903
let captured = manager
19111904
.capture_prompt_request(
19121905
"remember",
19131906
Some(&json!({"information":"hello world","context":"ctx"})),
19141907
)
1915-
.unwrap_or_else(|_| Default::default());
1908+
.expect("test fixture");
19161909
assert!(captured.is_none());
19171910
assert_eq!(manager.graph().node_count(), 0);
19181911
}
19191912

19201913
#[test]
19211914
fn auto_capture_full_records_and_redacts() {
1922-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1915+
let dir = tempfile::tempdir().expect("test fixture");
19231916
let brain = dir.path().join("capture-full.amem");
19241917
let mut manager =
1925-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1926-
.unwrap_or_else(|_| Default::default());
1918+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
19271919
manager.auto_capture_mode = AutoCaptureMode::Full;
19281920
manager.auto_capture_redact = true;
19291921

@@ -1936,15 +1928,15 @@ mod tests {
19361928
"reason":"email me at test@example.com"
19371929
})),
19381930
)
1939-
.unwrap_or_else(|_| Default::default());
1931+
.expect("test fixture");
19401932

19411933
assert!(manager.graph().node_count() >= 1);
19421934
let latest = manager
19431935
.graph()
19441936
.nodes()
19451937
.iter()
19461938
.max_by_key(|n| n.id)
1947-
.unwrap_or_else(|_| Default::default());
1939+
.expect("test fixture");
19481940
assert!(latest.content.contains("[auto-capture][tool]"));
19491941
assert!(latest.content.contains("[REDACTED_SECRET]"));
19501942
assert!(latest.content.contains("[REDACTED_PATH]"));
@@ -1953,18 +1945,17 @@ mod tests {
19531945

19541946
#[test]
19551947
fn auto_capture_temporal_chain() {
1956-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1948+
let dir = tempfile::tempdir().expect("test fixture");
19571949
let brain = dir.path().join("chain.amem");
19581950
let mut manager =
1959-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1960-
.unwrap_or_else(|_| Default::default());
1951+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
19611952
manager.auto_capture_mode = AutoCaptureMode::Full;
19621953

19631954
// First capture: no predecessor.
19641955
let id1 = manager
19651956
.capture_tool_call("memory_query", Some(&json!({"query": "first question"})))
1966-
.unwrap_or_else(|_| Default::default())
1967-
.unwrap_or_else(|_| Default::default());
1957+
.expect("test fixture")
1958+
.expect("test fixture");
19681959

19691960
assert_eq!(manager.last_temporal_node_id(), Some(id1));
19701961

@@ -1974,8 +1965,8 @@ mod tests {
19741965
"memory_similar",
19751966
Some(&json!({"query_text": "second question"})),
19761967
)
1977-
.unwrap_or_else(|_| Default::default())
1978-
.unwrap_or_else(|_| Default::default());
1968+
.expect("test fixture")
1969+
.expect("test fixture");
19791970

19801971
assert_eq!(manager.last_temporal_node_id(), Some(id2));
19811972

@@ -1988,48 +1979,42 @@ mod tests {
19881979

19891980
#[test]
19901981
fn temporal_chain_resets_on_new_session() {
1991-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
1982+
let dir = tempfile::tempdir().expect("test fixture");
19921983
let brain = dir.path().join("reset.amem");
19931984
let mut manager =
1994-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
1995-
.unwrap_or_else(|_| Default::default());
1985+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
19961986
manager.auto_capture_mode = AutoCaptureMode::Full;
19971987

19981988
let _id1 = manager
19991989
.capture_tool_call("memory_query", Some(&json!({"query": "first"})))
2000-
.unwrap_or_else(|_| Default::default());
1990+
.expect("test fixture");
20011991

20021992
assert!(manager.last_temporal_node_id().is_some());
20031993

20041994
// Starting a new session should reset the chain.
2005-
manager
2006-
.start_session(None)
2007-
.unwrap_or_else(|_| Default::default());
1995+
manager.start_session(None).expect("test fixture");
20081996
assert!(manager.last_temporal_node_id().is_none());
20091997
}
20101998

20111999
#[test]
20122000
fn memory_add_joins_temporal_chain() {
2013-
let dir = tempfile::tempdir().unwrap_or_else(|_| Default::default());
2001+
let dir = tempfile::tempdir().expect("test fixture");
20142002
let brain = dir.path().join("splice.amem");
20152003
let mut manager =
2016-
SessionManager::open(brain.to_str().unwrap_or_else(|_| Default::default()))
2017-
.unwrap_or_else(|_| Default::default());
2004+
SessionManager::open(brain.to_str().expect("test fixture")).expect("test fixture");
20182005
manager.auto_capture_mode = AutoCaptureMode::Full;
20192006

20202007
// Create a chain head via auto-capture.
20212008
let id1 = manager
20222009
.capture_tool_call("memory_query", Some(&json!({"query": "something"})))
2023-
.unwrap_or_else(|_| Default::default())
2024-
.unwrap_or_else(|_| Default::default());
2010+
.expect("test fixture")
2011+
.expect("test fixture");
20252012

20262013
// Simulate what memory_add tool does: add_event + link_temporal + advance.
20272014
let (id2, _) = manager
20282015
.add_event(EventType::Fact, "User prefers dark mode", 0.9, vec![])
2029-
.unwrap_or_else(|_| Default::default());
2030-
manager
2031-
.link_temporal(id1, id2)
2032-
.unwrap_or_else(|_| Default::default());
2016+
.expect("test fixture");
2017+
manager.link_temporal(id1, id2).expect("test fixture");
20332018
manager.advance_temporal_chain(id2);
20342019

20352020
assert_eq!(manager.last_temporal_node_id(), Some(id2));

0 commit comments

Comments
 (0)