uname: test uname using system abstraction

Author: leecannon

src/commands/uname.zig

@@ -3,8 +3,7 @@
 
 /// Is this command enabled for the current target?
 pub const enabled: bool = switch (shared.target_os) {
-    .linux => true,
-    .macos => true,
+    .linux, .macos => true,
     .windows => false,
 };
 
@@ -46,54 +45,53 @@ const impl = struct {
         const z: tracy.Zone = .begin(.{ .src = @src(), .name = command.name });
         defer z.end();
 
-        _ = system;
-
         const options = try parseArguments(allocator, io, args, exe_path);
         log.debug("{}", .{options});
 
-        return performUname(allocator, io, options);
+        return performUname(allocator, io, system, options);
     }
 
     fn performUname(
         allocator: std.mem.Allocator,
         io: IO,
+        system: System,
         options: UnameOptions,
     ) !void {
         const z: tracy.Zone = .begin(.{ .src = @src(), .name = "perform uname" });
         defer z.end();
 
         _ = allocator;
 
-        const utsname = std.posix.uname();
+        const uname = system.uname();
 
         var any_printed = false;
 
         if (options.kernel_name) {
-            try io.stdoutWriteAll(&utsname.sysname);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.sysname, 0));
             any_printed = true;
         }
 
         if (options.node_name) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.nodename);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.nodename, 0));
             any_printed = true;
         }
 
         if (options.kernel_release) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.release);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.release, 0));
             any_printed = true;
         }
 
         if (options.kernel_version) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.version);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.version, 0));
             any_printed = true;
         }
 
         if (options.machine) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.machine);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.machine, 0));
             any_printed = true;
         }
 
@@ -117,13 +115,13 @@ const impl = struct {
 
         if (options.os) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.sysname);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.sysname, 0));
             any_printed = true;
         }
 
         if (target_has_domainname and options.domainname) {
             if (any_printed) try io.stdoutWriteByte(' ');
-            try io.stdoutWriteAll(&utsname.domainname);
+            try io.stdoutWriteAll(std.mem.sliceTo(&uname.domainname, 0));
             any_printed = true;
         }
 
@@ -389,8 +387,29 @@ const impl = struct {
         try command.testVersion();
     }
 
-    // TODO: How do we test this without introducing the amount of complexity that https://github.com/leecannon/zsw does?
-    // https://github.com/leecannon/zig-coreutils/issues/7
+    test "uname" {
+        var stdout = std.ArrayList(u8).init(std.testing.allocator);
+        defer stdout.deinit();
+
+        try command.testExecute(&.{"-a"}, .{
+            .stdout = stdout.writer().any(),
+            .system_description = .{
+                .uname = .{
+                    .sysname = "Linux",
+                    .nodename = "node",
+                    .release = "5.15.0-100-generic",
+                    .version = "Some version",
+                    .machine = "x86_64",
+                    .domainname = null,
+                },
+            },
+        });
+
+        try std.testing.expectEqualStrings(
+            "Linux node 5.15.0-100-generic Some version x86_64 Linux (none)\n",
+            stdout.items,
+        );
+    }
 };
 
 const Arg = @import("../Arg.zig");

src/system/System.zig

@@ -64,6 +64,33 @@ pub const UserId = blk: {
     };
 };
 
