fixes

Author: mohammeds1992

cmd/push-validator/cmd_backup.go

@@ -1,19 +1,34 @@
 package main
 
 import (
-    "fmt"
+	"fmt"
 
-    "github.com/pushchain/push-validator-cli/internal/admin"
+	"github.com/pushchain/push-validator-cli/internal/admin"
 )
 
 // handleBackup creates a backup archive of the node configuration and
 // prints the resulting path, or a JSON object when --output=json.
 func handleBackup(d *Deps) error {
-    path, err := admin.Backup(admin.BackupOptions{HomeDir: d.Cfg.HomeDir})
-    if err != nil {
-        if flagOutput == "json" { d.Printer.JSON(map[string]any{"ok": false, "error": err.Error()}) } else { d.Printer.Error(fmt.Sprintf("backup error: %v", err)) }
-        return err
-    }
-    if flagOutput == "json" { d.Printer.JSON(map[string]any{"ok": true, "backup_path": path}) } else { d.Printer.Success(fmt.Sprintf("backup created: %s", path)) }
-    return nil
+	return handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		return admin.Backup(opts)
+	})
+}
+
+// handleBackupWith is the testable core of handleBackup with an injectable backup function.
+func handleBackupWith(d *Deps, backupFn func(admin.BackupOptions) (string, error)) error {
+	path, err := backupFn(admin.BackupOptions{HomeDir: d.Cfg.HomeDir})
+	if err != nil {
+		if flagOutput == "json" {
+			d.Printer.JSON(map[string]any{"ok": false, "error": err.Error()})
+		} else {
+			d.Printer.Error(fmt.Sprintf("backup error: %v", err))
+		}
+		return err
+	}
+	if flagOutput == "json" {
+		d.Printer.JSON(map[string]any{"ok": true, "backup_path": path})
+	} else {
+		d.Printer.Success(fmt.Sprintf("backup created: %s", path))
+	}
+	return nil
 }

cmd/push-validator/cmd_backup_test.go

@@ -1,7 +1,10 @@
 package main
 
 import (
+	"fmt"
 	"testing"
+
+	"github.com/pushchain/push-validator-cli/internal/admin"
 )
 
 func TestHandleBackup_Success(t *testing.T) {
@@ -111,3 +114,118 @@ func TestHandleBackup_Success_Text(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 }
+
+// --- Tests using handleBackupWith with injectable backup function ---
+
+func TestHandleBackupWith_Success_JSON(t *testing.T) {
+	origOutput := flagOutput
+	defer func() { flagOutput = origOutput }()
+	flagOutput = "json"
+
+	d := &Deps{
+		Cfg:     testCfg(),
+		Printer: getPrinter(),
+	}
+
+	err := handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		return "/tmp/backup.tar.gz", nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestHandleBackupWith_Success_Text(t *testing.T) {
+	origOutput := flagOutput
+	origNoColor := flagNoColor
+	origNoEmoji := flagNoEmoji
+	defer func() {
+		flagOutput = origOutput
+		flagNoColor = origNoColor
+		flagNoEmoji = origNoEmoji
+	}()
+	flagOutput = "text"
+	flagNoColor = true
+	flagNoEmoji = true
+
+	d := &Deps{
+		Cfg:     testCfg(),
+		Printer: getPrinter(),
+	}
+
+	err := handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		return "/tmp/backup.tar.gz", nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestHandleBackupWith_Error_JSON(t *testing.T) {
+	origOutput := flagOutput
+	defer func() { flagOutput = origOutput }()
+	flagOutput = "json"
+
+	d := &Deps{
+		Cfg:     testCfg(),
+		Printer: getPrinter(),
+	}
+
+	err := handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		return "", fmt.Errorf("disk full")
+	})
+	if err == nil || err.Error() != "disk full" {
+		t.Errorf("expected 'disk full', got: %v", err)
+	}
+}
+
+func TestHandleBackupWith_Error_Text(t *testing.T) {
+	origOutput := flagOutput
+	origNoColor := flagNoColor
+	origNoEmoji := flagNoEmoji
+	defer func() {
+		flagOutput = origOutput
+		flagNoColor = origNoColor
+		flagNoEmoji = origNoEmoji
+	}()
+	flagOutput = "text"
+	flagNoColor = true
+	flagNoEmoji = true
+
+	d := &Deps{
+		Cfg:     testCfg(),
+		Printer: getPrinter(),
+	}
+
+	err := handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		return "", fmt.Errorf("permission denied")
+	})
+	if err == nil || err.Error() != "permission denied" {
+		t.Errorf("expected 'permission denied', got: %v", err)
+	}
+}
+
+func TestHandleBackupWith_VerifiesHomeDir(t *testing.T) {
+	origOutput := flagOutput
+	defer func() { flagOutput = origOutput }()
+	flagOutput = "json"
+
+	cfg := testCfg()
+	cfg.HomeDir = "/custom/home"
+	d := &Deps{
+		Cfg:     cfg,
+		Printer: getPrinter(),
+	}
+
+	var capturedOpts admin.BackupOptions
+	err := handleBackupWith(d, func(opts admin.BackupOptions) (string, error) {
+		capturedOpts = opts
+		return "/backup.tar.gz", nil
+	})
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if capturedOpts.HomeDir != "/custom/home" {
+		t.Errorf("expected HomeDir=/custom/home, got %s", capturedOpts.HomeDir)
+	}
+}

