chore: add unit tests for various modules

Author: rajrohanyadav

internal/os/api/exit_code_test.go

@@ -0,0 +1,128 @@
+// Copyright 2020 New Relic Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+package api
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExitCodeErr_Error(t *testing.T) {
+	tests := []struct {
+		name     string
+		exitCode int
+		expected string
+	}{
+		{
+			name:     "exit code 0",
+			exitCode: 0,
+			expected: "returned non zero exit: 0",
+		},
+		{
+			name:     "exit code 1",
+			exitCode: 1,
+			expected: "returned non zero exit: 1",
+		},
+		{
+			name:     "exit code 3 (restart)",
+			exitCode: 3,
+			expected: "returned non zero exit: 3",
+		},
+		{
+			name:     "negative exit code",
+			exitCode: -1,
+			expected: "returned non zero exit: -1",
+		},
+		{
+			name:     "large exit code",
+			exitCode: 255,
+			expected: "returned non zero exit: 255",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := &ExitCodeErr{exitCode: tt.exitCode}
+			assert.Equal(t, tt.expected, err.Error())
+		})
+	}
+}
+
+func TestExitCodeErr_ExitCode(t *testing.T) {
+	tests := []struct {
+		name     string
+		exitCode int
+	}{
+		{
+			name:     "exit code success",
+			exitCode: ExitCodeSuccess,
+		},
+		{
+			name:     "exit code error",
+			exitCode: ExitCodeError,
+		},
+		{
+			name:     "exit code restart",
+			exitCode: ExitCodeRestart,
+		},
+		{
+			name:     "custom exit code",
+			exitCode: 42,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := &ExitCodeErr{exitCode: tt.exitCode}
+			assert.Equal(t, tt.exitCode, err.ExitCode())
+		})
+	}
+}
+
+func TestNewExitCodeErr(t *testing.T) {
+	tests := []struct {
+		name     string
+		exitCode int
+	}{
+		{
+			name:     "create with success code",
+			exitCode: ExitCodeSuccess,
+		},
+		{
+			name:     "create with error code",
+			exitCode: ExitCodeError,
+		},
+		{
+			name:     "create with restart code",
+			exitCode: ExitCodeRestart,
+		},
+		{
+			name:     "create with negative code",
+			exitCode: -1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := NewExitCodeErr(tt.exitCode)
+			assert.NotNil(t, err)
+			assert.Equal(t, tt.exitCode, err.ExitCode())
+		})
+	}
+}
+
+func TestExitCodeConstants(t *testing.T) {
+	assert.Equal(t, 0, ExitCodeSuccess)
+	assert.Equal(t, 1, ExitCodeError)
+	assert.Equal(t, 3, ExitCodeRestart)
+}
+
+func TestCheckExitCode_NilError(t *testing.T) {
+	result := CheckExitCode(nil)
+	assert.Equal(t, ExitCodeSuccess, result)
+}
+
+func TestExitCodeErr_ImplementsError(t *testing.T) {
+	var _ error = (*ExitCodeErr)(nil)
+}

internal/os/fs/fs_test.go

