chore: fix tests

Author: moshloop

cmd/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 	"strconv"
 
 	"github.com/samber/lo"
@@ -17,17 +18,13 @@ import (
 )
 
 var (
-	postgres server.Postgres
-
-	verbose    bool
+	postgres   server.Postgres
 	createDb   string
 	configFile string
 	encoding   string
 	locale     string
 	authMethod string
 	opts       pgtune.OptimizeOptions
-	// Auto-detected directories
-	detectedDirs *utils.PostgreSQLDirs
 )
 
 func getIntVar(name string) int {
@@ -69,10 +66,10 @@ This unified tool combines PostgreSQL server management, configuration generatio
 
 			// Load configuration if specified
 			if configFile != "" {
-				if pgConfig, err := config.LoadPostgresConf(configFile); err == nil {
+				if pconfig, err := config.LoadPostgresConf(configFile); err == nil {
 					return err
 				} else {
-					postgres.Config = pgConfig
+					postgres.Config = pconfig
 				}
 			} else if postgres.Config == nil {
 				postgres.Config = config.DefaultPostgresConf()
@@ -90,6 +87,10 @@ This unified tool combines PostgreSQL server management, configuration generatio
 				return err
 			}
 
+			if postgres.DryRun {
+				clicky.Infof("📋 Dry run mode enabled")
+			}
+
 			return nil
 		},
 	}
@@ -101,15 +102,11 @@ This unified tool combines PostgreSQL server management, configuration generatio
 	rootCmd.PersistentFlags().IntVarP(&postgres.Port, "port", "p", lo.CoalesceOrEmpty(getIntVar("PG_PORT"), 5432), "PostgreSQL port")
 	rootCmd.PersistentFlags().StringVar(&postgres.DataDir, "data-dir", os.Getenv("PGDATA"), "PostgreSQL data directory (auto-detected if not specified)")
 	rootCmd.PersistentFlags().StringVar(&postgres.BinDir, "bin-dir", "", "PostgreSQL binary directory (auto-detected if not specified)")
+	rootCmd.PersistentFlags().BoolVar(&postgres.DryRun, "dry-run", false, "Enable dry-run mode to simulate actions without making changes")
 	rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "", "Configuration file path")
 	rootCmd.PersistentFlags().StringVar(&locale, "locale", "C", "Locale for initialized database")
 	rootCmd.PersistentFlags().StringVar(&encoding, "encoding", "UTF8", "Encoding for initialized database")
-	rootCmd.PersistentFlags().BoolVar(&opts.Enabled, "pg-tune", os.Getenv("PG_TUNE") == "true", "Enable pg_tune optimization")
-	rootCmd.PersistentFlags().IntVar(&opts.MaxConnections, "max-connections", getIntVar("PG_TUNE_MAX_CONNECTIONS"), "Max connections for pg_tune (0 = auto-calculate)")
-	rootCmd.PersistentFlags().IntVar(&opts.MemoryMB, "memory", getIntVar("PG_TUNE_MEMORY"), "Override detected memory in MB for pg_tune")
-	rootCmd.PersistentFlags().IntVar(&opts.Cores, "cpus", getIntVar("PG_TUNE_CPUS"), "Override detected CPU count for pg_tune")
-	rootCmd.PersistentFlags().StringVar(&opts.DBType, "type", "web", "Database type for pg_tune: web, oltp, dw, desktop, mixed")
-	rootCmd.PersistentFlags().StringVar(&authMethod, "auth-method", lo.CoalesceOrEmpty(os.Getenv("PG_AUTH_METHOD"), string(pkg.AuthScramSHA)), "Authentication method for pg_hba.conf (auto-detected if not specified)")
+
 	clicky.BindAllFlags(rootCmd.PersistentFlags())
 
 	// Add command groups
@@ -140,22 +137,26 @@ This command can automatically:
 - Reset the superuser password
 
 Examples:
-  pgconfig auto-start                           Start PostgreSQL normally
-  pgconfig auto-start --auto-init               Initialize and start if needed
-  pgconfig auto-start --pg-tune                 Optimize config before starting
-  pgconfig auto-start --auto-upgrade            Upgrade if needed, then start
-  pgconfig auto-start --auto-reset-password     Reset password, then start
-  pgconfig auto-start --auto-init --pg-tune     Initialize, optimize, then start
-  pgconfig auto-start --dry-run                 Validate permissions without starting`,
+  postgres-cli auto-start                           Start PostgreSQL normally
+  postgres-cli auto-start --auto-init               Initialize and start if needed
+  postgres-cli auto-start --pg-tune                 Optimize config before starting
+  postgres-cli auto-start --auto-upgrade            Upgrade if needed, then start
+  postgres-cli auto-start --auto-reset-password     Reset password, then start
+  postgres-cli auto-start --auto-init --pg-tune     Initialize, optimize, then start
+  postgres-cli auto-start --dry-run                 Validate permissions without starting`,
 		RunE: runAutoStart,
 	}
 
