init push

cmd/api/main_test.go

@@ -0,0 +1,153 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"testing"
+)
+
+func TestMain_RunSuccess(t *testing.T) {
+	origRun := apiRunFn
+	origFatal := apiFatalFn
+	t.Cleanup(func() {
+		apiRunFn = origRun
+		apiFatalFn = origFatal
+	})
+
+	runCalled := false
+	fatalCalled := false
+	apiRunFn = func() error {
+		runCalled = true
+		return nil
+	}
+	apiFatalFn = func(v ...any) {
+		fatalCalled = true
+	}
+
+	main()
+
+	if !runCalled {
+		t.Fatalf("expected main to call run function")
+	}
+	if fatalCalled {
+		t.Fatalf("did not expect fatal function on successful run")
+	}
+}
+
+func TestMain_RunErrorCallsFatal(t *testing.T) {
+	origRun := apiRunFn
+	origFatal := apiFatalFn
+	t.Cleanup(func() {
+		apiRunFn = origRun
+		apiFatalFn = origFatal
+	})
+
+	errBoom := errors.New("boom")
+	fatalCalled := false
+	var fatalArgs []any
+
+	apiRunFn = func() error {
+		return errBoom
+	}
+	apiFatalFn = func(v ...any) {
+		fatalCalled = true
+		fatalArgs = v
+	}
+
+	main()
+
+	if !fatalCalled {
+		t.Fatalf("expected fatal function to be called on run error")
+	}
+	if len(fatalArgs) != 1 || fatalArgs[0] != errBoom {
+		t.Fatalf("unexpected fatal args: %#v", fatalArgs)
+	}
+}
+
+func TestServeAPI_StartError(t *testing.T) {
+	errBoom := errors.New("boom")
+	srv := &stubAPIServer{startErr: errBoom}
+
+	err := serveAPI(context.Background(), srv, ":8080")
+	if !errors.Is(err, errBoom) {
+		t.Fatalf("expected %v, got %v", errBoom, err)
+	}
+	if srv.shutdownCalled {
+		t.Fatalf("did not expect shutdown to be called on start error")
+	}
+}
+
+func TestServeAPI_ShutsDownOnContextCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	srv := &stubAPIServer{
+		started:      make(chan struct{}),
+		releaseStart: make(chan struct{}),
+	}
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- serveAPI(ctx, srv, ":8080")
+	}()
+
+	<-srv.started
+	cancel()
+
+	if err := <-errCh; err != nil {
+		t.Fatalf("expected nil error, got %v", err)
+	}
+	if !srv.shutdownCalled {
+		t.Fatalf("expected shutdown to be called")
+	}
+}
+
+func TestServeAPI_ReturnsShutdownError(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	errBoom := errors.New("shutdown failed")
+	srv := &stubAPIServer{
+		started:      make(chan struct{}),
+		releaseStart: make(chan struct{}),
+		shutdownErr:  errBoom,
+	}
+
+	errCh := make(chan error, 1)
+	go func() {
+		errCh <- serveAPI(ctx, srv, ":8080")
+	}()
+
+	<-srv.started
+	cancel()
+
+	if err := <-errCh; !errors.Is(err, errBoom) {
+		t.Fatalf("expected %v, got %v", errBoom, err)
+	}
+}
+
+type stubAPIServer struct {
+	startErr       error
+	shutdownErr    error
+	started        chan struct{}
+	releaseStart   chan struct{}
+	shutdownCalled bool
+	releaseOnce    sync.Once
+}
+
+func (s *stubAPIServer) Start(string) error {
+	if s.started != nil {
+		close(s.started)
+	}
+	if s.releaseStart != nil {
+		<-s.releaseStart
+	}
+	return s.startErr
+}
+
+func (s *stubAPIServer) Shutdown(context.Context) error {
+	s.shutdownCalled = true
+	if s.releaseStart != nil {
+		s.releaseOnce.Do(func() {
+			close(s.releaseStart)
+		})
+	}
+	return s.shutdownErr
+}