tests: achieve 78.3% coverage

Signed-off-by: Manik Rana <manikrana54@gmail.com>

go/vt/hook/hook_test.go

@@ -2,9 +2,11 @@ package hook
 
 import (
 	"context"
+	"io"
 	"os"
 	"os/exec"
 	"path"
+	"strings"
 	"testing"
 	"time"
 
@@ -22,6 +24,11 @@ func TestExecuteContext(t *testing.T) {
 	require.NoError(t, err)
 
 	sleepHookPath := path.Join(vtroot, "vthook", "sleep")
+
+	if _, err := os.Lstat(sleepHookPath); err == nil {
+		require.NoError(t, os.Remove(sleepHookPath))
+	}
+
 	require.NoError(t, os.Symlink(sleep, sleepHookPath))
 	defer func() {
 		require.NoError(t, os.Remove(sleepHookPath))
@@ -39,6 +46,75 @@ func TestExecuteContext(t *testing.T) {
 	assert.Equal(t, HOOK_SUCCESS, hr.ExitStatus)
 }
 
+func TestExecuteOptional(t *testing.T) {
+	vtroot, err := vtenv.VtRoot()
+	require.NoError(t, err)
+
+	sleep, err := exec.LookPath("sleep")
+	require.NoError(t, err)
+
+	sleepHookPath := path.Join(vtroot, "vthook", "sleep")
+
+	if _, err := os.Lstat(sleepHookPath); err == nil {
+		require.NoError(t, os.Remove(sleepHookPath))
+	}
+
+	require.NoError(t, os.Symlink(sleep, sleepHookPath))
+	defer func() {
+		require.NoError(t, os.Remove(sleepHookPath))
+	}()
+	tt := []struct {
+		name          string
+		hookName      string
+		parameters    []string
+		expectedError string
+	}{
+		{
+			name:       "HookSuccess",
+			hookName:   "echo",
+			parameters: []string{"test"},
+		},
+		{
+			name:          "HookDoesNotExist",
+			hookName:      "nonexistent-hook",
+			parameters:    []string{"test"},
+			expectedError: "",
+		},
+	}
+
+	for _, tc := range tt {
+		t.Run(tc.name, func(t *testing.T) {
+			h := NewHook(tc.hookName, tc.parameters)
+			err := h.ExecuteOptional()
+			if tc.expectedError == "" {
+				assert.NoError(t, err)
+			} else {
+				assert.Error(t, err)
+				assert.Contains(t, err.Error(), tc.expectedError)
+			}
+		})
+	}
+}
+
+func TestNewHook(t *testing.T) {
+	h := NewHook("test-hook", []string{"arg1", "arg2"})
+	assert.Equal(t, "test-hook", h.Name)
+	assert.Equal(t, []string{"arg1", "arg2"}, h.Parameters)
+}
+
+func TestNewSimpleHook(t *testing.T) {
+	h := NewSimpleHook("simple-hook")
+	assert.Equal(t, "simple-hook", h.Name)
+	assert.Empty(t, h.Parameters)
+}
+
+func TestNewHookWithEnv(t *testing.T) {
+	h := NewHookWithEnv("env-hook", []string{"arg1", "arg2"}, map[string]string{"KEY": "VALUE"})
+	assert.Equal(t, "env-hook", h.Name)
+	assert.Equal(t, []string{"arg1", "arg2"}, h.Parameters)
+	assert.Equal(t, map[string]string{"KEY": "VALUE"}, h.ExtraEnv)
+}
+
 func TestString(t *testing.T) {
 	tt := []struct {
 		name     string
@@ -104,3 +180,88 @@ func TestString(t *testing.T) {
 		})
 	}
 }
+
+func TestExecuteAsReadPipe(t *testing.T) {
+	vtroot, err := vtenv.VtRoot()
+	require.NoError(t, err)
+
+	cat, err := exec.LookPath("cat")
+	require.NoError(t, err)
+
+	catHookPath := path.Join(vtroot, "vthook", "cat")
+
+	if _, err := os.Lstat(catHookPath); err == nil {
+		require.NoError(t, os.Remove(catHookPath))
+	}
+
+	require.NoError(t, os.Symlink(cat, catHookPath))
+	defer func() {
+		require.NoError(t, os.Remove(catHookPath))
+	}()
+
+	h := NewHook("cat", nil)
+	reader, waitFunc, status, err := h.ExecuteAsReadPipe(strings.NewReader("Hello, World!\n"))
+	require.NoError(t, err)
+	defer reader.(io.Closer).Close()
+
+	output, err := io.ReadAll(reader)
+	require.NoError(t, err)
+	assert.Equal(t, "Hello, World!\n", string(output))
+
+	stderr, waitErr := waitFunc()
+	assert.Empty(t, stderr)
+	assert.NoError(t, waitErr)
+	assert.Equal(t, HOOK_SUCCESS, status)
+}
+
+func TestExecuteAsReadPipeErrorFindingHook(t *testing.T) {
+	h := NewHook("nonexistent-hook", nil)
+	reader, waitFunc, status, err := h.ExecuteAsReadPipe(strings.NewReader("Hello, World!\n"))
+	require.Error(t, err)
+	assert.Nil(t, reader)
+	assert.Nil(t, waitFunc)
+	assert.Equal(t, HOOK_DOES_NOT_EXIST, status)
+}
+
+func TestExecuteAsWritePipe(t *testing.T) {
+	vtroot, err := vtenv.VtRoot()
+	require.NoError(t, err)
+
+	echo, err := exec.LookPath("echo")
+	require.NoError(t, err)
+
+	echoHookPath := path.Join(vtroot, "vthook", "echo")
+
+	if _, err := os.Lstat(echoHookPath); err == nil {
+		require.NoError(t, os.Remove(echoHookPath))
+	}
+
+	require.NoError(t, os.Symlink(echo, echoHookPath))
+	defer func() {
+		require.NoError(t, os.Remove(echoHookPath))
+	}()
+
+	h := NewHook("echo", nil)
+	var writer strings.Builder
+	writerPtr := &writer
+	_, waitFunc, status, err := h.ExecuteAsWritePipe(writerPtr)
+	require.NoError(t, err)
+	defer writerPtr.Reset()
+
+	_, err = writer.Write([]byte("Hello, World!\n"))
+	require.NoError(t, err)
+
+	stderr, waitErr := waitFunc()
+	assert.Empty(t, stderr)
+	assert.NoError(t, waitErr)
+	assert.Equal(t, HOOK_SUCCESS, status)
+}
+
+func TestExecuteAsWritePipeErrorFindingHook(t *testing.T) {
+	h := NewHook("nonexistent-hook", nil)
+	var writer strings.Builder
+	writerPtr := &writer
+	_, _, status, err := h.ExecuteAsWritePipe(writerPtr)
+	assert.Error(t, err)
+	assert.Equal(t, HOOK_DOES_NOT_EXIST, status)
+}