chore: cmd unit tests

cmd/schedctl/list_test.go

@@ -0,0 +1,48 @@
+package cmd_test
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"schedctl/cmd/schedctl"
+)
+
+func TestNewListCmd(t *testing.T) {
+	listCmd := cmd.NewListCmd()
+
+	assert.NotNil(t, listCmd)
+	assert.Equal(t, "list", listCmd.Use)
+	assert.Equal(t, "list available schedulers", listCmd.Short)
+}
+
+func TestListCmdExecute(t *testing.T) {
+	listCmd := cmd.NewListCmd()
+
+	oldStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	os.Stdout = w
+
+	err := listCmd.Execute()
+	w.Close()
+	assert.NoError(t, err)
+
+	os.Stdout = oldStdout
+
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+
+	assert.NoError(t, err)
+	output := buf.String()
+	assert.NotEmpty(t, output, "List command should produce output")
+}
+
+func TestListCmdHasNoFlags(t *testing.T) {
+	listCmd := cmd.NewListCmd()
+
+	assert.False(t, listCmd.HasPersistentFlags(), "List command should not have persistent flags")
+	assert.False(t, listCmd.HasLocalFlags(), "List command should not have local flags")
+}

cmd/schedctl/ps_test.go

@@ -0,0 +1,62 @@
+package cmd_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"schedctl/cmd/schedctl"
+)
+
+func TestNewPsCmd(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	assert.NotNil(t, psCmd)
+	assert.Equal(t, "ps", psCmd.Use)
+	assert.Equal(t, "list running schedulers", psCmd.Short)
+}
+
+func TestPsCmdHasDriverFlag(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	driverFlag := psCmd.PersistentFlags().Lookup("driver")
+	assert.NotNil(t, driverFlag, "ps command should have 'driver' flag")
+	assert.Equal(t, "podman", driverFlag.DefValue, "driver flag should default to 'podman'")
+	assert.Equal(t, "d", driverFlag.Shorthand, "driver flag should have 'd' shorthand")
+}
+
+func TestPsCmdDriverFlagUsage(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	driverFlag := psCmd.PersistentFlags().Lookup("driver")
+	assert.Contains(t, driverFlag.Usage, "containerd", "driver flag usage should mention 'containerd'")
+	assert.Contains(t, driverFlag.Usage, "podman", "driver flag usage should mention 'podman'")
+}
+
+func TestPsCmdFlagShorthand(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	// Test that the short flag works
+	err := psCmd.ParseFlags([]string{"-d", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := psCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestPsCmdFlagLongForm(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	err := psCmd.ParseFlags([]string{"--driver", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := psCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestPsCmdDefaultDriverValue(t *testing.T) {
+	psCmd := cmd.NewPsCmd()
+
+	driverFlag := psCmd.PersistentFlags().Lookup("driver")
+	assert.Equal(t, "podman", driverFlag.Value.String(), "Default driver should be 'podman'")
+}

cmd/schedctl/root_test.go

@@ -0,0 +1,46 @@
+package cmd_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"schedctl/cmd/schedctl"
+)
+
+func TestNewRootCmd(t *testing.T) {
+	rootCmd := cmd.NewRootCmd()
+
+	assert.NotNil(t, rootCmd)
+	assert.Equal(t, "schedctl", rootCmd.Use)
+	assert.Equal(t, "Plug and play bpf schedulers for fun and profit", rootCmd.Short)
+	assert.Equal(t, "Plug and play bpf schedulers for fun and profit", rootCmd.Long)
+}
+
+func TestRootCmdHasSubcommands(t *testing.T) {
+	rootCmd := cmd.NewRootCmd()
+
+	expectedCommands := []string{"run", "ps", "stop", "list"}
+	actualCommands := make([]string, 0)
+
+	for _, command := range rootCmd.Commands() {
+		actualCommands = append(actualCommands, command.Use)
+	}
+
+	for _, expected := range expectedCommands {
+		assert.Contains(t, actualCommands, expected, "Root command should have %s subcommand", expected)
+	}
+}
+
+func TestRootCmdSubcommandCount(t *testing.T) {
+	rootCmd := cmd.NewRootCmd()
+
+	assert.Equal(t, 4, len(rootCmd.Commands()), "Root command should have exactly 4 subcommands")
+}
+
+func TestRootCmdExecuteWithoutArgs(t *testing.T) {
+	rootCmd := cmd.NewRootCmd()
+
+	err := rootCmd.Execute()
+	assert.NoError(t, err)
+}

cmd/schedctl/run_test.go

@@ -0,0 +1,118 @@
+package cmd_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"schedctl/cmd/schedctl"
+)
+
+func TestNewRunCmd(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	assert.NotNil(t, runCmd)
+	assert.Equal(t, "run", runCmd.Use)
+	assert.Equal(t, "Run a specific scheduler", runCmd.Short)
+}
+
+func TestRunCmdHasAttachFlag(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	attachFlag := runCmd.Flags().Lookup("attach")
+	assert.NotNil(t, attachFlag, "run command should have 'attach' flag")
+	assert.Equal(t, "false", attachFlag.DefValue, "attach flag should default to 'false'")
+	assert.Equal(t, "a", attachFlag.Shorthand, "attach flag should have 'a' shorthand")
+}
+
+func TestRunCmdHasDriverFlag(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	driverFlag := runCmd.PersistentFlags().Lookup("driver")
+	assert.NotNil(t, driverFlag, "run command should have 'driver' flag")
+	assert.Equal(t, "podman", driverFlag.DefValue, "driver flag should default to 'podman'")
+	assert.Equal(t, "d", driverFlag.Shorthand, "driver flag should have 'd' shorthand")
+}
+
+func TestRunCmdDriverFlagUsage(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	driverFlag := runCmd.PersistentFlags().Lookup("driver")
+	assert.Contains(t, driverFlag.Usage, "containerd", "driver flag usage should mention 'containerd'")
+	assert.Contains(t, driverFlag.Usage, "podman", "driver flag usage should mention 'podman'")
+}
+
+func TestRunCmdAttachFlagShorthand(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	err := runCmd.ParseFlags([]string{"-a"})
+	assert.NoError(t, err)
+
+	attachFlag := runCmd.Flags().Lookup("attach")
+	assert.Equal(t, "true", attachFlag.Value.String())
+}
+
+func TestRunCmdAttachFlagLongForm(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	err := runCmd.ParseFlags([]string{"--attach"})
+	assert.NoError(t, err)
+
+	attachFlag := runCmd.Flags().Lookup("attach")
+	assert.Equal(t, "true", attachFlag.Value.String())
+}
+
+func TestRunCmdDriverFlagShorthand(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	err := runCmd.ParseFlags([]string{"-d", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := runCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestRunCmdDriverFlagLongForm(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	// Test that the long flag works
+	err := runCmd.ParseFlags([]string{"--driver", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := runCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestRunCmdDefaultDriverValue(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	driverFlag := runCmd.PersistentFlags().Lookup("driver")
+	assert.Equal(t, "podman", driverFlag.Value.String(), "Default driver should be 'podman'")
+}
+
+func TestRunCmdDefaultAttachValue(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	attachFlag := runCmd.Flags().Lookup("attach")
+	assert.Equal(t, "false", attachFlag.Value.String(), "Default attach should be 'false'")
+}
+
+func TestRunCmdAcceptsArgs(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	err := runCmd.ParseFlags([]string{"scheduler-name"})
+	assert.NoError(t, err)
+}
+
+func TestRunCmdCombinedFlags(t *testing.T) {
+	runCmd := cmd.NewRunCmd()
+
+	err := runCmd.ParseFlags([]string{"-a", "-d", "containerd", "scheduler-name"})
+	assert.NoError(t, err)
+
+	attachFlag := runCmd.Flags().Lookup("attach")
+	driverFlag := runCmd.Flags().Lookup("driver")
+
+	assert.Equal(t, "true", attachFlag.Value.String())
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}

cmd/schedctl/stop_test.go

@@ -0,0 +1,72 @@
+package cmd_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"schedctl/cmd/schedctl"
+)
+
+func TestNewStopCmd(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	assert.NotNil(t, stopCmd)
+	assert.Equal(t, "stop", stopCmd.Use)
+	assert.Equal(t, "stop a scheduler", stopCmd.Short)
+}
+
+func TestStopCmdHasDriverFlag(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	driverFlag := stopCmd.PersistentFlags().Lookup("driver")
+	assert.NotNil(t, driverFlag, "stop command should have 'driver' flag")
+	assert.Equal(t, "podman", driverFlag.DefValue, "driver flag should default to 'podman'")
+	assert.Equal(t, "d", driverFlag.Shorthand, "driver flag should have 'd' shorthand")
+}
+
+func TestStopCmdDriverFlagUsage(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	driverFlag := stopCmd.PersistentFlags().Lookup("driver")
+	assert.Contains(t, driverFlag.Usage, "containerd", "driver flag usage should mention 'containerd'")
+	assert.Contains(t, driverFlag.Usage, "podman", "driver flag usage should mention 'podman'")
+}
+
+func TestStopCmdFlagShorthand(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	// Test that the short flag works
+	err := stopCmd.ParseFlags([]string{"-d", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := stopCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestStopCmdFlagLongForm(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	// Test that the long flag works
+	err := stopCmd.ParseFlags([]string{"--driver", "containerd"})
+	assert.NoError(t, err)
+
+	driverFlag := stopCmd.Flags().Lookup("driver")
+	assert.Equal(t, "containerd", driverFlag.Value.String())
+}
+
+func TestStopCmdDefaultDriverValue(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	driverFlag := stopCmd.PersistentFlags().Lookup("driver")
+	assert.Equal(t, "podman", driverFlag.Value.String(), "Default driver should be 'podman'")
+}
+
+func TestStopCmdAcceptsArgs(t *testing.T) {
+	stopCmd := cmd.NewStopCmd()
+
+	// The stop command should accept at least one argument (container ID)
+	// We're just testing that parsing doesn't fail with args
+	err := stopCmd.ParseFlags([]string{"container-id-123"})
+	assert.NoError(t, err)
+}