154 lines
2.9 KiB
Go
154 lines
2.9 KiB
Go
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
|
|
}
|