package main import ( "context" "net" "os" "testing" "time" "go.uber.org/fx" "gitea.privcloud.tech/vlad_marlo/mtusi2026lab5/internal/config" ) // TestDependencyGraph ensures constructor signatures and interface bindings agree. func TestDependencyGraph(t *testing.T) { if err := fx.ValidateApp(CreateApp(), fx.NopLogger); err != nil { t.Fatal(err) } } // TestInvalidConfigurationStopsStartup checks failure before a listener is acquired. func TestInvalidConfigurationStopsStartup(t *testing.T) { t.Setenv("APP_PORT", "0") app := fx.New(CreateApp(), fx.NopLogger) if err := app.Start(context.Background()); err == nil { t.Fatal("invalid listener configuration accepted") } } // TestCommandValidation ensures unsupported arguments cannot accidentally start a server. func TestCommandValidation(t *testing.T) { if err := run([]string{"unknown"}); err == nil { t.Fatal("unknown command accepted") } } // TestLoggerConfiguration checks that process logging uses its own validated section. func TestLoggerConfiguration(t *testing.T) { if _, err := newLogger(&config.Logger{Level: "invalid"}); err == nil { t.Fatal("invalid logger configuration accepted") } } // TestApplicationLifecycle starts the complete Fx graph and drains its real HTTP listener. func TestApplicationLifecycle(t *testing.T) { requirePersistence(t) listener, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } cfg := config.Default() cfg.HTTP.Host = "127.0.0.1" cfg.HTTP.Port = listener.Addr().(*net.TCPAddr).Port cfg.Logger.Level = "error" if err := listener.Close(); err != nil { t.Fatal(err) } app := fx.New(CreateApp(), fx.Replace(cfg)) ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second) defer cancel() if err := app.Start(ctx); err != nil { t.Fatal(err) } t.Cleanup(func() { stopCtx, stopCancel := context.WithTimeout(context.Background(), 5*time.Second) defer stopCancel() if err := app.Stop(stopCtx); err != nil { t.Error(err) } }) if err := checkReadiness(cfg.HTTP); err != nil { t.Fatal(err) } } // TestOccupiedListenerFailsStartup ensures bind failures propagate through the Fx lifecycle. func TestOccupiedListenerFailsStartup(t *testing.T) { requirePersistence(t) listener, err := net.Listen("tcp", "127.0.0.1:0") if err != nil { t.Fatal(err) } defer func() { _ = listener.Close() }() cfg := config.Default() cfg.HTTP.Host = "127.0.0.1" cfg.HTTP.Port = listener.Addr().(*net.TCPAddr).Port cfg.Logger.Level = "error" app := fx.New(CreateApp(), fx.Replace(cfg), fx.NopLogger) if err := app.Start(t.Context()); err == nil { _ = app.Stop(t.Context()) t.Fatal("startup succeeded on an occupied listener") } } // requirePersistence prevents infrastructure scenarios from silently passing on configuration failure. func requirePersistence(t *testing.T) { t.Helper() if os.Getenv("DATABASE_URL") == "" || os.Getenv("VALKEY_SHARDS") == "" { t.Skip("DATABASE_URL and VALKEY_SHARDS are required for real application lifecycle tests") } t.Setenv("CURSOR_SIGNING_KEY", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=") if err := migrate(); err != nil { t.Fatal(err) } }