mleku/orly
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

backporting relay client and pool from latest go-nostr

Browse Source
This commit is contained in:
mleku
2025-08-06 22:18:26 +01:00
parent a7dd958585
commit 9c8ff2976d
41 changed files with 1954 additions and 1623 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
pkg/protocol/ws/client_test.go
View File

@@ -1,146 +1,159 @@
package ws
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"orly.dev/pkg/crypto/p256k"
"orly.dev/pkg/encoders/envelopes/eventenvelope"
"orly.dev/pkg/encoders/envelopes/okenvelope"
"orly.dev/pkg/encoders/event"
"orly.dev/pkg/encoders/kind"
"orly.dev/pkg/encoders/tag"
"orly.dev/pkg/encoders/tags"
"orly.dev/pkg/encoders/timestamp"
"orly.dev/pkg/utils/chk"
"orly.dev/pkg/utils/normalize"
"sync"
"testing"
"time"
"orly.dev/pkg/crypto/p256k"
"orly.dev/pkg/encoders/event"
"orly.dev/pkg/encoders/kind"
"orly.dev/pkg/encoders/timestamp"
"orly.dev/pkg/utils/chk"
"orly.dev/pkg/utils/normalize"
"golang.org/x/net/websocket"
)
func TestPublish(t *testing.T) {
// test note to be sent over websocket
var err error
signer := &p256k.Signer{}
if err = signer.Generate(); chk.E(err) {
t.Fatal(err)
}
textNote := &event.E{
Kind: kind.TextNote,
Content: []byte("hello"),
CreatedAt: timestamp.FromUnix(1672068534), // random fixed timestamp
Tags: tags.New(tag.New("foo", "bar")),
Pubkey: signer.Pub(),
}
if err = textNote.Sign(signer); chk.E(err) {
t.Fatalf("textNote.Sign: %v", err)
}
// fake relay server
var mu sync.Mutex // guards published to satisfy `go test -race`
var published bool
ws := newWebsocketServer(
func(conn *websocket.Conn) {
mu.Lock()
published = true
mu.Unlock()
// verify the client sent exactly the textNote
var raw []json.RawMessage
if err := websocket.JSON.Receive(conn, &raw); chk.T(err) {
t.Errorf("websocket.JSON.Receive: %v", err)
}
if string(raw[0]) != fmt.Sprintf(`"%s"`, eventenvelope.L) {
t.Errorf("got type %s, want %s", raw[0], eventenvelope.L)
}
env := eventenvelope.NewSubmission()
if raw[1], err = env.Unmarshal(raw[1]); chk.E(err) {
t.Fatal(err)
}
if !bytes.Equal(env.E.Serialize(), textNote.Serialize()) {
t.Errorf(
"received event:\n%s\nwant:\n%s", env.E.Serialize(),
textNote.Serialize(),
)
}
// send back an ok nip-20 command result
var res []byte
if res = okenvelope.NewFrom(
textNote.ID, true, nil,
).Marshal(res); chk.E(err) {
t.Fatal(err)
}
if err := websocket.Message.Send(conn, res); chk.T(err) {
t.Errorf("websocket.JSON.Send: %v", err)
}
},
)
defer ws.Close()
// connect a client and send the text note
rl := mustRelayConnect(ws.URL)
err = rl.Publish(context.Bg(), textNote)
if err != nil {
t.Errorf("publish should have succeeded")
}
if !published {
t.Errorf("fake relay server saw no event")
}
}
func TestPublishBlocked(t *testing.T) {
// test note to be sent over websocket
var err error
signer := &p256k.Signer{}
if err = signer.Generate(); chk.E(err) {
t.Fatal(err)
}
textNote := &event.E{
Kind: kind.TextNote,
Content: []byte("hello"),
CreatedAt: timestamp.FromUnix(1672068534), // random fixed timestamp
Pubkey: signer.Pub(),
}
if err = textNote.Sign(signer); chk.E(err) {
t.Fatalf("textNote.Sign: %v", err)
}
// fake relay server
ws := newWebsocketServer(
func(conn *websocket.Conn) {
// discard received message; not interested
var raw []json.RawMessage
if err := websocket.JSON.Receive(conn, &raw); chk.T(err) {
t.Errorf("websocket.JSON.Receive: %v", err)
}
// send back a not ok nip-20 command result
var res []byte
if res = okenvelope.NewFrom(
textNote.ID, false,
normalize.Msg(normalize.Blocked, "no reason"),
).Marshal(res); chk.E(err) {
t.Fatal(err)
}
if err := websocket.Message.Send(conn, res); chk.T(err) {
t.Errorf("websocket.JSON.Send: %v", err)
}
// res := []any{"OK", textNote.ID, false, "blocked"}
chk.E(websocket.JSON.Send(conn, res))
},
)
defer ws.Close()
// connect a client and send a text note
rl := mustRelayConnect(ws.URL)
if err = rl.Publish(context.Bg(), textNote); !chk.E(err) {
t.Errorf("should have failed to publish")
}
}
// func TestPublish(t *testing.T) {
// // test note to be sent over websocket
// var err error
// signer := &p256k.Signer{}
// if err = signer.Generate(); chk.E(err) {
// t.Fatal(err)
// }
// textNote := &event.E{
// Kind: kind.TextNote,
// Content: []byte("hello"),
// CreatedAt: timestamp.FromUnix(1672068534), // random fixed timestamp
// Pubkey: signer.Pub(),
// }
// if err = textNote.Sign(signer); chk.E(err) {
// t.Fatalf("textNote.Sign: %v", err)
// }
// // fake relay server
// var published bool
// ws := newWebsocketServer(
// func(conn *websocket.Conn) {
// // receive message
// var raw []json.RawMessage
// if err := websocket.JSON.Receive(conn, &raw); chk.T(err) {
// t.Errorf("websocket.JSON.Receive: %v", err)
// }
// // check that it's an EVENT message
// if len(raw) < 2 {
// t.Errorf("message too short: %v", raw)
// }
// var msgType string
// if err := json.Unmarshal(raw[0], &msgType); chk.T(err) {
// t.Errorf("json.Unmarshal: %v", err)
// }
// if msgType != "EVENT" {
// t.Errorf("expected EVENT message, got %q", msgType)
// }
// // check that the event is the one we sent
// var ev event.E
// if err := json.Unmarshal(raw[1], &ev); chk.T(err) {
// t.Errorf("json.Unmarshal: %v", err)
// }
// published = true
// if !bytes.Equal(ev.ID, textNote.ID) {
// t.Errorf(
// "event ID mismatch: got %x, want %x",
// ev.ID, textNote.ID,
// )
// }
// if !bytes.Equal(ev.Pubkey, textNote.Pubkey) {
// t.Errorf(
// "event pubkey mismatch: got %x, want %x",
// ev.Pubkey, textNote.Pubkey,
// )
// }
// if !bytes.Equal(ev.Content, textNote.Content) {
// t.Errorf(
// "event content mismatch: got %q, want %q",
// ev.Content, textNote.Content,
// )
// }
// fmt.Printf(
// "received event: %s\n",
// textNote.Serialize(),
// )
// // send back an ok nip-20 command result
// var res []byte
// if res = okenvelope.NewFrom(
// textNote.ID, true, nil,
// ).Marshal(res); chk.E(err) {
// t.Fatal(err)
// }
// if err := websocket.Message.Send(conn, res); chk.T(err) {
// t.Errorf("websocket.Message.Send: %v", err)
// }
// },
// )
// defer ws.Close()
// // connect a client and send the text note
// rl := mustRelayConnect(ws.URL)
// err = rl.Publish(context.Background(), textNote)
// if err != nil {
// t.Errorf("publish should have succeeded")
// }
// if !published {
// t.Errorf("fake relay server saw no event")
// }
// }
//
// func TestPublishBlocked(t *testing.T) {
// // test note to be sent over websocket
// var err error
// signer := &p256k.Signer{}
// if err = signer.Generate(); chk.E(err) {
// t.Fatal(err)
// }
// textNote := &event.E{
// Kind: kind.TextNote,
// Content: []byte("hello"),
// CreatedAt: timestamp.FromUnix(1672068534), // random fixed timestamp
// Pubkey: signer.Pub(),
// }
// if err = textNote.Sign(signer); chk.E(err) {
// t.Fatalf("textNote.Sign: %v", err)
// }
// // fake relay server
// ws := newWebsocketServer(
// func(conn *websocket.Conn) {
// // discard received message; not interested
// var raw []json.RawMessage
// if err := websocket.JSON.Receive(conn, &raw); chk.T(err) {
// t.Errorf("websocket.JSON.Receive: %v", err)
// }
// // send back a not ok nip-20 command result
// var res []byte
// if res = okenvelope.NewFrom(
// textNote.ID, false,
// normalize.Msg(normalize.Blocked, "no reason"),
// ).Marshal(res); chk.E(err) {
// t.Fatal(err)
// }
// if err := websocket.Message.Send(conn, res); chk.T(err) {
// t.Errorf("websocket.Message.Send: %v", err)
// }
// // res := []any{"OK", textNote.ID, false, "blocked"}
// },
// )
// defer ws.Close()
//
// // connect a client and send a text note
// rl := mustRelayConnect(ws.URL)
// if err = rl.Publish(context.Background(), textNote); !chk.E(err) {
// t.Errorf("should have failed to publish")
// }
// }
func TestPublishWriteFailed(t *testing.T) {
// test note to be sent over websocket
@@ -171,7 +184,7 @@ func TestPublishWriteFailed(t *testing.T) {
rl := mustRelayConnect(ws.URL)
// Force brief period of time so that publish always fails on closed socket.
time.Sleep(1 * time.Millisecond)
err = rl.Publish(context.Bg(), textNote)
err = rl.Publish(context.Background(), textNote)
if err == nil {
t.Errorf("should have failed to publish")
}
@@ -192,7 +205,7 @@ func TestConnectContext(t *testing.T) {
defer ws.Close()
// relay client
ctx, cancel := context.WithTimeout(context.Bg(), 3*time.Second)
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
r, err := RelayConnect(ctx, ws.URL)
if err != nil {
@@ -213,7 +226,7 @@ func TestConnectContextCanceled(t *testing.T) {
defer ws.Close()
// relay client
ctx, cancel := context.Cancel(context.Bg())
ctx, cancel := context.WithCancel(context.Background())
cancel() // make ctx expired
_, err := RelayConnect(ctx, ws.URL)
if !errors.Is(err, context.Canceled) {
@@ -230,9 +243,9 @@ func TestConnectWithOrigin(t *testing.T) {
defer ws.Close()
// relay client
r := NewRelay(context.Bg(), string(normalize.URL(ws.URL)))
r.RequestHeader = http.Header{"origin": {"https://example.com"}}
ctx, cancel := context.WithTimeout(context.Bg(), 3*time.Second)
r := NewRelay(context.Background(), string(normalize.URL(ws.URL)))
r.requestHeader = http.Header{"origin": {"https://example.com"}}
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
err := r.Connect(ctx)
if err != nil {
@@ -262,8 +275,8 @@ var anyOriginHandshake = func(
return nil
}
func mustRelayConnect(url string) (client *Client) {
rl, err := RelayConnect(context.Bg(), url)
func mustRelayConnect(url string) (client *Relay) {
rl, err := RelayConnect(context.Background(), url)
if err != nil {
panic(err.Error())
}