add ability to list all units

helpers.go

@@ -55,6 +55,34 @@ func GetPID(ctx context.Context, unit string, opts Options) (int, error) {
 	return strconv.Atoi(value)
 }
 
+func GetUnits(ctx context.Context, opts Options) ([]Unit, error) {
+	args := []string{"list-units", "--all", "--no-legend", "--full", "--no-pager"}
+	if opts.UserMode {
+		args = append(args, "--user")
+	}
+	stdout, stderr, _, err := execute(ctx, args)
+	if err != nil {
+		return []Unit{}, errors.Join(err, filterErr(stderr))
+	}
+	lines := strings.Split(stdout, "\n")
+	units := []Unit{}
+	for _, line := range lines {
+		entry := strings.Fields(line)
+		if len(entry) < 4 {
+			continue
+		}
+		unit := Unit{
+			Name:        entry[0],
+			Load:        entry[1],
+			Active:      entry[2],
+			Sub:         entry[3],
+			Description: strings.Join(entry[4:], " "),
+		}
+		units = append(units, unit)
+	}
+	return units, nil
+}
+
 func GetMaskedUnits(ctx context.Context, opts Options) ([]string, error) {
 	args := []string{"list-unit-files", "--state=masked"}
 	if opts.UserMode {

helpers_test.go

@@ -238,6 +238,54 @@ func TestGetMemoryUsage(t *testing.T) {
 	})
 }
 
+func TestGetUnits(t *testing.T) {
+	type testCase struct {
+		err       error
+		runAsUser bool
+		opts      Options
+	}
+	testCases := []testCase{{
+		// Run these tests only as a user
+		runAsUser: true,
+		opts:      Options{UserMode: true},
+		err:       nil,
+	}}
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("as %s", userString), func(t *testing.T) {
+			if (userString == "root" || userString == "system") && tc.runAsUser {
+				t.Skip("skipping user test while running as superuser")
+			} else if (userString != "root" && userString != "system") && !tc.runAsUser {
+				t.Skip("skipping superuser test while running as user")
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+			defer cancel()
+			units, err := GetUnits(ctx, tc.opts)
+			if !errors.Is(err, tc.err) {
+				t.Errorf("error is %v, but should have been %v", err, tc.err)
+			}
+			if len(units) == 0 {
+				t.Errorf("Expected at least one unit, but got none")
+			}
+			unit := units[0]
+			if unit.Name == "" {
+				t.Errorf("Expected unit name to be non-empty, but got empty")
+			}
+			if unit.Load == "" {
+				t.Errorf("Expected unit load state to be non-empty, but got empty")
+			}
+			if unit.Active == "" {
+				t.Errorf("Expected unit active state to be non-empty, but got empty")
+			}
+			if unit.Sub == "" {
+				t.Errorf("Expected unit sub state to be non-empty, but got empty")
+			}
+			if unit.Description == "" {
+				t.Errorf("Expected unit description to be non-empty, but got empty")
+			}
+		})
+	}
+}
+
 func TestGetPID(t *testing.T) {
 	type testCase struct {
 		unit      string

structs.go

@@ -3,3 +3,11 @@ package systemctl
 type Options struct {
 	UserMode bool
 }
+
+type Unit struct {
+	Name        string
+	Load        string
+	Active      string
+	Sub         string
+	Description string
+}

systemctl_test.go

@@ -42,7 +42,6 @@ func TestMain(m *testing.M) {
 
 func TestDaemonReload(t *testing.T) {
 	testCases := []struct {
-		unit      string
 		err       error
 		opts      Options
 		runAsUser bool
@@ -50,22 +49,26 @@ func TestDaemonReload(t *testing.T) {
 		/* Run these tests only as a user */
 
 		// fail to reload system daemon as user
-		{"", ErrInsufficientPermissions, Options{UserMode: false}, true},
+		{ErrInsufficientPermissions, Options{UserMode: false}, true},
 		// reload user's scope daemon
-		{"", nil, Options{UserMode: true}, true},
+		{nil, Options{UserMode: true}, true},
 		/* End user tests*/
 
 		/* Run these tests only as a superuser */
 
 		// succeed to reload daemon
-		{"", nil, Options{UserMode: false}, false},
+		{nil, Options{UserMode: false}, false},
 		// fail to connect to user bus as system
-		{"", ErrBusFailure, Options{UserMode: true}, false},
+		{ErrBusFailure, Options{UserMode: true}, false},
 
 		/* End superuser tests*/
 	}
 	for _, tc := range testCases {
-		t.Run(fmt.Sprintf("%s as %s", tc.unit, userString), func(t *testing.T) {
+		mode := "user"
+		if tc.opts.UserMode == false {
+			mode = "system"
+		}
+		t.Run(fmt.Sprintf("DaemonReload as %s, %s mode", userString, mode), func(t *testing.T) {
 			if (userString == "root" || userString == "system") && tc.runAsUser {
 				t.Skip("skipping user test while running as superuser")
 			} else if (userString != "root" && userString != "system") && !tc.runAsUser {

util.go

@@ -52,23 +52,23 @@ func execute(ctx context.Context, args []string) (string, string, int, error) {
 
 func filterErr(stderr string) error {
 	switch {
-	case strings.Contains(`does not exist`, stderr):
+	case strings.Contains(stderr, `does not exist`):
 		return errors.Join(ErrDoesNotExist, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`not found.`, stderr):
+	case strings.Contains(stderr, `not found.`):
 		return errors.Join(ErrDoesNotExist, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`not loaded.`, stderr):
+	case strings.Contains(stderr, `not loaded.`):
 		return errors.Join(ErrUnitNotLoaded, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`No such file or directory`, stderr):
+	case strings.Contains(stderr, `No such file or directory`):
 		return errors.Join(ErrDoesNotExist, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`Interactive authentication required`, stderr):
+	case strings.Contains(stderr, `Interactive authentication required`):
 		return errors.Join(ErrInsufficientPermissions, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`Access denied`, stderr):
+	case strings.Contains(stderr, `Access denied`):
 		return errors.Join(ErrInsufficientPermissions, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`DBUS_SESSION_BUS_ADDRESS`, stderr):
+	case strings.Contains(stderr, `DBUS_SESSION_BUS_ADDRESS`):
 		return errors.Join(ErrBusFailure, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`is masked`, stderr):
+	case strings.Contains(stderr, `is masked`):
 		return errors.Join(ErrMasked, fmt.Errorf("stderr: %s", stderr))
-	case strings.Contains(`Failed`, stderr):
+	case strings.Contains(stderr, `Failed`):
 		return errors.Join(ErrUnspecified, fmt.Errorf("stderr: %s", stderr))
 	default:
 		return nil