From 0575acc601db877509bb317d282af6268c535af4 Mon Sep 17 00:00:00 2001
From: IbraAoad <Ibrahim.Awwad@canonical.com>
Date: Thu, 20 Feb 2025 16:58:58 +0200
Subject: [PATCH] refactor(systemdCollector): use dependency injection via
 Manager interface

Signed-off-by: IbraAoad <Ibrahim.Awwad@canonical.com>
---
 collector/systemd_linux.go      | 16 ++++----
 collector/systemd_linux_test.go | 67 ++++++++++++++++-----------------
 2 files changed, 41 insertions(+), 42 deletions(-)

diff --git a/collector/systemd_linux.go b/collector/systemd_linux.go
index f73828ef..40c78438 100644
--- a/collector/systemd_linux.go
+++ b/collector/systemd_linux.go
@@ -83,8 +83,8 @@ type systemdCollector struct {
 
 var unitStatesName = []string{"active", "activating", "deactivating", "inactive", "failed"}
 
-var getManagerPropertyFunc = func(conn *dbus.Conn, name string) (string, error) {
-	return conn.GetManagerProperty(name)
+type Manager interface {
+	GetManagerProperty(prop string) (string, error)
 }
 
 func init() {
@@ -437,8 +437,8 @@ func (c *systemdCollector) collectSummaryMetrics(ch chan<- prometheus.Metric, su
 	}
 }
 
-func (c *systemdCollector) collectSystemState(conn *dbus.Conn, ch chan<- prometheus.Metric) error {
-	systemState, err := getManagerPropertyFunc(conn, "SystemState")
+func (c *systemdCollector) collectSystemState(m Manager, ch chan<- prometheus.Metric) error {
+	systemState, err := m.GetManagerProperty("SystemState")
 	if err != nil {
 		return fmt.Errorf("couldn't get system state: %w", err)
 	}
@@ -506,8 +506,8 @@ func filterUnits(units []unit, includePattern, excludePattern *regexp.Regexp, lo
 	return filtered
 }
 
-func (c *systemdCollector) getSystemdVersion(conn *dbus.Conn) (float64, string) {
-	version, err := getManagerPropertyFunc(conn, "Version")
+func (c *systemdCollector) getSystemdVersion(m Manager) (float64, string) {
+	version, err := m.GetManagerProperty("Version")
 	if err != nil {
 		c.logger.Debug("Unable to get systemd version property, defaulting to 0")
 		return 0, ""
@@ -523,8 +523,8 @@ func (c *systemdCollector) getSystemdVersion(conn *dbus.Conn) (float64, string)
 	return v, version
 }
 
-func (c *systemdCollector) getSystemdVirtualization(conn *dbus.Conn) string {
-	virt, err := getManagerPropertyFunc(conn, "Virtualization")
+func (c *systemdCollector) getSystemdVirtualization(m Manager) string {
+	virt, err := m.GetManagerProperty("Virtualization")
 	if err != nil {
 		c.logger.Debug("Could not get Virtualization property", "err", err)
 		return "unknown"
diff --git a/collector/systemd_linux_test.go b/collector/systemd_linux_test.go
index 92aa848e..0ac0bdad 100644
--- a/collector/systemd_linux_test.go
+++ b/collector/systemd_linux_test.go
@@ -139,59 +139,58 @@ func testSummaryHelper(t *testing.T, state string, actual float64, expected floa
 	}
 }
 
+// fakeManager implements the Manager interface for testing.
+type fakeManager struct {
+	result string
+	err    error
+}
+
+// GetManagerProperty returns the controlled result for tests.
+func (f *fakeManager) GetManagerProperty(prop string) (string, error) {
+	return f.result, f.err
+}
+
 func Test_systemdCollector_getSystemdVirtualization(t *testing.T) {
-	type fields struct {
-		logger *slog.Logger
-	}
-	type args struct {
-		conn *dbus.Conn
+	logger := slog.New(slog.NewTextHandler(io.Discard, nil))
+	c, err := NewSystemdCollector(logger)
+	if err != nil {
+		t.Fatal(err)
 	}
+	sysdCollector := c.(*systemdCollector)
+
 	tests := []struct {
-		name   string
-		fields fields
-		args   args
-		mock   func(conn *dbus.Conn, name string) (string, error)
-		want   string
+		name string
+		fake *fakeManager
+		want string
 	}{
 		{
-			name:   "Error",
-			fields: fields{logger: slog.New(slog.NewTextHandler(io.Discard, nil))},
-			args:   args{conn: &dbus.Conn{}},
-			mock: func(conn *dbus.Conn, name string) (string, error) {
-				return "", errors.New("test error")
+			name: "Error",
+			fake: &fakeManager{
+				err: errors.New("test error"),
 			},
 			want: "unknown",
 		},
 		{
-			name:   "Empty",
-			fields: fields{logger: slog.New(slog.NewTextHandler(io.Discard, nil))},
-			args:   args{conn: &dbus.Conn{}},
-			mock: func(conn *dbus.Conn, name string) (string, error) {
-				return `""`, nil
+			name: "Empty",
+			fake: &fakeManager{
+				result: `""`,
 			},
 			want: "none",
 		},
 		{
-			name:   "Valid",
-			fields: fields{logger: slog.New(slog.NewTextHandler(io.Discard, nil))},
-			args:   args{conn: &dbus.Conn{}},
-			mock: func(conn *dbus.Conn, name string) (string, error) {
-				return `"kvm"`, nil
+			name: "Valid",
+			fake: &fakeManager{
+				result: `"kvm"`,
 			},
 			want: "kvm",
 		},
 	}
+
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			origFunc := getManagerPropertyFunc
-			defer func() { getManagerPropertyFunc = origFunc }()
-			getManagerPropertyFunc = tt.mock
-
-			c := &systemdCollector{
-				logger: tt.fields.logger,
-			}
-			if got := c.getSystemdVirtualization(tt.args.conn); got != tt.want {
-				t.Errorf("systemdCollector.getSystemdVirtualization() = %v, want %v", got, tt.want)
+			got := sysdCollector.getSystemdVirtualization(tt.fake)
+			if got != tt.want {
+				t.Errorf("getSystemdVirtualization() = %v, want %v", got, tt.want)
 			}
 		})
 	}