Coracle/nostrlib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

go mod tidy works now at least.

Browse Source
This commit is contained in:
fiatjaf
2025-04-15 18:39:14 -03:00
parent 2b5b646a62
commit cb0dd45a32
37 changed files with 540 additions and 917 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
eventstore/test/benchmark_test.go
View File

@@ -7,12 +7,11 @@ import (
"os"
"testing"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr/eventstore/badger"
"fiatjaf.com/nostr/eventstore/lmdb"
"fiatjaf.com/nostr/eventstore/slicestore"
"fiatjaf.com/nostr/eventstore/sqlite3"
"fiatjaf.com/nostr"
)
func BenchmarkSliceStore(b *testing.B) {
@@ -35,61 +34,53 @@ func BenchmarkBadger(b *testing.B) {
runBenchmarkOn(b, d)
}
func BenchmarkSQLite(b *testing.B) {
os.RemoveAll(dbpath + "sqlite")
q := &sqlite3.SQLite3Backend{DatabaseURL: dbpath + "sqlite", QueryTagsLimit: 50}
q.Init()
runBenchmarkOn(b, q)
}
func runBenchmarkOn(b *testing.B, db eventstore.Store) {
for i := 0; i < 10000; i++ {
eTag := make([]byte, 32)
binary.BigEndian.PutUint16(eTag, uint16(i))
ref, _ := nostr.GetPublicKey(sk3)
ref := nostr.GetPublicKey(sk3)
if i%3 == 0 {
ref, _ = nostr.GetPublicKey(sk4)
ref = nostr.GetPublicKey(sk4)
}
evt := &nostr.Event{
evt := nostr.Event{
CreatedAt: nostr.Timestamp(i*10 + 2),
Content: fmt.Sprintf("hello %d", i),
Tags: nostr.Tags{
{"t", fmt.Sprintf("t%d", i)},
{"e", hex.EncodeToString(eTag)},
{"p", ref},
{"p", ref.Hex()},
},
Kind: i % 10,
Kind: uint16(i % 10),
}
sk := sk3
if i%3 == 0 {
sk = sk4
}
evt.Sign(sk)
db.SaveEvent(ctx, evt)
db.SaveEvent(evt)
}
filters := make([]nostr.Filter, 0, 10)
filters = append(filters, nostr.Filter{Kinds: []int{1, 4, 8, 16}})
pk3, _ := nostr.GetPublicKey(sk3)
filters = append(filters, nostr.Filter{Authors: []string{pk3, nostr.GeneratePrivateKey()}})
filters = append(filters, nostr.Filter{Authors: []string{pk3, nostr.GeneratePrivateKey()}, Kinds: []int{3, 4}})
filters = append(filters, nostr.Filter{Kinds: []uint16{1, 4, 8, 16}})
pk3 := nostr.GetPublicKey(sk3)
filters = append(filters, nostr.Filter{Authors: []nostr.PubKey{pk3, nostr.Generate().Public()}})
filters = append(filters, nostr.Filter{Authors: []nostr.PubKey{pk3, nostr.Generate().Public()}, Kinds: []uint16{3, 4}})
filters = append(filters, nostr.Filter{})
filters = append(filters, nostr.Filter{Limit: 20})
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3}}})
pk4, _ := nostr.GetPublicKey(sk4)
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3, pk4}}})
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3, pk4}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex()}}})
pk4 := nostr.GetPublicKey(sk4)
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex(), pk4.Hex()}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex(), pk4.Hex()}}})
eTags := make([]string, 20)
for i := 0; i < 20; i++ {
eTag := make([]byte, 32)
binary.BigEndian.PutUint16(eTag, uint16(i))
eTags[i] = hex.EncodeToString(eTag)
}
filters = append(filters, nostr.Filter{Kinds: []int{9}, Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Kinds: []int{5}, Tags: nostr.TagMap{"e": eTags, "t": []string{"t5"}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{9}, Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Kinds: []uint16{5}, Tags: nostr.TagMap{"e": eTags, "t": []string{"t5"}}})
filters = append(filters, nostr.Filter{Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Tags: nostr.TagMap{"e": eTags}, Limit: 50})
@@ -97,17 +88,17 @@ func runBenchmarkOn(b *testing.B, db eventstore.Store) {
for q, filter := range filters {
b.Run(fmt.Sprintf("q-%d", q), func(b *testing.B) {
for i := 0; i < b.N; i++ {
_, _ = db.QueryEvents(ctx, filter)
_ = db.QueryEvents(filter)
}
})
}
})
b.Run("insert", func(b *testing.B) {
evt := &nostr.Event{Kind: 788, CreatedAt: nostr.Now(), Content: "blergh", Tags: nostr.Tags{{"t", "spam"}}}
evt := nostr.Event{Kind: 788, CreatedAt: nostr.Now(), Content: "blergh", Tags: nostr.Tags{{"t", "spam"}}}
evt.Sign(sk4)
for i := 0; i < b.N; i++ {
db.SaveEvent(ctx, evt)
db.SaveEvent(evt)
}
})
}