cmd/push-validator/cmd_dashboard.go

@@ -14,6 +14,35 @@ import (
 	"github.com/pushchain/push-validator-cli/internal/dashboard"
 )
 
+// dashboardFlags holds the parsed flag values for the dashboard command.
+type dashboardFlags struct {
+	refreshInterval time.Duration
+	rpcTimeout      time.Duration
+	debugMode       bool
+}
+
+// dashboardCoreDeps holds injectable dependencies for runDashboardCmdCore.
+type dashboardCoreDeps struct {
+	isTTY          func() bool
+	runStatic      func(ctx context.Context, opts dashboard.Options) error
+	runInteractive func(opts dashboard.Options) error
+}
+
+// runDashboardCmdCore contains the testable logic for the dashboard RunE handler.
+func runDashboardCmdCore(ctx context.Context, opts dashboard.Options, deps dashboardCoreDeps) error {
+	if !deps.isTTY() {
+		if opts.Debug {
+			fmt.Fprintln(os.Stderr, "Debug: Non-TTY detected, using static mode")
+		}
+		return deps.runStatic(ctx, opts)
+	}
+
+	if opts.Debug {
+		fmt.Fprintln(os.Stderr, "Debug: TTY detected, using interactive mode")
+	}
+	return deps.runInteractive(opts)
+}
+
 // dashboardCmd provides an interactive TUI dashboard for monitoring validator status
 func createDashboardCmd() *cobra.Command {
 	var (
@@ -37,10 +66,7 @@ The dashboard auto-refreshes every 2 seconds by default. Press '?' for help.
 For non-interactive environments (CI/pipes), dashboard automatically falls back
 to a static text snapshot.`,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// Load configuration
 			cfg := loadCfg()
-
-			// Build dashboard options
 			opts := dashboard.Options{
 				Config:          cfg,
 				RefreshInterval: refreshInterval,
@@ -52,26 +78,14 @@ to a static text snapshot.`,
 			}
 			opts = normalizeDashboardOptions(opts)
 
-			// Check if we're in a TTY environment
-			isTTY := term.IsTerminal(int(os.Stdout.Fd()))
-
-			if !isTTY {
-				// Non-TTY environment (CI/pipes): use static mode
-				if debugMode {
-					fmt.Fprintln(os.Stderr, "Debug: Non-TTY detected, using static mode")
-				}
-				return runDashboardStatic(cmd.Context(), opts)
-			}
-
-			// TTY environment: use interactive Bubble Tea dashboard
-			if debugMode {
-				fmt.Fprintln(os.Stderr, "Debug: TTY detected, using interactive mode")
-			}
-			return runDashboardInteractive(opts)
+			return runDashboardCmdCore(cmd.Context(), opts, dashboardCoreDeps{
+				isTTY:          func() bool { return term.IsTerminal(int(os.Stdout.Fd())) },
+				runStatic:      runDashboardStatic,
+				runInteractive: runDashboardInteractive,
+			})
 		},
 	}
 
