2e6a0f4ef3
* chore(io): Migrate pkg/cli to Medium abstraction - Update `PIDFile` struct to include `io.Medium` field. - Update `NewPIDFile` signature to accept `io.Medium`. - Update `PIDFile` methods to use injected medium instead of `io.Local`. - Add `Medium` field to `DaemonOptions`. - Update `NewDaemon` to default to `io.Local` if no medium is provided. - Update `pkg/cli/daemon_test.go` to reflect changes and add mock medium tests. * chore(io): Migrate pkg/cli to Medium abstraction - Update `PIDFile` struct to include `io.Medium` field. - Update `NewPIDFile` signature to accept `io.Medium`. - Update `PIDFile` methods to use injected medium instead of `io.Local`. - Add `Medium` field to `DaemonOptions`. - Update `NewDaemon` to default to `io.Local` if no medium is provided. - Update `pkg/cli/daemon_test.go` to reflect changes and add mock medium tests. - Fix flaky test `TestLinuxKitManager_Stop_Good_ContextCancelled` by checking context at the start of `Stop`. - Add fail-fast context checks to all `LinuxKitManager` methods taking a context.
293 lines
6.7 KiB
Go
293 lines
6.7 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/host-uk/core/pkg/io"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestDetectMode(t *testing.T) {
|
|
t.Run("daemon mode from env", func(t *testing.T) {
|
|
t.Setenv("CORE_DAEMON", "1")
|
|
assert.Equal(t, ModeDaemon, DetectMode())
|
|
})
|
|
|
|
t.Run("mode string", func(t *testing.T) {
|
|
assert.Equal(t, "interactive", ModeInteractive.String())
|
|
assert.Equal(t, "pipe", ModePipe.String())
|
|
assert.Equal(t, "daemon", ModeDaemon.String())
|
|
assert.Equal(t, "unknown", Mode(99).String())
|
|
})
|
|
}
|
|
|
|
func TestPIDFile(t *testing.T) {
|
|
t.Run("acquire and release", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
pidPath := filepath.Join(tmpDir, "test.pid")
|
|
|
|
pid := NewPIDFile(io.Local, pidPath)
|
|
|
|
// Acquire should succeed
|
|
err := pid.Acquire()
|
|
require.NoError(t, err)
|
|
|
|
// File should exist with our PID
|
|
data, err := os.ReadFile(pidPath)
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(data), "")
|
|
|
|
// Release should remove file
|
|
err = pid.Release()
|
|
require.NoError(t, err)
|
|
|
|
_, err = os.Stat(pidPath)
|
|
assert.True(t, os.IsNotExist(err))
|
|
})
|
|
|
|
t.Run("stale pid file", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
pidPath := filepath.Join(tmpDir, "stale.pid")
|
|
|
|
// Write a stale PID (non-existent process)
|
|
err := os.WriteFile(pidPath, []byte("999999999"), 0644)
|
|
require.NoError(t, err)
|
|
|
|
pid := NewPIDFile(io.Local, pidPath)
|
|
|
|
// Should acquire successfully (stale PID removed)
|
|
err = pid.Acquire()
|
|
require.NoError(t, err)
|
|
|
|
err = pid.Release()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("creates parent directory", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
pidPath := filepath.Join(tmpDir, "subdir", "nested", "test.pid")
|
|
|
|
pid := NewPIDFile(io.Local, pidPath)
|
|
|
|
err := pid.Acquire()
|
|
require.NoError(t, err)
|
|
|
|
_, err = os.Stat(pidPath)
|
|
require.NoError(t, err)
|
|
|
|
err = pid.Release()
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("path getter", func(t *testing.T) {
|
|
pid := NewPIDFile(io.Local, "/tmp/test.pid")
|
|
assert.Equal(t, "/tmp/test.pid", pid.Path())
|
|
})
|
|
|
|
t.Run("with mock medium", func(t *testing.T) {
|
|
mock := io.NewMockMedium()
|
|
pidPath := "/tmp/mock.pid"
|
|
pid := NewPIDFile(mock, pidPath)
|
|
|
|
err := pid.Acquire()
|
|
require.NoError(t, err)
|
|
|
|
assert.True(t, mock.Exists(pidPath))
|
|
data, _ := mock.Read(pidPath)
|
|
assert.NotEmpty(t, data)
|
|
|
|
err = pid.Release()
|
|
require.NoError(t, err)
|
|
assert.False(t, mock.Exists(pidPath))
|
|
})
|
|
}
|
|
|
|
func TestHealthServer(t *testing.T) {
|
|
t.Run("health and ready endpoints", func(t *testing.T) {
|
|
hs := NewHealthServer("127.0.0.1:0") // Random port
|
|
|
|
err := hs.Start()
|
|
require.NoError(t, err)
|
|
defer func() { _ = hs.Stop(context.Background()) }()
|
|
|
|
addr := hs.Addr()
|
|
require.NotEmpty(t, addr)
|
|
|
|
// Health should be OK
|
|
resp, err := http.Get("http://" + addr + "/health")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
|
|
// Ready should be OK by default
|
|
resp, err = http.Get("http://" + addr + "/ready")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
|
|
// Set not ready
|
|
hs.SetReady(false)
|
|
|
|
resp, err = http.Get("http://" + addr + "/ready")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
})
|
|
|
|
t.Run("with health checks", func(t *testing.T) {
|
|
hs := NewHealthServer("127.0.0.1:0")
|
|
|
|
healthy := true
|
|
hs.AddCheck(func() error {
|
|
if !healthy {
|
|
return assert.AnError
|
|
}
|
|
return nil
|
|
})
|
|
|
|
err := hs.Start()
|
|
require.NoError(t, err)
|
|
defer func() { _ = hs.Stop(context.Background()) }()
|
|
|
|
addr := hs.Addr()
|
|
|
|
// Should be healthy
|
|
resp, err := http.Get("http://" + addr + "/health")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
|
|
// Make unhealthy
|
|
healthy = false
|
|
|
|
resp, err = http.Get("http://" + addr + "/health")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
})
|
|
}
|
|
|
|
func TestDaemon(t *testing.T) {
|
|
t.Run("start and stop", func(t *testing.T) {
|
|
tmpDir := t.TempDir()
|
|
|
|
d := NewDaemon(DaemonOptions{
|
|
PIDFile: filepath.Join(tmpDir, "test.pid"),
|
|
HealthAddr: "127.0.0.1:0",
|
|
ShutdownTimeout: 5 * time.Second,
|
|
})
|
|
|
|
err := d.Start()
|
|
require.NoError(t, err)
|
|
|
|
// Health server should be running
|
|
addr := d.HealthAddr()
|
|
require.NotEmpty(t, addr)
|
|
|
|
resp, err := http.Get("http://" + addr + "/health")
|
|
require.NoError(t, err)
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
|
|
// Stop should succeed
|
|
err = d.Stop()
|
|
require.NoError(t, err)
|
|
|
|
// PID file should be removed
|
|
_, err = os.Stat(filepath.Join(tmpDir, "test.pid"))
|
|
assert.True(t, os.IsNotExist(err))
|
|
})
|
|
|
|
t.Run("double start fails", func(t *testing.T) {
|
|
d := NewDaemon(DaemonOptions{
|
|
HealthAddr: "127.0.0.1:0",
|
|
})
|
|
|
|
err := d.Start()
|
|
require.NoError(t, err)
|
|
defer func() { _ = d.Stop() }()
|
|
|
|
err = d.Start()
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "already running")
|
|
})
|
|
|
|
t.Run("run without start fails", func(t *testing.T) {
|
|
d := NewDaemon(DaemonOptions{})
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
|
|
err := d.Run(ctx)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "not started")
|
|
})
|
|
|
|
t.Run("set ready", func(t *testing.T) {
|
|
d := NewDaemon(DaemonOptions{
|
|
HealthAddr: "127.0.0.1:0",
|
|
})
|
|
|
|
err := d.Start()
|
|
require.NoError(t, err)
|
|
defer func() { _ = d.Stop() }()
|
|
|
|
addr := d.HealthAddr()
|
|
|
|
// Initially ready
|
|
resp, _ := http.Get("http://" + addr + "/ready")
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
|
|
// Set not ready
|
|
d.SetReady(false)
|
|
|
|
resp, _ = http.Get("http://" + addr + "/ready")
|
|
assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
|
|
_ = resp.Body.Close()
|
|
})
|
|
|
|
t.Run("no health addr returns empty", func(t *testing.T) {
|
|
d := NewDaemon(DaemonOptions{})
|
|
assert.Empty(t, d.HealthAddr())
|
|
})
|
|
|
|
t.Run("default shutdown timeout", func(t *testing.T) {
|
|
d := NewDaemon(DaemonOptions{})
|
|
assert.Equal(t, 30*time.Second, d.opts.ShutdownTimeout)
|
|
})
|
|
|
|
t.Run("with mock medium", func(t *testing.T) {
|
|
mock := io.NewMockMedium()
|
|
pidPath := "/tmp/daemon.pid"
|
|
|
|
d := NewDaemon(DaemonOptions{
|
|
Medium: mock,
|
|
PIDFile: pidPath,
|
|
HealthAddr: "127.0.0.1:0",
|
|
})
|
|
|
|
err := d.Start()
|
|
require.NoError(t, err)
|
|
|
|
assert.True(t, mock.Exists(pidPath))
|
|
|
|
err = d.Stop()
|
|
require.NoError(t, err)
|
|
assert.False(t, mock.Exists(pidPath))
|
|
})
|
|
}
|
|
|
|
func TestRunWithTimeout(t *testing.T) {
|
|
t.Run("creates shutdown function", func(t *testing.T) {
|
|
// Just test that it returns a function
|
|
shutdown := RunWithTimeout(100 * time.Millisecond)
|
|
assert.NotNil(t, shutdown)
|
|
})
|
|
}
|