PLM-186. Add unit tests for CLI

Author: sandraromanchenko

main_test.go

@@ -0,0 +1,285 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"reflect"
+	"strconv"
+	"testing"
+
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
+)
+
+type testHelper struct {
+	t        *testing.T
+	server   *httptest.Server
+	oldStdout *os.File
+	stdoutW   *os.File
+}
+
+func extractPort(serverURL string) int {
+	u, err := url.Parse(serverURL)
+	if err != nil {
+		return 0
+	}
+	port, _ := strconv.Atoi(u.Port())
+	return port
+}
+
+// newTestHelper creates a new test helper with stdout redirection
+func newTestHelper(t *testing.T) *testHelper {
+	oldStdout := os.Stdout
+	_, w, _ := os.Pipe()
+	os.Stdout = w
+
+	return &testHelper{
+		t:         t,
+		oldStdout: oldStdout,
+		stdoutW:   w,
+	}
+}
+
+// cleanup restores stdout and closes the test server
+func (h *testHelper) cleanup() {
+	os.Stdout = h.oldStdout
+	if h.server != nil {
+		h.server.Close()
+	}
+}
+
+// setupCommand prepares a command for testing with the test server port
+func (h *testHelper) setupCommand(cmd *cobra.Command) func() {
+	originalRunE := cmd.RunE
+	cmd.RunE = func(c *cobra.Command, args []string) error {
+		port := extractPort(h.server.URL)
+		c.Flags().Set("port", fmt.Sprintf("%d", port))
+		return originalRunE(c, args)
+	}
+	return func() { cmd.RunE = originalRunE }
+}
+
+func TestStartCmd(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "start",
+		RunE: startCmd.RunE,
+	}
+
+	testCmd.Flags().Int("port", 3000, "Port number")
+	testCmd.Flags().StringSlice("include-namespaces", nil,
+		"Namespaces to include in the replication (e.g. db1.collection1,db2.collection2)")
+	testCmd.Flags().StringSlice("exclude-namespaces", nil,
+		"Namespaces to exclude from the replication (e.g. db3.collection3,db4.*)")
+
+	h := newTestHelper(t)
+	defer h.cleanup()
+
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/start" {
+			var startReq startRequest
+			if r.ContentLength > 0 {
+				data := make([]byte, r.ContentLength)
+				r.Body.Read(data)
+				json.Unmarshal(data, &startReq)
+			}
+			expectedInclude := []string{"db1.collection1"}
+			expectedExclude := []string{"db3.collection3", "db4.*"}
+
+			if !reflect.DeepEqual(startReq.IncludeNamespaces, expectedInclude) {
+				t.Errorf("Expected include namespaces %v, got %v", expectedInclude, startReq.IncludeNamespaces)
+			}
+			if !reflect.DeepEqual(startReq.ExcludeNamespaces, expectedExclude) {
+				t.Errorf("Expected exclude namespaces %v, got %v", expectedExclude, startReq.ExcludeNamespaces)
+			}
+			response := startResponse{Ok: true}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCmd.SetArgs([]string{"--exclude-namespaces=db3.collection3,db4.*", "--include-namespaces=db1.collection1"})
+	err := testCmd.Execute()
+	require.NoError(t, err)
+}
+
+func TestStartCmd_NamespaceValidation(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "start",
+		RunE: startCmd.RunE,
+	}
+
+	testCmd.Flags().Int("port", 3000, "Port number")
+	testCmd.Flags().StringSlice("include-namespaces", nil,
+		"Namespaces to include in the replication (e.g. db1.collection1,db2.collection2)")
+	testCmd.Flags().StringSlice("exclude-namespaces", nil,
+		"Namespaces to exclude from the replication (e.g. db3.collection3,db4.*)")
+
+	h := newTestHelper(t)
+	defer h.cleanup()
+
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/start" {
+			var startReq startRequest
+			if r.ContentLength > 0 {
+				data := make([]byte, r.ContentLength)
+				r.Body.Read(data)
+				json.Unmarshal(data, &startReq)
+			}
+
+			t.Logf("Received exclude namespaces: %v", startReq.ExcludeNamespaces)
+			t.Logf("Received include namespaces: %v", startReq.IncludeNamespaces)
+
+			response := startResponse{Ok: true}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCases := []struct {
+		name        string
+		excludeArgs string
+		expectError bool
+	}{
+		{"valid_db.collection", "db.collection", false},
+		{"valid_db.*", "db.*", false},
+		{"valid_multiple", "db1.collection1,db2.*", false},
+		{"malformed_extra_chars", "$#@!!#invalid", false}, // validation should be added?
+		{"malformed_double_dot", "dfa..collection", false}, // validation should be added?
+		{"malformed_trailing_dot", "db.collection.", false}, // validation should be added?
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			testCmd.SetArgs([]string{"--exclude-namespaces=" + tc.excludeArgs})
+			err := testCmd.Execute()
+
+			if tc.expectError {
+				require.Error(t, err, "Expected error for: %s", tc.excludeArgs)
+			} else {
+				require.NoError(t, err, "Expected success for: %s", tc.excludeArgs)
+			}
+		})
+	}
+}
+
+func TestStatusCmd(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "status",
+		RunE: statusCmd.RunE,
+	}
+	testCmd.Flags().Int("port", 3000, "Port number")
+
+	h := newTestHelper(t)
+	defer h.cleanup()
+
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/status" {
+			response := statusResponse{Ok: true, State: "idle"}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCmd.SetArgs([]string{})
+	err := testCmd.Execute()
+	require.NoError(t, err)
+}
+
+func TestFinalizeCmd(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "finalize",
+		RunE: finalizeCmd.RunE,
+	}
+	testCmd.Flags().Int("port", 3000, "Port number")
+	testCmd.Flags().Bool("ignore-history-lost", false, "Ignore history lost error")
+
+	h := newTestHelper(t)
+	defer h.cleanup()
+
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/finalize" {
+			var finalizeReq finalizeRequest
+			if r.ContentLength > 0 {
+				data := make([]byte, r.ContentLength)
+				r.Body.Read(data)
+				json.Unmarshal(data, &finalizeReq)
+			}
+			require.Equal(t, true, finalizeReq.IgnoreHistoryLost)
+			response := finalizeResponse{Ok: true}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCmd.SetArgs([]string{"--ignore-history-lost"})
+	err := testCmd.Execute()
+	require.NoError(t, err)
+}
+
+func TestPauseCmd(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "pause",
+		RunE: pauseCmd.RunE,
+	}
+	testCmd.Flags().Int("port", 3000, "Port number")
+	h := newTestHelper(t)
+	defer h.cleanup()
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/pause" {
+			response := pauseResponse{Ok: true}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCmd.SetArgs([]string{})
+	err := testCmd.Execute()
+	require.NoError(t, err)
+}
+
+func TestResumeCmd(t *testing.T) {
+	testCmd := &cobra.Command{
+		Use: "resume",
+		RunE: resumeCmd.RunE,
+	}
+	testCmd.Flags().Int("port", 3000, "Port number")
+	testCmd.Flags().Bool("from-failure", false, "Resume from failure")
+
+	h := newTestHelper(t)
+	defer h.cleanup()
+
+	h.server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/resume" {
+			var resumeReq resumeRequest
+			if r.ContentLength > 0 {
+				data := make([]byte, r.ContentLength)
+				r.Body.Read(data)
+				json.Unmarshal(data, &resumeReq)
+			}
+			require.Equal(t, true, resumeReq.FromFailure)
+			response := resumeResponse{Ok: true}
+			json.NewEncoder(w).Encode(response)
+		}
+	}))
+
+	cleanup := h.setupCommand(testCmd)
+	defer cleanup()
+
+	testCmd.SetArgs([]string{"--from-failure"})
+	err := testCmd.Execute()
+	require.NoError(t, err)
+}