-	cmd.Flags().Bool("auto-init", true, "Automatically initialize database if data directory doesn't exist")
-	cmd.Flags().Bool("pg-tune", true, "Run pg_tune to optimize postgresql.conf before starting")
+	cmd.Flags().IntVar(&opts.MaxConnections, "max-connections", getIntVar("PG_TUNE_MAX_CONNECTIONS"), "Max connections for pg_tune (0 = auto-calculate)")
+	cmd.Flags().IntVar(&opts.MemoryMB, "memory", getIntVar("PG_TUNE_MEMORY"), "Override detected memory in MB for pg_tune")
+	cmd.Flags().IntVar(&opts.Cores, "cpus", getIntVar("PG_TUNE_CPUS"), "Override detected CPU count for pg_tune")
+	cmd.Flags().StringVar(&opts.DBType, "type", "web", "Database type for pg_tune: web, oltp, dw, desktop, mixed")
+	cmd.Flags().StringVar(&authMethod, "auth-method", lo.CoalesceOrEmpty(os.Getenv("PG_AUTH_METHOD"), string(pkg.AuthScramSHA)), "Authentication method for pg_hba.conf (auto-detected if not specified)")
+	cmd.Flags().BoolVar(&opts.Enabled, "pg-tune", true, "Run pg_tune to optimize postgresql.conf before starting")
 	cmd.Flags().Bool("auto-upgrade", true, "Automatically upgrade PostgreSQL if version mismatch detected")
 	cmd.Flags().Bool("auto-reset-password", true, "Reset postgres superuser password on start")
+	cmd.Flags().Bool("auto-init", true, "Automatically initialize database if data directory doesn't exist")
 	cmd.Flags().Int("upgrade-to", 0, "Target PostgreSQL version for upgrade (default: auto-detect latest)")
-	cmd.Flags().Bool("dry-run", false, "Validate permissions and configuration without making changes")
 
 	return cmd
 }
