forked from mtusi2026/mtusi2026lab3
109 lines
3.1 KiB
Go
109 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"go.uber.org/fx"
|
|
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab3/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)
|
|
}
|
|
}
|