-	// Flags
 	cmd.Flags().DurationVar(&refreshInterval, "refresh-interval", 2*time.Second, "Dashboard refresh interval")
 	cmd.Flags().DurationVar(&rpcTimeout, "rpc-timeout", 15*time.Second, "RPC request timeout")
 	cmd.Flags().BoolVar(&debugMode, "debug", false, "Enable debug mode for troubleshooting")

cmd/push-validator/cmd_dashboard_test.go

@@ -1,6 +1,8 @@
 package main
 
 import (
+	"context"
+	"fmt"
 	"testing"
 	"time"
 
@@ -78,3 +80,127 @@ func TestNormalizeDashboardOptions_SmallRefresh(t *testing.T) {
 		t.Errorf("RPCTimeout = %v, want 2s", opts.RPCTimeout)
 	}
 }
+
+// --- Tests for runDashboardCmdCore ---
+
+func TestRunDashboardCmdCore_NonTTY_CallsStatic(t *testing.T) {
+	staticCalled := false
+	interactiveCalled := false
+
+	deps := dashboardCoreDeps{
+		isTTY: func() bool { return false },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error {
+			staticCalled = true
+			return nil
+		},
+		runInteractive: func(opts dashboard.Options) error {
+			interactiveCalled = true
+			return nil
+		},
+	}
+
+	opts := dashboard.Options{RefreshInterval: 2 * time.Second}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !staticCalled {
+		t.Error("expected runStatic to be called")
+	}
+	if interactiveCalled {
+		t.Error("expected runInteractive NOT to be called")
+	}
+}
+
+func TestRunDashboardCmdCore_TTY_CallsInteractive(t *testing.T) {
+	staticCalled := false
+	interactiveCalled := false
+
+	deps := dashboardCoreDeps{
+		isTTY: func() bool { return true },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error {
+			staticCalled = true
+			return nil
+		},
+		runInteractive: func(opts dashboard.Options) error {
+			interactiveCalled = true
+			return nil
+		},
+	}
+
+	opts := dashboard.Options{RefreshInterval: 2 * time.Second}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if staticCalled {
+		t.Error("expected runStatic NOT to be called")
+	}
+	if !interactiveCalled {
+		t.Error("expected runInteractive to be called")
+	}
+}
+
+func TestRunDashboardCmdCore_Static_Error(t *testing.T) {
+	deps := dashboardCoreDeps{
+		isTTY: func() bool { return false },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error {
+			return fmt.Errorf("fetch failed")
+		},
+		runInteractive: func(opts dashboard.Options) error { return nil },
+	}
+
+	opts := dashboard.Options{}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err == nil || err.Error() != "fetch failed" {
+		t.Errorf("expected 'fetch failed', got: %v", err)
+	}
+}
+
+func TestRunDashboardCmdCore_Interactive_Error(t *testing.T) {
+	deps := dashboardCoreDeps{
+		isTTY:     func() bool { return true },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error { return nil },
+		runInteractive: func(opts dashboard.Options) error {
+			return fmt.Errorf("TUI error")
+		},
+	}
+
+	opts := dashboard.Options{}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err == nil || err.Error() != "TUI error" {
+		t.Errorf("expected 'TUI error', got: %v", err)
+	}
+}
+
+func TestRunDashboardCmdCore_Debug_NonTTY(t *testing.T) {
+	deps := dashboardCoreDeps{
+		isTTY: func() bool { return false },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error {
+			return nil
+		},
+		runInteractive: func(opts dashboard.Options) error { return nil },
+	}
+
+	opts := dashboard.Options{Debug: true}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestRunDashboardCmdCore_Debug_TTY(t *testing.T) {
+	deps := dashboardCoreDeps{
+		isTTY:     func() bool { return true },
+		runStatic: func(ctx context.Context, opts dashboard.Options) error { return nil },
+		runInteractive: func(opts dashboard.Options) error {
+			return nil
+		},
+	}
+
+	opts := dashboard.Options{Debug: true}
+	err := runDashboardCmdCore(context.Background(), opts, deps)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}