@@ -0,0 +1,209 @@
+// Copyright New Relic Corporation. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package fs
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestReadFirstLine(t *testing.T) {
+	tests := []struct {
+		name        string
+		content     string
+		expected    string
+		expectError bool
+	}{
+		{
+			name:     "single line",
+			content:  "Hello World",
+			expected: "Hello World",
+		},
+		{
+			name:     "multiple lines returns first",
+			content:  "First Line\nSecond Line\nThird Line",
+			expected: "First Line",
+		},
+		{
+			name:     "trims whitespace",
+			content:  "  Trimmed Content  \nSecond Line",
+			expected: "Trimmed Content",
+		},
+		{
+			name:     "empty file",
+			content:  "",
+			expected: "",
+		},
+		{
+			name:     "only newline",
+			content:  "\n",
+			expected: "",
+		},
+		{
+			name:     "tabs and spaces",
+			content:  "\t  Hello  \t\nWorld",
+			expected: "Hello",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpFile := createTempFile(t, tt.content)
+			defer os.Remove(tmpFile)
+
+			result, err := ReadFirstLine(tmpFile)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestReadFirstLine_FileNotFound(t *testing.T) {
+	result, err := ReadFirstLine("/nonexistent/path/file.txt")
+	assert.Error(t, err)
+	assert.Equal(t, "unknown", result)
+	assert.Contains(t, err.Error(), "cannot open file")
+}
+
+func TestReadFileFieldMatching(t *testing.T) {
+	tests := []struct {
+		name        string
+		content     string
+		pattern     string
+		expected    string
+		expectError bool
+	}{
+		{
+			name:     "match on first line",
+			content:  "VERSION=1.2.3\nNAME=test",
+			pattern:  `VERSION=(.+)`,
+			expected: "1.2.3",
+		},
+		{
+			name:     "match on second line",
+			content:  "NAME=test\nVERSION=1.2.3",
+			pattern:  `VERSION=(.+)`,
+			expected: "1.2.3",
+		},
+		{
+			name:     "match with quotes",
+			content:  `NAME="Ubuntu"\nVERSION="20.04"`,
+			pattern:  `NAME="([^"]+)"`,
+			expected: "Ubuntu",
+		},
+		{
+			name:     "no match returns unknown",
+			content:  "FOO=bar\nBAZ=qux",
+			pattern:  `VERSION=(.+)`,
+			expected: "unknown",
+		},
+		{
+			name:     "complex regex",
+			content:  "Red Hat Enterprise Linux release 8.4 (Ootpa)",
+			pattern:  `release (\d+\.\d+)`,
+			expected: "8.4",
+		},
+		{
+			name:     "empty file returns unknown",
+			content:  "",
+			pattern:  `(.+)`,
+			expected: "unknown",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpFile := createTempFile(t, tt.content)
+			defer os.Remove(tmpFile)
+
+			re := regexp.MustCompile(tt.pattern)
+			result, err := ReadFileFieldMatching(tmpFile, re)
+			if tt.expectError {
+				assert.Error(t, err)
+			} else {
+				// Note: err may still be nil even when result is "unknown"
+				assert.Equal(t, tt.expected, result)
+			}
+		})
+	}
+}
+
+func TestReadFileFieldMatching_FileNotFound(t *testing.T) {
+	re := regexp.MustCompile(`(.+)`)
+	result, err := ReadFileFieldMatching("/nonexistent/path/file.txt", re)
+	assert.Error(t, err)
+	assert.Equal(t, "unknown", result)
+	assert.Contains(t, err.Error(), "cannot open file")
+}
+
+func TestReadFileFieldMatching_MultipleCaptures(t *testing.T) {
+	content := "VERSION_ID=8.4"
+	tmpFile := createTempFile(t, content)
+	defer os.Remove(tmpFile)
+
+	// Pattern with multiple capture groups - should return first capture
+	re := regexp.MustCompile(`VERSION_ID=(\d+)\.(\d+)`)
+	result, err := ReadFileFieldMatching(tmpFile, re)
+	assert.NoError(t, err)
+	assert.Equal(t, "8", result) // First capture group
+}
+
+func TestReadFileFieldMatching_LinuxReleaseFiles(t *testing.T) {
+	tests := []struct {
+		name     string
+		content  string
+		pattern  string
+		expected string
+	}{
+		{
+			name:     "os-release NAME",
+			content:  `NAME="Ubuntu"\nVERSION="20.04.3 LTS (Focal Fossa)"`,
+			pattern:  `NAME="?([^"\n]+)"?`,
+			expected: "Ubuntu",
+		},
+		{
+			name:     "centos-release",
+			content:  "CentOS Linux release 7.9.2009 (Core)",
+			pattern:  `release (\d+\.\d+)`,
+			expected: "7.9",
+		},
+		{
+			name:     "redhat-release",
+			content:  "Red Hat Enterprise Linux release 8.4 (Ootpa)",
+			pattern:  `release (\d+\.\d+)`,
+			expected: "8.4",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpFile := createTempFile(t, tt.content)
+			defer os.Remove(tmpFile)
+
+			re := regexp.MustCompile(tt.pattern)
+			result, err := ReadFileFieldMatching(tmpFile, re)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+// createTempFile creates a temporary file with the given content and returns its path
+func createTempFile(t *testing.T, content string) string {
+	t.Helper()
+	tmpDir := t.TempDir()
+	tmpFile := filepath.Join(tmpDir, "testfile")
+	err := os.WriteFile(tmpFile, []byte(content), 0644)
+	require.NoError(t, err)
+	return tmpFile
+}