added simple websocket test

- bump to v0.21.1

relay-tester/client.go

@@ -56,6 +56,11 @@ func (c *Client) Close() error {
 	return c.conn.Close()
 }
 
+// URL returns the relay URL.
+func (c *Client) URL() string {
+	return c.url
+}
+
 // Send sends a JSON message to the relay.
 func (c *Client) Send(msg interface{}) (err error) {
 	c.mu.Lock()

relay-tester/test.go

@@ -291,6 +291,11 @@ func (s *TestSuite) registerTests() {
 			Required: true,
 			Func:     testSupportsEose,
 		},
+		{
+			Name:     "Subscription receives event after ping period",
+			Required: true,
+			Func:     testSubscriptionReceivesEventAfterPingPeriod,
+		},
 		{
 			Name:     "Closes complete subscriptions after EOSE",
 			Required: false,
@@ -420,6 +425,20 @@ func (s *TestSuite) GetResults() map[string]TestResult {
 	return s.results
 }
 
+// ListTests returns a list of all test names in execution order.
+func (s *TestSuite) ListTests() []string {
+	return s.order
+}
+
+// GetTestNames returns all registered test names as a map (name -> required).
+func (s *TestSuite) GetTestNames() map[string]bool {
+	result := make(map[string]bool)
+	for name, tc := range s.tests {
+		result[name] = tc.Required
+	}
+	return result
+}
+
 // FormatJSON formats results as JSON.
 func FormatJSON(results []TestResult) (output string, err error) {
 	var data []byte

relay-tester/tests.go

@@ -1632,6 +1632,96 @@ func testSupportsEose(client *Client, key1, key2 *KeyPair) (result TestResult) {
 	}
 }
 
+func testSubscriptionReceivesEventAfterPingPeriod(client *Client, key1, key2 *KeyPair) (result TestResult) {
+	// Create a second client for publishing
+	publisherClient, err := NewClient(client.URL())
+	if err != nil {
+		return TestResult{Pass: false, Info: fmt.Sprintf("failed to create publisher client: %v", err)}
+	}
+	defer publisherClient.Close()
+
+	// Subscribe to events from key1
+	filter := map[string]interface{}{
+		"authors": []string{hex.Enc(key1.Pubkey)},
+		"kinds":   []int{int(kind.TextNote.K)},
+	}
+	ch, err := client.Subscribe("test-ping-period", []interface{}{filter})
+	if err != nil {
+		return TestResult{Pass: false, Info: fmt.Sprintf("failed to subscribe: %v", err)}
+	}
+	defer client.Unsubscribe("test-ping-period")
+
+	// Wait for EOSE to ensure subscription is established
+	eoseTimeout := time.After(3 * time.Second)
+	gotEose := false
+	for !gotEose {
+		select {
+		case msg, ok := <-ch:
+			if !ok {
+				return TestResult{Pass: false, Info: "channel closed before EOSE"}
+			}
+			var raw []interface{}
+			if err = json.Unmarshal(msg, &raw); err != nil {
+				continue
+			}
+			if len(raw) >= 2 {
+				if typ, ok := raw[0].(string); ok && typ == "EOSE" {
+					gotEose = true
+					break
+				}
+			}
+		case <-eoseTimeout:
+			return TestResult{Pass: false, Info: "timeout waiting for EOSE"}
+		}
+	}
+
+	// Wait for at least one ping period (30 seconds) to ensure connection is idle
+	// and has been pinged at least once
+	pingPeriod := 35 * time.Second // Slightly longer than 30s to ensure at least one ping
+	time.Sleep(pingPeriod)
+
+	// Now publish an event from the publisher client that matches the subscription
+	ev, err := CreateEvent(key1.Secret, kind.TextNote.K, "event after ping period", nil)
+	if err != nil {
+		return TestResult{Pass: false, Info: fmt.Sprintf("failed to create event: %v", err)}
+	}
+	if err = publisherClient.Publish(ev); err != nil {
+		return TestResult{Pass: false, Info: fmt.Sprintf("failed to publish: %v", err)}
+	}
+	accepted, _, err := publisherClient.WaitForOK(ev.ID, 5*time.Second)
+	if err != nil || !accepted {
+		return TestResult{Pass: false, Info: "event not accepted"}
+	}
+
+	// Wait for event to come through subscription (should work even after ping period)
+	eventTimeout := time.After(5 * time.Second)
+	for {
+		select {
+		case msg, ok := <-ch:
+			if !ok {
+				return TestResult{Pass: false, Info: "subscription closed"}
+			}
+			var raw []interface{}
+			if err = json.Unmarshal(msg, &raw); err != nil {
+				continue
+			}
+			if len(raw) >= 3 && raw[0] == "EVENT" {
+				if evData, ok := raw[2].(map[string]interface{}); ok {
+					evJSON, _ := json.Marshal(evData)
+					receivedEv := event.New()
+					if _, err = receivedEv.Unmarshal(evJSON); err == nil {
+						if string(receivedEv.ID) == string(ev.ID) {
+							return TestResult{Pass: true}
+						}
+					}
+				}
+			}
+		case <-eventTimeout:
+			return TestResult{Pass: false, Info: "timeout waiting for event after ping period"}
+		}
+	}
+}
+
 func testClosesCompleteSubscriptionsAfterEose(client *Client, key1, key2 *KeyPair) (result TestResult) {
 	// Create a filter that fetches a specific event by ID (complete subscription)
 	fakeID := "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"