package server import ( "bytes" "context" "log" "net/http/httptest" "path/filepath" "strings" "sync" "testing" "time" "github.com/coder/websocket" "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/buildinfo" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" ) type logBuffer struct { mu sync.Mutex buffer bytes.Buffer } func (b *logBuffer) Write(p []byte) (int, error) { b.mu.Lock() defer b.mu.Unlock() return b.buffer.Write(p) } func (b *logBuffer) String() string { b.mu.Lock() defer b.mu.Unlock() return b.buffer.String() } func TestPersistentConnection(t *testing.T) { var logs logBuffer previousOutput := log.Writer() log.SetOutput(&logs) defer log.SetOutput(previousOutput) ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() srv := httptest.NewServer(Handler(ctx)) defer srv.Close() conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) if err != nil { t.Fatal(err) } defer conn.CloseNow() for _, request := range []protocol.Message{ {Type: protocol.Ping, ID: "1"}, {Type: "unknown", ID: "2"}, {Type: protocol.Ping, ID: "3"}, } { before := time.Now().UTC().Truncate(time.Second) if err := wsjson.Write(ctx, conn, request); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.ID != request.ID { t.Fatalf("ID = %q, want %q", response.ID, request.ID) } if request.Type != protocol.Ping { if response.Type != protocol.Error || response.Error == "" { t.Fatalf("expected error response, got %+v", response) } continue } if response.Type != protocol.Pong { t.Fatalf("expected pong, got %+v", response) } wantBuild := buildinfo.Current() if response.Build == nil || response.Build.Version != wantBuild.Version || response.Build.Commit != wantBuild.Commit { t.Fatalf("pong missing server build identity: %+v", response.Build) } if response.Protocol != protocol.ProtocolVersion { t.Fatalf("pong protocol = %d, want %d", response.Protocol, protocol.ProtocolVersion) } stamp, err := time.Parse(time.RFC3339, response.Time) if err != nil { t.Fatal(err) } if stamp.Before(before) || stamp.After(time.Now().UTC()) || stamp.Nanosecond() != 0 || !strings.HasSuffix(response.Time, "Z") { t.Fatalf("invalid current UTC time to seconds: %q", response.Time) } } for _, expected := range []string{ `command received: client=`, `type="ping" id="1"`, `response sent: client=`, `type="pong" id="1" time="`, `type="error" id="2"`, } { if !strings.Contains(logs.String(), expected) { t.Errorf("missing log %q in %s", expected, logs.String()) } } } // TestWelcomeEnvelopeCarriesServerIdentity proves a client that never pings // still learns the server build and protocol from the unsolicited welcome. func TestWelcomeEnvelopeCarriesServerIdentity(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() store, err := pipeline.Open(filepath.Join(t.TempDir(), "identity.db")) if err != nil { t.Fatal(err) } defer store.Close() handler := Handler(ctx, store) srv := httptest.NewServer(handler) defer srv.Close() defer func() { cancel(); WaitRuns(handler) }() conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) if err != nil { t.Fatal(err) } defer conn.CloseNow() var welcome protocol.Message if err := wsjson.Read(ctx, conn, &welcome); err != nil { t.Fatal(err) } if welcome.Type != protocol.PipelineList { t.Fatalf("first frame = %q, want welcome pipelines list", welcome.Type) } wantBuild := buildinfo.Current() if welcome.Build == nil || welcome.Build.Version != wantBuild.Version || welcome.Build.Commit != wantBuild.Commit { t.Fatalf("welcome missing server build identity: %+v", welcome.Build) } if welcome.Protocol != protocol.ProtocolVersion { t.Fatalf("welcome protocol = %d, want %d", welcome.Protocol, protocol.ProtocolVersion) } }