99 lines
3.5 KiB
Go
99 lines
3.5 KiB
Go
package config
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func lookup(values map[string]string) func(string) (string, bool) {
|
|
return func(key string) (string, bool) {
|
|
value, ok := values[key]
|
|
return value, ok
|
|
}
|
|
}
|
|
|
|
func TestLoadDevelopmentRequiresDSNWithoutLeakingIt(t *testing.T) {
|
|
secret := "user:secret@tcp(localhost:3308)/chorus"
|
|
cfg, err := LoadFromLookup(lookup(map[string]string{
|
|
"CHORUS_ENV": "development",
|
|
"CHORUS_DSN": secret,
|
|
}))
|
|
if err != nil {
|
|
t.Fatalf("LoadFromLookup() error = %v", err)
|
|
}
|
|
if cfg.DBDSN != secret || cfg.ListenAddress != "127.0.0.1:8080" {
|
|
t.Fatalf("unexpected config: %#v", cfg)
|
|
}
|
|
if cfg.WorkerLeaseDuration != 60*time.Second || cfg.WorkerPollInterval != 250*time.Millisecond || cfg.ProviderHTTPTimeout != 45*time.Second || cfg.ProviderMaxResponseBytes != 32<<20 {
|
|
t.Fatalf("unexpected worker defaults: %#v", cfg)
|
|
}
|
|
}
|
|
|
|
func TestLoadProductionFailsClosed(t *testing.T) {
|
|
_, err := LoadFromLookup(lookup(map[string]string{
|
|
"CHORUS_ENV": "production",
|
|
"CHORUS_DSN": "sensitive-dsn",
|
|
}))
|
|
if err == nil {
|
|
t.Fatal("LoadFromLookup() expected an error")
|
|
}
|
|
for _, name := range []string{"CHORUS_MASTER_KEY", "CHORUS_SESSION_KEY", "CHORUS_STORAGE_ROOT"} {
|
|
if !strings.Contains(err.Error(), name) {
|
|
t.Errorf("error %q does not identify %s", err, name)
|
|
}
|
|
}
|
|
if strings.Contains(err.Error(), "sensitive-dsn") {
|
|
t.Fatalf("error leaked DSN: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsUnknownEnvironment(t *testing.T) {
|
|
_, err := LoadFromLookup(lookup(map[string]string{"CHORUS_ENV": "prod"}))
|
|
if err == nil {
|
|
t.Fatal("LoadFromLookup() expected an error")
|
|
}
|
|
}
|
|
|
|
func TestLoadProductionPortalLimits(t *testing.T) {
|
|
values := map[string]string{
|
|
"CHORUS_ENV": "production", "CHORUS_DSN": "sensitive-dsn", "CHORUS_MASTER_KEY": strings.Repeat("m", 32),
|
|
"CHORUS_SESSION_KEY": strings.Repeat("s", 32), "CHORUS_STORAGE_ROOT": "/var/lib/chorus",
|
|
"CHORUS_SESSION_TTL_MINUTES": "480", "CHORUS_LOGIN_ATTEMPTS": "5", "CHORUS_LOGIN_WINDOW_SECONDS": "60",
|
|
"CHORUS_MAX_PROMPT_BYTES": "8000", "CHORUS_MAX_IMAGES": "8", "CHORUS_MAX_IMAGE_BYTES": "10485760",
|
|
"CHORUS_MAX_UPLOAD_BYTES": "33554432", "CHORUS_MAX_IMAGE_PIXELS": "40000000", "CHORUS_HISTORY_LIMIT": "50",
|
|
"CHORUS_WORKER_LEASE_SECONDS": "60", "CHORUS_WORKER_POLL_MILLISECONDS": "250",
|
|
"CHORUS_PROVIDER_HTTP_TIMEOUT_SECONDS": "45", "CHORUS_PROVIDER_MAX_RESPONSE_BYTES": "33554432",
|
|
}
|
|
cfg, err := LoadFromLookup(lookup(values))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := cfg.ValidateProduction(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
values["CHORUS_MAX_UPLOAD_BYTES"] = "100"
|
|
if _, err := LoadFromLookup(lookup(values)); err == nil {
|
|
t.Fatal("inconsistent upload limits accepted")
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsUnsafeWorkerLease(t *testing.T) {
|
|
_, err := LoadFromLookup(lookup(map[string]string{
|
|
"CHORUS_DSN": "test-dsn", "CHORUS_WORKER_LEASE_SECONDS": "50", "CHORUS_PROVIDER_HTTP_TIMEOUT_SECONDS": "45",
|
|
}))
|
|
if err == nil || !strings.Contains(err.Error(), "worker lease") {
|
|
t.Fatalf("expected worker lease error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestWorkerCanOnlyBeDisabledInTest(t *testing.T) {
|
|
if _, err := LoadFromLookup(lookup(map[string]string{"CHORUS_DSN": "test-dsn", "CHORUS_TEST_DISABLE_WORKER": "true"})); err == nil {
|
|
t.Fatal("development accepted disabled worker")
|
|
}
|
|
cfg, err := LoadFromLookup(lookup(map[string]string{"CHORUS_ENV": "test", "CHORUS_DSN": "test-dsn", "CHORUS_TEST_DISABLE_WORKER": "true"}))
|
|
if err != nil || !cfg.TestDisableWorker {
|
|
t.Fatalf("test worker fixture was rejected: %#v %v", cfg, err)
|
|
}
|
|
}
|