111 lines
3.4 KiB
Zig
111 lines
3.4 KiB
Zig
const std = @import("std");
|
|
const testing = std.testing;
|
|
const src = @import("src");
|
|
|
|
test "CLI basic functionality" {
|
|
// Test that CLI module can be imported
|
|
const allocator = testing.allocator;
|
|
_ = allocator;
|
|
|
|
// Test basic string operations used in CLI
|
|
const test_str = "ml sync";
|
|
try testing.expect(test_str.len > 0);
|
|
try testing.expect(std.mem.startsWith(u8, test_str, "ml"));
|
|
}
|
|
|
|
test "CLI command validation" {
|
|
// Test command validation logic
|
|
const commands = [_][]const u8{ "init", "sync", "queue", "q", "status", "monitor", "cancel", "prune", "watch", "validate" };
|
|
|
|
for (commands) |cmd| {
|
|
try testing.expect(cmd.len > 0);
|
|
try testing.expect(std.mem.indexOf(u8, cmd, " ") == null);
|
|
}
|
|
}
|
|
|
|
test "CLI argument parsing" {
|
|
// Test basic argument parsing scenarios
|
|
const test_cases = [_]struct {
|
|
input: []const []const u8,
|
|
expected_command: ?[]const u8,
|
|
}{
|
|
.{ .input = &[_][]const u8{"init"}, .expected_command = "init" },
|
|
.{ .input = &[_][]const u8{ "sync", "/tmp/test" }, .expected_command = "sync" },
|
|
.{ .input = &[_][]const u8{ "queue", "test_job" }, .expected_command = "queue" },
|
|
.{ .input = &[_][]const u8{}, .expected_command = null },
|
|
};
|
|
|
|
for (test_cases) |case| {
|
|
if (case.input.len > 0) {
|
|
if (case.expected_command) |expected| {
|
|
try testing.expect(std.mem.eql(u8, case.input[0], expected));
|
|
}
|
|
} else {
|
|
try testing.expect(case.expected_command == null);
|
|
}
|
|
}
|
|
}
|
|
|
|
test "CLI path validation" {
|
|
// Test path validation logic
|
|
const test_paths = [_]struct {
|
|
path: []const u8,
|
|
is_valid: bool,
|
|
}{
|
|
.{ .path = "/tmp/test", .is_valid = true },
|
|
.{ .path = "./relative", .is_valid = true },
|
|
.{ .path = "", .is_valid = false },
|
|
.{ .path = " ", .is_valid = false },
|
|
};
|
|
|
|
for (test_paths) |case| {
|
|
if (case.is_valid) {
|
|
try testing.expect(case.path.len > 0);
|
|
try testing.expect(!std.mem.eql(u8, case.path, ""));
|
|
} else {
|
|
try testing.expect(case.path.len == 0 or std.mem.eql(u8, case.path, " "));
|
|
}
|
|
}
|
|
}
|
|
|
|
test "CLI error handling" {
|
|
// Test error handling scenarios
|
|
const error_scenarios = [_]struct {
|
|
name: []const u8,
|
|
should_fail: bool,
|
|
}{
|
|
.{ .name = "missing_config", .should_fail = true },
|
|
.{ .name = "invalid_command", .should_fail = true },
|
|
.{ .name = "missing_args", .should_fail = true },
|
|
.{ .name = "valid_operation", .should_fail = false },
|
|
};
|
|
|
|
for (error_scenarios) |scenario| {
|
|
if (scenario.should_fail) {
|
|
try testing.expect(scenario.name.len > 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
test "CLI memory management" {
|
|
// Test basic memory management
|
|
const allocator = testing.allocator;
|
|
|
|
// Test allocation and deallocation
|
|
const test_str = try allocator.alloc(u8, 10);
|
|
defer allocator.free(test_str);
|
|
|
|
try testing.expect(test_str.len == 10);
|
|
|
|
// Fill with test data
|
|
for (test_str, 0..) |*byte, i| {
|
|
byte.* = @intCast(i % 256);
|
|
}
|
|
|
|
// Test string formatting
|
|
const formatted = try std.fmt.allocPrint(allocator, "test_{d}", .{42});
|
|
defer allocator.free(formatted);
|
|
|
|
try testing.expect(std.mem.startsWith(u8, formatted, "test_"));
|
|
try testing.expect(std.mem.endsWith(u8, formatted, "42"));
|
|
}
|