added tests

internal/agent/agent.go

@@ -28,6 +28,8 @@ type Agent struct {
 	Stats    *Stats
 	Exporter exporter.Exporter
 
+	interrupt chan os.Signal
+
 	wg sync.WaitGroup
 }
 
@@ -56,8 +58,9 @@ func New() (*Agent, error) {
 	}
 
 	return &Agent{
-		Config: config,
-		Stats:  NewStats(),
+		Config:    config,
+		Stats:     NewStats(),
+		interrupt: make(chan os.Signal, 1),
 	}, nil
 }
 
@@ -75,8 +78,7 @@ func (a *Agent) Run() error {
 	}
 	a.Exporter = exporter
 
-	interrupt := make(chan os.Signal, 1)
-	signal.Notify(interrupt, os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+	signal.Notify(a.interrupt, os.Interrupt, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
 
 	a.wg.Add(2)
 
@@ -90,7 +92,7 @@ func (a *Agent) Run() error {
 		a.startReporting(ctx)
 	}()
 
-	<-interrupt
+	<-a.interrupt
 
 	logging.LogInfo("shutting down agent...")
 	cancelBackgroundTasks()
@@ -116,6 +118,10 @@ func (a *Agent) Run() error {
 	return nil
 }
 
+func (a *Agent) Shutdown() {
+	a.interrupt <- os.Interrupt
+}
+
 func (a *Agent) startPolling(ctx context.Context) {
 	ticker := time.NewTicker(utils.IntToDuration(a.Config.PollInterval))
 	defer ticker.Stop()

internal/agent/agent_test.go

@@ -2,11 +2,17 @@ package agent
 
 import (
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 )
 
 func TestRun(t *testing.T) {
-	_, err := New()
+	agnt, err := New()
+	require.NoError(t, err)
+
+	time.AfterFunc(5*time.Second, func() { agnt.Shutdown() })
+
+	err = agnt.Run()
 	require.NoError(t, err)
 }

internal/entities/errors.go

@@ -33,11 +33,6 @@ var (
 	ErrUnexpected = errors.New("unexpected error")
 )
 
-// Constructor wrapper.
-func NewStackError(err error) error {
-	return errors.New(err.Error())
-}
-
 var _ error = (*RetriableError)(nil)
 
 // Error to handle retries.

internal/entities/filepath_test.go

@@ -0,0 +1,59 @@
+package entities
+
+import (
+	"os"
+	"testing"
+)
+
+func TestFilePathSet_ValidPath(t *testing.T) {
+	tempFile, err := os.CreateTemp("", "testfile")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+	defer func() {
+		rErr := os.Remove(tempFile.Name())
+		if rErr != nil {
+			t.Error(rErr)
+		}
+	}()
+
+	var fp FilePath
+	if err := fp.Set(tempFile.Name()); err != nil {
+		t.Errorf("expected Set to succeed, got error: %v", err)
+	}
+
+	if fp.String() != tempFile.Name() {
+		t.Errorf("expected FilePath to be %s, got %s", tempFile.Name(), fp.String())
+	}
+}
+
+func TestFilePathSet_InvalidPath(t *testing.T) {
+	var fp FilePath
+	invalidPath := "/nonexistent/path/to/file"
+
+	err := fp.Set(invalidPath)
+	if err == nil {
+		t.Errorf("expected error for invalid path, got nil")
+	}
+
+	expectedErrMsg := "invalid file path"
+	if err != nil && err.Error()[:len(expectedErrMsg)] != expectedErrMsg {
+		t.Errorf("expected error message to start with %q, got %q", expectedErrMsg, err.Error())
+	}
+}
+
+func TestFilePathString(t *testing.T) {
+	fp := FilePath("/path/to/file")
+
+	if fp.String() != "/path/to/file" {
+		t.Errorf("expected String to return '/path/to/file', got %s", fp.String())
+	}
+}
+
+func TestFilePathType(t *testing.T) {
+	fp := FilePath("/path/to/file")
+
+	if fp.Type() != "string" {
+		t.Errorf("expected Type to return 'string', got %s", fp.Type())
+	}
+}

internal/entities/secret_test.go

@@ -0,0 +1,64 @@
+package entities
+
+import (
+	"testing"
+)
+
+func TestSecretSet(t *testing.T) {
+	var s Secret
+	err := s.Set("mysecrettokenvalueforauthentication")
+
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	if s != "mysecrettokenvalueforauthentication" {
+		t.Errorf("expected Secret to be set to 'mysecrettokenvalueforauthentication', got %s", s)
+	}
+}
+
+func TestSecretSet_WarnOnShortSecret(t *testing.T) {
+	var s Secret
+	err := s.Set("short")
+
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+
+	if s != "short" {
+		t.Errorf("expected Secret to be set to 'short', got %s", s)
+	}
+}
+
+func TestSecretType(t *testing.T) {
+	var s Secret
+	if s.Type() != "string" {
+		t.Errorf("expected Type to return 'string', got %s", s.Type())
+	}
+}
+
+func TestSecretString_Masking(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"supersecretpassword", "s*****************d"},
+		{"short", "s***t"},
+		{"ab", "ab"},
+		{"a", "a"},
+		{"", ""},
+	}
+
+	for _, tt := range tests {
+		var s Secret
+		err := s.Set(tt.input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		result := s.String()
+
+		if result != tt.expected {
+			t.Errorf("expected masked output to be '%s', got '%s' for input '%s'", tt.expected, result, tt.input)
+		}
+	}
+}

internal/httpserver/server_test.go

@@ -0,0 +1,83 @@
+package httpserver
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"testing"
+	"time"
+
+	"github.com/ex0rcist/metflix/internal/entities"
+)
+
+func TestNew(t *testing.T) {
+	handler := http.NewServeMux()
+	address := entities.Address("127.0.0.1:8080")
+
+	server := New(handler, address)
+
+	if server.server.Addr != address.String() {
+		t.Errorf("expected server address %s, got %s", address.String(), server.server.Addr)
+	}
+
+	if server.server.Handler != handler {
+		t.Errorf("expected server handler to be %v, got %v", handler, server.server.Handler)
+	}
+
+	if server.notify == nil {
+		t.Error("expected notify channel to be initialized")
+	}
+}
+
+func TestServerStart(t *testing.T) {
+	handler := http.NewServeMux()
+	handler.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	})
+
+	address := entities.Address("127.0.0.1:8080")
+	server := New(handler, address)
+
+	server.Start()
+
+	time.Sleep(100 * time.Millisecond)
+
+	actualAddr := server.server.Addr
+
+	req, err := http.NewRequest(http.MethodGet, "http://"+actualAddr+"/test", nil)
+	if err != nil {
+		t.Fatalf("failed to create request: %v", err)
+	}
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Fatalf("failed to make request to server: %v", err)
+	}
+	defer func() {
+		bcErr := resp.Body.Close()
+		if bcErr != nil {
+			t.Error(bcErr)
+		}
+	}()
+
+	if resp.StatusCode != http.StatusOK {
+		t.Errorf("expected status code 200, got %d", resp.StatusCode)
+	}
+
+	err = server.Shutdown(context.Background())
+	if err != nil {
+		t.Fatalf("failed to shutdown server: %v", err)
+	}
+
+	select {
+	case err, ok := <-server.Notify():
+		if ok {
+			if !errors.Is(err, http.ErrServerClosed) {
+				t.Errorf("expected error 'http: Server closed', got %v", err)
+			}
+		}
+	case <-time.After(time.Second):
+		t.Error("timeout: notify channel did not close after shutdown")
+	}
+}

internal/logging/logging_test.go

@@ -1,14 +1,39 @@
-package logging_test
+package logging
 
 import (
+	"context"
+	"errors"
 	"testing"
 
-	"github.com/ex0rcist/metflix/internal/logging"
 	"github.com/stretchr/testify/require"
 )
 
 func TestSetup(t *testing.T) {
 	require := require.New(t)
 
-	require.NotPanics(func() { logging.Setup() })
+	require.NotPanics(func() { Setup() })
+}
+
+func TestBasic(t *testing.T) {
+	require := require.New(t)
+
+	Setup()
+
+	require.NotPanics(func() {
+		LogInfo("some message")
+		LogInfoCtx(context.Background(), "some message")
+		LogInfoF("some message %d", 42)
+
+		LogWarn("some message")
+		LogWarnCtx(context.Background(), "some message")
+		LogWarnF("some message %d", 42)
+
+		LogError(errors.New("some message"))
+		LogErrorCtx(context.Background(), errors.New("some message"))
+		LogErrorF("some message %d", errors.New("test"))
+
+		LogDebug("some message")
+		LogDebugCtx(context.Background(), "some message")
+		LogDebugF("some message %d", 42)
+	})
 }