627724f702
the main motivation for this change is to be able to run tests.
before this commit, Start, Router and Log operated on global variables,
making automated testing unreasonably hard.
this commit puts all that a server needs in a new Server type,
which also made it possible for a Server.Shutdown - see ShutdownAware
doc comments.
BREAKING CHANGES:
- Relay.OnInitialized takes one argument now, *relayer.Server.
- relayer.Router is now replaced by relayer.Server.Router().
package users can still hook into the router from OnInitialized
for custom HTTP routing.
- relayer.Log is gone. apart from another global var, imho this was
a too opinionated choice for a framework to build a custom relay upon.
this commit introduces a Logger interface which package users can implement
for zerolog to make it log like before. see Server.Log for details.
other notable changes: finally added a couple basic tests, for start up
and shutdown. doc comments now explain most of the essentials,
hopefully making it more approachable for newcomers and easier to understand
the relayer package.
the changes in handlers.go are minimal, although git diff goes crazy.
this is because most of the lines are simply shifted indentation back by one
due to go fmt.
before this commit:
func handleWebsocket(relay Relay) func(http.ResponseWriter, *http.Request)
func handleNIP11(relay Relay) func(http.ResponseWriter, *http.Request)
after:
func (s *Server) handleWebsocket(w http.ResponseWriter, r *http.Request)
func (s *Server) handleNIP11(w http.ResponseWriter, r *http.Request)
107 lines
2.5 KiB
Go
107 lines
2.5 KiB
Go
package relayer
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gorilla/websocket"
|
|
"github.com/nbd-wtf/go-nostr"
|
|
)
|
|
|
|
func TestServerStartShutdown(t *testing.T) {
|
|
var (
|
|
serverHost string
|
|
inited bool
|
|
storeInited bool
|
|
shutdown bool
|
|
)
|
|
ready := make(chan struct{})
|
|
rl := &testRelay{
|
|
name: "test server start",
|
|
init: func() error {
|
|
inited = true
|
|
return nil
|
|
},
|
|
onInitialized: func(s *Server) {
|
|
serverHost = s.Addr()
|
|
close(ready)
|
|
},
|
|
onShutdown: func(context.Context) { shutdown = true },
|
|
storage: &testStorage{
|
|
init: func() error { storeInited = true; return nil },
|
|
},
|
|
}
|
|
srv := NewServer("127.0.0.1:0", rl)
|
|
done := make(chan error)
|
|
go func() { done <- srv.Start(); close(done) }()
|
|
|
|
// verify everything's initialized
|
|
select {
|
|
case <-ready:
|
|
// continue
|
|
case <-time.After(time.Second):
|
|
t.Fatal("srv.Start too long to initialize")
|
|
}
|
|
if !inited {
|
|
t.Error("didn't call testRelay.init")
|
|
}
|
|
if !storeInited {
|
|
t.Error("didn't call testStorage.init")
|
|
}
|
|
|
|
// check that http requests are served
|
|
if _, err := http.Get("http://" + serverHost); err != nil {
|
|
t.Errorf("GET %s: %v", serverHost, err)
|
|
}
|
|
|
|
// verify server shuts down
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(ctx); err != nil {
|
|
t.Errorf("srv.Shutdown: %v", err)
|
|
}
|
|
if !shutdown {
|
|
t.Error("didn't call testRelay.onShutdown")
|
|
}
|
|
select {
|
|
case err := <-done:
|
|
if err != nil {
|
|
t.Errorf("srv.Start: %v", err)
|
|
}
|
|
case <-time.After(time.Second):
|
|
t.Error("srv.Start too long to return")
|
|
}
|
|
}
|
|
|
|
func TestServerShutdownWebsocket(t *testing.T) {
|
|
// set up a new relay server
|
|
srv := startTestRelay(t, &testRelay{storage: &testStorage{}})
|
|
|
|
// connect a client to it
|
|
ctx1, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
client, err := nostr.RelayConnectContext(ctx1, "ws://"+srv.Addr())
|
|
if err != nil {
|
|
t.Fatalf("nostr.RelayConnectContext: %v", err)
|
|
}
|
|
|
|
// now, shut down the server
|
|
ctx2, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
if err := srv.Shutdown(ctx2); err != nil {
|
|
t.Errorf("srv.Shutdown: %v", err)
|
|
}
|
|
|
|
// wait for the client to receive a "connection close"
|
|
select {
|
|
case err := <-client.ConnectionError:
|
|
if _, ok := err.(*websocket.CloseError); !ok {
|
|
t.Errorf("client.ConnextionError: %v (%T); want websocket.CloseError", err, err)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Error("client took too long to disconnect")
|
|
}
|
|
}
|