refactor: agent and cmd types and tests

Author: mlataza

cmd/agent_smith/config.go

@@ -20,15 +20,14 @@ type fetchConfigurationResponse struct {
 	Configuration agent.Device `json:"configuration"`
 }
 
-func runConfig(params *configParams) {
+func runConfig(params *configContext) {
 	logger := utils.ConfigureLogger("agent_smith", os.Stdout, utils.Default)
 
 	// Show header
 	logger.Info("Agent Smith started", "version", version.Version, "os", runtime.GOOS)
 
 	// Get installation paths data
-	var pathsData agent.PathsData
-	err := pathsData.Load(context.Background(), params.OrgId, logger)
+	pathsData, err := agent.NewPathsData(context.Background(), params.OrgId, logger, params.Sys, params.Domain)
 	if err != nil {
 		logger.Error("Failed to read paths", "error", err)
 		return

cmd/agent_smith/config_context.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+
+	"github.com/RewstApp/agent-smith-go/internal/agent"
+	"github.com/RewstApp/agent-smith-go/internal/utils"
+)
+
+type configContext struct {
+	OrgId                string
+	ConfigUrl            string
+	ConfigSecret         string
+	LoggingLevel         string
+	UseSyslog            bool
+	DisableAgentPostback bool
+	NoAutoUpdates        bool
+
+	Sys    agent.SystemInfoProvider
+	Domain agent.DomainInfoProvider
+}
+
+func newConfigContext(args []string, sys agent.SystemInfoProvider, domain agent.DomainInfoProvider) (*configContext, error) {
+	var params configContext
+
+	fs := flag.NewFlagSet("config", flag.ContinueOnError)
+	fs.StringVar(&params.OrgId, "org-id", "", "Organization ID")
+	fs.StringVar(&params.ConfigUrl, "config-url", "", "Configuration URL")
+	fs.StringVar(&params.ConfigSecret, "config-secret", "", "Configuration Secret")
+	fs.StringVar(&params.LoggingLevel, "logging-level", string(utils.Default), fmt.Sprintf("Logging level: %s", getAllowedConfigLevelsString(", ")))
+	fs.BoolVar(&params.UseSyslog, "syslog", false, "Write log messages to system log")
+	fs.BoolVar(&params.DisableAgentPostback, "disable-agent-postback", false, "Disable agent postback")
+	fs.BoolVar(&params.NoAutoUpdates, "no-auto-updates", false, "No auto updates")
+	fs.SetOutput(bytes.NewBuffer([]byte{}))
+
+	err := fs.Parse(args)
+	if err != nil {
+		return nil, err
+	}
+
+	if params.OrgId == "" {
+		return nil, fmt.Errorf("missing org-id")
+	}
+
+	if params.ConfigUrl == "" {
+		return nil, fmt.Errorf("missing config-url")
+	}
+
+	if params.ConfigSecret == "" {
+		return nil, fmt.Errorf("missing config-secret")
+	}
+
+	if !allowedLoggingLevels[params.LoggingLevel] {
+		return nil, fmt.Errorf("invalid logging-level")
+	}
+
+	params.Sys = sys
+	params.Domain = domain
+
+	return &params, nil
+}

cmd/agent_smith/config_context_test.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestNewConfigContext(t *testing.T) {
+	orgId := "test123"
+	configUrl := "https://config.url/"
+	configSecret := "secret123"
+
+	result, _ := newConfigContext([]string{"--org-id", orgId, "--config-url", configUrl, "--config-secret", configSecret}, nil, nil)
+
+	if result.OrgId != orgId {
+		t.Errorf("expected %v, got %v", orgId, result.OrgId)
+	}
+
+	if result.ConfigUrl != configUrl {
+		t.Errorf("expected %v, got %v", configUrl, result.ConfigUrl)
+	}
+
+	if result.ConfigSecret != configSecret {
+		t.Errorf("expected %v, got %v", configSecret, result.ConfigSecret)
+	}
+
+	if result.Sys != nil {
+		t.Errorf("expected nil, got %v", result.Sys)
+	}
+
+	if result.Domain != nil {
+		t.Errorf("expected nil, got %v", result.Domain)
+	}
+
+	errorTests := []struct {
+		args    []string
+		message string
+	}{
+		{[]string{"--config-url", configUrl, "--config-secret", configSecret}, "missing org-id"},
+		{[]string{"--org-id", orgId, "--config-secret", configSecret}, "missing config-url"},
+		{[]string{"--org-id", orgId, "--config-url", configUrl}, "missing config-secret"},
+		{[]string{"--=uninstall"}, "bad flag syntax"},
+		{[]string{"--org-id", orgId, "--config-url", configUrl, "--config-secret", configSecret, "--logging-level", "invalid"}, "invalid logging-level"},
+	}
+
+	for _, errorTest := range errorTests {
+		_, err := newConfigContext(errorTest.args, nil, nil)
+
+		if err == nil || !strings.Contains(err.Error(), errorTest.message) {
+			t.Errorf("expected error %s, got %v", errorTest.message, err.Error())
+		}
+	}
+}

cmd/agent_smith/main.go

@@ -1,54 +1,14 @@
 package main
 
 import (
-	"bytes"
-	"flag"
 	"fmt"
 	"os"
 	"strings"
 
+	"github.com/RewstApp/agent-smith-go/internal/agent"
 	"github.com/RewstApp/agent-smith-go/internal/utils"
 )
 
-type uninstallParams struct {
-	OrgId     string
-	Uninstall bool
-}
-
-func parseUninstallParams(args []string) (*uninstallParams, error) {
-	var params uninstallParams
-
-	fs := flag.NewFlagSet("uninstall", flag.ContinueOnError)
-	fs.StringVar(&params.OrgId, "org-id", "", "Organization ID")
-	fs.BoolVar(&params.Uninstall, "uninstall", false, "Uninstall the agent")
-	fs.SetOutput(bytes.NewBuffer([]byte{}))
-
-	err := fs.Parse(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if params.OrgId == "" {
-		return nil, fmt.Errorf("missing org-id")
-	}
-
-	if !params.Uninstall {
-		return nil, fmt.Errorf("missing uninstall")
-	}
-
-	return &params, nil
-}
-
-type configParams struct {
-	OrgId                string
-	ConfigUrl            string
-	ConfigSecret         string
-	LoggingLevel         string
-	UseSyslog            bool
-	DisableAgentPostback bool
-	NoAutoUpdates        bool
-}
-
 var allowedLoggingLevels = map[string]bool{
 	string(utils.Info):    true,
 	string(utils.Warn):    true,
@@ -58,43 +18,6 @@ var allowedLoggingLevels = map[string]bool{
 	string(utils.Default): true,
 }
 
-func parseConfigParams(args []string) (*configParams, error) {
-	var params configParams
-
-	fs := flag.NewFlagSet("config", flag.ContinueOnError)
-	fs.StringVar(&params.OrgId, "org-id", "", "Organization ID")
-	fs.StringVar(&params.ConfigUrl, "config-url", "", "Configuration URL")
-	fs.StringVar(&params.ConfigSecret, "config-secret", "", "Configuration Secret")
-	fs.StringVar(&params.LoggingLevel, "logging-level", string(utils.Default), fmt.Sprintf("Logging level: %s", getAllowedConfigLevelsString(", ")))
-	fs.BoolVar(&params.UseSyslog, "syslog", false, "Write log messages to system log")
-	fs.BoolVar(&params.DisableAgentPostback, "disable-agent-postback", false, "Disable agent postback")
-	fs.BoolVar(&params.NoAutoUpdates, "no-auto-updates", false, "No auto updates")
-	fs.SetOutput(bytes.NewBuffer([]byte{}))
-
-	err := fs.Parse(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if params.OrgId == "" {
-		return nil, fmt.Errorf("missing org-id")
-	}
-
-	if params.ConfigUrl == "" {
-		return nil, fmt.Errorf("missing config-url")
-	}
-
-	if params.ConfigSecret == "" {
-		return nil, fmt.Errorf("missing config-secret")
-	}
-
-	if !allowedLoggingLevels[params.LoggingLevel] {
-		return nil, fmt.Errorf("invalid logging-level")
-	}
-
-	return &params, nil
-}
-
 func getAllowedConfigLevelsString(separator string) string {
 	var levels []string
 	for level := range allowedLoggingLevels {
@@ -109,108 +32,36 @@ func getAllowedConfigLevelsString(separator string) string {
 	return strings.Join(levels, separator)
 }
 
-type serviceParams struct {
-	OrgId      string
-	ConfigFile string
-	LogFile    string
-}
-
-func parseServiceParams(args []string) (*serviceParams, error) {
-	var params serviceParams
-
-	fs := flag.NewFlagSet("config", flag.ContinueOnError)
-	fs.StringVar(&params.OrgId, "org-id", "", "Organization ID")
-	fs.StringVar(&params.ConfigFile, "config-file", "", "Configuration File")
-	fs.StringVar(&params.LogFile, "log-file", "", "Log file")
-	fs.SetOutput(bytes.NewBuffer([]byte{}))
-
-	err := fs.Parse(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if params.OrgId == "" {
-		return nil, fmt.Errorf("missing org-id")
-	}
-
-	if params.ConfigFile == "" {
-		return nil, fmt.Errorf("missing config-file")
-	}
-
-	if params.LogFile == "" {
-		return nil, fmt.Errorf("missing log-file")
-	}
-
-	return &params, nil
-}
-
-type updateParams struct {
-	OrgId                string
-	Update               bool
-	LoggingLevel         string
-	UseSyslog            bool
-	DisableAgentPostback bool
-	NoAutoUpdates        bool
-}
-
-func parseUpdateParams(args []string) (*updateParams, error) {
-	var params updateParams
-
-	fs := flag.NewFlagSet("config", flag.ContinueOnError)
-	fs.StringVar(&params.OrgId, "org-id", "", "Organization ID")
-	fs.BoolVar(&params.Update, "update", false, "Update the agent")
-	fs.StringVar(&params.LoggingLevel, "logging-level", string(utils.Default), fmt.Sprintf("Logging level: %s", getAllowedConfigLevelsString(", ")))
-	fs.BoolVar(&params.UseSyslog, "syslog", false, "Write log messages to system log")
-	fs.BoolVar(&params.DisableAgentPostback, "disable-agent-postback", false, "Disable agent postback")
-	fs.BoolVar(&params.NoAutoUpdates, "no-auto-updates", false, "No auto updates")
-	fs.SetOutput(bytes.NewBuffer([]byte{}))
-
-	err := fs.Parse(args)
-	if err != nil {
-		return nil, err
-	}
-
-	if params.OrgId == "" {
-		return nil, fmt.Errorf("missing org-id")
-	}
-
-	if !params.Update {
-		return nil, fmt.Errorf("missing update")
-	}
-
-	if !allowedLoggingLevels[params.LoggingLevel] {
-		return nil, fmt.Errorf("invalid logging-level")
-	}
-
-	return &params, nil
-}
-
 func main() {
-	uninstallParams, err := parseUninstallParams(os.Args[1:])
+	// Create providers
+	sys := agent.NewSystemInfoProvider()
+	domain := agent.NewDomainInfoProvider()
+
+	uninstallContext, err := newUninstallContext(os.Args[1:])
 	if err == nil {
 		// Run uninstall routine
-		runUninstall(uninstallParams)
+		runUninstall(uninstallContext)
 		return
 	}
 
-	configParams, err := parseConfigParams(os.Args[1:])
+	configContext, err := newConfigContext(os.Args[1:], sys, domain)
 	if err == nil {
 		// Run config routine
-		runConfig(configParams)
+		runConfig(configContext)
 		return
 	}
 
-	serviceParams, err := parseServiceParams(os.Args[1:])
+	serviceContext, err := newServiceContext(os.Args[1:], sys, domain)
 	if err == nil {
 		// Run service routine
-		runService(serviceParams)
+		runService(serviceContext)
 		return
 	}
 
-	updateParams, err := parseUpdateParams(os.Args[1:])
+	updateContext, err := newUpdateContext(os.Args[1:], sys, domain)
 	if err == nil {
 		// Run update routine
-		runUpdate(updateParams)
+		runUpdate(updateContext)
 		return
 	}