Wrote roots-ws golang implementation.
This commit is contained in:
289
envelope/enclose_test.go
Normal file
289
envelope/enclose_test.go
Normal file
@@ -0,0 +1,289 @@
|
||||
package envelope
|
||||
|
||||
import (
|
||||
"github.com/stretchr/testify/assert"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestEncloseEvent(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
event []byte
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "empty event",
|
||||
event: []byte("{}"),
|
||||
want: []byte(`["EVENT",{}]`),
|
||||
},
|
||||
{
|
||||
name: "invalid json",
|
||||
event: []byte("in[valid,]"),
|
||||
want: []byte(`["EVENT",in[valid,]]`),
|
||||
},
|
||||
{
|
||||
name: "populated event",
|
||||
event: []byte(`{"id":"abc123","kind":1,"sig":"abc123"}`),
|
||||
want: []byte(`["EVENT",{"id":"abc123","kind":1,"sig":"abc123"}]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseEvent(tc.event)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseOK(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
eventID string
|
||||
status bool
|
||||
message string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "successful event",
|
||||
eventID: "abc123",
|
||||
status: true,
|
||||
message: "Event accepted",
|
||||
want: []byte(`["OK","abc123",true,"Event accepted"]`),
|
||||
},
|
||||
{
|
||||
name: "rejected event",
|
||||
eventID: "xyz789",
|
||||
status: false,
|
||||
message: "Invalid signature",
|
||||
want: []byte(`["OK","xyz789",false,"Invalid signature"]`),
|
||||
},
|
||||
{
|
||||
name: "empty message",
|
||||
eventID: "def456",
|
||||
status: true,
|
||||
message: "",
|
||||
want: []byte(`["OK","def456",true,""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseOK(tc.eventID, tc.status, tc.message)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseReq(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
subID string
|
||||
filters [][]byte
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "single filter",
|
||||
subID: "sub1",
|
||||
filters: [][]byte{[]byte(`{"kinds":[1],"limit":10}`)},
|
||||
want: []byte(`["REQ","sub1",{"kinds":[1],"limit":10}]`),
|
||||
},
|
||||
{
|
||||
name: "multiple filters",
|
||||
subID: "sub2",
|
||||
filters: [][]byte{[]byte(`{"kinds":[1]}`), []byte(`{"authors":["abc"]}`)},
|
||||
want: []byte(`["REQ","sub2",{"kinds":[1]},{"authors":["abc"]}]`),
|
||||
},
|
||||
{
|
||||
name: "no filters",
|
||||
subID: "sub3",
|
||||
filters: [][]byte{},
|
||||
want: []byte(`["REQ","sub3"]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseReq(tc.subID, tc.filters)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseSubscriptionEvent(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
subID string
|
||||
event []byte
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "basic event",
|
||||
subID: "sub1",
|
||||
event: []byte(`{"id":"abc123","kind":1}`),
|
||||
want: []byte(`["EVENT","sub1",{"id":"abc123","kind":1}]`),
|
||||
},
|
||||
{
|
||||
name: "empty event",
|
||||
subID: "sub2",
|
||||
event: []byte(`{}`),
|
||||
want: []byte(`["EVENT","sub2",{}]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseSubscriptionEvent(tc.subID, tc.event)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseEOSE(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
subID string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "valid subscription ID",
|
||||
subID: "sub1",
|
||||
want: []byte(`["EOSE","sub1"]`),
|
||||
},
|
||||
{
|
||||
name: "empty subscription ID",
|
||||
subID: "",
|
||||
want: []byte(`["EOSE",""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseEOSE(tc.subID)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseClose(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
subID string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "valid subscription ID",
|
||||
subID: "sub1",
|
||||
want: []byte(`["CLOSE","sub1"]`),
|
||||
},
|
||||
{
|
||||
name: "empty subscription ID",
|
||||
subID: "",
|
||||
want: []byte(`["CLOSE",""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseClose(tc.subID)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseClosed(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
subID string
|
||||
message string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "with message",
|
||||
subID: "sub1",
|
||||
message: "Subscription complete",
|
||||
want: []byte(`["CLOSED","sub1","Subscription complete"]`),
|
||||
},
|
||||
{
|
||||
name: "empty message",
|
||||
subID: "sub2",
|
||||
message: "",
|
||||
want: []byte(`["CLOSED","sub2",""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseClosed(tc.subID, tc.message)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseNotice(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
message string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "valid message",
|
||||
message: "This is a notice",
|
||||
want: []byte(`["NOTICE","This is a notice"]`),
|
||||
},
|
||||
{
|
||||
name: "empty message",
|
||||
message: "",
|
||||
want: []byte(`["NOTICE",""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseNotice(tc.message)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseAuthChallenge(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
challenge string
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "valid challenge",
|
||||
challenge: "random-challenge-string",
|
||||
want: []byte(`["AUTH","random-challenge-string"]`),
|
||||
},
|
||||
{
|
||||
name: "empty challenge",
|
||||
challenge: "",
|
||||
want: []byte(`["AUTH",""]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseAuthChallenge(tc.challenge)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEncloseAuthResponse(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
event []byte
|
||||
want Envelope
|
||||
}{
|
||||
{
|
||||
name: "valid event",
|
||||
event: []byte(`{"id":"abc123","kind":22242}`),
|
||||
want: []byte(`["AUTH",{"id":"abc123","kind":22242}]`),
|
||||
},
|
||||
{
|
||||
name: "empty event",
|
||||
event: []byte(`{}`),
|
||||
want: []byte(`["AUTH",{}]`),
|
||||
},
|
||||
}
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
got := EncloseAuthResponse(tc.event)
|
||||
assert.Equal(t, tc.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user