Add Unit tests for Logs, Resolve, Rules and Sigs Packages (#56)

* added log-resolve-rules-sigs tests

Signed-off-by: amanycodes <amanycodes@gmail.com>

* added cli-test mock comments

Signed-off-by: amanycodes <amanycodes@gmail.com>

---------

Signed-off-by: amanycodes <amanycodes@gmail.com>

Author: amanycodes

README.md

@@ -1,5 +1,5 @@
 # preq
-![Coverage](https://img.shields.io/badge/Coverage-39.8%25-red)
+![Coverage](https://img.shields.io/badge/Coverage-45.2%25-orange)
 [![Unit Tests](https://github.com/prequel-dev/cre/actions/workflows/build.yml/badge.svg)](https://github.com/prequel-dev/cre/actions/workflows/build.yml)
 [![Unit Tests](https://github.com/prequel-dev/preq/actions/workflows/build.yml/badge.svg)](https://github.com/prequel-dev/preq/actions/workflows/build.yml)
 [![Unit Tests](https://github.com/prequel-dev/prequel-compiler/actions/workflows/build.yml/badge.svg)](https://github.com/prequel-dev/prequel-compiler/actions/workflows/build.yml)

internal/pkg/cli/cli.go

@@ -41,6 +41,7 @@ var (
 	ruleUpdateFile   = filepath.Join(defaultConfigDir, ".ruleupdate")
 )
 
+// Package-level variables to allow mocking in tests.
 var (
 	getRulesFunc = func(ctx context.Context, conf *config.Config, configDir, cmdLineRules, token, ruleUpdateFile, baseAddr string, tlsPort, udpPort int) ([]utils.RulePathT, error) {
 		return rules.GetRules(ctx, conf, configDir, cmdLineRules, token, ruleUpdateFile, baseAddr, tlsPort, udpPort)
@@ -114,6 +115,7 @@ func InitAndExecute(ctx context.Context) error {
 	}
 
 	// Log in for community rule updates
+	// Mockable function variable to allow for testing without real network calls
 	if token, err = loginUserFunc(ctx, baseAddr, ruleToken); err != nil {
 		log.Error().Err(err).Msg("Failed to login")
 
@@ -137,6 +139,7 @@ func InitAndExecute(ctx context.Context) error {
 		c.Skip = timez.DefaultSkip
 	}
 
+	// Mockable function variable to allow for testing without real network calls
 	rulesPaths, err = getRulesFunc(ctx, c, defaultConfigDir, Options.Rules, token, ruleUpdateFile, baseAddr, tlsPort, udpPort)
 	if err != nil {
 		log.Error().Err(err).Msg("Failed to get rules")

internal/pkg/logs/logs_test.go

@@ -0,0 +1,73 @@
+package logs
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/rs/zerolog"
+)
+
+func TestShortenCaller(t *testing.T) {
+	testCases := []struct {
+		name     string
+		file     string
+		line     int
+		expected string
+	}{
+		{
+			name:     "long unix path",
+			file:     "/home/user/go/src/github.com/prequel-dev/preq/internal/pkg/cli/cli.go",
+			line:     42,
+			expected: "cli.go:42",
+		},
+		{
+			name:     "long windows path",
+			file:     `C:\Users\user\go\src\github.com\prequel-dev\preq\internal\pkg\cli\cli.go`,
+			line:     101,
+			expected: `C:\Users\user\go\src\github.com\prequel-dev\preq\internal\pkg\cli\cli.go:101`,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			result := shortenCaller(0, tc.file, tc.line)
+			if result != tc.expected {
+				t.Errorf("Expected '%s', but got '%s'", tc.expected, result)
+			}
+		})
+	}
+}
+
+func TestMkTimestampFormatter(t *testing.T) {
+	const testTimeFormat = time.RFC1123
+
+	var buf bytes.Buffer
+
+	writer := zerolog.ConsoleWriter{
+		Out:             &buf,
+		FormatTimestamp: mkTimestampFormatter(testTimeFormat, 37),
+		NoColor:         true,
+	}
+
+	logger := zerolog.New(writer).With().Timestamp().Logger()
+
+	logTime := time.Date(2023, 10, 28, 10, 30, 0, 0, time.UTC)
+	expectedTimeString := logTime.Local().Format(testTimeFormat)
+
+	zerolog.TimestampFunc = func() time.Time {
+		return logTime
+	}
+	t.Cleanup(func() {
+		zerolog.TimestampFunc = time.Now
+	})
+
+	logger.Info().Msg("hello world")
+
+	output := buf.String()
+
+	if !strings.Contains(output, expectedTimeString) {
+		t.Errorf("Expected log output to contain timestamp '%s', but it was not found in '%s'", expectedTimeString, output)
+	}
+}

internal/pkg/resolve/resolve_test.go

@@ -0,0 +1,159 @@
+package resolve
+
+import (
+	"compress/gzip"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/prequel-dev/prequel-compiler/pkg/datasrc"
+)
+
+func createTestFile(t *testing.T, dir, name, content string, useGzip bool) string {
+	t.Helper()
+	path := filepath.Join(dir, name)
+
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatalf("Failed to create test file: %v", err)
+	}
+
+	var fileContent strings.Builder
+	fileContent.WriteString(content + "\n")
+	for fileContent.Len() < detectSampleSize+100 {
+		fileContent.WriteString("This is a filler line to make the file large enough.\n")
+	}
+
+	finalBytes := []byte(fileContent.String())
+
+	if useGzip {
+		gz := gzip.NewWriter(f)
+		if _, err := gz.Write(finalBytes); err != nil {
+			t.Fatalf("Failed to write gzipped content: %v", err)
+		}
+		gz.Close()
+	} else {
+		if _, err := f.Write(finalBytes); err != nil {
+			t.Fatalf("Failed to write plain content: %v", err)
+		}
+	}
+	f.Close()
+	return path
+}
+
+func TestNewLogSrc(t *testing.T) {
+	tempDir := t.TempDir()
+	logContent := "2023-10-28T10:30:00Z This is a test log line."
+
+	t.Run("with plain text file", func(t *testing.T) {
+		path := createTestFile(t, tempDir, "test.log", logContent, false)
+
+		src, err := newLogSrc(path)
+		if err != nil {
+			t.Fatalf("newLogSrc failed for plain file: %v", err)
+		}
+		defer src.Close()
+
+		info, _ := os.Stat(path)
+		if src.Size() != info.Size() {
+			t.Errorf("Expected size %d, got %d", info.Size(), src.Size())
+		}
+	})
+
+	t.Run("with gzipped file", func(t *testing.T) {
+		path := createTestFile(t, tempDir, "test.log.gz", logContent, true)
+
+		src, err := newLogSrc(path)
+		if err != nil {
+			t.Fatalf("newLogSrc failed for gzipped file: %v", err)
+		}
+		defer src.Close()
+
+		if src.Size() != -1 {
+			t.Errorf("Expected size -1 for gzip, got %d", src.Size())
+		}
+	})
+
+	t.Run("with window option", func(t *testing.T) {
+		path := createTestFile(t, tempDir, "window.log", logContent, false)
+		expectedWindow := int64(30)
+
+		src, err := newLogSrc(path, WithWindow(expectedWindow))
+		if err != nil {
+			t.Fatalf("newLogSrc failed: %v", err)
+		}
+		defer src.Close()
+
+		if src.Window() != expectedWindow {
+			t.Errorf("Expected window %d, got %d", expectedWindow, src.Window())
+		}
+	})
+
+	t.Run("with non-existent file", func(t *testing.T) {
+		_, err := newLogSrc(filepath.Join(tempDir, "not-real.log"))
+		if err == nil {
+			t.Fatal("Expected an error for a non-existent file, but got nil")
+		}
+	})
+}
+
+func TestResolveSource(t *testing.T) {
+	tempDir := t.TempDir()
+	logContent := "2023-10-28T10:40:00Z some log content"
+	logPath := createTestFile(t, tempDir, "app.log", logContent, false)
+
+	t.Run("with valid source", func(t *testing.T) {
+		dss := &datasrc.DataSources{
+			Sources: []datasrc.Source{
+				{
+					Name:      "my-app",
+					Type:      "log",
+					Locations: []datasrc.Location{{Path: logPath}},
+				},
+			},
+		}
+
+		results := Resolve(dss)
+		if len(results) != 1 {
+			t.Fatalf("Expected 1 resolved source, got %d", len(results))
+		}
+		if results[0].Name() != "my-app" {
+			t.Errorf("Expected resolved source name to be 'my-app', got '%s'", results[0].Name())
+		}
+	})
+}
+
+func TestPipeStdin(t *testing.T) {
+	var b strings.Builder
+	b.WriteString("2023-10-28T11:00:00Z Piped log content\n")
+	for b.Len() < detectSampleSize+100 {
+		b.WriteString("Filler line for stdin test.\n")
+	}
+	logContent := b.String()
+
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("os.Pipe failed: %v", err)
+	}
+
+	originalStdin := os.Stdin
+	os.Stdin = r
+	t.Cleanup(func() {
+		os.Stdin = originalStdin
+	})
+
+	go func() {
+		defer w.Close()
+		w.Write([]byte(logContent))
+	}()
+
+	results, err := PipeStdin()
+	if err != nil {
+		t.Fatalf("PipeStdin returned an unexpected error: %v", err)
+	}
+
+	if len(results) != 1 {
+		t.Fatalf("Expected PipeStdin to return 1 LogData source, but got %d", len(results))
+	}
+}