browser/platform/config/config_test.go

package config

import (
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func TestLoadUsesDefaultAddress(t *testing.T) {
	t.Setenv("PLATFORM_ADDR", "")
	t.Setenv("PLATFORM_STORAGE_BACKEND", "")
	t.Setenv("PLATFORM_MYSQL_DSN", "")
	t.Setenv("PLATFORM_DATA_DIR", "")
	t.Setenv("PLATFORM_METADATA_PATH", "")
	t.Setenv("PLATFORM_LOG_DIR", "")
	t.Setenv("PLATFORM_LOG_BODY_BACKEND", "")
	t.Setenv("PLATFORM_BOOTSTRAP_ADMIN_EMAIL", "")
	t.Setenv("PLATFORM_BOOTSTRAP_ADMIN_PASSWORD", "")
	t.Setenv("PLATFORM_SECRET_ENVELOPE_KEY", "")
	t.Setenv("PLATFORM_BUILDER_DOCKER_BINARY", "")
	t.Setenv("PLATFORM_BUILDER_IMAGE", "")
	t.Setenv("PLATFORM_BUILDER_SOURCE_DIR", "")
	t.Setenv("PLATFORM_BUILDER_WORKSPACE_DIR", "")
	t.Setenv("PLATFORM_BUILDER_CACHE_DIR", "")
	t.Setenv("PLATFORM_BUILDER_TIMEOUT_SECONDS", "")

	cfg := Load()
	if cfg.Addr != defaultAddr {
		t.Fatalf("expected default addr %q, got %q", defaultAddr, cfg.Addr)
	}
	if cfg.StorageBackend != "file" || cfg.MySQLDSN != "" || cfg.DataDir != ".platform-data" || cfg.LogBodyBackend != "" {
		t.Fatalf("unexpected default storage config: %+v", cfg)
	}
	if cfg.MetadataPath != filepath.Join(".platform-data", "metadata.json") || cfg.LogDir != filepath.Join(".platform-data", "logs") {
		t.Fatalf("unexpected default storage paths: %+v", cfg)
	}
	if cfg.BuilderDockerBinary != defaultBuilderDockerBinary || cfg.BuilderImage != defaultBuilderImage || cfg.BuilderSourceDir != "" || cfg.BuilderWorkspaceDir != filepath.Join(".platform-data", "distribution-builds") || cfg.BuilderCacheDir != filepath.Join(".platform-data", "distribution-build-cache") || cfg.BuilderTimeoutSeconds != defaultBuilderTimeoutSeconds {
		t.Fatalf("unexpected default builder config: %+v", cfg)
	}
}

func TestLoadUsesConfiguredAddress(t *testing.T) {
	t.Setenv("PLATFORM_ADDR", ":18080")
	t.Setenv("PLATFORM_STORAGE_BACKEND", "mysql")
	t.Setenv("PLATFORM_MYSQL_DSN", "platform:platform@tcp(127.0.0.1:3306)/platform?parseTime=true")
	t.Setenv("PLATFORM_DATA_DIR", "/tmp/platform-data")
	t.Setenv("PLATFORM_METADATA_PATH", "/tmp/platform-metadata.json")
	t.Setenv("PLATFORM_LOG_DIR", "/tmp/platform-logs")
	t.Setenv("PLATFORM_LOG_BODY_BACKEND", "file")
	t.Setenv("PLATFORM_BOOTSTRAP_ADMIN_EMAIL", "admin@example.test")
	t.Setenv("PLATFORM_BOOTSTRAP_ADMIN_PASSWORD", "configured-secret")
	t.Setenv("PLATFORM_SECRET_ENVELOPE_KEY", "configured-envelope-key-at-least-32-bytes")
	t.Setenv("PLATFORM_BUILDER_DOCKER_BINARY", "/usr/local/bin/docker")
	t.Setenv("PLATFORM_BUILDER_IMAGE", "registry.example.test/distribution-builder:2.0.0")
	t.Setenv("PLATFORM_BUILDER_SOURCE_DIR", "/srv/run-source")
	t.Setenv("PLATFORM_BUILDER_WORKSPACE_DIR", "/srv/distribution-builds")
	t.Setenv("PLATFORM_BUILDER_CACHE_DIR", "/srv/distribution-build-cache")
	t.Setenv("PLATFORM_BUILDER_TIMEOUT_SECONDS", "900")

	cfg := Load()
	if cfg.Addr != ":18080" {
		t.Fatalf("expected configured addr, got %q", cfg.Addr)
	}
	if cfg.StorageBackend != "mysql" || cfg.MySQLDSN != "platform:platform@tcp(127.0.0.1:3306)/platform?parseTime=true" || cfg.DataDir != "/tmp/platform-data" || cfg.MetadataPath != "/tmp/platform-metadata.json" || cfg.LogDir != "/tmp/platform-logs" || cfg.LogBodyBackend != "file" || cfg.BootstrapAdminEmail != "admin@example.test" || cfg.BootstrapAdminPassword != "configured-secret" || cfg.SecretEnvelopeKey != "configured-envelope-key-at-least-32-bytes" {
		t.Fatalf("unexpected configured storage: %+v", cfg)
	}
	if cfg.BuilderDockerBinary != "/usr/local/bin/docker" || cfg.BuilderImage != "registry.example.test/distribution-builder:2.0.0" || cfg.BuilderSourceDir != "/srv/run-source" || cfg.BuilderWorkspaceDir != "/srv/distribution-builds" || cfg.BuilderCacheDir != "/srv/distribution-build-cache" || cfg.BuilderTimeoutSeconds != 900 {
		t.Fatalf("unexpected configured builder: %+v", cfg)
	}
}

func TestLoadReadsPlatformEnvFile(t *testing.T) {
	clearPlatformEnv(t)
	chdirTemp(t)

	if err := os.Mkdir("platform", 0o755); err != nil {
		t.Fatalf("create platform dir: %v", err)
	}
	env := strings.Join([]string{
		"PLATFORM_ADDR=:19090",
		"PLATFORM_STORAGE_BACKEND=mysql",
		"PLATFORM_MYSQL_DSN='platform:platform@tcp(127.0.0.1:3306)/platform?parseTime=true'",
		"PLATFORM_LOG_BODY_BACKEND=file",
	}, "\n")
	if err := os.WriteFile(filepath.Join("platform", ".env"), []byte(env), 0o600); err != nil {
		t.Fatalf("write env file: %v", err)
	}

	cfg := Load()
	if cfg.Addr != ":19090" || cfg.StorageBackend != "mysql" || cfg.MySQLDSN != "platform:platform@tcp(127.0.0.1:3306)/platform?parseTime=true" || cfg.LogBodyBackend != "file" {
		t.Fatalf("expected config from platform/.env, got %+v", cfg)
	}
}

func TestLoadKeepsProcessEnvOverEnvFile(t *testing.T) {
	clearPlatformEnv(t)
	chdirTemp(t)
	t.Setenv("PLATFORM_STORAGE_BACKEND", "memory")

	if err := os.WriteFile(".env", []byte("PLATFORM_STORAGE_BACKEND=mysql\nPLATFORM_MYSQL_DSN=file-dsn\n"), 0o600); err != nil {
		t.Fatalf("write env file: %v", err)
	}

	cfg := Load()
	if cfg.StorageBackend != "memory" {
		t.Fatalf("expected process env storage backend, got %+v", cfg)
	}
	if cfg.MySQLDSN != "file-dsn" {
		t.Fatalf("expected missing process DSN to come from env file, got %+v", cfg)
	}
}

func clearPlatformEnv(t *testing.T) {
	t.Helper()
	for _, key := range []string{
		"PLATFORM_ADDR",
		"PLATFORM_STORAGE_BACKEND",
		"PLATFORM_MYSQL_DSN",
		"PLATFORM_DATA_DIR",
		"PLATFORM_METADATA_PATH",
		"PLATFORM_LOG_DIR",
		"PLATFORM_LOG_BODY_BACKEND",
		"PLATFORM_BOOTSTRAP_ADMIN_EMAIL",
		"PLATFORM_BOOTSTRAP_ADMIN_PASSWORD",
		"PLATFORM_SECRET_ENVELOPE_KEY",
		"PLATFORM_BUILDER_DOCKER_BINARY",
		"PLATFORM_BUILDER_IMAGE",
		"PLATFORM_BUILDER_SOURCE_DIR",
		"PLATFORM_BUILDER_WORKSPACE_DIR",
		"PLATFORM_BUILDER_CACHE_DIR",
		"PLATFORM_BUILDER_TIMEOUT_SECONDS",
	} {
		t.Setenv(key, "")
		if err := os.Unsetenv(key); err != nil {
			t.Fatalf("unset %s: %v", key, err)
		}
	}
}

func chdirTemp(t *testing.T) {
	t.Helper()
	previous, err := os.Getwd()
	if err != nil {
		t.Fatalf("get working directory: %v", err)
	}
	if err := os.Chdir(t.TempDir()); err != nil {
		t.Fatalf("chdir temp: %v", err)
	}
	t.Cleanup(func() {
		if err := os.Chdir(previous); err != nil {
			t.Fatalf("restore working directory: %v", err)
		}
	})
}