Adds more unit tests

Author: jscalev

internal/cleanup/cleanup.go

@@ -2,11 +2,8 @@ package cleanup
 
 import (
 	"fmt"
-	"os"
 	"path/filepath"
-	"strconv"
 
-	"github.com/!azure/azure-extension-platform/pkg/utils"
 	"github.com/Azure/run-command-handler-linux/internal/constants"
 	"github.com/Azure/run-command-handler-linux/internal/types"
 	"github.com/Azure/run-command-handler-linux/pkg/linuxutils"
@@ -41,28 +38,28 @@ func deleteAllScriptsAndSettings(ctx *log.Context, metadata types.RCMetadata, h
 }
 
 func deleteScriptsAndSettingsExceptMostRecent(ctx *log.Context, metadata types.RCMetadata, h types.HandlerEnvironment, runAsUser string) {
-	runtimeSettingsRegexFormat := metadata.ExtName + ".\\d+.settings"
-	runtimeSettingsLastSeqNumFormat := metadata.ExtName + ".%d.settings"
+	/* 	runtimeSettingsRegexFormat := metadata.ExtName + ".\\d+.settings"
+	   	runtimeSettingsLastSeqNumFormat := metadata.ExtName + ".%d.settings"
 
-	// check if directory exists
-	_, err := os.Open(metadata.DownloadPath)
-	if err == nil {
-		err := utils.TryClearExtensionScriptsDirectoriesAndSettingsFilesExceptMostRecent(metadata.DownloadPath, h.HandlerEnvironment.ConfigFolder, "",
-			uint64(metadata.SeqNum), runtimeSettingsRegexFormat, runtimeSettingsLastSeqNumFormat)
-		if err != nil {
-			ctx.Log("event", "could not clear settings and script files", "error", err)
-		}
-	} else {
-		ctx.Log("message", "directory does not exist. Skipping cleanup")
-	}
+	   	// check if directory exists
+	   	_, err := os.Open(metadata.DownloadPath)
+	   	if err == nil {
+	   		err := utils.TryClearExtensionScriptsDirectoriesAndSettingsFilesExceptMostRecent(metadata.DownloadPath, h.HandlerEnvironment.ConfigFolder, "",
+	   			uint64(metadata.SeqNum), runtimeSettingsRegexFormat, runtimeSettingsLastSeqNumFormat)
+	   		if err != nil {
+	   			ctx.Log("event", "could not clear settings and script files", "error", err)
+	   		}
+	   	} else {
+	   		ctx.Log("message", "directory does not exist. Skipping cleanup")
+	   	}
 
-	if runAsUser != "" {
-		runAsDownloadParent := filepath.Join(fmt.Sprintf(constants.RunAsDir, runAsUser), metadata.DownloadDir)
-		seqNumString := strconv.Itoa(metadata.SeqNum)
-		ctx.Log("message", "removing all files from the download 'runas' directory "+runAsDownloadParent)
-		err = utils.TryDeleteDirectoriesExcept(runAsDownloadParent, seqNumString)
-		if err != nil {
-			ctx.Log("event", "could not clear runas script")
-		}
-	}
+	   	if runAsUser != "" {
+	   		runAsDownloadParent := filepath.Join(fmt.Sprintf(constants.RunAsDir, runAsUser), metadata.DownloadDir)
+	   		seqNumString := strconv.Itoa(metadata.SeqNum)
+	   		ctx.Log("message", "removing all files from the download 'runas' directory "+runAsDownloadParent)
+	   		err = utils.TryDeleteDirectoriesExcept(runAsDownloadParent, seqNumString)
+	   		if err != nil {
+	   			ctx.Log("event", "could not clear runas script")
+	   		}
+	   	} */
 }

internal/commandProcessor/commandProcessor.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/Azure/azure-extension-platform/pkg/handlerenv"
 	"github.com/Azure/azure-extension-platform/pkg/logging"
+	"github.com/Azure/azure-extension-platform/vmextension"
 	"github.com/Azure/run-command-handler-linux/internal/constants"
 	"github.com/Azure/run-command-handler-linux/internal/handlersettings"
 	"github.com/Azure/run-command-handler-linux/internal/instanceview"
@@ -22,6 +23,8 @@ import (
 
 var (
 	handlerEnvironmentGetter func(name, version string) (he *handlerenv.HandlerEnvironment, _ error) = handlerenv.GetHandlerEnvironment
+	fnGetHandlerSettings                                                                             = handlersettings.GetHandlerSettings
+	fnReportInstanceView                                                                             = instanceview.ReportInstanceView
 )
 
 func ProcessImmediateHandlerCommand(cmd types.Cmd, hs handlersettings.HandlerSettingsFile, extensionName string, seqNum int) error {
@@ -82,7 +85,7 @@ func ProcessHandlerCommandWithDetails(ctx *log.Context, cmd types.Cmd, hEnv type
 	}
 
 	metadata := types.NewRCMetadata(extensionName, seqNum, downloadFolder, constants.DataDir)
-	instanceview.ReportInstanceView(ctx, hEnv, metadata, types.StatusTransitioning, cmd, &instView)
+	fnReportInstanceView(ctx, hEnv, metadata, types.StatusTransitioning, cmd, &instView)
 
 	// execute the subcommand
 	stdout, stderr, cmdInvokeError, exitCode := cmd.Functions.Invoke(ctx, hEnv, &instView, metadata, cmd)
@@ -97,13 +100,19 @@ func ProcessHandlerCommandWithDetails(ctx *log.Context, cmd types.Cmd, hEnv type
 		instView.ExitCode = exitCode
 		statusToReport := types.StatusSuccess
 
+		// Add an error clarification if we have one
+		var ewc vmextension.ErrorWithClarification
+		if errors.As(cmdInvokeError, &ewc) {
+			instView.ErrorClarificationValue = ewc.ErrorCode
+		}
+
 		// If TreatFailureAsDeploymentFailure is set to true and the exit code is non-zero, set extension status to error
-		cfg, err := handlersettings.GetHandlerSettings(hEnv.HandlerEnvironment.ConfigFolder, extensionName, seqNum, ctx)
+		cfg, err := fnGetHandlerSettings(hEnv.HandlerEnvironment.ConfigFolder, extensionName, seqNum, ctx)
 		if err == nil && cfg.PublicSettings.TreatFailureAsDeploymentFailure && cmd.FailExitCode != 0 {
 			statusToReport = types.StatusError
 		}
 
-		instanceview.ReportInstanceView(ctx, hEnv, metadata, statusToReport, cmd, &instView)
+		fnReportInstanceView(ctx, hEnv, metadata, statusToReport, cmd, &instView)
 		return errors.Wrapf(err, "command execution failed")
 	} else { // No error. Succeeded
 		instView.ExecutionMessage = "Execution completed"
@@ -112,7 +121,7 @@ func ProcessHandlerCommandWithDetails(ctx *log.Context, cmd types.Cmd, hEnv type
 		instView.ExitCode = constants.ExitCode_Okay
 	}
 
-	instanceview.ReportInstanceView(ctx, hEnv, metadata, types.StatusSuccess, cmd, &instView)
+	fnReportInstanceView(ctx, hEnv, metadata, types.StatusSuccess, cmd, &instView)
 	ctx.Log("event", "end")
 
 	return nil

internal/commandProcessor/commandProcessor_test.go

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/Azure/azure-extension-platform/vmextension"
 	"github.com/Azure/run-command-handler-linux/internal/cleanup"
 	"github.com/Azure/run-command-handler-linux/internal/constants"
 	"github.com/Azure/run-command-handler-linux/internal/handlersettings"
@@ -190,3 +191,43 @@ func Test_GetSeqNumFromFailedToFind(t *testing.T) {
 	require.Nil(t, err)
 	require.Equal(t, 0, actualSeqNum)
 }
+
+func Test_ProcessHandlerCommandWithDetails_Failure_WithClarification(t *testing.T) {
+	var last types.RunCommandInstanceView
+
+	origReportInstanceView := fnReportInstanceView
+	defer func() { fnReportInstanceView = origReportInstanceView }()
+	fnReportInstanceView = func(ctx *log.Context, hEnv types.HandlerEnvironment, metadata types.RCMetadata, t types.StatusType, c types.Cmd, instanceview *types.RunCommandInstanceView) error {
+		last = *instanceview
+		return nil
+	}
+
+	ewc := vmextension.ErrorWithClarification{
+		ErrorCode: 1234,
+		Err:       errors.New("the chipmunks are upset"),
+	}
+
+	mockFunc := types.CmdFunctions{
+		Invoke: func(_ *log.Context, _ types.HandlerEnvironment, iv *types.RunCommandInstanceView, _ types.RCMetadata, _ types.Cmd) (string, string, error, int) {
+			return "x", "y", ewc, 3
+		},
+	}
+
+	orig := fnGetHandlerSettings
+	defer func() { fnGetHandlerSettings = orig }()
+	fnGetHandlerSettings = func(string, string, int, *log.Context) (handlersettings.HandlerSettings, error) {
+		return handlersettings.HandlerSettings{
+			PublicSettings: handlersettings.PublicSettings{
+				TreatFailureAsDeploymentFailure: false,
+			},
+		}, nil
+	}
+
+	cmd := types.Cmd{Name: "run", FailExitCode: 3, Functions: mockFunc}
+	hEnv := types.HandlerEnvironment{}
+	ctx := log.NewContext(log.NewNopLogger())
+
+	err := ProcessHandlerCommandWithDetails(ctx, cmd, hEnv, "x", 1, "/tmp")
+	require.Nil(t, err, "expected no error because TreatFailureAsDeploymentFailure is false")
+	require.Equal(t, 1234, last.ErrorClarificationValue, "expected clarification 1234 but got %d", last.ErrorClarificationValue)
+}

internal/immediatecmds/immediatecmds.go

@@ -13,19 +13,29 @@ import (
 	"github.com/pkg/errors"
 )
 
+var (
+	fnServiceDisable     = service.Disable
+	fnServiceDeRegister  = service.DeRegister
+	fnServiceEnable      = service.Enable
+	fnServiceIsEnabled   = service.IsEnabled
+	fnServiceIsInstalled = service.IsInstalled
+	fnServiceRegister    = service.Register
+	fnServiceStart       = service.Start
+)
+
 // Updates the service definition if any immediate run command service exists.
 // The action is skipped if the service has already been upgraded.
 func Update(ctx *log.Context, h types.HandlerEnvironment, extName string, seqNum int, extensionEvents *extensionevents.ExtensionEventManager) (int, error) {
 	ctx.Log("message", "updating immediate run command")
-	isInstalled, err := service.IsInstalled(ctx)
+	isInstalled, err := fnServiceIsInstalled(ctx)
 	if err != nil {
 		errMessage := fmt.Sprintf("Failed to check if any runcommand service is installed: %v", err)
 		extensionEvents.LogErrorEvent("immediateupdate", errMessage)
 		return constants.FileSystem_CreateDataDirectoryFailed, errors.Wrap(err, "failed to check if any runcommand service is installed")
 	}
 
 	if isInstalled {
-		err = service.Register(ctx, extensionEvents)
+		err = fnServiceRegister(ctx, extensionEvents)
 		if err != nil {
 			errMessage := fmt.Sprintf("Failed to upgrade run command service: %v", err)
 			extensionEvents.LogErrorEvent("immediateupdate", errMessage)
@@ -37,23 +47,23 @@ func Update(ctx *log.Context, h types.HandlerEnvironment, extName string, seqNum
 }
 
 func Disable(ctx *log.Context, h types.HandlerEnvironment, extName string, seqNum int, extensionEvents *extensionevents.ExtensionEventManager) (int, error) {
-	isInstalled, err := service.IsInstalled(ctx)
+	isInstalled, err := fnServiceIsInstalled(ctx)
 	if err != nil {
 		errMessage := fmt.Sprintf("Failed to check if runcommand service is installed: %v", err)
 		extensionEvents.LogErrorEvent("immediatedisable", errMessage)
 		return constants.ExitCode_DisableInstalledServiceFailed, errors.Wrap(err, "failed to check if runcommand service is installed")
 	}
 
 	if isInstalled {
-		isEnabled, err := service.IsEnabled(ctx)
+		isEnabled, err := fnServiceIsEnabled(ctx)
 		if err != nil {
 			errMessage := fmt.Sprintf("Failed to check if service is enabled: %v", err)
 			extensionEvents.LogErrorEvent("immediatedisable", errMessage)
 			return constants.ExitCode_InstallServiceFailed, errors.Wrap(err, "failed to check if service is enabled")
 		}
 
 		if isEnabled {
-			err := service.Disable(ctx, extensionEvents)
+			err := fnServiceDisable(ctx, extensionEvents)
 			if err != nil {
 				errMessage := fmt.Sprintf("Failed to disable run command service: %v", err)
 				extensionEvents.LogErrorEvent("immediatedisable", errMessage)
@@ -75,19 +85,19 @@ func Install() (int, error) {
 
 func Uninstall(ctx *log.Context, h types.HandlerEnvironment, extName string, seqNum int, extensionEvents *extensionevents.ExtensionEventManager) (int, error) {
 	ctx.Log("message", "proceeding to uninstall immediate run command")
-	isInstalled, err := service.IsInstalled(ctx)
+	isInstalled, err := fnServiceIsInstalled(ctx)
 	if err != nil {
 		errMessage := fmt.Sprintf("Failed to check if runcommand service is installed: %v", err)
 		extensionEvents.LogErrorEvent("immediatedisable", errMessage)
 		return constants.FileSystem_RemoveDataDirectoryFailed, errors.Wrap(err, "failed to check if runcommand service is installed")
 	}
 
 	if isInstalled {
-		error := service.DeRegister(ctx, extensionEvents)
-		if error != nil {
-			errMessage := fmt.Sprintf("Failed to uninstall run command service: %v", error)
+		err2 := fnServiceDeRegister(ctx, extensionEvents)
+		if err2 != nil {
+			errMessage := fmt.Sprintf("Failed to uninstall run command service: %v", err2)
 			extensionEvents.LogErrorEvent("immediatedisable", errMessage)
-			return constants.ExitCode_UninstallInstalledServiceFailed, errors.Wrap(err, "failed to uninstall run command service")
+			return constants.ExitCode_UninstallInstalledServiceFailed, errors.Wrap(err2, "failed to uninstall run command service")
 		}
 	}
 	return constants.ExitCode_Okay, nil
@@ -96,37 +106,37 @@ func Uninstall(ctx *log.Context, h types.HandlerEnvironment, extName string, seq
 func Enable(ctx *log.Context, h types.HandlerEnvironment, extName string, seqNum int, cfg handlersettings.HandlerSettings, extensionEvents *extensionevents.ExtensionEventManager) (int, error) {
 	// If installService == true, then install RunCommand as a service
 	if cfg.InstallAsService() {
-		isInstalled, err2 := service.IsInstalled(ctx)
+		isInstalled, err2 := fnServiceIsInstalled(ctx)
 		if err2 != nil {
 			ctx.Log("message", "could not check if service is already installed. Proceeding to overwrite configuration file to make sure it gets installed.")
 			extensionEvents.LogErrorEvent("immediateenable", "could not check if service is already installed. Proceeding to overwrite configuration file to make sure it gets installed.")
 		}
 
 		if !isInstalled {
-			err3 := service.Register(ctx, extensionEvents)
+			err3 := fnServiceRegister(ctx, extensionEvents)
 			if err3 != nil {
 				errMessage := fmt.Sprintf("Failed to install RunCommand as a service: %v", err3)
 				extensionEvents.LogErrorEvent("immediateenable", errMessage)
 				return constants.Immediate_CouldNotStartService, err3
 			}
 		} else {
-			isEnabled, err3 := service.IsEnabled(ctx)
+			isEnabled, err3 := fnServiceIsEnabled(ctx)
 			if err3 != nil {
 				errMessage := fmt.Sprintf("Failed to check if service is already enabled: %v", err3)
 				extensionEvents.LogErrorEvent("immediateenable", errMessage)
 				return constants.Immediate_CouldNotCheckServiceAlreadyEnabled, vmextension.NewErrorWithClarification(constants.Immediate_CouldNotCheckServiceAlreadyEnabled, errors.Wrap(err3, errMessage))
 			}
 
 			if !isEnabled {
-				err4 := service.Enable(ctx, extensionEvents)
+				err4 := fnServiceEnable(ctx, extensionEvents)
 
 				if err4 != nil {
 					errMessage := fmt.Sprintf("Failed to enable service: %v", err4)
 					extensionEvents.LogErrorEvent("immediateenable", errMessage)
 					return constants.Immediate_EnableServiceFailed, vmextension.NewErrorWithClarification(constants.Immediate_EnableServiceFailed, errors.Wrap(err4, errMessage))
 				}
 
-				err5 := service.Start(ctx, extensionEvents)
+				err5 := fnServiceStart(ctx, extensionEvents)
 
 				if err5 != nil {
 					errMessage := fmt.Sprintf("Failed to start service: %v", err5)