7
eventstore/test/db_test.go
View File

@@ -5,16 +5,17 @@ import (
"os"
"testing"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr/eventstore/badger"
"fiatjaf.com/nostr/eventstore/lmdb"
"fiatjaf.com/nostr/eventstore/slicestore"
)
const (
var (
dbpath = "/tmp/eventstore-test"
sk3 = "0000000000000000000000000000000000000000000000000000000000000003"
sk4 = "0000000000000000000000000000000000000000000000000000000000000004"
sk3 = nostr.MustSecretKeyFromHex("0000000000000000000000000000000000000000000000000000000000000003")
sk4 = nostr.MustSecretKeyFromHex("0000000000000000000000000000000000000000000000000000000000000004")
)
var ctx = context.Background()

65
eventstore/test/first_test.go
View File

@@ -7,8 +7,8 @@ import (
"strings"
"testing"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"github.com/stretchr/testify/require"
)
@@ -16,11 +16,11 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
err := db.Init()
require.NoError(t, err)
allEvents := make([]*nostr.Event, 0, 10)
allEvents := make([]nostr.Event, 0, 10)
// insert
for i := 0; i < 10; i++ {
evt := &nostr.Event{
evt := nostr.Event{
CreatedAt: nostr.Timestamp(i*10 + 2),
Content: fmt.Sprintf("hello %d", i),
Tags: nostr.Tags{
@@ -38,7 +38,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
}
evt.Sign(sk)
allEvents = append(allEvents, evt)
err = db.SaveEvent(ctx, evt)
err = db.SaveEvent(evt)
require.NoError(t, err)
}
@@ -67,60 +67,61 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
}
{
results, err := w.QuerySync(ctx, nostr.Filter{IDs: []string{allEvents[7].ID, allEvents[9].ID}})
results, err := w.QuerySync(ctx, nostr.Filter{IDs: []nostr.ID{allEvents[7].ID, allEvents[9].ID}})
require.NoError(t, err)
require.Len(t, results, 2)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[7], allEvents[9]},
[]nostr.Event{allEvents[7], allEvents[9]},
results,
"id query error")
}
{
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []int{1}})
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []uint16{1}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[1], allEvents[3], allEvents[5], allEvents[7], allEvents[9]},
[]nostr.Event{allEvents[1], allEvents[3], allEvents[5], allEvents[7], allEvents[9]},
results,
"kind query error")
}
{
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []int{9}})
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []uint16{9}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[0], allEvents[2], allEvents[4], allEvents[6], allEvents[8]},
[]nostr.Event{allEvents[0], allEvents[2], allEvents[4], allEvents[6], allEvents[8]},
results,
"second kind query error")
}
{
pk4, _ := nostr.GetPublicKey(sk4)
results, err := w.QuerySync(ctx, nostr.Filter{Authors: []string{pk4}})
pk4 := nostr.GetPublicKey(sk4)
results, err := w.QuerySync(ctx, nostr.Filter{Authors: []nostr.PubKey{pk4}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[0], allEvents[3], allEvents[6], allEvents[9]},
[]nostr.Event{allEvents[0], allEvents[3], allEvents[6], allEvents[9]},
results,
"pubkey query error")
}
{
pk3, _ := nostr.GetPublicKey(sk3)
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []int{9}, Authors: []string{pk3}})
pk3 := nostr.GetPublicKey(sk3)
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []uint16{9}, Authors: []nostr.PubKey{pk3}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[2], allEvents[4], allEvents[8]},
[]nostr.Event{allEvents[2], allEvents[4], allEvents[8]},
results,
"pubkey kind query error")
}
{
pk3, _ := nostr.GetPublicKey(sk3)
pk4, _ := nostr.GetPublicKey(sk4)
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []int{9, 5, 7}, Authors: []string{pk3, pk4, pk4[1:] + "a"}})
pk3 := nostr.GetPublicKey(sk3)
pk4 := nostr.GetPublicKey(sk4)
pk4[1] = 'a'
results, err := w.QuerySync(ctx, nostr.Filter{Kinds: []uint16{9, 5, 7}, Authors: []nostr.PubKey{pk3, pk4}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[0], allEvents[2], allEvents[4], allEvents[6], allEvents[8]},
[]nostr.Event{allEvents[0], allEvents[2], allEvents[4], allEvents[6], allEvents[8]},
results,
"2 pubkeys and kind query error")
}
@@ -129,14 +130,14 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
results, err := w.QuerySync(ctx, nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "4", "6"}}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[2], allEvents[4], allEvents[6]},
[]nostr.Event{allEvents[2], allEvents[4], allEvents[6]},
results,
"tag query error")
}
// delete
require.NoError(t, db.DeleteEvent(ctx, allEvents[4]), "delete 1 error")
require.NoError(t, db.DeleteEvent(ctx, allEvents[5]), "delete 2 error")
require.NoError(t, db.DeleteEvent(allEvents[4].ID), "delete 1 error")
require.NoError(t, db.DeleteEvent(allEvents[5].ID), "delete 2 error")
// query again
{
@@ -152,7 +153,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
results, err := w.QuerySync(ctx, nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "6"}}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[2], allEvents[6]},
[]nostr.Event{allEvents[2], allEvents[6]},
results,
"second tag query error")
}
@@ -161,7 +162,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
results, err := w.QuerySync(ctx, nostr.Filter{Tags: nostr.TagMap{"e": []string{allEvents[3].Tags[1][1]}}})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{allEvents[3]},
[]nostr.Event{allEvents[3]},
results,
"'e' tag query error")
}
@@ -184,7 +185,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
p := "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
p2 := "2eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"
newEvents := []*nostr.Event{
newEvents := []nostr.Event{
{Tags: nostr.Tags{nostr.Tag{"p", p}}, Kind: 1984, CreatedAt: nostr.Timestamp(100), Content: "first"},
{Tags: nostr.Tags{nostr.Tag{"p", p}, nostr.Tag{"t", "x"}}, Kind: 1984, CreatedAt: nostr.Timestamp(101), Content: "middle"},
{Tags: nostr.Tags{nostr.Tag{"p", p}}, Kind: 1984, CreatedAt: nostr.Timestamp(102), Content: "last"},
@@ -195,21 +196,21 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{Tags: nostr.Tags{nostr.Tag{"p", p}, nostr.Tag{"p", p2}}, Kind: 1, CreatedAt: nostr.Timestamp(104), Content: "trololo"},
}
sk := nostr.GeneratePrivateKey()
sk := nostr.Generate()
for _, newEvent := range newEvents {
newEvent.Sign(sk)
require.NoError(t, db.SaveEvent(ctx, newEvent))
require.NoError(t, db.SaveEvent(newEvent))
}
{
results, err := w.QuerySync(ctx, nostr.Filter{
Tags: nostr.TagMap{"p": []string{p}},
Kinds: []int{1984},
Kinds: []uint16{1984},
Limit: 2,
})
require.NoError(t, err)
require.ElementsMatch(t,
[]*nostr.Event{newEvents[2], newEvents[1]},
[]nostr.Event{newEvents[2], newEvents[1]},
results,
"'p' tag 1 query error")
}
@@ -222,7 +223,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
require.NoError(t, err)
require.ElementsMatch(t,
// the results won't be in canonical time order because this query is too awful, needs a kind
[]*nostr.Event{newEvents[1]},
[]nostr.Event{newEvents[1]},
results,
"'p' tag 2 query error")
}
@@ -230,7 +231,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{
results, err := w.QuerySync(ctx, nostr.Filter{
Tags: nostr.TagMap{"p": []string{p, p2}},
Kinds: []int{1},
Kinds: []uint16{1},
Limit: 4,
})
require.NoError(t, err)

26
eventstore/test/manyauthors_test.go
View File

@@ -2,13 +2,12 @@ package test
import (
"encoding/binary"
"encoding/hex"
"fmt"
"slices"
"testing"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"github.com/stretchr/testify/require"
)
@@ -18,35 +17,35 @@ func manyAuthorsTest(t *testing.T, db eventstore.Store) {
const total = 10000
const limit = 500
const authors = 1700
kinds := []int{6, 7, 8}
kinds := []uint16{6, 7, 8}
bigfilter := nostr.Filter{
Authors: make([]string, authors),
Authors: make([]nostr.PubKey, authors),
Kinds: kinds,
Limit: limit,
}
for i := 0; i < authors; i++ {
sk := make([]byte, 32)
binary.BigEndian.PutUint32(sk, uint32(i%(total/5))+1)
pk, _ := nostr.GetPublicKey(hex.EncodeToString(sk))
pk := nostr.GetPublicKey([32]byte(sk))
bigfilter.Authors[i] = pk
}
ordered := make([]*nostr.Event, 0, total)
ordered := make([]nostr.Event, 0, total)
for i := 0; i < total; i++ {
sk := make([]byte, 32)
binary.BigEndian.PutUint32(sk, uint32(i%(total/5))+1)
evt := &nostr.Event{
evt := nostr.Event{
CreatedAt: nostr.Timestamp(i*i) / 4,
Content: fmt.Sprintf("lots of stuff %d", i),
Tags: nostr.Tags{},
Kind: i % 10,
Kind: uint16(i % 10),
}
err := evt.Sign(hex.EncodeToString(sk))
err := evt.Sign([32]byte(sk))
require.NoError(t, err)
err = db.SaveEvent(ctx, evt)
err = db.SaveEvent(evt)
require.NoError(t, err)
if bigfilter.Matches(evt) {
@@ -56,12 +55,11 @@ func manyAuthorsTest(t *testing.T, db eventstore.Store) {
w := eventstore.RelayWrapper{Store: db}
res, err := w.QuerySync(ctx, bigfilter)
res := slices.Collect(w.QueryEvents(bigfilter))
require.NoError(t, err)
require.Len(t, res, limit)
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventPtrReverse))
slices.SortFunc(ordered, nostr.CompareEventPtrReverse)
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse))
slices.SortFunc(ordered, nostr.CompareEventReverse)
require.Equal(t, ordered[0], res[0])
require.Equal(t, ordered[limit-1], res[limit-1])
require.Equal(t, ordered[0:limit], res)

7
eventstore/test/relaywrapper_test.go
View File

@@ -2,16 +2,17 @@ package test
import (
"context"
"slices"
"testing"
"time"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr/eventstore/slicestore"
"fiatjaf.com/nostr"
"github.com/stretchr/testify/require"
)
var sk = "486d5f6d4891f4ce3cd5f4d6b62d184ec8ea10db455830ab7918ca43d4d7ad24"
var sk = nostr.MustSecretKeyFromHex("486d5f6d4891f4ce3cd5f4d6b62d184ec8ea10db455830ab7918ca43d4d7ad24")
func TestRelayWrapper(t *testing.T) {
ctx := context.Background()
@@ -44,6 +45,6 @@ func TestRelayWrapper(t *testing.T) {
}
time.Sleep(time.Millisecond * 200)
evts, _ := w.QuerySync(ctx, nostr.Filter{Kinds: []int{3}})
evts := slices.Collect(w.QueryEvents(nostr.Filter{Kinds: []uint16{3}}))
require.Len(t, evts, 1)
}

38
eventstore/test/second_test.go
View File

@@ -4,10 +4,11 @@ import (
"encoding/binary"
"encoding/hex"
"fmt"
"slices"
"testing"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"github.com/stretchr/testify/require"
)
@@ -18,33 +19,33 @@ func runSecondTestOn(t *testing.T, db eventstore.Store) {
eTag := make([]byte, 32)
binary.BigEndian.PutUint16(eTag, uint16(i))
ref, _ := nostr.GetPublicKey(sk3)
ref := nostr.GetPublicKey(sk3)
if i%3 == 0 {
ref, _ = nostr.GetPublicKey(sk4)
ref = nostr.GetPublicKey(sk4)
}
evt := &nostr.Event{
evt := nostr.Event{
CreatedAt: nostr.Timestamp(i*10 + 2),
Content: fmt.Sprintf("hello %d", i),
Tags: nostr.Tags{
{"t", fmt.Sprintf("t%d", i)},
{"e", hex.EncodeToString(eTag)},
{"p", ref},
{"p", ref.Hex()},
},
Kind: i % 10,
Kind: uint16(i % 10),
}
sk := sk3
if i%3 == 0 {
sk = sk4
}
evt.Sign(sk)
err := db.SaveEvent(ctx, evt)
err := db.SaveEvent(evt)
require.NoError(t, err)
}
w := eventstore.RelayWrapper{Store: db}
pk3, _ := nostr.GetPublicKey(sk3)
pk4, _ := nostr.GetPublicKey(sk4)
pk3 := nostr.GetPublicKey(sk3)
pk4 := nostr.GetPublicKey(sk4)
eTags := make([]string, 20)
for i := 0; i < 20; i++ {
eTag := make([]byte, 32)
@@ -53,16 +54,16 @@ func runSecondTestOn(t *testing.T, db eventstore.Store) {
}
filters := make([]nostr.Filter, 0, 10)
filters = append(filters, nostr.Filter{Kinds: []int{1, 4, 8, 16}})
filters = append(filters, nostr.Filter{Authors: []string{pk3, nostr.GeneratePrivateKey()}})
filters = append(filters, nostr.Filter{Authors: []string{pk3, nostr.GeneratePrivateKey()}, Kinds: []int{3, 4}})
filters = append(filters, nostr.Filter{Kinds: []uint16{1, 4, 8, 16}})
filters = append(filters, nostr.Filter{Authors: []nostr.PubKey{pk3, nostr.Generate().Public()}})
filters = append(filters, nostr.Filter{Authors: []nostr.PubKey{pk3, nostr.Generate().Public()}, Kinds: []uint16{3, 4}})
filters = append(filters, nostr.Filter{})
filters = append(filters, nostr.Filter{Limit: 20})
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3}}})
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3, pk4}}})
filters = append(filters, nostr.Filter{Kinds: []int{8, 9}, Tags: nostr.TagMap{"p": []string{pk3, pk4}}})
filters = append(filters, nostr.Filter{Kinds: []int{9}, Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Kinds: []int{5}, Tags: nostr.TagMap{"e": eTags, "t": []string{"t5"}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex()}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex(), pk4.Hex()}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{8, 9}, Tags: nostr.TagMap{"p": []string{pk3.Hex(), pk4.Hex()}}})
filters = append(filters, nostr.Filter{Kinds: []uint16{9}, Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Kinds: []uint16{5}, Tags: nostr.TagMap{"e": eTags, "t": []string{"t5"}}})
filters = append(filters, nostr.Filter{Tags: nostr.TagMap{"e": eTags}})
filters = append(filters, nostr.Filter{Tags: nostr.TagMap{"e": eTags}, Limit: 50})
@@ -73,8 +74,7 @@ func runSecondTestOn(t *testing.T, db eventstore.Store) {
label := fmt.Sprintf("filter %d: %s", q, filter)
t.Run(fmt.Sprintf("q-%d", q), func(t *testing.T) {
results, err := w.QuerySync(ctx, filter)
require.NoError(t, err, filter)
results := slices.Collect(w.QueryEvents(filter))
require.NotEmpty(t, results, label)
})
}