+pub const Uname = if (is_test) struct {
+    sysname: [64:0]u8,
+    nodename: [64:0]u8,
+    release: [64:0]u8,
+    version: [64:0]u8,
+    machine: [64:0]u8,
+    domainname: [64:0]u8,
+} else switch (target_os) {
+    .linux, .macos => std.posix.utsname,
+    .windows => @compileError("uname not supported on windows"),
+};
+
+pub inline fn uname(system: System) Uname {
+    if (is_test) {
+        if (system._backend.uname) |uname_backend| {
+            return uname_backend.uname();
+        }
+
+        @panic("`uname` called with no uname backend configured");
+    }
+
+    return switch (target_os) {
+        .linux, .macos => std.posix.uname(),
+        .windows => @panic("uname not supported on windows"),
+    };
+}
+
 pub const Dir = struct {
     _data: Data,
 

src/system/backend/Description.zig

@@ -4,7 +4,9 @@
 time: TimeSource = .host,
 file_system: ?*FileSystemDescription = null,
 user_group: ?UserGroupDescription = null,
+uname: ?UnameDescription = null,
 
 pub const FileSystemDescription = @import("FileSystem.zig").FileSystemDescription;
 pub const TimeSource = @import("Time.zig").Source;
 pub const UserGroupDescription = @import("UserGroup.zig").UserGroupDescription;
+pub const UnameDescription = @import("Uname.zig").UnameDescription;

src/system/backend/TestBackend.zig

@@ -8,6 +8,7 @@ allocator: std.mem.Allocator,
 time: Time,
 file_system: ?FileSystem,
 user_group: ?UserGroup,
+uname: ?Uname,
 
 pub fn create(allocator: std.mem.Allocator, description: Description) !*TestBackend {
     const self = try allocator.create(TestBackend);
@@ -18,6 +19,7 @@ pub fn create(allocator: std.mem.Allocator, description: Description) !*TestBack
         .time = .{ .source = description.time },
         .file_system = null,
         .user_group = null,
+        .uname = null,
     };
 
     if (description.user_group) |ug_description| {
@@ -30,6 +32,11 @@ pub fn create(allocator: std.mem.Allocator, description: Description) !*TestBack
         try self.file_system.?.init(self, fs_description);
     }
 
+    if (description.uname) |uname_description| {
+        self.uname = @as(Uname, undefined);
+        self.uname.?.init(uname_description);
+    }
+
     return self;
 }
 
@@ -43,6 +50,7 @@ pub const Description = @import("Description.zig");
 pub const FileSystem = @import("FileSystem.zig");
 const Time = @import("Time.zig");
 const UserGroup = @import("UserGroup.zig");
+const Uname = @import("Uname.zig");
 const System = @import("../System.zig");
 
 const log = std.log.scoped(.system_test_backend);

src/system/backend/Uname.zig

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2025 Lee Cannon <leecannon@leecannon.xyz>
+
+const Uname = @This();
+
+uname_source: System.Uname,
+
+pub fn init(self: *Uname, description: UnameDescription) void {
+    @memset(std.mem.asBytes(self), 0);
+
+    if (description.sysname.len > self.uname_source.sysname.len) {
+        @panic("UnameDescription.sysname is too long");
+    }
+    @memcpy(self.uname_source.sysname[0..description.sysname.len], description.sysname);
+
+    if (description.nodename.len > self.uname_source.nodename.len) {
+        @panic("UnameDescription.nodename is too long");
+    }
+    @memcpy(self.uname_source.nodename[0..description.nodename.len], description.nodename);
+
+    if (description.release.len > self.uname_source.release.len) {
+        @panic("UnameDescription.release is too long");
+    }
+    @memcpy(self.uname_source.release[0..description.release.len], description.release);
+
+    if (description.version.len > self.uname_source.version.len) {
+        @panic("UnameDescription.version is too long");
+    }
+    @memcpy(self.uname_source.version[0..description.version.len], description.version);
+
+    if (description.machine.len > self.uname_source.machine.len) {
+        @panic("UnameDescription.machine is too long");
+    }
+    @memcpy(self.uname_source.machine[0..description.machine.len], description.machine);
+
+    if (description.domainname) |domainname| {
+        if (domainname.len > self.uname_source.domainname.len) {
+            @panic("UnameDescription.domainname is too long");
+        }
+        @memcpy(self.uname_source.domainname[0..domainname.len], domainname);
+    } else {
+        std.mem.copyForwards(u8, &self.uname_source.domainname, "(none)");
+    }
+}
+
+pub inline fn uname(self: Uname) System.Uname {
+    return self.uname_source;
+}
+
+pub const UnameDescription = struct {
+    sysname: []const u8,
+    nodename: []const u8,
+    release: []const u8,
+    version: []const u8,
+    machine: []const u8,
+    domainname: ?[]const u8,
+};
+
+const System = @import("../System.zig");
+
+const std = @import("std");