diff options
| -rw-r--r-- | cmd/mobius-hotline-server/main.go | 88 | ||||
| -rw-r--r-- | cmd/mobius-hotline-server/main_test.go | 181 |
2 files changed, 231 insertions, 38 deletions
diff --git a/cmd/mobius-hotline-server/main.go b/cmd/mobius-hotline-server/main.go index 65e1b01..e230771 100644 --- a/cmd/mobius-hotline-server/main.go +++ b/cmd/mobius-hotline-server/main.go @@ -40,7 +40,7 @@ func main() { redisAddr := flag.String("redis-addr", "", "Redis server address for API features") redisPassword := flag.String("redis-password", "", "Redis password, if required") redisDB := flag.Int("redis-db", 0, "Redis DB number, defaults to 0") - configDir := flag.String("config", configSearchPaths(), "Path to config root") + configDir := flag.String("config", findConfigPath(), "Path to config root") printVersion := flag.Bool("version", false, "Print version and exit") logLevel := flag.String("log-level", "info", "Log level") logFile := flag.String("log-file", "", "Path to log file") @@ -192,61 +192,73 @@ func main() { log.Fatal(srv.ListenAndServe(ctx)) } -func configSearchPaths() string { +// findConfigPath searches for an existing config directory from the predefined search order. +// Returns the first directory that exists, or falls back to "config" as the default. +func findConfigPath() string { for _, cfgPath := range mobius.ConfigSearchOrder { - if _, err := os.Stat(cfgPath); err == nil { + if info, err := os.Stat(cfgPath); err == nil && info.IsDir() { return cfgPath } } + // Default fallback - will be created by --init flag if needed return "config" } -// copyDir recursively copies a directory tree, attempting to preserve permissions. +// copyDir recursively copies a directory tree from embedded filesystem to local filesystem. func copyDir(src, dst string) error { + return copyDirRecursive(src, dst) +} + +// copyDirRecursive handles the recursive copying logic. +func copyDirRecursive(src, dst string) error { entries, err := cfgTemplate.ReadDir(src) if err != nil { - return err + return fmt.Errorf("failed to read source directory %s: %w", src, err) } - for _, dirEntry := range entries { - if dirEntry.IsDir() { - if err := os.MkdirAll(path.Join(dst, dirEntry.Name()), 0777); err != nil { - panic(err) - } - subdirEntries, _ := cfgTemplate.ReadDir(path.Join(src, dirEntry.Name())) - for _, subDirEntry := range subdirEntries { - f, err := os.Create(path.Join(dst, dirEntry.Name(), subDirEntry.Name())) - if err != nil { - return err - } - srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name(), subDirEntry.Name())) - if err != nil { - return fmt.Errorf("error copying srcFile: %w", err) - } - _, err = io.Copy(f, srcFile) - if err != nil { - return err - } - _ = f.Close() - } - } else { - f, err := os.Create(path.Join(dst, dirEntry.Name())) - if err != nil { - return err - } + for _, entry := range entries { + srcPath := path.Join(src, entry.Name()) + dstPath := path.Join(dst, entry.Name()) - srcFile, err := cfgTemplate.Open(path.Join(src, dirEntry.Name())) - if err != nil { - return err + if entry.IsDir() { + // Create directory with proper permissions + if err := os.MkdirAll(dstPath, 0755); err != nil { + return fmt.Errorf("failed to create directory %s: %w", dstPath, err) + } + + // Recursively copy subdirectory + if err := copyDirRecursive(srcPath, dstPath); err != nil { + return fmt.Errorf("failed to copy subdirectory %s: %w", srcPath, err) } - _, err = io.Copy(f, srcFile) - if err != nil { - return err + } else { + // Copy file + if err := copyFile(srcPath, dstPath); err != nil { + return fmt.Errorf("failed to copy file %s to %s: %w", srcPath, dstPath, err) } - _ = f.Close() } } return nil } + +// copyFile copies a single file from embedded filesystem to local filesystem. +func copyFile(src, dst string) error { + srcFile, err := cfgTemplate.Open(src) + if err != nil { + return fmt.Errorf("failed to open source file: %w", err) + } + defer srcFile.Close() + + dstFile, err := os.Create(dst) + if err != nil { + return fmt.Errorf("failed to create destination file: %w", err) + } + defer dstFile.Close() + + if _, err := io.Copy(dstFile, srcFile); err != nil { + return fmt.Errorf("failed to copy file contents: %w", err) + } + + return nil +} diff --git a/cmd/mobius-hotline-server/main_test.go b/cmd/mobius-hotline-server/main_test.go new file mode 100644 index 0000000..17a2cb4 --- /dev/null +++ b/cmd/mobius-hotline-server/main_test.go @@ -0,0 +1,181 @@ +package main + +import ( + "os" + "path/filepath" + "testing" + + "github.com/jhalter/mobius/internal/mobius" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestCopyDir(t *testing.T) { + // Test using the actual embedded config directory + dstDir := t.TempDir() + + // Execute copyDir with the embedded mobius/config directory + err := copyDir("mobius/config", dstDir) + require.NoError(t, err) + + // Verify some expected files exist (based on the embedded config) + expectedFiles := []string{ + "config.yaml", + "Agreement.txt", + "MessageBoard.txt", + "ThreadedNews.yaml", + "Users/admin.yaml", + "Users/guest.yaml", + "banner.jpg", + } + + for _, expectedFile := range expectedFiles { + fullPath := filepath.Join(dstDir, expectedFile) + assert.FileExists(t, fullPath, "Expected file %s to exist", expectedFile) + + // Verify file is not empty + info, err := os.Stat(fullPath) + require.NoError(t, err) + assert.Greater(t, info.Size(), int64(0), "File %s should not be empty", expectedFile) + } + + // Verify directories were created + expectedDirs := []string{ + "Users", + "Files", + } + + for _, expectedDir := range expectedDirs { + fullPath := filepath.Join(dstDir, expectedDir) + info, err := os.Stat(fullPath) + require.NoError(t, err) + assert.True(t, info.IsDir(), "Expected %s to be a directory", expectedDir) + } +} + +func TestCopyDirNonexistentSource(t *testing.T) { + dstDir := t.TempDir() + + err := copyDir("nonexistent/directory", dstDir) + assert.Error(t, err) + assert.Contains(t, err.Error(), "failed to read source directory") +} + +func TestCopyDirRecursive(t *testing.T) { + // Test the recursive functionality using embedded config + dstDir := t.TempDir() + + err := copyDirRecursive("mobius/config", dstDir) + require.NoError(t, err) + + // Verify nested structure is copied correctly + nestedPath := filepath.Join(dstDir, "Users", "admin.yaml") + assert.FileExists(t, nestedPath) + + // Verify nested Files directory + filesDir := filepath.Join(dstDir, "Files") + info, err := os.Stat(filesDir) + require.NoError(t, err) + assert.True(t, info.IsDir()) +} + +func TestCopyFile(t *testing.T) { + dstDir := t.TempDir() + dstFile := filepath.Join(dstDir, "copied.yaml") + + // Copy a single file from embedded config + err := copyFile("mobius/config/config.yaml", dstFile) + require.NoError(t, err) + + // Verify file was copied correctly + assert.FileExists(t, dstFile) + + // Verify file is not empty + info, err := os.Stat(dstFile) + require.NoError(t, err) + assert.Greater(t, info.Size(), int64(0)) +} + +func TestCopyFileErrors(t *testing.T) { + t.Run("source file does not exist", func(t *testing.T) { + dstDir := t.TempDir() + err := copyFile("nonexistent.txt", filepath.Join(dstDir, "dest.txt")) + assert.Error(t, err) + assert.Contains(t, err.Error(), "failed to open source file") + }) + + t.Run("destination directory does not exist", func(t *testing.T) { + err := copyFile("mobius/config/config.yaml", "/nonexistent/directory/dest.txt") + assert.Error(t, err) + assert.Contains(t, err.Error(), "failed to create destination file") + }) +} + +func TestCopyDirPermissions(t *testing.T) { + dstDir := t.TempDir() + + err := copyDir("mobius/config", dstDir) + require.NoError(t, err) + + // Check directory permissions + info, err := os.Stat(filepath.Join(dstDir, "Users")) + require.NoError(t, err) + assert.True(t, info.IsDir()) + + // Check that directory has reasonable permissions (at least readable/executable) + mode := info.Mode() + assert.True(t, mode&0400 != 0, "Directory should be readable") + assert.True(t, mode&0100 != 0, "Directory should be executable") +} + +func TestFindConfigPath(t *testing.T) { + // Test function behavior by checking it returns one of the expected paths or fallback + t.Run("returns valid path", func(t *testing.T) { + result := findConfigPath() + + // Should return either one of the search paths that exists, or "config" fallback + validPaths := append([]string{"config"}, mobius.ConfigSearchOrder...) + + found := false + for _, validPath := range validPaths { + if result == validPath { + found = true + break + } + } + + assert.True(t, found, "findConfigPath should return one of the valid paths or fallback, got: %s", result) + }) + + // Test directory vs file validation + t.Run("validates directory vs file", func(t *testing.T) { + // This test verifies the function logic but can't control system directories + // The function correctly validates that only directories are returned + result := findConfigPath() + + // Verify result is an actual directory if it exists + if result != "config" { + info, err := os.Stat(result) + require.NoError(t, err, "Returned path should exist") + assert.True(t, info.IsDir(), "Returned path should be a directory") + } + }) + + // Test with existing directory + t.Run("finds existing directory", func(t *testing.T) { + tmpDir := t.TempDir() + originalDir, err := os.Getwd() + require.NoError(t, err) + defer os.Chdir(originalDir) + + err = os.Chdir(tmpDir) + require.NoError(t, err) + + // Create a config directory + err = os.Mkdir("config", 0755) + require.NoError(t, err) + + result := findConfigPath() + assert.Equal(t, "config", result) + }) +}
\ No newline at end of file |