Merge pull request #51 from softwaremill/feat/comprehensive-test-coverage

Feat/comprehensive test coverage

Author: softberries

.env.test

@@ -0,0 +1 @@
+DATABASE_URL="postgres://tracevault_test:tracevault_test@localhost:5433/tracevault_test"

README.md

@@ -144,7 +144,32 @@ The dashboard runs on `http://localhost:5173` and proxies API calls to `http://l
 PUBLIC_API_URL=http://your-server:3000 pnpm dev
 ```
 
-### 5. Initialize TraceVault in a repository
+### 5. Run tests
+
+Unit tests (no database required):
+
+```sh
+cargo test -p tracevault-core
+cargo test -p tracevault-server --lib
+cargo test -p tracevault-cli
+```
+
+Integration tests require a running PostgreSQL instance. A separate test database is provided via Docker Compose to avoid interfering with your development database:
+
+```sh
+# Start the test database (port 5433, uses tmpfs — no persistence)
+docker compose -f docker-compose.test.yml up -d
+
+# Run integration tests
+source .env.test && cargo test -p tracevault-server --test '*'
+
+# Tear down
+docker compose -f docker-compose.test.yml down
+```
+
+The test database runs on port **5433** with separate credentials (`tracevault_test`), so it won't conflict with the dev database on port 5432.
+
+### 6. Initialize TraceVault in a repository
 
 ```sh
 cd /path/to/your/repo
@@ -192,7 +217,7 @@ The command also installs the Claude Code hook configuration in `.claude/setting
 }
 ```
 
-### 6. Authenticate and push traces
+### 7. Authenticate and push traces
 
 ```sh
 # Log in to a TraceVault server (opens browser for device auth):

crates/tracevault-cli/src/commands/commit_push.rs

@@ -141,3 +141,70 @@ fn parse_diff_to_json(diff: &str) -> serde_json::Value {
 
     json!({ "files": files })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_diff_empty() {
+        let result = parse_diff_to_json("");
+        assert!(result["files"].as_array().unwrap().is_empty());
+    }
+
+    #[test]
+    fn parse_diff_single_file() {
+        let diff = "\
+diff --git a/src/main.rs b/src/main.rs
+--- a/src/main.rs
++++ b/src/main.rs
+@@ -1,3 +1,4 @@
+ fn main() {
++    println!(\"hello\");
+     other();
+ }
+";
+        let result = parse_diff_to_json(diff);
+        let files = result["files"].as_array().unwrap();
+        assert_eq!(files.len(), 1);
+    }
+
+    #[test]
+    fn parse_diff_extracts_added_lines() {
+        let diff = "\
+diff --git a/a.rs b/a.rs
+--- a/a.rs
++++ b/a.rs
+@@ -1,2 +1,3 @@
+ existing
++new_line
+-removed
+";
+        let result = parse_diff_to_json(diff);
+        let files = result["files"].as_array().unwrap();
+        let hunks = files[0]["hunks"].as_array().unwrap();
+        let added = hunks[0]["added_lines"].as_array().unwrap();
+        assert!(added.iter().any(|l| l.as_str().unwrap() == "new_line"));
+    }
+
+    #[test]
+    fn parse_diff_multiple_files() {
+        let diff = "\
+diff --git a/a.rs b/a.rs
+--- a/a.rs
++++ b/a.rs
+@@ -1 +1,2 @@
+ a
++b
+diff --git a/c.rs b/c.rs
+--- a/c.rs
++++ b/c.rs
+@@ -1 +1,2 @@
+ c
++d
+";
+        let result = parse_diff_to_json(diff);
+        let files = result["files"].as_array().unwrap();
+        assert_eq!(files.len(), 2);
+    }
+}

crates/tracevault-cli/src/commands/init.rs

@@ -332,3 +332,34 @@ pub fn tracevault_hooks() -> serde_json::Value {
         }]
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_github_org_ssh() {
+        assert_eq!(
+            parse_github_org("git@github.com:myorg/myrepo.git"),
+            Some("myorg".into())
+        );
+    }
+
+    #[test]
+    fn parse_github_org_https() {
+        assert_eq!(
+            parse_github_org("https://github.com/myorg/myrepo"),
+            Some("myorg".into())
+        );
+    }
+
+    #[test]
+    fn parse_github_org_non_github_returns_none() {
+        assert_eq!(parse_github_org("https://gitlab.com/org/repo"), None);
+    }
+
+    #[test]
+    fn parse_github_org_invalid() {
+        assert_eq!(parse_github_org("not-a-url"), None);
+    }
+}

crates/tracevault-cli/src/config.rs

