chore: moved tests into test/ folder

Author: 0byte-coding

AGENTS.md

@@ -98,9 +98,22 @@ try writer.flush();
 ```
 
 ### Testing
-- Unit tests go in the same file as the code being tested
-- Integration tests go in `test/main.zig`
+- **All tests go in the `test/` folder, NOT in source files**
+- Tests import the shgit module via `const shgit = @import("shgit")`
+- Unit tests for specific modules go in `test/main.zig`
+- Integration tests also go in `test/main.zig`
+- The `src/root.zig` file exports all modules for testing
+- The `test/main.zig` file must include:
+  ```zig
+  const std = @import("std");
+  const shgit = @import("shgit");
+
+  test {
+      std.testing.refAllDeclsRecursive(@This());
+  }
+  ```
 - Use `std.testing.allocator` for memory leak detection
+- Access modules via `shgit.module_name` (e.g., `shgit.git`, `shgit.config`, `shgit.fs_utils`)
 
 ## CLI Argument Parsing (argzon)
 Arguments defined in `src/args.zon` using ZON format:

build.zig

@@ -98,36 +98,28 @@ pub fn build(b: *std.Build) void {
     }
 
     // Tests (only available in default mode)
-    if (argzon_mod_for_tests) |argzon_mod| {
-        // Unit tests for src/
-        const src_tests = b.addTest(.{
-            .root_module = b.createModule(.{
-                .root_source_file = b.path("src/main.zig"),
-                .target = target,
-                .optimize = optimize,
-                .imports = &.{
-                    .{ .name = "argzon", .module = argzon_mod },
-                    .{ .name = "asset", .module = asset_mod },
-                },
-            }),
-            .filters = if (test_filter) |f| &.{f} else &.{},
+    if (argzon_mod_for_tests) |_| {
+        // Create shgit module for tests
+        const shgit_mod = b.addModule("shgit", .{
+            .root_source_file = b.path("src/root.zig"),
         });
-        const run_src_tests = b.addRunArtifact(src_tests);
 
         // Integration tests in test/
         const integration_tests = b.addTest(.{
             .root_module = b.createModule(.{
                 .root_source_file = b.path("test/main.zig"),
                 .target = target,
                 .optimize = optimize,
+                .imports = &.{
+                    .{ .name = "shgit", .module = shgit_mod },
+                },
             }),
             .filters = if (test_filter) |f| &.{f} else &.{},
         });
         const run_integration_tests = b.addRunArtifact(integration_tests);
 
         // Test step
         const test_step = b.step("test", "Run all tests");
-        test_step.dependOn(&run_src_tests.step);
         test_step.dependOn(&run_integration_tests.step);
     }
 }

src/commands/clone.zig

@@ -118,10 +118,3 @@ fn extractRepoName(url: []const u8) ?[]const u8 {
     if (name.len > 0) return name;
     return null;
 }
-
-test "extractRepoName" {
-    try std.testing.expectEqualStrings("repo", extractRepoName("https://github.com/user/repo.git").?);
-    try std.testing.expectEqualStrings("repo", extractRepoName("https://github.com/user/repo").?);
-    try std.testing.expectEqualStrings("repo", extractRepoName("git@github.com:user/repo.git").?);
-    try std.testing.expectEqualStrings("myrepo", extractRepoName("/path/to/myrepo").?);
-}

src/commands/link.zig

@@ -119,9 +119,3 @@ fn linkFile(
     // Add to local git exclude
     try git.addLocalExclude(allocator, target_base, rel_path);
 }
-
-test "link module compiles" {
-    // Basic compilation test
-    _ = linkDirectory;
-    _ = linkFile;
-}

src/commands/worktree.zig

@@ -288,11 +288,3 @@ fn matchesPattern(path: []const u8, pattern: []const u8) bool {
 
     return false;
 }
-
-test "matchesPattern" {
-    try std.testing.expect(matchesPattern(".env", ".env"));
-    try std.testing.expect(matchesPattern("src/.env", ".env"));
-    try std.testing.expect(matchesPattern(".env.local", ".env.local"));
-    try std.testing.expect(!matchesPattern(".env.local", ".env"));
-    try std.testing.expect(matchesPattern("src/config/.env", ".env"));
-}

src/config.zig

@@ -90,7 +90,7 @@ pub fn loadConfig(allocator: std.mem.Allocator, shgit_root: []const u8) !Config
     return parseConfig(allocator, content);
 }
 
-fn parseConfig(allocator: std.mem.Allocator, content: []const u8) !Config {
+pub fn parseConfig(allocator: std.mem.Allocator, content: []const u8) !Config {
     // Simple ZON-like parsing for sync_patterns
     var cfg = Config{};
     var patterns: std.ArrayList(SyncPattern) = .empty;
@@ -238,62 +238,3 @@ pub fn initShgitStructure(allocator: std.mem.Allocator, path: []const u8) !void
 
     log.info("created shgit structure at {s}", .{path});
 }
-
-test "parseConfig new format" {
-    const content =
-        \\.{
-        \\    .sync_patterns = .{
-        \\        .{
-        \\            .pattern = ".env",
-        \\            .mode = .symlink,
-        \\        },
-        \\        .{
-        \\            .pattern = ".env.local",
-        \\            .mode = .copy,
-        \\        },
-        \\    },
-        \\    .main_repo = "myrepo",
-        \\}
-    ;
-
-    var cfg = try parseConfig(std.testing.allocator, content);
-    defer cfg.deinit(std.testing.allocator);
-
-    try std.testing.expectEqual(@as(usize, 2), cfg.sync_patterns.len);
-    try std.testing.expectEqualStrings(".env", cfg.sync_patterns[0].pattern);
-    try std.testing.expectEqual(SyncMode.symlink, cfg.sync_patterns[0].mode);
-    try std.testing.expectEqualStrings(".env.local", cfg.sync_patterns[1].pattern);
-    try std.testing.expectEqual(SyncMode.copy, cfg.sync_patterns[1].mode);
-    try std.testing.expectEqualStrings("myrepo", cfg.main_repo.?);
-}
-
-test "parseConfig legacy format" {
-    const content =
-        \\.{
-        \\    .sync_patterns = .{
-        \\        ".env",
-        \\        ".env.local",
-        \\    },
-        \\    .main_repo = "myrepo",
-        \\}
-    ;
-
-    var cfg = try parseConfig(std.testing.allocator, content);
-    defer cfg.deinit(std.testing.allocator);
-
-    try std.testing.expectEqual(@as(usize, 2), cfg.sync_patterns.len);
-    try std.testing.expectEqualStrings(".env", cfg.sync_patterns[0].pattern);
-    try std.testing.expectEqual(SyncMode.symlink, cfg.sync_patterns[0].mode);
-    try std.testing.expectEqualStrings(".env.local", cfg.sync_patterns[1].pattern);
-    try std.testing.expectEqual(SyncMode.symlink, cfg.sync_patterns[1].mode);
-    try std.testing.expectEqualStrings("myrepo", cfg.main_repo.?);
-}
-
-test "parseConfig empty" {
-    const content = ".{\n}\n";
-    var cfg = try parseConfig(std.testing.allocator, content);
-    defer cfg.deinit(std.testing.allocator);
-
-    try std.testing.expectEqual(@as(usize, 0), cfg.sync_patterns.len);
-    try std.testing.expect(cfg.main_repo == null);
-}

src/fs_utils.zig

@@ -60,31 +60,3 @@ pub fn relativePath(allocator: std.mem.Allocator, from: []const u8, to: []const
 
     return result.toOwnedSlice(allocator);
 }
-
-test "relativePath same directory" {
-    const allocator = std.testing.allocator;
-    const rel = try relativePath(allocator, "/a/b/file1", "/a/b/file2");
-    defer allocator.free(rel);
-    try std.testing.expectEqualStrings("file2", rel);
-}
-
-test "relativePath parent directory" {
-    const allocator = std.testing.allocator;
-    const rel = try relativePath(allocator, "/a/b/c/file", "/a/b/target");
-    defer allocator.free(rel);
-    try std.testing.expectEqualStrings("../target", rel);
-}
-
-test "relativePath sibling directory" {
-    const allocator = std.testing.allocator;
-    const rel = try relativePath(allocator, "/a/b/c/file", "/a/x/y/target");
-    defer allocator.free(rel);
-    try std.testing.expectEqualStrings("../../x/y/target", rel);
-}
-
-test "relativePath deeply nested" {
-    const allocator = std.testing.allocator;
-    const rel = try relativePath(allocator, "/repo/worktree/.vscode/settings.json", "/link/.vscode/settings.json");
-    defer allocator.free(rel);
-    try std.testing.expectEqualStrings("../../../link/.vscode/settings.json", rel);
-}

src/git.zig

@@ -158,45 +158,3 @@ pub fn addLocalExclude(allocator: std.mem.Allocator, repo_path: []const u8, rel_
 
     log.debug("added {s} to local exclude", .{rel_path});
 }
-
-test "addLocalExclude with submodule" {
-    const testing = std.testing;
-    var arena = std.heap.ArenaAllocator.init(testing.allocator);
-    defer arena.deinit();
-    const allocator = arena.allocator();
-
-    // Create a temporary test directory structure
-    var tmp_dir = testing.tmpDir(.{});
-    defer tmp_dir.cleanup();
-
-    // Create repo structure similar to submodule
-    try tmp_dir.dir.makePath("repo");
-    try tmp_dir.dir.makePath(".git/modules/repo/info");
-
-    // Write .git file with relative gitdir (like submodules do)
-    const git_file = try tmp_dir.dir.createFile("repo/.git", .{});
-    defer git_file.close();
-    try git_file.writeAll("gitdir: ../.git/modules/repo\n");
-
-    // Create exclude file
-    const exclude_file = try tmp_dir.dir.createFile(".git/modules/repo/info/exclude", .{});
-    defer exclude_file.close();
-    try exclude_file.writeAll("# test exclude file\n");
-
-    // Get absolute path to repo
-    const tmp_path = try tmp_dir.dir.realpathAlloc(allocator, ".");
-    const repo_path = try std.fs.path.join(allocator, &.{ tmp_path, "repo" });
-
-    // Add a file to local exclude
-    try addLocalExclude(allocator, repo_path, ".env");
-
-    // Read exclude file and verify it was added
-    const exclude_content = try tmp_dir.dir.readFileAlloc(allocator, ".git/modules/repo/info/exclude", 4096);
-    try testing.expect(std.mem.indexOf(u8, exclude_content, "/.env") != null);
-}
-
-test "git module compiles" {
-    _ = init;
-    _ = addSubmodule;
-    _ = addWorktree;
-}

src/main.zig

@@ -52,7 +52,3 @@ pub fn main() !void {
         try stdout.flush();
     }
 }
-
-test {
-    std.testing.refAllDecls(@This());
-}

src/root.zig

@@ -0,0 +1,14 @@
+// Root module for shgit - exports all public modules for testing
+
+pub const config = @import("config.zig");
+pub const git = @import("git.zig");
+pub const fs_utils = @import("fs_utils.zig");
+
+// Commands
+pub const commands = struct {
+    pub const clone = @import("commands/clone.zig");
+    pub const link = @import("commands/link.zig");
+    pub const worktree = @import("commands/worktree.zig");
+    pub const sync = @import("commands/sync.zig");
+    pub const init = @import("commands/init.zig");
+};