@@ -166,34 +167,35 @@ func runAutoStart(cmd *cobra.Command, args []string) error {
 	autoUpgrade, _ := cmd.Flags().GetBool("auto-upgrade")
 	autoResetPassword, _ := cmd.Flags().GetBool("auto-reset-password")
 	upgradeTo, _ := cmd.Flags().GetInt("upgrade-to")
-	dryRun, _ := cmd.Flags().GetBool("dry-run")
 
 	// Log current user context
 	uid, gid, username, err := utils.GetCurrentUserInfo()
 	if err != nil {
 		return fmt.Errorf("failed to get user info: %w", err)
 	}
-	fmt.Printf("Running as user: %s (UID: %d, GID: %d)\n", username, uid, gid)
 
-	clicky.Infof("✅ Permission checks passed")
-
-	// If dry-run mode, exit successfully
-	if dryRun {
-		clicky.Infof("\n✅ Dry-run validation completed successfully")
-		clicky.Infof("All permission checks passed. Ready to start PostgreSQL.")
-		return nil
-	}
+	clicky.Infof("Running auto-start with: %s", clicky.Map(map[string]any{
+		"auto-init":           autoInit,
+		"pg-tune":             opts.Enabled,
+		"auto-upgrade":        autoUpgrade,
+		"auto-reset-password": autoResetPassword,
+		"upgrade-to":          upgradeTo,
+		"database":            postgres.Database,
+		"uid":                 uid,
+		"gid":                 gid,
+		"username":            username,
+	}))
 
 	// Check if already running
-	if postgres.IsRunning() {
+	if !postgres.DryRun && postgres.IsRunning() {
 		clicky.Infof("PostgreSQL is already running")
 		return nil
 	}
 
 	// Step 1: Auto-init if data directory doesn't exist
 	if !postgres.Exists() {
 		if autoInit {
-			clicky.Infof("🔧 Initializing PostgreSQL database...")
+
 			if err := postgres.InitDB(); err != nil {
 				return fmt.Errorf("failed to initialize database: %w", err)
 			}
@@ -217,61 +219,61 @@ func runAutoStart(cmd *cobra.Command, args []string) error {
 		}
 
 		if currentVersion < targetVersion {
-			fmt.Printf("🚀 Upgrading PostgreSQL from version %d to %d...\n", currentVersion, targetVersion)
 			if err := postgres.Upgrade(targetVersion); err != nil {
 				return fmt.Errorf("failed to upgrade PostgreSQL: %w", err)
 			}
-			clicky.Infof("✅ PostgreSQL upgrade completed successfully")
 		} else {
 			fmt.Printf("✅ PostgreSQL is already at version %d (target: %d)\n", currentVersion, targetVersion)
 		}
 	}
 
 	// Step 3: Run pg_tune if requested
 	if opts.Enabled {
-		clicky.Infof("🔧 Running pg_tune to optimize configuration...")
 
-		err := pgtune.OptimizeAndSave(opts)
+		content, err := pgtune.OptimizeAndSave(opts)
 		if err != nil {
 			return fmt.Errorf("failed to run pg_tune: %w", err)
 		}
+		if postgres.DryRun {
+			clicky.Infof("📄 Generated postgresql.auto.conf by pg_tune:")
 
-		clicky.Infof("✅ Configuration optimized successfully")
+			fmt.Println(clicky.CodeBlock("properties", content).ANSI())
+		} else {
+			configPath := filepath.Join(opts.DataDir, "postgresql.auto.conf")
+			if err := os.WriteFile(configPath, []byte(content), 0644); err != nil {
+				return fmt.Errorf("failed to write postgresql.auto.conf: %w", err)
+			}
+			clicky.Infof("✅ pg_tune optimization applied and saved to %s", configPath)
+
+		}
 	}
 
 	// Step 4: Reset password if requested
 	if autoResetPassword {
-		newPassword := os.Getenv("POSTGRES_PASSWORD")
+
+		newPassword, err := utils.FileEnv("POSTGRES_PASSWORD", "")
+		if err != nil {
+			return fmt.Errorf("failed to read password: %w", err)
+		}
 		sensitivePassword := utils.NewSensitiveString(newPassword)
 		if err := postgres.ResetPassword(sensitivePassword); err != nil {
 			return fmt.Errorf("failed to reset password: %w", err)
 		}
-		clicky.Infof("✅ Password reset completed successfully")
+
 	}
 
 	if createDb != "" {
-		fmt.Printf("🛠️  Ensuring database '%s' exists...\n", createDb)
+
 		if err := postgres.CreateDatabase(createDb); err != nil {
 			//FIXME
 			fmt.Printf("❌ Failed to create database '%s': %v\n", createDb, err)
 			// return fmt.Errorf("failed to create database '%s': %w", createDb, err)
-		} else {
-			fmt.Printf("✅ Database '%s' is ready\n", createDb)
-
 		}
 	}
 
 	if err := postgres.SetupPgHBA(authMethod); err != nil {
 		return fmt.Errorf("failed to setup pg_hba.conf: %w", err)
 	}
-
-	// // Step 5: Start PostgreSQL
-	// clicky.Infof("🚀 Starting PostgreSQL...")
-	// if err := postgres.Start(); err != nil {
-	// 	return fmt.Errorf("failed to start PostgreSQL: %w", err)
-	// }
-
-	clicky.Infof("✅ Ready to start")
 	return nil
 }
 

cmd/server.go

@@ -19,7 +19,6 @@ func createServerCommands() *cobra.Command {
 
 	// Add all server commands
 	serverCmd.AddCommand(
-		createInfoCommands(),
 		createHealthCommand(),
 		createInitDBCommand(),
 		createResetPasswordCommand(),
@@ -86,102 +85,6 @@ func createRestartCommand() *cobra.Command {
 	}
 }
 
-// createInfoCommands creates the info subcommand group
-func createInfoCommands() *cobra.Command {
-	infoCmd := &cobra.Command{
-		Use:   "info",
-		Short: "Information and status commands",
-		Long:  "Commands for getting information about the PostgreSQL instance",
-	}
-
-	// describe-config command
-	describeConfigCmd := &cobra.Command{
-		Use:   "describe-config",
-		Short: "Describe PostgreSQL configuration parameters",
-		Long:  "Execute 'postgres --describe-config' and return parsed parameters",
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			params, err := postgres.DescribeConfig()
-			if err != nil {
-				return fmt.Errorf("failed to describe config: %w", err)
-			}
-
-			fmt.Println(clicky.MustFormat(params))
-			return nil
-		},
-	}
-	describeConfigCmd.Flags().StringP("output", "o", "table", "Output format (table, json, yaml)")
-
-	// detect-version command
-	detectVersionCmd := &cobra.Command{
-		Use:   "detect-version",
-		Short: "Detect PostgreSQL version from data directory",
-		Long:  "Read the PostgreSQL version from the PG_VERSION file in the data directory",
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			version, err := postgres.DetectVersion()
-			if err != nil {
-				return fmt.Errorf("failed to detect version: %w", err)
-			}
-
-			fmt.Printf("PostgreSQL version: %d\n", version)
-			return nil
-		},
-	}
-
-	// get-version command
-	getVersionCmd := &cobra.Command{
-		Use:   "get-version",
-		Short: "Get PostgreSQL version from binary",
-		Long:  "Execute 'postgres --version' to get version information",
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			version := postgres.GetVersion()
-			if version == "" {
-				return fmt.Errorf("failed to get version")
-			}
-
-			fmt.Printf("PostgreSQL version: %s\n", version)
-			return nil
-		},
-	}
-
-	// exists command
-	existsCmd := &cobra.Command{
-		Use:   "exists",
-		Short: "Check if PostgreSQL data directory exists and is valid",
-		Long:  "Check if the data directory contains valid PostgreSQL files",
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			exists := postgres.Exists()
-			fmt.Printf("PostgreSQL data directory exists: %t\n", exists)
-			if !exists {
-				return fmt.Errorf("PostgreSQL data directory does not exist or is invalid")
-			}
-			return nil
-		},
-	}
-
-	// is-running command
-	isRunningCmd := &cobra.Command{
-		Use:   "is-running",
-		Short: "Check if PostgreSQL server is running",
-		Long:  "Check if PostgreSQL process is running by examining the PID file",
-		RunE: func(cmd *cobra.Command, args []string) error {
-
-			running := postgres.IsRunning()
-			fmt.Printf("PostgreSQL is running: %t\n", running)
-			if !running {
-				return fmt.Errorf("PostgreSQL is not running")
-			}
-			return nil
-		},
-	}
-
-	infoCmd.AddCommand(describeConfigCmd, detectVersionCmd, getVersionCmd, existsCmd, isRunningCmd)
-	return infoCmd
-}
-
 // createHealthCommand creates the health command
 func createHealthCommand() *cobra.Command {
 	return &cobra.Command{
@@ -227,12 +130,9 @@ func createResetPasswordCommand() *cobra.Command {
 				return fmt.Errorf("password is required")
 			}
 
-			clicky.Infof("Resetting password for user %s", postgres.Username)
-
 			if err := postgres.ResetPassword(postgres.Password); err != nil {
 				return fmt.Errorf("failed to reset password: %w", err)
 			}
-			fmt.Println("Password reset successfully")
 			return nil
 		},
 	}

