test: add mocking for windows service

Author: mlataza

internal/service/common.go internal/service/service.gointernal/service/common.go renamed to internal/service/service.go

@@ -1,30 +1,30 @@
-package service
-
-type AgentParams struct {
-	Name                string
-	AgentExecutablePath string
-	OrgId               string
-	ConfigFilePath      string
-	LogFilePath         string
-}
-
-type Service interface {
-	Start() error
-	Stop() error
-	Close() error
-	Delete() error
-	IsActive() bool
-}
-
-type ServiceExitCode int
-
-const (
-	GenericError ServiceExitCode = 1
-	ConfigError  ServiceExitCode = 2
-	LogFileError ServiceExitCode = 3
-)
-
-type Runner interface {
-	Name() string
-	Execute(stop <-chan struct{}, running chan<- struct{}) ServiceExitCode
-}
+package service
+
+type AgentParams struct {
+	Name                string
+	AgentExecutablePath string
+	OrgId               string
+	ConfigFilePath      string
+	LogFilePath         string
+}
+
+type Service interface {
+	Start() error
+	Stop() error
+	Close() error
+	Delete() error
+	IsActive() bool
+}
+
+type ServiceExitCode int
+
+const (
+	GenericError ServiceExitCode = 1
+	ConfigError  ServiceExitCode = 2
+	LogFileError ServiceExitCode = 3
+)
+
+type Runner interface {
+	Name() string
+	Execute(stop <-chan struct{}, running chan<- struct{}) ServiceExitCode
+}

internal/service/service_windows.go

@@ -14,7 +14,16 @@ import (
 const pollingInterval = 250 * time.Millisecond
 
 type windowsService struct {
-	handle *mgr.Service
+	handle windowsServiceHandle
+}
+
+// Replaces mgr.Service
+type windowsServiceHandle interface {
+	Close() error
+	Start(args ...string) error
+	Control(c svc.Cmd) (svc.Status, error)
+	Query() (svc.Status, error)
+	Delete() error
 }
 
 func (winSvc *windowsService) Close() error {
@@ -59,8 +68,25 @@ func (winSvc *windowsService) IsActive() bool {
 	return status.State == svc.Running
 }
 
-func Create(params AgentParams) (Service, error) {
-	svcMgr, err := mgr.Connect()
+// Substitute for mgr.Mgr
+type windowsServiceManager interface {
+	Disconnect() error
+	CreateService(name string, exepath string, c mgr.Config, args ...string) (*mgr.Service, error)
+	OpenService(name string) (*mgr.Service, error)
+}
+
+type windowsServiceManagerFactory interface {
+	Connect() (windowsServiceManager, error)
+}
+
+type defaultWindowsServiceManagerFactory struct{}
+
+func (f *defaultWindowsServiceManagerFactory) Connect() (windowsServiceManager, error) {
+	return mgr.Connect()
+}
+
+func createWithFactory(params AgentParams, factory windowsServiceManagerFactory) (Service, error) {
+	svcMgr, err := factory.Connect()
 	if err != nil {
 		return nil, err
 	}
@@ -80,8 +106,8 @@ func Create(params AgentParams) (Service, error) {
 	}, nil
 }
 
-func Open(name string) (Service, error) {
-	svcMgr, err := mgr.Connect()
+func openWithFactory(name string, factory windowsServiceManagerFactory) (Service, error) {
+	svcMgr, err := factory.Connect()
 	if err != nil {
 		return nil, err
 	}
@@ -97,6 +123,14 @@ func Open(name string) (Service, error) {
 	}, nil
 }
 
+func Create(params AgentParams) (Service, error) {
+	return createWithFactory(params, &defaultWindowsServiceManagerFactory{})
+}
+
+func Open(name string) (Service, error) {
+	return openWithFactory(name, &defaultWindowsServiceManagerFactory{})
+}
+
 type windowsRunner struct {
 	runner   Runner
 	exitCode int
@@ -106,7 +140,7 @@ func (host *windowsRunner) Execute(args []string, request <-chan svc.ChangeReque
 	response <- svc.Status{State: svc.StartPending}
 
 	// Make the channels
-	stop := make(chan struct{})
+	stop := make(chan struct{}, 1)
 	running := make(chan struct{})
 
 	// Make go routines for the channels
@@ -148,22 +182,41 @@ func (host *windowsRunner) Execute(args []string, request <-chan svc.ChangeReque
 	return host.exitCode == 0, uint32(host.exitCode)
 }
 
+type windowsServiceFactory interface {
+	IsWindowsService() (bool, error)
+	Run(name string, handler svc.Handler) error
+}
+
+type defaultWindowsServiceFactory struct{}
+
+func (f *defaultWindowsServiceFactory) IsWindowsService() (bool, error) {
+	return svc.IsWindowsService()
+}
+
+func (f *defaultWindowsServiceFactory) Run(name string, handler svc.Handler) error {
+	return svc.Run(name, handler)
+}
+
 func Run(runner Runner) (int, error) {
+	return runWithFactory(runner, &defaultWindowsServiceFactory{})
+}
+
+func runWithFactory(runner Runner, factory windowsServiceFactory) (int, error) {
 	// Check if this is running as a service
-	isWinSvc, err := svc.IsWindowsService()
+	isWinSvc, err := factory.IsWindowsService()
 	if err != nil {
-		return 1, err
+		return int(GenericError), err
 	}
 
 	if !isWinSvc {
-		return 1, fmt.Errorf("executable should be run as a service")
+		return int(GenericError), fmt.Errorf("executable should be run as a service")
 	}
 
 	// Start the windows service
 	host := &windowsRunner{
 		runner: runner,
 	}
-	err = svc.Run(runner.Name(), host)
+	err = factory.Run(runner.Name(), host)
 	if err != nil {
 		return host.exitCode, err
 	}