feat: add test infrastructure with Makefile, helpers, and integration test setup

Signed-off-by: jbrinkman <joe.brinkman@improving.com>

Author: jbrinkman

README.md

@@ -43,6 +43,7 @@ valkey-ai-tasks/
 - Go 1.24 or later
 - Valkey server
 - Docker and Docker Compose (for containerized deployment)
+- GNU Make (for running Makefile commands)
 
 ### Installation
 
@@ -65,6 +66,46 @@ valkey-ai-tasks/
    go run cmd/mcpserver/main.go
    ```
 
+### Running Tests
+
+The project includes a Makefile in the `go` directory with targets for running tests:
+
+1. Run all tests:
+   ```bash
+   cd go
+   make test
+   ```
+
+2. Run integration tests only:
+   ```bash
+   cd go
+   make integ-test
+   ```
+
+3. Run tests with a filter:
+   ```bash
+   cd go
+   make test filter=TestName
+   ```
+
+4. Run tests with verbose output:
+   ```bash
+   cd go
+   make test verbose=1
+   ```
+
+5. Generate test coverage report:
+   ```bash
+   cd go
+   make coverage
+   ```
+
+6. View all available Makefile targets:
+   ```bash
+   cd go
+   make help
+   ```
+
 #### Docker Deployment
 
 1. Clone the repository:

go/Makefile

@@ -0,0 +1,90 @@
+# Makefile for valkey-ai-tasks project
+
+# Go parameters
+GOCMD=go
+GOBUILD=$(GOCMD) build
+GOTEST=$(GOCMD) test
+GOGET=$(GOCMD) get
+GOMOD=$(GOCMD) mod
+GOFMT=$(GOCMD) fmt
+
+# Project directories
+TEST_DIR=./tests
+INTEG_TEST_DIR=$(TEST_DIR)/integration
+
+# Test parameters
+COVERAGE_DIR=./coverage
+COVERAGE_FILE=$(COVERAGE_DIR)/coverage.out
+COVERAGE_HTML=$(COVERAGE_DIR)/coverage.html
+
+# Default filter is empty (run all tests)
+filter?=.
+
+# Default verbosity is off
+verbose?=
+
+# Set verbosity flag if verbose is set
+ifdef verbose
+	VERBOSE_FLAG=-v
+else
+	VERBOSE_FLAG=
+endif
+
+.PHONY: all build test integ-test clean fmt tidy coverage
+
+# Default target
+all: build test
+
+# Build the application
+build:
+	@echo "Building application..."
+	@$(GOBUILD) ./...
+
+# Run all tests
+test:
+	@echo "Running all tests..."
+	@$(GOTEST) $(VERBOSE_FLAG) ./... -run $(filter)
+
+# Run only integration tests
+integ-test:
+	@echo "Running integration tests..."
+	@$(GOTEST) $(VERBOSE_FLAG) ./tests/integration/... -run $(filter)
+
+# Run tests with coverage
+coverage:
+	@echo "Running tests with coverage..."
+	@mkdir -p $(COVERAGE_DIR)
+	@$(GOTEST) -coverprofile=$(COVERAGE_FILE) ./...
+	@$(GOCMD) tool cover -html=$(COVERAGE_FILE) -o $(COVERAGE_HTML)
+	@echo "Coverage report generated at $(COVERAGE_HTML)"
+
+# Format code
+fmt:
+	@echo "Formatting code..."
+	@$(GOFMT) ./...
+
+# Update dependencies
+tidy:
+	@echo "Updating dependencies..."
+	@$(GOMOD) tidy
+
+# Clean build artifacts
+clean:
+	@echo "Cleaning build artifacts..."
+	@rm -rf $(COVERAGE_DIR)
+	@find . -type f -name "*.test" -delete
+
+# Help target
+help:
+	@echo "Available targets:"
+	@echo "  all         : Build and run tests"
+	@echo "  build       : Build the application"
+	@echo "  test        : Run all tests"
+	@echo "                 Usage: make test [filter=TestName] [verbose=1]"
+	@echo "  integ-test  : Run integration tests only"
+	@echo "                 Usage: make integ-test [filter=TestName] [verbose=1]"
+	@echo "  coverage    : Generate test coverage report"
+	@echo "  fmt         : Format code"
+	@echo "  tidy        : Update dependencies"
+	@echo "  clean       : Clean build artifacts"
+	@echo "  help        : Show this help message"

go/go.mod

@@ -7,11 +7,15 @@ toolchain go1.24.2
 require (
 	github.com/google/uuid v1.6.0
 	github.com/mark3labs/mcp-go v0.32.0
+	github.com/stretchr/testify v1.10.0
 	github.com/valkey-io/valkey-glide/go/v2 v2.0.0-rc6
 )
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/spf13/cast v1.7.1 // indirect
 	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
 	google.golang.org/protobuf v1.33.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go/go.sum

@@ -18,13 +18,16 @@ github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU
 github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
 github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/valkey-io/valkey-glide/go/v2 v2.0.0-rc6 h1:kUUNaXrrEiMD5oLq97Dt+XHwOADpl5qjaQ5yznA4Q8k=
 github.com/valkey-io/valkey-glide/go/v2 v2.0.0-rc6/go.mod h1:LK5zmODJa5xnxZndarh1trntExb3GVGJXz4GwDCagho=
 github.com/yosida95/uritemplate/v3 v3.0.2 h1:Ed3Oyj9yrmi9087+NczuL5BwkIc4wvTb5zIM+UJPGz4=
 github.com/yosida95/uritemplate/v3 v3.0.2/go.mod h1:ILOh0sOhIJR3+L/8afwt/kE++YT040gmv5BQTMR2HP4=
 google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
 google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

go/tests/README.md

@@ -0,0 +1,67 @@
+# Testing Directory Structure
+
+This directory contains the testing infrastructure for the valkey-ai-tasks project.
+
+## Directory Structure
+
+- `integration/`: Contains integration tests that verify the interaction between different components of the system
+- `mocks/`: Contains mock implementations of interfaces used in testing
+- `utils/`: Contains utility functions and helpers for testing
+
+## Dependencies
+
+This project uses the following testing libraries:
+
+- [Testify](https://github.com/stretchr/testify): A toolkit with common assertions and mocks that is compatible with the standard library
+
+## Running Tests
+
+To run all tests:
+
+```bash
+cd /path/to/valkey-ai-tasks/go
+go test ./tests/...
+```
+
+To run specific test categories:
+
+```bash
+# Run integration tests only
+go test ./tests/integration/...
+
+# Run a specific test file
+go test ./tests/integration/specific_test.go
+```
+
+To run tests with verbose output:
+
+```bash
+go test -v ./tests/...
+```
+
+## Writing Tests
+
+When adding new tests:
+
+1. Place integration tests in the appropriate subdirectory under `integration/`
+2. Add mock implementations to the `mocks/` directory
+3. Use Testify's assertion and mock packages for testing
+4. Use utility functions from `utils/` for common testing operations
+5. Follow Go testing best practices and naming conventions
+
+### Example Test
+
+```go
+func TestSomething(t *testing.T) {
+    // Use the test utilities
+    ctx, req, cancel := utils.SetupTest(t)
+    defer utils.CleanupTest(t, cancel)
+    
+    // Your test code here
+    result := SomeFunction()
+    
+    // Use testify assertions
+    req.Equal(expected, result)
+    req.NoError(err)
+}
+```

go/tests/integration/example_test.go

@@ -0,0 +1,19 @@
+package integration_test
+
+import (
+	"testing"
+
+	"github.com/jbrinkman/valkey-ai-tasks/go/tests/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestExample is a simple example integration test
+func TestExample(t *testing.T) {
+	// Use the test utilities
+	ctx, req, cancel := utils.SetupTest(t)
+	defer utils.CleanupTest(t, cancel)
+
+	// This is just a placeholder test to verify the integration test structure
+	assert.NotNil(t, ctx)
+	req.True(true, "This test should always pass")
+}

go/tests/utils/test_helpers.go

@@ -0,0 +1,38 @@
+// Package utils provides testing utilities for the valkey-ai-tasks project
+package utils
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestContext returns a context with timeout for use in tests
+func TestContext(t *testing.T) (context.Context, context.CancelFunc) {
+	t.Helper()
+	return context.WithTimeout(context.Background(), 5*time.Second)
+}
+
+// RequireTestify returns a testify require instance for cleaner assertions
+// This is just a convenience function to make test code more readable
+func RequireTestify(t *testing.T) *require.Assertions {
+	t.Helper()
+	return require.New(t)
+}
+
+// SetupTest is a helper function to set up common test requirements
+// It returns a context with timeout and a testify require instance
+func SetupTest(t *testing.T) (context.Context, *require.Assertions, context.CancelFunc) {
+	t.Helper()
+	ctx, cancel := TestContext(t)
+	req := RequireTestify(t)
+	return ctx, req, cancel
+}
+
+// CleanupTest is a helper function to clean up after tests
+func CleanupTest(t *testing.T, cancel context.CancelFunc) {
+	t.Helper()
+	cancel()
+}

go/tests/utils/test_helpers_test.go

@@ -0,0 +1,38 @@
+package utils_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/jbrinkman/valkey-ai-tasks/go/tests/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTestContext(t *testing.T) {
+	ctx, cancel := utils.TestContext(t)
+	defer cancel()
+
+	// Verify that the context has a deadline
+	deadline, hasDeadline := ctx.Deadline()
+	assert.True(t, hasDeadline)
+	assert.WithinDuration(t, time.Now().Add(5*time.Second), deadline, 100*time.Millisecond)
+}
+
+func TestRequireTestify(t *testing.T) {
+	req := utils.RequireTestify(t)
+	
+	// Simple test to verify the require instance works
+	req.True(true, "This should pass")
+}
+
+func TestSetupTest(t *testing.T) {
+	ctx, req, cancel := utils.SetupTest(t)
+	defer utils.CleanupTest(t, cancel)
+
+	// Verify that the context has a deadline
+	_, hasDeadline := ctx.Deadline()
+	assert.True(t, hasDeadline)
+	
+	// Verify that the require instance works
+	req.NotNil(ctx, "Context should not be nil")
+}