test: adding unit tests

Author: gnugomez

command/command_test.go

@@ -0,0 +1,9 @@
+package command
+
+import "testing"
+
+func TestDeployCommandExists(t *testing.T) {
+	if _, ok := Commands["deploy"]; !ok {
+		t.Fatal("Command 'deploy' should exist in Commands map")
+	}
+}

command/deploy.go

@@ -10,6 +10,14 @@ import (
 	"github.com/gnugomez/voyage/log"
 )
 
+type Syncer interface {
+	Sync(subDirs []string) ([]string, error)
+}
+
+type Deployer interface {
+	DeployCompose(targetPath string, daemonMode bool) error
+}
+
 // stringSlice implements flag.Value interface for handling multiple string values
 type stringSlice []string
 
@@ -32,7 +40,9 @@ type DeployCommandParameters struct {
 }
 
 type deployCommand struct {
-	params DeployCommandParameters
+	params   DeployCommandParameters
+	syncer   Syncer
+	deployer Deployer
 }
 
 func (d *deployCommand) GetBaseParameters() BaseParameters {
@@ -44,8 +54,6 @@ func (d *deployCommand) Handle() {
 		return
 	}
 
-	repository := git.CreateRepository(d.params.Repo, d.params.Branch, d.params.OutPath)
-
 	log.Debug("Running command with parameters", "repo", d.params.Repo, "branch", d.params.Branch, "remoteComposePaths", d.params.RemoteComposePaths, "out-path", d.params.OutPath)
 
 	// Create map of subdirectories to compose paths for change detection
@@ -66,9 +74,9 @@ func (d *deployCommand) Handle() {
 		subDirToComposePaths[subDir] = append(subDirToComposePaths[subDir], composePath)
 	}
 
-	updatedSubDirs, err := repository.Sync(subDirs)
+	updatedSubDirs, err := d.syncer.Sync(subDirs)
 	if err != nil {
-		log.Fatal("Error syncing repository", "error", err)
+		log.Error("Error syncing repository", "error", err)
 		return
 	}
 
@@ -91,9 +99,9 @@ func (d *deployCommand) Handle() {
 	// Deploy all collected compose files
 	for _, composePath := range composePathsToDeploy {
 		log.Info("Deploying compose file", "composePath", composePath)
-		err := docker.DeployCompose(filepath.Join(d.params.OutPath, composePath), true)
+		err := d.deployer.DeployCompose(filepath.Join(d.params.OutPath, composePath), true)
 		if err != nil {
-			log.Fatal("Error running docker-compose up", "error", err, "composePath", composePath)
+			log.Error("Error running docker-compose up", "error", err, "composePath", composePath)
 			return
 		}
 	}
@@ -104,6 +112,9 @@ func createDeployCommand() *Command {
 
 	d := &deployCommand{
 		params: params,
+		// Default implementations
+		syncer:   git.CreateRepository(params.Repo, params.Branch, params.OutPath),
+		deployer: docker.NewDeployer(),
 	}
 
 	return &Command{

command/deploy_test.go

@@ -0,0 +1,162 @@
+package command
+
+import (
+	"errors"
+	"testing"
+)
+
+// --- Mocks ---
+
+type mockSyncer struct {
+	SyncFunc func(subDirs []string) ([]string, error)
+}
+
+func (m *mockSyncer) Sync(subDirs []string) ([]string, error) {
+	if m.SyncFunc != nil {
+		return m.SyncFunc(subDirs)
+	}
+	return nil, nil
+}
+
+type mockDeployer struct {
+	DeployComposeFunc func(targetPath string, daemonMode bool) error
+}
+
+func (m *mockDeployer) DeployCompose(targetPath string, daemonMode bool) error {
+	if m.DeployComposeFunc != nil {
+		return m.DeployComposeFunc(targetPath, daemonMode)
+	}
+	return nil
+}
+
+func TestDeployCommand_Handle(t *testing.T) {
+	t.Run("Changes detected, should deploy", func(t *testing.T) {
+		syncer := &mockSyncer{}
+		deployer := &mockDeployer{}
+
+		dc := &deployCommand{
+			params: DeployCommandParameters{
+				Repo:               "repo",
+				Branch:             "main",
+				OutPath:            "/tmp",
+				RemoteComposePaths: []string{"app1/docker-compose.yml"},
+			},
+			syncer:   syncer,
+			deployer: deployer,
+		}
+
+		syncer.SyncFunc = func(subDirs []string) ([]string, error) {
+			return []string{"app1"}, nil
+		}
+
+		deployerCalled := false
+		deployer.DeployComposeFunc = func(targetPath string, daemonMode bool) error {
+			deployerCalled = true
+			return nil
+		}
+
+		dc.Handle()
+
+		if !deployerCalled {
+			t.Error("Deployer.DeployCompose should have been called, but it wasn't")
+		}
+	})
+
+	t.Run("No changes detected, should not deploy", func(t *testing.T) {
+		syncer := &mockSyncer{}
+		deployer := &mockDeployer{}
+
+		dc := &deployCommand{
+			params: DeployCommandParameters{
+				Repo:               "repo",
+				Branch:             "main",
+				OutPath:            "/tmp",
+				RemoteComposePaths: []string{"app1/docker-compose.yml"},
+				Force:              false, // Explicitly false
+			},
+			syncer:   syncer,
+			deployer: deployer,
+		}
+
+		syncer.SyncFunc = func(subDirs []string) ([]string, error) {
+			return []string{}, nil // No changes
+		}
+
+		deployerCalled := false
+		deployer.DeployComposeFunc = func(targetPath string, daemonMode bool) error {
+			deployerCalled = true
+			return nil
+		}
+
+		dc.Handle()
+
+		if deployerCalled {
+			t.Error("Deployer.DeployCompose should not have been called, but it was")
+		}
+	})
+
+	t.Run("No changes, but force flag is set, should deploy", func(t *testing.T) {
+		syncer := &mockSyncer{}
+		deployer := &mockDeployer{}
+
+		dc := &deployCommand{
+			params: DeployCommandParameters{
+				Repo:               "repo",
+				Branch:             "main",
+				OutPath:            "/tmp",
+				RemoteComposePaths: []string{"app1/docker-compose.yml"},
+				Force:              true, // Force is true
+			},
+			syncer:   syncer,
+			deployer: deployer,
+		}
+
+		syncer.SyncFunc = func(subDirs []string) ([]string, error) {
+			return []string{}, nil // No changes
+		}
+
+		deployerCalled := false
+		deployer.DeployComposeFunc = func(targetPath string, daemonMode bool) error {
+			deployerCalled = true
+			return nil
+		}
+
+		dc.Handle()
+
+		if !deployerCalled {
+			t.Error("Deployer.DeployCompose should have been called with force flag, but it wasn't")
+		}
+	})
+
+	t.Run("Sync fails, should not deploy", func(t *testing.T) {
+		syncer := &mockSyncer{}
+		deployer := &mockDeployer{}
+
+		dc := &deployCommand{
+			params: DeployCommandParameters{
+				Repo:               "repo",
+				Branch:             "main",
+				OutPath:            "/tmp",
+				RemoteComposePaths: []string{"app1/docker-compose.yml"},
+			},
+			syncer:   syncer,
+			deployer: deployer,
+		}
+
+		syncer.SyncFunc = func(subDirs []string) ([]string, error) {
+			return nil, errors.New("sync failed")
+		}
+
+		deployerCalled := false
+		deployer.DeployComposeFunc = func(targetPath string, daemonMode bool) error {
+			deployerCalled = true
+			return nil
+		}
+
+		dc.Handle()
+
+		if deployerCalled {
+			t.Error("Deployer.DeployCompose should not have been called when sync fails, but it was")
+		}
+	})
+}

docker/deploy.go

@@ -2,65 +2,59 @@ package docker
 
 import (
 	"fmt"
+	"io"
 	"os"
-	"os/exec"
 )
 
-func DeployCompose(targetPath string, daemonMode bool) error {
-	if err := checkForDockerEnv(); err != nil {
-		return err
-	}
-	if err := checkTargetPath(targetPath); err != nil {
-		return err
-	}
+// Deployer handles the logic for deploying a docker-compose application.
+type Deployer struct {
+	dockerService DockerService
+	fileExists    func(path string) bool
+	stdout        io.Writer
+	stderr        io.Writer
+}
 
-	args := []string{"compose", "-f", targetPath, "up"}
-	if daemonMode {
-		args = append(args, "-d")
+// NewDeployer creates a new Deployer with default dependencies.
+func NewDeployer() *Deployer {
+	return &Deployer{
+		dockerService: NewCliDockerService(),
+		fileExists:    osFileExists,
+		stdout:        os.Stdout,
+		stderr:        os.Stderr,
 	}
-	cmd := exec.Command("docker", args...)
+}
 
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
+// DeployCompose checks the environment and runs 'docker compose up'.
+func (d *Deployer) DeployCompose(targetPath string, daemonMode bool) error {
+	// Check docker availability
+	if err := d.isDockerAvailable(); err != nil {
+		return err
+	}
 
-	if err := cmd.Run(); err != nil {
-		return fmt.Errorf("failed to run docker compose: %w", err)
+	// Check target file
+	if !d.fileExists(targetPath) {
+		return fmt.Errorf("target path does not exist: %s", targetPath)
 	}
 
-	return nil
+	// Run compose
+	return d.dockerService.ComposeUp(targetPath, daemonMode, d.stdout, d.stderr)
 }
 
-func checkTargetPath(targetPath string) error {
-	if _, err := os.Stat(targetPath); os.IsNotExist(err) {
-		return fmt.Errorf("target path does not exist: %v", err)
+func (d *Deployer) isDockerAvailable() error {
+	daemonRunning, err := d.dockerService.IsDaemonRunning()
+	if err != nil || !daemonRunning {
+		return fmt.Errorf("docker daemon is not running: %w", err)
 	}
-	return nil
-}
 
-func checkForDockerEnv() error {
-	if sockRunning, err := isDockerSocketRunning(); !sockRunning && err != nil {
-		return fmt.Errorf("docker socket is not running: %v", err)
+	composeInstalled, err := d.dockerService.IsComposeInstalled()
+	if err != nil || !composeInstalled {
+		return fmt.Errorf("docker compose is not installed: %w", err)
 	}
-	if installed, err := isDockerComposeInstalled(); !installed && err != nil {
-		return fmt.Errorf("docker compose is not installed: %v", err)
-	}
-	return nil
-}
 
-func isDockerComposeInstalled() (bool, error) {
-	cmd := exec.Command("docker", "compose", "--version")
-	err := cmd.Run()
-	if err != nil {
-		return false, err
-	}
-	return true, nil
+	return nil
 }
 
-func isDockerSocketRunning() (bool, error) {
-	cmd := exec.Command("docker", "info")
-	err := cmd.Run()
-	if err != nil {
-		return false, err
-	}
-	return true, nil
+func osFileExists(path string) bool {
+	_, err := os.Stat(path)
+	return err == nil
 }