22
eventstore/test/unbalanced_test.go
View File

@@ -2,13 +2,12 @@ package test
import (
"encoding/binary"
"encoding/hex"
"fmt"
"slices"
"testing"
"fiatjaf.com/nostr/eventstore"
"fiatjaf.com/nostr"
"fiatjaf.com/nostr/eventstore"
"github.com/stretchr/testify/require"
)
@@ -21,33 +20,33 @@ func unbalancedTest(t *testing.T, db eventstore.Store) {
const authors = 1400
bigfilter := nostr.Filter{
Authors: make([]string, authors),
Authors: make([]nostr.PubKey, authors),
Limit: limit,
}
for i := 0; i < authors; i++ {
sk := make([]byte, 32)
binary.BigEndian.PutUint32(sk, uint32(i%(authors*2))+1)
pk, _ := nostr.GetPublicKey(hex.EncodeToString(sk))
pk := nostr.GetPublicKey([32]byte(sk))
bigfilter.Authors[i] = pk
}
// fmt.Println("filter", bigfilter)
expected := make([]*nostr.Event, 0, total)
expected := make([]nostr.Event, 0, total)
for i := 0; i < total; i++ {
skseed := uint32(i%(authors*2)) + 1
sk := make([]byte, 32)
binary.BigEndian.PutUint32(sk, skseed)
evt := &nostr.Event{
evt := nostr.Event{
CreatedAt: nostr.Timestamp(skseed)*1000 + nostr.Timestamp(i),
Content: fmt.Sprintf("unbalanced %d", i),
Tags: nostr.Tags{},
Kind: 1,
}
err := evt.Sign(hex.EncodeToString(sk))
err := evt.Sign([32]byte(sk))
require.NoError(t, err)
err = db.SaveEvent(ctx, evt)
err = db.SaveEvent(evt)
require.NoError(t, err)
if bigfilter.Matches(evt) {
@@ -55,7 +54,7 @@ func unbalancedTest(t *testing.T, db eventstore.Store) {
}
}
slices.SortFunc(expected, nostr.CompareEventPtrReverse)
slices.SortFunc(expected, nostr.CompareEventReverse)
if len(expected) > limit {
expected = expected[0:limit]
}
@@ -63,11 +62,10 @@ func unbalancedTest(t *testing.T, db eventstore.Store) {
w := eventstore.RelayWrapper{Store: db}
res, err := w.QuerySync(ctx, bigfilter)
res := slices.Collect(w.QueryEvents(bigfilter))
require.NoError(t, err)
require.Equal(t, limit, len(res))
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventPtrReverse))
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse))
require.Equal(t, expected[0], res[0])
// fmt.Println(" expected result")