cmd/version.go

@@ -16,9 +16,17 @@ var (
 
 // GetVersionInfo returns formatted version information
 func GetVersionInfo() string {
-	return fmt.Sprintf(`postgres-cli version: %s
-Git commit: %s
-Build date: %s
-Go version: %s
-OS/Arch: %s/%s`, Version, GitCommit, BuildDate, runtime.Version(), runtime.GOOS, runtime.GOARCH)
+	// Shorten git commit to first 7 chars
+	shortCommit := GitCommit
+	if len(shortCommit) > 7 {
+		shortCommit = shortCommit[:7]
+	}
+
+	return fmt.Sprintf("postgres-cli v%s (git:%s, built:%s, %s, %s/%s)",
+		Version,
+		shortCommit,
+		BuildDate,
+		runtime.Version(),
+		runtime.GOOS,
+		runtime.GOARCH)
 }

docker-entrypoint.sh

@@ -46,7 +46,7 @@ fi
 postgres-cli server status
 
 # Run postgres-cli auto-start (includes permission checks)
-postgres-cli auto-start --pg-tune --auto-upgrade --upgrade-to=$PG_VERSION --auto-init --data-dir "$PGDATA" --auto-reset-password
+postgres-cli auto-start  --upgrade-to=$PG_VERSION --data-dir "$PGDATA" $POSTGRES_CLI_ARGS
 
 cat $PGDATA/pg_hba.conf