refactor: defer close connection or file

agent/internal/app/app.go

@@ -55,7 +55,11 @@ func (a *App) Run() {
 	a.log.Info().Msg("connection to the hub successful")
 
 	conn := rpc.NewConnectAgent(GRPCConn)
-	defer conn.Close()
+	defer func() {
+		if err := conn.Close(); err != nil {
+			a.log.Warn().Err(err).Msg("failed to close rpc connection")
+		}
+	}()
 
 	var DockerService collector.Docker
 

agent/internal/service/agent_service/agent.go

@@ -50,7 +50,7 @@ func (a *AgentService) RegisterAgentConn(ctx context.Context) error {
 	AgentID := a.settings.GetAgentID()
 	AgentName := a.cfg.AppName
 	AgentData := domain.RegisterAgentRequest{
-		AgentId:      AgentID,
+		AgentID:      AgentID,
 		AgentName:    AgentName,
 		Host:         info,
 		Capabilities: caps,

agent/internal/service/agent_service/agent_test.go

@@ -2,8 +2,12 @@ package agent_service
 
 import (
 	"context"
+	"errors"
+	"testing"
 
+	"github.com/lorsanstand/HomeOps-Hub/agent/internal/utils/config_yaml"
 	"github.com/lorsanstand/HomeOps-Hub/shared/domain"
+	"github.com/rs/zerolog"
 )
 
 type CollectorMock struct {
@@ -18,8 +22,88 @@ func (c *CollectorMock) GatherInfoSystem() (domain.HostInfo, []domain.Capability
 type ConnectionMock struct {
 	regAgentErr error
 	regResp     domain.RegisterAgentResponse
+	regData     domain.RegisterAgentRequest
 }
 
 func (c *ConnectionMock) RegisterAgent(ctx context.Context, RegisterData domain.RegisterAgentRequest) (domain.RegisterAgentResponse, error) {
+	c.regData = RegisterData
 	return c.regResp, c.regAgentErr
 }
+
+type SettingsMock struct {
+	insertErr error
+	agentID   string
+	countUse  int
+}
+
+func (s *SettingsMock) InsertAgentID(agentID string) error {
+	s.agentID = agentID
+	s.countUse++
+	return s.insertErr
+}
+
+func (s *SettingsMock) GetAgentID() string {
+	return s.agentID
+}
+
+func TestAgentService_RegisterAgentConn(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name             string
+		wantErr          error
+		insertAgentIDUse int
+		settings         SettingsMock
+		collector        CollectorMock
+		conn             ConnectionMock
+		cfg              config_yaml.AgentConfig
+	}{
+		{
+			name:             "success",
+			wantErr:          nil,
+			insertAgentIDUse: 1,
+			settings:         SettingsMock{agentID: "", insertErr: nil},
+			collector: CollectorMock{
+				host: domain.HostInfo{System: "Linux", Hostname: "test", Arch: "x64"},
+				caps: []domain.Capability{
+					{Available: true, Version: "0", Name: "testCaps", Reason: ""},
+				},
+			},
+			conn: ConnectionMock{regAgentErr: nil, regResp: domain.RegisterAgentResponse{AgentID: "123", Heartbeat: 4}},
+			cfg:  config_yaml.AgentConfig{AppName: "test"},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			ctx := context.Background()
+
+			svc := NewAgentService(&tt.collector,
+				&tt.conn,
+				&tt.settings,
+				&tt.cfg,
+				zerolog.New(nil),
+			)
+
+			err := svc.RegisterAgentConn(ctx)
+			if !errors.Is(err, tt.wantErr) {
+				t.Fatalf("expected error %v, got: %v", tt.wantErr, err)
+			}
+
+			if tt.insertAgentIDUse != tt.settings.countUse {
+				t.Errorf("expected count insert agent id %v, got: %v", tt.insertAgentIDUse, tt.settings.countUse)
+			}
+
+			if tt.settings.agentID != tt.conn.regResp.AgentID {
+				t.Errorf("expected insert agent id %v, got: %v", tt.conn.regResp.AgentID, tt.settings.agentID)
+			}
+
+			if tt.cfg.AppName != tt.conn.regData.AgentName {
+				t.Fatalf("expected agent name %v, got: %v", tt.cfg.AppName, tt.conn.regData.AgentName)
+			}
+
+		})
+	}
+}

agent/internal/service/docker_service/docker_test.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rs/zerolog"
 )
 
-var testError error = errors.New("test")
+var errTest error = errors.New("test")
 
 type DockerMock struct {
 	pingErr      error
@@ -46,11 +46,11 @@ func TestCheckDockerDaemon(t *testing.T) {
 		{
 			name: "docker error",
 			mock: DockerMock{
-				pingErr:      testError,
+				pingErr:      errTest,
 				containers:   nil,
 				containerErr: nil,
 			},
-			wantErr: testError,
+			wantErr: errTest,
 		},
 	}
 
@@ -98,10 +98,10 @@ func TestContainersList(t *testing.T) {
 			mock: DockerMock{
 				pingErr:      nil,
 				containers:   nil,
-				containerErr: testError,
+				containerErr: errTest,
 			},
 			wantLen: 0,
-			wantErr: testError,
+			wantErr: errTest,
 		},
 		{
 			name: "docker empty container",

agent/internal/utils/settings/settings.go

@@ -13,7 +13,7 @@ type Settings struct {
 	path    string
 }
 
-func ReadSettings(path string) (*Settings, error) {
+func ReadSettings(path string) (sett *Settings, err error) {
 	if path == "" {
 		homeDir, err := os.UserHomeDir()
 		if err != nil {
@@ -22,7 +22,7 @@ func ReadSettings(path string) (*Settings, error) {
 		path = filepath.Join(homeDir, ".config", "homeops")
 	}
 
-	err := os.Mkdir(path, 0755)
+	err = os.Mkdir(path, 0755)
 	if err != nil {
 		if !errors.Is(err, os.ErrExist) {
 			return nil, err
@@ -39,7 +39,12 @@ func ReadSettings(path string) (*Settings, error) {
 			return nil, err
 		}
 	} else {
-		defer file.Close()
+		defer func() {
+			closeErr := file.Close()
+			if err == nil {
+				err = closeErr
+			}
+		}()
 		err = json.NewDecoder(file).Decode(&settings)
 		if err != nil && !errors.Is(err, io.EOF) {
 			return nil, err
@@ -51,12 +56,17 @@ func ReadSettings(path string) (*Settings, error) {
 	return &settings, nil
 }
 
-func (s *Settings) InsertAgentID(agentID string) error {
+func (s *Settings) InsertAgentID(agentID string) (err error) {
 	file, err := os.OpenFile(s.path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
 	if err != nil {
 		return err
 	}
-	defer file.Close()
+	defer func() {
+		closeErr := file.Close()
+		if err == nil {
+			err = closeErr
+		}
+	}()
 
 	sett := Settings{AgentID: agentID}