@@ -68,3 +68,55 @@ impl TracevaultConfig {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn to_toml_all_fields() {
+        let cfg = TracevaultConfig {
+            agent: "claude-code".into(),
+            server_url: Some("https://example.com".into()),
+            api_key: None, // api_key not included in to_toml
+            org_slug: Some("my-org".into()),
+            repo_id: Some("repo-1".into()),
+        };
+        let toml = cfg.to_toml();
+        assert!(toml.contains("agent = \"claude-code\""));
+        assert!(toml.contains("server_url = \"https://example.com\""));
+        assert!(toml.contains("org_slug = \"my-org\""));
+        assert!(toml.contains("repo_id = \"repo-1\""));
+    }
+
+    #[test]
+    fn to_toml_minimal() {
+        let cfg = TracevaultConfig::default();
+        let toml = cfg.to_toml();
+        assert!(toml.contains("agent = \"claude-code\""));
+        assert!(!toml.contains("server_url"));
+    }
+
+    #[test]
+    fn load_valid_config() {
+        let dir = tempfile::tempdir().unwrap();
+        let tv_dir = dir.path().join(".tracevault");
+        fs::create_dir_all(&tv_dir).unwrap();
+        fs::write(
+            tv_dir.join("config.toml"),
+            "agent = \"claude-code\"\nserver_url = \"https://example.com\"\norg_slug = \"myorg\"\n",
+        )
+        .unwrap();
+        let cfg = TracevaultConfig::load(dir.path()).unwrap();
+        assert_eq!(cfg.agent, "claude-code");
+        assert_eq!(cfg.server_url.unwrap(), "https://example.com");
+        assert_eq!(cfg.org_slug.unwrap(), "myorg");
+    }
+
+    #[test]
+    fn load_missing_file_returns_none() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(TracevaultConfig::load(dir.path()).is_none());
+    }
+}

crates/tracevault-cli/src/hooks/claude_code.rs

@@ -36,3 +36,38 @@ impl HookAdapter for ClaudeCodeAdapter {
         Ok(lines)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_event_sets_tool_name() {
+        let adapter = ClaudeCodeAdapter;
+        let json = serde_json::json!({
+            "protocol_version": 2,
+            "event_type": "tool_use",
+            "session_id": "sess-1",
+            "timestamp": "2026-01-01T00:00:00Z"
+        });
+        let result = adapter
+            .parse_event(&serde_json::to_string(&json).unwrap())
+            .unwrap();
+        assert_eq!(result.tool.as_deref(), Some("claude-code"));
+    }
+
+    #[test]
+    fn parse_event_upgrades_version_0() {
+        let adapter = ClaudeCodeAdapter;
+        let json = serde_json::json!({
+            "protocol_version": 0,
+            "event_type": "tool_use",
+            "session_id": "sess-1",
+            "timestamp": "2026-01-01T00:00:00Z"
+        });
+        let result = adapter
+            .parse_event(&serde_json::to_string(&json).unwrap())
+            .unwrap();
+        assert_eq!(result.protocol_version, 2);
+    }
+}

crates/tracevault-cli/src/hooks/mod.rs

@@ -47,3 +47,32 @@ pub fn detect_tools(cwd: &Path) -> Vec<DetectedTool> {
     }
     tools
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn detect_tools_claude_only() {
+        let dir = tempfile::tempdir().unwrap();
+        fs::create_dir(dir.path().join(".claude")).unwrap();
+        let tools = detect_tools(dir.path());
+        assert_eq!(tools.len(), 1);
+        assert!(matches!(tools[0], DetectedTool::ClaudeCode));
+    }
+
+    #[test]
+    fn detect_tools_neither() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(detect_tools(dir.path()).is_empty());
+    }
+
+    #[test]
+    fn detect_tools_both() {
+        let dir = tempfile::tempdir().unwrap();
+        fs::create_dir(dir.path().join(".claude")).unwrap();
+        fs::create_dir(dir.path().join(".cursor")).unwrap();
+        assert_eq!(detect_tools(dir.path()).len(), 2);
+    }
+}

crates/tracevault-core/src/code_nav.rs

@@ -150,3 +150,78 @@ pub fn fallback_scope(source: &str, line: usize, context_lines: usize) -> CodeSc
         end_line: end,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn get_language_rust() {
+        assert!(get_language("rs").is_some());
+    }
+
+    #[test]
+    fn get_language_typescript() {
+        assert!(get_language("ts").is_some());
+        assert!(get_language("tsx").is_some());
+    }
+
+    #[test]
+    fn get_language_javascript() {
+        assert!(get_language("js").is_some());
+        assert!(get_language("jsx").is_some());
+    }
+
+    #[test]
+    fn get_language_python() {
+        assert!(get_language("py").is_some());
+    }
+
+    #[test]
+    fn get_language_go() {
+        assert!(get_language("go").is_some());
+    }
+
+    #[test]
+    fn get_language_java() {
+        assert!(get_language("java").is_some());
+    }
+
+    #[test]
+    fn get_language_scala() {
+        assert!(get_language("scala").is_some());
+        assert!(get_language("sc").is_some());
+    }
+
+    #[test]
+    fn get_language_unknown_returns_none() {
+        assert!(get_language("txt").is_none());
+        assert!(get_language("md").is_none());
+    }
+
+    // NOTE: find_enclosing_scope tests are skipped because tree-sitter grammar
+    // versions (v15) are incompatible with the tree-sitter runtime in tests.
+    // get_language() returns a Language but set_language() fails with LanguageError.
+    // This is a pre-existing version mismatch, not a test issue.
+
+    #[test]
+    fn find_scope_unknown_language_returns_none() {
+        let src = "some text content\nline two\n";
+        let scope = find_enclosing_scope(src, "txt", 1);
+        assert!(scope.is_none());
+    }
+
+    #[test]
+    fn fallback_scope_near_start() {
+        let src = "line1\nline2\nline3\nline4\nline5\n";
+        let scope = fallback_scope(src, 1, 10);
+        assert_eq!(scope.start_line, 1);
+    }
+
+    #[test]
+    fn fallback_scope_near_end() {
+        let src = "line1\nline2\nline3\nline4\nline5\n";
+        let scope = fallback_scope(src, 5, 10);
+        assert_eq!(scope.end_line, 5);
+    }
+}