kdeps · jjuliano · Mar 11, 2025 · Mar 12, 2025 · May 27, 2025 · May 27, 2025
diff --git a/.gitignore b/.gitignore
@@ -221,4 +221,15 @@ pkg/**/**/*.txt
 pkg/**/**/*.yaml
 pkg/**/**/*.cover
 pkg/**/**/*.cov
+pkg/**/**/*.pkl
 *.cov
+*.pkl
+*.db
+*.backup
+*.html
+*.txt
+temp_end
+temp_main
+./kdeps
+kdeps
+pkg/resolver/test-requesttest-resource
diff --git a/.golangci.yml b/.golangci.yml
diff --git a/Makefile b/Makefile
@@ -33,22 +33,23 @@ test: test-coverage
 
 test-coverage:
 	@echo "$(OK_COLOR)==> Running the unit tests with coverage$(NO_COLOR)"
-	@NON_INTERACTIVE=1 go test -failfast -short -coverprofile=coverage_raw.out ./... | tee coverage.txt || true
-	@if [ -f coverage_raw.out ]; then \
-		{ head -n1 coverage_raw.out; grep -aE "^[[:alnum:]/._-]+\\.go:" coverage_raw.out; } > coverage.out; \
-		rm coverage_raw.out; \
-	fi
-	@echo "$(OK_COLOR)==> Coverage report:$(NO_COLOR)"
-	@go tool cover -func=coverage.out | tee coverage.txt || true
-	@COVERAGE=$$(grep total: coverage.txt | awk '{print $$3}' | sed 's/%//'); \
+	@TIMESTAMP=$$(date +%s); \
+	NON_INTERACTIVE=1 go test -failfast -short -coverprofile=coverage_raw_$$TIMESTAMP.out ./... | tee coverage_$$TIMESTAMP.txt || true; \
+	if [ -f coverage_raw_$$TIMESTAMP.out ]; then \
+		{ head -n1 coverage_raw_$$TIMESTAMP.out; grep -aE "^[[:alnum:]/._-]+\\.go:" coverage_raw_$$TIMESTAMP.out; } > coverage_$$TIMESTAMP.out; \
+		rm coverage_raw_$$TIMESTAMP.out; \
+	fi; \
+	echo "$(OK_COLOR)==> Coverage report:$(NO_COLOR)"; \
+	go tool cover -func=coverage_$$TIMESTAMP.out | tee coverage_$$TIMESTAMP.txt || true; \
+	COVERAGE=$$(grep total: coverage_$$TIMESTAMP.txt | awk '{print $$3}' | sed 's/%//'); \
 	REQUIRED=$${COVERAGE_THRESHOLD:-70.0}; \
 	if (( $$(echo $$COVERAGE '<' $$REQUIRED | bc -l) )); then \
 	    echo "Coverage $$COVERAGE% is below required $$REQUIRED%"; \
 	    exit 1; \
 	else \
 	    echo "Coverage requirement met: $$COVERAGE% (threshold $$REQUIRED%)"; \
-	fi
-	@rm coverage.txt
+	fi; \
+	rm coverage_$$TIMESTAMP.txt coverage_$$TIMESTAMP.out 2> /dev/null
 
 format: tools
 	@echo "$(OK_COLOR)>> [go vet] running$(NO_COLOR)" & \
@@ -79,10 +80,10 @@ tools:
 
 	@if ! command -v golangci-lint > /dev/null ; then \
 		echo ">> [$@]: golangci-lint not found: installing"; \
-		go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.63.2; \
+		go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest; \
 	fi
 
 tools-update:
 	go install github.com/daixiang0/gci@latest; \
 	go install mvdan.cc/gofumpt@latest; \
-	go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.63.2;
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest;
diff --git a/cleanup_test.go b/cleanup_test.go
diff --git a/cmd/add.go b/cmd/add.go
@@ -2,9 +2,7 @@ package cmd
 
 import (
 	"context"
-	"fmt"
 
-	"github.com/kdeps/kdeps/pkg/archiver"
 	"github.com/kdeps/kdeps/pkg/logging"
 	"github.com/spf13/afero"
 	"github.com/spf13/cobra"
@@ -21,11 +19,11 @@ func NewAddCommand(fs afero.Fs, ctx context.Context, kdepsDir string, logger *lo
 		RunE: func(cmd *cobra.Command, args []string) error {
 			pkgFile := args[0]
 			// Use the passed dependencies
-			_, err := archiver.ExtractPackage(fs, ctx, kdepsDir, pkgFile, logger)
+			_, err := ExtractPackageFn(fs, ctx, kdepsDir, pkgFile, logger)
 			if err != nil {
 				return err
 			}
-			fmt.Println("AI agent installed locally:", pkgFile)
+			PrintlnFn("AI agent installed locally:", pkgFile)
 			return nil
 		},
 	}

diff --git a/cmd/add_test.go b/cmd/add_test.go
@@ -1,10 +1,13 @@
-package cmd
+package cmd_test
 
 import (
 	"context"
+	"fmt"
 	"path/filepath"
 	"testing"
 
+	"github.com/kdeps/kdeps/cmd"
+	"github.com/kdeps/kdeps/pkg/archiver"
 	"github.com/kdeps/kdeps/pkg/logging"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/assert"
@@ -153,3 +156,128 @@ func TestNewAddCommandRunE(t *testing.T) {
 		t.Fatalf("expected error due to missing package file, got nil")
 	}
 }
+
+func TestNewAddCommand_Structure(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	ctx := context.Background()
+	kdepsDir := "/test/kdeps"
+	logger := logging.NewTestLogger()
+
+	cmd := NewAddCommand(fs, ctx, kdepsDir, logger)
+
+	if cmd.Use != "install [package]" {
+		t.Errorf("expected Use 'install [package]', got %q", cmd.Use)
+	}
+	if len(cmd.Aliases) != 1 || cmd.Aliases[0] != "i" {
+		t.Errorf("expected Aliases ['i'], got %v", cmd.Aliases)
+	}
+	if cmd.Short != "Install an AI agent locally" {
+		t.Errorf("expected Short 'Install an AI agent locally', got %q", cmd.Short)
+	}
+	if cmd.Example != "$ kdeps install ./myAgent.kdeps" {
+		t.Errorf("expected Example, got %q", cmd.Example)
+	}
+}
+
+func TestNewAddCommand_ArgsValidation(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	ctx := context.Background()
+	kdepsDir := "/test/kdeps"
+	logger := logging.NewTestLogger()
+
+	cmd := NewAddCommand(fs, ctx, kdepsDir, logger)
+
+	// No arguments should error
+	err := cmd.Args(cmd, []string{})
+	if err == nil {
+		t.Error("expected error when no arguments provided")
+	}
+
+	// One argument should pass
+	err = cmd.Args(cmd, []string{"test.kdeps"})
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+}
+
+func TestNewAddCommand_RunE_ErrorPath(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	ctx := context.Background()
+	kdepsDir := "/test/kdeps"
+	logger := logging.NewTestLogger()
+
+	cmd := NewAddCommand(fs, ctx, kdepsDir, logger)
+	cmd.SetArgs([]string{"nonexistent.kdeps"})
+	err := cmd.Execute()
+	if err == nil {
+		t.Error("expected error for nonexistent package file")
+	}
+}
+
+// TestNewAddCommand_Success tests the success path with mocked ExtractPackage
+func TestNewAddCommand_Success(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	ctx := context.Background()
+	kdepsDir := "/tmp/kdeps"
+	logger := logging.NewTestLogger()
+
+	// Store original function
+	originalExtractPackageFn := cmd.ExtractPackageFn
+
+	// Restore original function after test
+	defer func() {
+		cmd.ExtractPackageFn = originalExtractPackageFn
+	}()
+
+	// Mock ExtractPackage for success path
+	cmd.ExtractPackageFn = func(fs afero.Fs, ctx context.Context, kdepsDir, kdepsPackage string, logger *logging.Logger) (*archiver.KdepsPackage, error) {
+		return &archiver.KdepsPackage{Workflow: "test-workflow"}, nil
+	}
+
+	// Capture the printed message
+	originalPrintlnFn := cmd.PrintlnFn
+	defer func() {
+		cmd.PrintlnFn = originalPrintlnFn
+	}()
+
+	var printedMessage string
+	cmd.PrintlnFn = func(a ...interface{}) (n int, err error) {
+		printedMessage = fmt.Sprintln(a...)
+		return len(printedMessage), nil
+	}
+
+	// Test the success path
+	addCmd := cmd.NewAddCommand(fs, ctx, kdepsDir, logger)
+	err := addCmd.RunE(addCmd, []string{"test.kdeps"})
+
+	assert.NoError(t, err)
+	assert.Contains(t, printedMessage, "AI agent installed locally: test.kdeps")
+}
+
+// TestNewAddCommand_ExtractPackageError tests error handling when ExtractPackage fails
+func TestNewAddCommand_ExtractPackageError(t *testing.T) {
+	fs := afero.NewMemMapFs()
+	ctx := context.Background()
+	kdepsDir := "/tmp/kdeps"
+	logger := logging.NewTestLogger()
+
+	// Store original function
+	originalExtractPackageFn := cmd.ExtractPackageFn
+
+	// Restore original function after test
+	defer func() {
+		cmd.ExtractPackageFn = originalExtractPackageFn
+	}()
+
+	// Mock ExtractPackage for error path
+	cmd.ExtractPackageFn = func(fs afero.Fs, ctx context.Context, kdepsDir, kdepsPackage string, logger *logging.Logger) (*archiver.KdepsPackage, error) {
+		return nil, fmt.Errorf("extract package error")
+	}
+
+	// Test the error path
+	addCmd := cmd.NewAddCommand(fs, ctx, kdepsDir, logger)
+	err := addCmd.RunE(addCmd, []string{"test.kdeps"})
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "extract package error")
+}
diff --git a/cmd/build.go b/cmd/build.go
@@ -2,11 +2,7 @@ package cmd
 
 import (
 	"context"
-	"fmt"
 
-	"github.com/docker/docker/client"
-	"github.com/kdeps/kdeps/pkg/archiver"
-	"github.com/kdeps/kdeps/pkg/docker"
 	"github.com/kdeps/kdeps/pkg/logging"
 	"github.com/kdeps/schema/gen/kdeps"
 	"github.com/spf13/afero"
@@ -24,27 +20,27 @@ func NewBuildCommand(fs afero.Fs, ctx context.Context, kdepsDir string, systemCf
 		RunE: func(cmd *cobra.Command, args []string) error {
 			pkgFile := args[0]
 			// Use the passed dependencies
-			pkgProject, err := archiver.ExtractPackage(fs, ctx, kdepsDir, pkgFile, logger)
+			pkgProject, err := ExtractPackageFn(fs, ctx, kdepsDir, pkgFile, logger)
 			if err != nil {
 				return err
 			}
-			runDir, _, _, _, _, _, _, _, err := docker.BuildDockerfile(fs, ctx, systemCfg, kdepsDir, pkgProject, logger)
+			runDir, _, _, _, _, _, _, _, err := BuildDockerfileFn(fs, ctx, systemCfg, kdepsDir, pkgProject, logger)
 			if err != nil {
 				return err
 			}
-			dockerClient, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+			dockerClient, err := NewDockerClientFn()
 			if err != nil {
 				return err
 			}
-			agentContainerName, agentContainerNameAndVersion, err := docker.BuildDockerImage(fs, ctx, systemCfg, dockerClient, runDir, kdepsDir, pkgProject, logger)
+			agentContainerName, agentContainerNameAndVersion, err := BuildDockerImageFn(fs, ctx, systemCfg, dockerClient, runDir, kdepsDir, pkgProject, logger)
 			if err != nil {
 				return err
 			}
 
-			if err := docker.CleanupDockerBuildImages(fs, ctx, agentContainerName, dockerClient); err != nil {
+			if err := CleanupDockerBuildImagesFn(fs, ctx, agentContainerName, dockerClient); err != nil {
 				return err
 			}
-			fmt.Println("Kdeps AI Agent docker image created:", agentContainerNameAndVersion)
+			PrintlnFn("Kdeps AI Agent docker image created:", agentContainerNameAndVersion)
 			return nil
 		},
 	}