test: replace placeholder coverage with behavioral tests

Author: glennmichael123

tests/assertions_test.zig

@@ -1,19 +1,30 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for assertions module
-// TODO: Implement comprehensive tests for all assertion methods
-
-test "assertions basic equality" {
-    // Test toBe and toEqual
-    try std.testing.expect(true);
+test "assertions report equality failures and support negation" {
+    const allocator = std.testing.allocator;
+    try ztf.expect(allocator, @as(i32, 42)).toBe(42);
+    try ztf.expect(allocator, @as(i32, 42)).not().toBe(7);
+    try std.testing.expectError(ztf.AssertionError.AssertionFailed, ztf.expect(allocator, @as(i32, 42)).toBe(7));
 }
 
-test "assertions comparison operators" {
-    // Test toBeGreaterThan, toBeLessThan, etc.
-    try std.testing.expect(true);
+test "assertions cover comparisons and optionals" {
+    const allocator = std.testing.allocator;
+    try ztf.expect(allocator, @as(i32, 10)).toBeGreaterThan(5);
+    try ztf.expect(allocator, @as(i32, 5)).toBeLessThan(10);
+    try ztf.expect(allocator, @as(?i32, null)).toBeNull();
+    try ztf.expect(allocator, @as(?i32, 3)).toBeDefined();
 }
 
-test "assertions string operations" {
-    // Test string-specific assertions
-    try std.testing.expect(true);
+test "assertions cover strings and error unions" {
+    const allocator = std.testing.allocator;
+    const Failing = struct {
+        fn call() !void {
+            return error.ExpectedFailure;
+        }
+    };
+    try ztf.expect(allocator, "zig test framework").toContain("test");
+    try ztf.expect(allocator, "zig test framework").toStartWith("zig");
+    try ztf.expect(allocator, "zig test framework").toEndWith("framework");
+    try ztf.expect(allocator, Failing.call).toThrowError(error.ExpectedFailure);
 }

tests/cli_test.zig

@@ -1,19 +1,25 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for CLI module
-// TODO: Implement comprehensive tests for CLI parsing
-
-test "CLI parse help flag" {
-    // Test --help flag parsing
-    try std.testing.expect(true);
+test "CLI parses the help flag" {
+    var cli = ztf.CLI.init(std.testing.allocator);
+    try cli.parse(&.{ "zig-test", "--help" });
+    try std.testing.expect(cli.options.help);
 }
 
-test "CLI parse reporter option" {
-    // Test --reporter option parsing
-    try std.testing.expect(true);
+test "CLI parses a representative discovery invocation" {
+    var cli = ztf.CLI.init(std.testing.allocator);
+    try cli.parse(&.{ "zig-test", "--test-dir", "specs", "--grep", "database", "--coverage", "--no-color", "--bail" });
+    try std.testing.expectEqualStrings("specs", cli.options.test_dir.?);
+    try std.testing.expectEqualStrings("database", cli.options.filter.?);
+    try std.testing.expect(cli.options.coverage);
+    try std.testing.expect(cli.options.no_color);
+    try std.testing.expect(cli.options.bail);
 }
 
-test "CLI parse filter option" {
-    // Test --filter option parsing
-    try std.testing.expect(true);
+test "CLI rejects missing and invalid values" {
+    var missing = ztf.CLI.init(std.testing.allocator);
+    try std.testing.expectError(ztf.cli.CLIError.MissingValue, missing.parse(&.{ "zig-test", "--reporter" }));
+    var invalid = ztf.CLI.init(std.testing.allocator);
+    try std.testing.expectError(ztf.cli.CLIError.InvalidArgument, invalid.parse(&.{ "zig-test", "--jobs", "0" }));
 }

tests/matchers_test.zig

@@ -1,19 +1,26 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for matchers module
-// TODO: Implement comprehensive tests for advanced matchers
-
-test "matchers numeric operations" {
-    // Test toBeCloseTo, toBeNaN, etc.
-    try std.testing.expect(true);
+test "numeric matchers accept special and approximate values" {
+    try ztf.toBeCloseTo(0.1 + 0.2, 0.3, 10);
+    try ztf.toBeNaN(std.math.nan(f64));
+    try ztf.toBeInfinite(std.math.inf(f64));
+    try std.testing.expectError(ztf.AssertionError.AssertionFailed, ztf.toBeCloseTo(1.0, 2.0, 4));
 }
 
-test "matchers array operations" {
-    // Test array-specific matchers
-    try std.testing.expect(true);
+test "array matchers inspect contents and length" {
+    const values = [_]i32{ 1, 2, 3, 5, 8 };
+    const matcher = ztf.expectArray(std.testing.allocator, &values);
+    try matcher.toHaveLength(5);
+    try matcher.toContain(5);
+    try matcher.toContainAll(&.{ 1, 3, 8 });
+    try std.testing.expectError(ztf.AssertionError.AssertionFailed, matcher.toContain(13));
 }
 
-test "matchers struct operations" {
-    // Test struct-specific matchers
-    try std.testing.expect(true);
+test "struct matchers inspect named fields" {
+    const User = struct { name: []const u8, active: bool };
+    const matcher = ztf.expectStruct(std.testing.allocator, User{ .name = "Ada", .active = true });
+    try matcher.toHaveField("name", "Ada");
+    try matcher.toHaveField("active", true);
+    try std.testing.expectError(ztf.AssertionError.AssertionFailed, matcher.toHaveField("name", "Grace"));
 }

tests/mock_test.zig

@@ -1,19 +1,34 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for mock module
-// TODO: Implement comprehensive tests for mocking and spying
-
-test "mock function call tracking" {
-    // Test mock call recording
-    try std.testing.expect(true);
+test "mock records calls and exposes the latest invocation" {
+    var mock = ztf.createMock(std.testing.allocator, i32);
+    defer mock.deinit();
+    try mock.recordCall("first");
+    try mock.recordCall("second");
+    try std.testing.expectEqual(@as(usize, 2), mock.callCount());
+    try std.testing.expectEqualStrings("second", mock.getLastCall().?.args);
+    try mock.toHaveBeenCalledWith("first");
 }
 
-test "mock return values" {
-    // Test mock return value functionality
-    try std.testing.expect(true);
+test "mock returns configured values in order" {
+    var mock = ztf.createMock(std.testing.allocator, i32);
+    defer mock.deinit();
+    _ = try mock.mockReturnValueOnce(10);
+    _ = try mock.mockReturnValue(20);
+    try std.testing.expectEqual(@as(?i32, 10), mock.getReturnValue());
+    try std.testing.expectEqual(@as(?i32, 20), mock.getReturnValue());
+    try std.testing.expectEqual(@as(?i32, 20), mock.getReturnValue());
 }
 
-test "spy functionality" {
-    // Test spy wrapping of functions
-    try std.testing.expect(true);
+test "mock clear preserves return values while reset removes them" {
+    var mock = ztf.createMock(std.testing.allocator, i32);
+    defer mock.deinit();
+    try mock.recordCall("call");
+    _ = try mock.mockReturnValue(7);
+    _ = mock.mockClear();
+    try std.testing.expectEqual(@as(usize, 0), mock.callCount());
+    try std.testing.expectEqual(@as(?i32, 7), mock.getReturnValue());
+    _ = mock.mockReset();
+    try std.testing.expectEqual(@as(?i32, null), mock.getReturnValue());
 }

tests/reporter_test.zig

@@ -1,19 +1,71 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for reporter module
-// TODO: Implement comprehensive tests for all reporter types
+fn passingTest(_: std.mem.Allocator) !void {}
 
 test "reporter spec output" {
-    // Test SpecReporter formatting
-    try std.testing.expect(true);
+    var buffer: [2048]u8 = undefined;
+    const writer: std.Io.Writer = .fixed(&buffer);
+    var reporter = ztf.SpecReporter.init(std.testing.allocator, writer);
+    reporter.reporter.use_colors = false;
+    var results = ztf.TestResults.init(std.testing.allocator);
+    defer results.deinit();
+    results.total = 1;
+    results.passed = 1;
+    var test_case = ztf.TestCase.init("passes", passingTest);
+    test_case.status = .passed;
+
+    try reporter.reporter.onRunStart(1);
+    try reporter.reporter.onSuiteStart("suite");
+    try reporter.reporter.onTestEnd(&test_case);
+    try reporter.reporter.onSuiteEnd("suite");
+    try reporter.reporter.onRunEnd(&results);
+
+    const output = buffer[0..reporter.writer.end];
+    try std.testing.expect(std.mem.indexOf(u8, output, "Running 1 test(s)") != null);
+    try std.testing.expect(std.mem.indexOf(u8, output, "Passed:  1") != null);
 }
 
 test "reporter dot output" {
-    // Test DotReporter formatting
-    try std.testing.expect(true);
+    var buffer: [1024]u8 = undefined;
+    const writer: std.Io.Writer = .fixed(&buffer);
+    var reporter = ztf.DotReporter.init(std.testing.allocator, writer);
+    reporter.reporter.use_colors = false;
+    var results = ztf.TestResults.init(std.testing.allocator);
+    defer results.deinit();
+    results.total = 1;
+    results.passed = 1;
+    var test_case = ztf.TestCase.init("passes", passingTest);
+    test_case.status = .passed;
+
+    try reporter.reporter.onRunStart(1);
+    try reporter.reporter.onTestEnd(&test_case);
+    try reporter.reporter.onRunEnd(&results);
+
+    const output = buffer[0..reporter.writer.end];
+    try std.testing.expect(std.mem.indexOf(u8, output, ".") != null);
+    try std.testing.expect(std.mem.indexOf(u8, output, "Passed: 1") != null);
 }
 
 test "reporter json output" {
-    // Test JsonReporter formatting
-    try std.testing.expect(true);
+    var buffer: [2048]u8 = undefined;
+    const writer: std.Io.Writer = .fixed(&buffer);
+    var reporter = ztf.JsonReporter.init(std.testing.allocator, writer);
+    defer reporter.deinit();
+    var results = ztf.TestResults.init(std.testing.allocator);
+    defer results.deinit();
+    results.total = 1;
+    results.passed = 1;
+    var test_case = ztf.TestCase.init("passes", passingTest);
+    test_case.status = .passed;
+
+    try reporter.reporter.onRunStart(1);
+    try reporter.reporter.onSuiteStart("suite");
+    try reporter.reporter.onTestEnd(&test_case);
+    try reporter.reporter.onSuiteEnd("suite");
+    try reporter.reporter.onRunEnd(&results);
+
+    const output = buffer[0..reporter.writer.end];
+    try std.testing.expect(std.mem.indexOf(u8, output, "\"name\":\"passes\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, output, "\"passed\":1") != null);
 }

tests/suite_test.zig

@@ -1,19 +1,51 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for suite module
-// TODO: Implement comprehensive tests for test suite management
+fn passingTest(_: std.mem.Allocator) !void {}
+fn hookOne(_: std.mem.Allocator) !void {}
+fn hookTwo(_: std.mem.Allocator) !void {}
 
-test "suite creation and management" {
-    // Test TestSuite initialization
-    try std.testing.expect(true);
+test "suite owns tests and nested suites" {
+    const allocator = std.testing.allocator;
+    const parent = try ztf.TestSuite.init(allocator, "parent");
+    defer parent.deinit();
+    const child = try ztf.TestSuite.init(allocator, "child");
+    try parent.addTest(ztf.TestCase.init("one", passingTest));
+    try child.addTest(ztf.TestCase.init("two", passingTest));
+    try parent.addSuite(child);
+    try std.testing.expectEqual(@as(usize, 2), parent.countTests());
+    try std.testing.expectEqual(parent, child.parent.?);
 }
 
-test "suite nested describe blocks" {
-    // Test nested test suites
-    try std.testing.expect(true);
+test "nested hooks preserve before and after ordering" {
+    const allocator = std.testing.allocator;
+    const parent = try ztf.TestSuite.init(allocator, "parent");
+    defer parent.deinit();
+    const child = try ztf.TestSuite.init(allocator, "child");
+    try parent.addSuite(child);
+    try parent.addBeforeEach(hookOne);
+    try child.addBeforeEach(hookTwo);
+    try parent.addAfterEach(hookOne);
+    try child.addAfterEach(hookTwo);
+
+    var before = try child.getAllBeforeEachHooks(allocator);
+    defer before.deinit(allocator);
+    var after = try child.getAllAfterEachHooks(allocator);
+    defer after.deinit(allocator);
+    try std.testing.expectEqual(hookOne, before.items[0]);
+    try std.testing.expectEqual(hookTwo, before.items[1]);
+    try std.testing.expectEqual(hookTwo, after.items[0]);
+    try std.testing.expectEqual(hookOne, after.items[1]);
 }
 
-test "suite skip and only functionality" {
-    // Test skip and only modifiers
-    try std.testing.expect(true);
+test "suite skip and only state inherits from parents" {
+    const allocator = std.testing.allocator;
+    const parent = try ztf.TestSuite.init(allocator, "parent");
+    defer parent.deinit();
+    const child = try ztf.TestSuite.init(allocator, "child");
+    try parent.addSuite(child);
+    parent.skip = true;
+    parent.only = true;
+    try std.testing.expect(child.shouldSkip());
+    try std.testing.expect(child.hasOnly());
 }

tests/test_runner_test.zig

@@ -1,19 +1,30 @@
 const std = @import("std");
+const ztf = @import("zig_test_framework");
 
-// Placeholder tests for test_runner module
-// TODO: Implement comprehensive tests for TestRunner
+fn passingTest(_: std.mem.Allocator) !void {}
 
 test "test runner initialization" {
-    // Test that TestRunner can be initialized
-    try std.testing.expect(true);
+    var registry = ztf.TestRegistry.init(std.testing.allocator);
+    defer registry.deinit();
+    var runner = ztf.TestRunner.init(std.testing.allocator, &registry, .{});
+    defer runner.deinit();
+    try std.testing.expectEqual(@as(usize, 0), runner.results.total);
+    try std.testing.expectEqual(ztf.ReporterType.spec, runner.options.reporter_type);
 }
 
-test "test runner executes tests" {
-    // Test that TestRunner can execute registered tests
-    try std.testing.expect(true);
-}
+test "test runner executes matching tests and skips filtered tests" {
+    const allocator = std.testing.allocator;
+    var registry = ztf.TestRegistry.init(allocator);
+    defer registry.deinit();
+    const suite = try ztf.TestSuite.init(allocator, "runner suite");
+    try suite.addTest(ztf.TestCase.init("selected", passingTest));
+    try suite.addTest(ztf.TestCase.init("ignored", passingTest));
+    try registry.registerSuite(suite);
 
-test "test runner reports results" {
-    // Test that TestRunner correctly reports test results
-    try std.testing.expect(true);
+    var runner = ztf.TestRunner.init(allocator, &registry, .{ .filter = "selected", .use_colors = false });
+    defer runner.deinit();
+    try std.testing.expect(try runner.run());
+    try std.testing.expectEqual(@as(usize, 2), runner.results.total);
+    try std.testing.expectEqual(@as(usize, 1), runner.results.passed);
+    try std.testing.expectEqual(@as(usize, 1), runner.results.skipped);
 }