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

fix types so tests compile.

Browse Source
This commit is contained in:
fiatjaf
2025-05-12 09:34:25 -03:00
parent f4855dba4e
commit 7b1f4ae49a
17 changed files with 64 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
eventstore/badger/badger_test.go
View File

@@ -47,7 +47,7 @@ func TestBasicStoreAndQuery(t *testing.T) {
// collect results // collect results
results := make([]nostr.Event, 0) results := make([]nostr.Event, 0)
for event := range db.QueryEvents(filter) { for event := range db.QueryEvents(filter, 500) {
results = append(results, event) results = append(results, event)
} }

3
eventstore/badger/fuzz_test.go
View File

@@ -61,7 +61,6 @@ func FuzzQuery(f *testing.F) {
return return
} }
db.MaxLimit = 500
defer db.Close() defer db.Close()
// ~ start actual test // ~ start actual test
@@ -116,7 +115,7 @@ func FuzzQuery(f *testing.F) {
start := time.Now() start := time.Now()
// fmt.Println(filter) // fmt.Println(filter)
res := slices.Collect(db.QueryEvents(filter)) res := slices.Collect(db.QueryEvents(filter, 500))
end := time.Now() end := time.Now()
require.NoError(t, err) require.NoError(t, err)

4
eventstore/bluge/bluge_test.go
View File

@@ -46,7 +46,7 @@ func TestBlugeFlow(t *testing.T) {
{ {
n := 0 n := 0
for range bl.QueryEvents(nostr.Filter{Search: "good"}) { for range bl.QueryEvents(nostr.Filter{Search: "good"}, 400) {
n++ n++
} }
assert.Equal(t, 3, n) assert.Equal(t, 3, n)
@@ -58,7 +58,7 @@ func TestBlugeFlow(t *testing.T) {
{ {
n := 0 n := 0
for res := range bl.QueryEvents(nostr.Filter{Search: "good"}) { for res := range bl.QueryEvents(nostr.Filter{Search: "good"}, 400) {
n++ n++
assert.Equal(t, res.Content, "good night") assert.Equal(t, res.Content, "good night")
assert.Equal(t, assert.Equal(t,

3
eventstore/lmdb/fuzz_test.go
View File

@@ -36,7 +36,6 @@ func FuzzQuery(f *testing.F) {
db := &LMDBBackend{} db := &LMDBBackend{}
db.Path = "/tmp/lmdbtest" db.Path = "/tmp/lmdbtest"
db.extraFlags = lmdb.NoSync db.extraFlags = lmdb.NoSync
db.MaxLimit = 500
if err := db.Init(); err != nil { if err := db.Init(); err != nil {
t.Fatal(err) t.Fatal(err)
return return
@@ -95,7 +94,7 @@ func FuzzQuery(f *testing.F) {
start := time.Now() start := time.Now()
res := slices.Collect(db.QueryEvents(filter)) res := slices.Collect(db.QueryEvents(filter, 500))
end := time.Now() end := time.Now()
require.Equal(t, len(expected), len(res), "number of results is different than expected") require.Equal(t, len(expected), len(res), "number of results is different than expected")

12
eventstore/mmm/fuzz_test.go
View File

@@ -40,9 +40,7 @@ func FuzzTest(f *testing.F) {
for i := range nlayers { for i := range nlayers {
name := string([]byte{97 + byte(i)}) name := string([]byte{97 + byte(i)})
err = mmm.EnsureLayer(name, &IndexingLayer{ err = mmm.EnsureLayer(name, &IndexingLayer{})
MaxLimit: 1000,
})
require.NoError(t, err, "layer %s/%d", name, i) require.NoError(t, err, "layer %s/%d", name, i)
} }
@@ -90,7 +88,7 @@ func FuzzTest(f *testing.F) {
// verify each layer has the correct events // verify each layer has the correct events
for _, layer := range mmm.layers { for _, layer := range mmm.layers {
count := 0 count := 0
for evt := range layer.QueryEvents(nostr.Filter{}) { for evt := range layer.QueryEvents(nostr.Filter{}, 500) {
require.True(t, evt.Tags.ContainsAny("t", []string{layer.name})) require.True(t, evt.Tags.ContainsAny("t", []string{layer.name}))
count++ count++
} }
@@ -148,13 +146,13 @@ func FuzzTest(f *testing.F) {
for _, layer := range mmm.layers { for _, layer := range mmm.layers {
// verify event still accessible from other layers // verify event still accessible from other layers
if slices.Contains(foundlayers, layer) { if slices.Contains(foundlayers, layer) {
next, stop := iter.Pull(layer.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{evt.Kind}})) // hack next, stop := iter.Pull(layer.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{evt.Kind}}, 500)) // hack
_, fetched := next() _, fetched := next()
require.True(t, fetched) require.True(t, fetched)
stop() stop()
} else { } else {
// and not accessible from this layer we just deleted // and not accessible from this layer we just deleted
next, stop := iter.Pull(layer.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{evt.Kind}})) // hack next, stop := iter.Pull(layer.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{evt.Kind}}, 500)) // hack
_, fetched := next() _, fetched := next()
require.True(t, fetched) require.True(t, fetched)
stop() stop()
@@ -166,7 +164,7 @@ func FuzzTest(f *testing.F) {
// now delete a layer and events that only exist in that layer should vanish // now delete a layer and events that only exist in that layer should vanish
layer := mmm.layers[rnd.Int()%len(mmm.layers)] layer := mmm.layers[rnd.Int()%len(mmm.layers)]
eventsThatShouldVanish := make([]nostr.ID, 0, nevents/2) eventsThatShouldVanish := make([]nostr.ID, 0, nevents/2)
for evt := range layer.QueryEvents(nostr.Filter{}) { for evt := range layer.QueryEvents(nostr.Filter{}, 500) {
if len(evt.Tags) == 1+len(deleted[evt.ID]) { if len(evt.Tags) == 1+len(deleted[evt.ID]) {
eventsThatShouldVanish = append(eventsThatShouldVanish, evt.ID) eventsThatShouldVanish = append(eventsThatShouldVanish, evt.ID)
} }

8
eventstore/slicestore/slicestore_test.go
View File

@@ -27,7 +27,7 @@ func TestBasicStuff(t *testing.T) {
} }
list := make([]nostr.Event, 0, 20) list := make([]nostr.Event, 0, 20)
for event := range ss.QueryEvents(nostr.Filter{}) { for event := range ss.QueryEvents(nostr.Filter{}, 500) {
list = append(list, event) list = append(list, event)
} }
require.Len(t, list, 20) require.Len(t, list, 20)
@@ -36,18 +36,16 @@ func TestBasicStuff(t *testing.T) {
t.Fatalf("order is incorrect") t.Fatalf("order is incorrect")
} }
until := nostr.Timestamp(9999)
list = make([]nostr.Event, 0, 7) list = make([]nostr.Event, 0, 7)
for event := range ss.QueryEvents(nostr.Filter{Limit: 15, Until: &until, Kinds: []nostr.Kind{11}}) { for event := range ss.QueryEvents(nostr.Filter{Limit: 15, Until: nostr.Timestamp(9999), Kinds: []nostr.Kind{11}}, 500) {
list = append(list, event) list = append(list, event)
} }
if len(list) != 7 { if len(list) != 7 {
t.Fatalf("should have gotten 7, not %d", len(list)) t.Fatalf("should have gotten 7, not %d", len(list))
} }
since := nostr.Timestamp(10009)
list = make([]nostr.Event, 0, 5) list = make([]nostr.Event, 0, 5)
for event := range ss.QueryEvents(nostr.Filter{Since: &since}) { for event := range ss.QueryEvents(nostr.Filter{Since: nostr.Timestamp(10009)}, 500) {
list = append(list, event) list = append(list, event)
} }
require.Len(t, list, 5) require.Len(t, list, 5)

2
eventstore/test/benchmark_test.go
View File

@@ -88,7 +88,7 @@ func runBenchmarkOn(b *testing.B, db eventstore.Store) {
for q, filter := range filters { for q, filter := range filters {
b.Run(fmt.Sprintf("q-%d", q), func(b *testing.B) { b.Run(fmt.Sprintf("q-%d", q), func(b *testing.B) {
for i := 0; i < b.N; i++ { for i := 0; i < b.N; i++ {
_ = db.QueryEvents(filter) _ = db.QueryEvents(filter, 500)
} }
}) })
} }

34
eventstore/test/first_test.go
View File

@@ -44,7 +44,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
// query // query
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{})) results := slices.Collect(db.QueryEvents(nostr.Filter{}, 500))
require.Len(t, results, len(allEvents)) require.Len(t, results, len(allEvents))
require.ElementsMatch(t, require.ElementsMatch(t,
allEvents, allEvents,
@@ -54,8 +54,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{ {
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
since := nostr.Timestamp(i*10 + 1) results := slices.Collect(db.QueryEvents(nostr.Filter{Since: nostr.Timestamp(i*10 + 1)}, 500))
results := slices.Collect(db.QueryEvents(nostr.Filter{Since: &since}))
require.ElementsMatch(t, require.ElementsMatch(t,
allEvents[i:], allEvents[i:],
results, results,
@@ -64,7 +63,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{IDs: []nostr.ID{allEvents[7].ID, allEvents[9].ID}})) results := slices.Collect(db.QueryEvents(nostr.Filter{IDs: []nostr.ID{allEvents[7].ID, allEvents[9].ID}}, 500))
require.Len(t, results, 2) require.Len(t, results, 2)
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[7], allEvents[9]}, []nostr.Event{allEvents[7], allEvents[9]},
@@ -73,7 +72,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{1}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{1}}, 500))
require.ElementsMatch(t, 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, results,
@@ -81,7 +80,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9}}, 500))
require.ElementsMatch(t, 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, results,
@@ -90,7 +89,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{ {
pk4 := nostr.GetPublicKey(sk4) pk4 := nostr.GetPublicKey(sk4)
results := slices.Collect(db.QueryEvents(nostr.Filter{Authors: []nostr.PubKey{pk4}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Authors: []nostr.PubKey{pk4}}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[0], allEvents[3], allEvents[6], allEvents[9]}, []nostr.Event{allEvents[0], allEvents[3], allEvents[6], allEvents[9]},
results, results,
@@ -99,7 +98,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{ {
pk3 := nostr.GetPublicKey(sk3) pk3 := nostr.GetPublicKey(sk3)
results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9}, Authors: []nostr.PubKey{pk3}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9}, Authors: []nostr.PubKey{pk3}}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[2], allEvents[4], allEvents[8]}, []nostr.Event{allEvents[2], allEvents[4], allEvents[8]},
results, results,
@@ -109,7 +108,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{ {
pk3 := nostr.GetPublicKey(sk3) pk3 := nostr.GetPublicKey(sk3)
pk4 := nostr.GetPublicKey(sk4) pk4 := nostr.GetPublicKey(sk4)
results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9, 5, 7}, Authors: []nostr.PubKey{pk3, pk4}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Kinds: []nostr.Kind{9, 5, 7}, Authors: []nostr.PubKey{pk3, pk4}}, 500))
require.ElementsMatch(t, 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, results,
@@ -117,7 +116,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "4", "6"}}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "4", "6"}}}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[2], allEvents[4], allEvents[6]}, []nostr.Event{allEvents[2], allEvents[4], allEvents[6]},
results, results,
@@ -130,7 +129,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
// query again // query again
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{})) results := slices.Collect(db.QueryEvents(nostr.Filter{}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
slices.Concat(allEvents[0:4], allEvents[6:]), slices.Concat(allEvents[0:4], allEvents[6:]),
results, results,
@@ -138,7 +137,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "6"}}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"t": []string{"2", "6"}}}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[2], allEvents[6]}, []nostr.Event{allEvents[2], allEvents[6]},
results, results,
@@ -146,7 +145,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"e": []string{allEvents[3].Tags[1][1]}}})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"e": []string{allEvents[3].Tags[1][1]}}}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{allEvents[3]}, []nostr.Event{allEvents[3]},
results, results,
@@ -155,8 +154,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
{ {
for i := 0; i < 4; i++ { for i := 0; i < 4; i++ {
until := nostr.Timestamp(i*10 + 1) results := slices.Collect(db.QueryEvents(nostr.Filter{Until: nostr.Timestamp(i*10 + 1)}, 500))
results := slices.Collect(db.QueryEvents(nostr.Filter{Until: &until}))
require.ElementsMatch(t, require.ElementsMatch(t,
allEvents[:i], allEvents[:i],
@@ -188,7 +186,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p}}, Kinds: []nostr.Kind{1984}, Limit: 2})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p}}, Kinds: []nostr.Kind{1984}, Limit: 2}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
[]nostr.Event{newEvents[2], newEvents[1]}, []nostr.Event{newEvents[2], newEvents[1]},
results, results,
@@ -197,7 +195,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p}, "t": []string{"x"}}, Limit: 4})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p}, "t": []string{"x"}}, Limit: 4}, 500))
require.ElementsMatch(t, require.ElementsMatch(t,
// the results won't be in canonical time order because this query is too awful, needs a kind // 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]},
@@ -206,7 +204,7 @@ func runFirstTestOn(t *testing.T, db eventstore.Store) {
} }
{ {
results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p, p2}}, Kinds: []nostr.Kind{1}, Limit: 4})) results := slices.Collect(db.QueryEvents(nostr.Filter{Tags: nostr.TagMap{"p": []string{p, p2}}, Kinds: []nostr.Kind{1}, Limit: 4}, 500))
for _, idx := range []int{5, 6, 7} { for _, idx := range []int{5, 6, 7} {
require.True(t, require.True(t,
slices.ContainsFunc( slices.ContainsFunc(

2
eventstore/test/manyauthors_test.go
View File

@@ -53,7 +53,7 @@ func manyAuthorsTest(t *testing.T, db eventstore.Store) {
} }
} }
res := slices.Collect(db.QueryEvents(bigfilter)) res := slices.Collect(db.QueryEvents(bigfilter, 500))
require.Len(t, res, limit) require.Len(t, res, limit)
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse)) require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse))
slices.SortFunc(ordered, nostr.CompareEventReverse) slices.SortFunc(ordered, nostr.CompareEventReverse)

2
eventstore/test/second_test.go
View File

@@ -71,7 +71,7 @@ func runSecondTestOn(t *testing.T, db eventstore.Store) {
for q, filter := range filters { for q, filter := range filters {
label := fmt.Sprintf("filter %d: %s", q, filter) label := fmt.Sprintf("filter %d: %s", q, filter)
t.Run(fmt.Sprintf("q-%d", q), func(t *testing.T) { t.Run(fmt.Sprintf("q-%d", q), func(t *testing.T) {
results := slices.Collect(db.QueryEvents(filter)) results := slices.Collect(db.QueryEvents(filter, 500))
require.NotEmpty(t, results, label) require.NotEmpty(t, results, label)
}) })
} }

2
eventstore/test/unbalanced_test.go
View File

@@ -60,7 +60,7 @@ func unbalancedTest(t *testing.T, db eventstore.Store) {
} }
require.Len(t, expected, limit) require.Len(t, expected, limit)
res := slices.Collect(db.QueryEvents(bigfilter)) res := slices.Collect(db.QueryEvents(bigfilter, 500))
require.Equal(t, limit, len(res)) require.Equal(t, limit, len(res))
require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse)) require.True(t, slices.IsSortedFunc(res, nostr.CompareEventReverse))

38
filter_test.go
View File

@@ -1,6 +1,7 @@
package nostr package nostr
import ( import (
"math"
"slices" "slices"
"testing" "testing"
@@ -15,8 +16,8 @@ func TestFilterUnmarshal(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.Condition(t, func() (success bool) { assert.Condition(t, func() (success bool) {
if f.Since == nil || f.Since.Time().UTC().Format("2006-01-02") != "2022-02-07" || if f.Since == 0 || f.Since.Time().UTC().Format("2006-01-02") != "2022-02-07" ||
f.Until != nil || f.Until != 0 ||
f.Tags == nil || len(f.Tags) != 2 || !slices.Contains(f.Tags["something"], "bab") || f.Tags == nil || len(f.Tags) != 2 || !slices.Contains(f.Tags["something"], "bab") ||
f.Search != "test" { f.Search != "test" {
return false return false
@@ -26,11 +27,10 @@ func TestFilterUnmarshal(t *testing.T) {
} }
func TestFilterMarshal(t *testing.T) { func TestFilterMarshal(t *testing.T) {
until := Timestamp(12345678)
filterj, err := json.Marshal(Filter{ filterj, err := json.Marshal(Filter{
Kinds: []Kind{KindTextNote, KindRecommendServer, KindEncryptedDirectMessage}, Kinds: []Kind{KindTextNote, KindRecommendServer, KindEncryptedDirectMessage},
Tags: TagMap{"fruit": {"banana", "mango"}}, Tags: TagMap{"fruit": {"banana", "mango"}},
Until: &until, Until: Timestamp(12345678),
}) })
assert.NoError(t, err) assert.NoError(t, err)
@@ -45,9 +45,9 @@ func TestFilterUnmarshalWithLimitZero(t *testing.T) {
assert.NoError(t, err) assert.NoError(t, err)
assert.Condition(t, func() (success bool) { assert.Condition(t, func() (success bool) {
if f.Since == nil || if f.Since == 0 ||
f.Since.Time().UTC().Format("2006-01-02") != "2022-02-07" || f.Since.Time().UTC().Format("2006-01-02") != "2022-02-07" ||
f.Until != nil || f.Until != 0 ||
f.Tags == nil || len(f.Tags) != 2 || !slices.Contains(f.Tags["something"], "bab") || f.Tags == nil || len(f.Tags) != 2 || !slices.Contains(f.Tags["something"], "bab") ||
f.Search != "test" || f.Search != "test" ||
f.LimitZero == false { f.LimitZero == false {
@@ -58,11 +58,10 @@ func TestFilterUnmarshalWithLimitZero(t *testing.T) {
} }
func TestFilterMarshalWithLimitZero(t *testing.T) { func TestFilterMarshalWithLimitZero(t *testing.T) {
until := Timestamp(12345678)
filterj, err := json.Marshal(Filter{ filterj, err := json.Marshal(Filter{
Kinds: []Kind{KindTextNote, KindRecommendServer, KindEncryptedDirectMessage}, Kinds: []Kind{KindTextNote, KindRecommendServer, KindEncryptedDirectMessage},
Tags: TagMap{"fruit": {"banana", "mango"}}, Tags: TagMap{"fruit": {"banana", "mango"}},
Until: &until, Until: Timestamp(12345678),
LimitZero: true, LimitZero: true,
}) })
assert.NoError(t, err) assert.NoError(t, err)
@@ -97,13 +96,13 @@ func TestFilterEquality(t *testing.T) {
Filter{ Filter{
Kinds: []Kind{KindEncryptedDirectMessage, KindDeletion}, Kinds: []Kind{KindEncryptedDirectMessage, KindDeletion},
Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}}, Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}},
Since: &tm, Since: tm,
IDs: []ID{{'a', 'a'}, {'b', 'b'}}, IDs: []ID{{'a', 'a'}, {'b', 'b'}},
}, },
Filter{ Filter{
Kinds: []Kind{KindDeletion, KindEncryptedDirectMessage}, Kinds: []Kind{KindDeletion, KindEncryptedDirectMessage},
Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}}, Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}},
Since: &tm, Since: tm,
IDs: []ID{{'a', 'a'}, {'b', 'b'}}, IDs: []ID{{'a', 'a'}, {'b', 'b'}},
}, },
), "kind+2tags+since+ids filters should be equal") ), "kind+2tags+since+ids filters should be equal")
@@ -115,11 +114,10 @@ func TestFilterEquality(t *testing.T) {
} }
func TestFilterClone(t *testing.T) { func TestFilterClone(t *testing.T) {
ts := Now() - 60*60
flt := Filter{ flt := Filter{
Kinds: []Kind{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, Kinds: []Kind{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}}, Tags: TagMap{"letter": {"a", "b"}, "fruit": {"banana"}},
Since: &ts, Since: Now() - 60*60,
IDs: []ID{MustIDFromHex("9894b4b5cb5166d23ee8899a4151cf0c66aec00bde101982a13b8e8ceb972df9")}, IDs: []ID{MustIDFromHex("9894b4b5cb5166d23ee8899a4151cf0c66aec00bde101982a13b8e8ceb972df9")},
} }
clone := flt.Clone() clone := flt.Clone()
@@ -138,16 +136,16 @@ func TestFilterClone(t *testing.T) {
assert.False(t, FilterEqual(flt, clone3), "modifying the clone tag map should cause it to not be equal anymore") assert.False(t, FilterEqual(flt, clone3), "modifying the clone tag map should cause it to not be equal anymore")
clone4 := flt.Clone() clone4 := flt.Clone()
*clone4.Since++ clone4.Since++
assert.False(t, FilterEqual(flt, clone4), "modifying the clone since should cause it to not be equal anymore") assert.False(t, FilterEqual(flt, clone4), "modifying the clone since should cause it to not be equal anymore")
} }
func TestTheoreticalLimit(t *testing.T) { func TestTheoreticalLimit(t *testing.T) {
require.Equal(t, 6, GetTheoreticalLimit(Filter{IDs: []ID{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}})) require.Equal(t, 6, Filter{IDs: []ID{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}}.GetTheoreticalLimit())
require.Equal(t, 9, GetTheoreticalLimit(Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}}, Kinds: []Kind{3, 0, 10002}})) require.Equal(t, 9, Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}}, Kinds: []Kind{3, 0, 10002}}.GetTheoreticalLimit())
require.Equal(t, 4, GetTheoreticalLimit(Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}}, Kinds: []Kind{10050}})) require.Equal(t, 4, Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}}, Kinds: []Kind{10050}}.GetTheoreticalLimit())
require.Equal(t, -1, GetTheoreticalLimit(Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}}})) require.Equal(t, math.MaxInt, Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}}}.GetTheoreticalLimit())
require.Equal(t, -1, GetTheoreticalLimit(Filter{Kinds: []Kind{3, 0, 10002}})) require.Equal(t, math.MaxInt, Filter{Kinds: []Kind{3, 0, 10002}}.GetTheoreticalLimit())
require.Equal(t, 24, GetTheoreticalLimit(Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}, Kinds: []Kind{30023, 30024}, Tags: TagMap{"d": []string{"aaa", "bbb"}}})) require.Equal(t, 24, Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}, Kinds: []Kind{30023, 30024}, Tags: TagMap{"d": []string{"aaa", "bbb"}}}.GetTheoreticalLimit())
require.Equal(t, -1, GetTheoreticalLimit(Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}, Kinds: []Kind{30023, 30024}})) require.Equal(t, math.MaxInt, Filter{Authors: []PubKey{{'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'}}, Kinds: []Kind{30023, 30024}}.GetTheoreticalLimit())
} }

2
khatru/examples/readme-demo/main.go
View File

@@ -18,7 +18,7 @@ func main() {
// set up some basic properties (will be returned on the NIP-11 endpoint) // set up some basic properties (will be returned on the NIP-11 endpoint)
relay.Info.Name = "my relay" relay.Info.Name = "my relay"
relay.Info.PubKey = "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798" relay.Info.PubKey = nostr.MustPubKeyFromHex("79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798")
relay.Info.Description = "this is my custom relay" relay.Info.Description = "this is my custom relay"
relay.Info.Icon = "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fliquipedia.net%2Fcommons%2Fimages%2F3%2F35%2FSCProbe.jpg&f=1&nofb=1&ipt=0cbbfef25bce41da63d910e86c3c343e6c3b9d63194ca9755351bb7c2efa3359&ipo=images" relay.Info.Icon = "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fliquipedia.net%2Fcommons%2Fimages%2F3%2F35%2FSCProbe.jpg&f=1&nofb=1&ipt=0cbbfef25bce41da63d910e86c3c343e6c3b9d63194ca9755351bb7c2efa3359&ipo=images"

4
nip04/nip04_test.go
View File

@@ -11,8 +11,8 @@ import (
func TestSharedKeysAreTheSame(t *testing.T) { func TestSharedKeysAreTheSame(t *testing.T) {
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
sk1 := nostr.GeneratePrivateKey() sk1 := nostr.Generate()
sk2 := nostr.GeneratePrivateKey() sk2 := nostr.Generate()
pk1 := nostr.GetPublicKey(sk1) pk1 := nostr.GetPublicKey(sk1)
pk2 := nostr.GetPublicKey(sk2) pk2 := nostr.GetPublicKey(sk2)

11
nip13/nip13_test.go
View File

@@ -13,7 +13,7 @@ import (
) )
func TestCheck(t *testing.T) { func TestCheck(t *testing.T) {
const eventID = "000000000e9d97a1ab09fc381030b346cdd7a142ad57e6df0b46dc9bef6c7e2d" eventID := nostr.MustIDFromHex("000000000e9d97a1ab09fc381030b346cdd7a142ad57e6df0b46dc9bef6c7e2d")
tests := []struct { tests := []struct {
minDifficulty int minDifficulty int
wantErr error wantErr error
@@ -47,7 +47,8 @@ func TestCommittedDifficulty(t *testing.T) {
} }
for i, tc := range tests { for i, tc := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) { t.Run(strconv.Itoa(i), func(t *testing.T) {
work := CommittedDifficulty(&nostr.Event{ID: tc.id, Tags: tc.tags}) id := nostr.MustIDFromHex(tc.id)
work := CommittedDifficulty(nostr.Event{ID: id, Tags: tc.tags})
require.Equal(t, tc.result, work) require.Equal(t, tc.result, work)
}) })
} }
@@ -57,7 +58,7 @@ func TestDoWorkShort(t *testing.T) {
event := nostr.Event{ event := nostr.Event{
Kind: nostr.KindTextNote, Kind: nostr.KindTextNote,
Content: "It's just me mining my own business", Content: "It's just me mining my own business",
PubKey: "a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243", PubKey: nostr.MustPubKeyFromHex("a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243"),
} }
pow, err := DoWork(context.Background(), event, 2) pow, err := DoWork(context.Background(), event, 2)
if err != nil { if err != nil {
@@ -77,7 +78,7 @@ func TestDoWorkLong(t *testing.T) {
event := nostr.Event{ event := nostr.Event{
Kind: nostr.KindTextNote, Kind: nostr.KindTextNote,
Content: "It's just me mining my own business", Content: "It's just me mining my own business",
PubKey: "a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243", PubKey: nostr.MustPubKeyFromHex("a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243"),
} }
ctx, cancel := context.WithTimeout(context.Background(), time.Minute) ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
defer cancel() defer cancel()
@@ -111,7 +112,7 @@ func TestDoWorkTimeout(t *testing.T) {
event := nostr.Event{ event := nostr.Event{
Kind: nostr.KindTextNote, Kind: nostr.KindTextNote,
Content: "It's just me mining my own business", Content: "It's just me mining my own business",
PubKey: "a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243", PubKey: nostr.MustPubKeyFromHex("a48380f4cfcc1ad5378294fcac36439770f9c878dd880ffa94bb74ea54a6f243"),
} }
done := make(chan error) done := make(chan error)
go func() { go func() {

2
nip44/nip44.go
View File

@@ -154,7 +154,7 @@ func Decrypt(b64ciphertextWrapped string, conversationKey [32]byte) (string, err
var maxThreshold, _ = hex.DecodeString("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141") var maxThreshold, _ = hex.DecodeString("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")
func GenerateConversationKey(pub nostr.PubKey, sk [32]byte) ([32]byte, error) { func GenerateConversationKey(pub nostr.PubKey, sk nostr.SecretKey) ([32]byte, error) {
var ck [32]byte var ck [32]byte
if bytes.Compare(sk[:], maxThreshold) != -1 || sk == [32]byte{} { if bytes.Compare(sk[:], maxThreshold) != -1 || sk == [32]byte{} {

4
nip49/nip49_test.go
View File

@@ -6,6 +6,7 @@ import (
"strings" "strings"
"testing" "testing"
"fiatjaf.com/nostr"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
@@ -35,7 +36,8 @@ func TestEncryptAndDecrypt(t *testing.T) {
{"ÅΩẛ̣", "11b25a101667dd9208db93c0827c6bdad66729a5b521156a7e9d3b22b3ae8944", 9, 0x01}, {"ÅΩẛ̣", "11b25a101667dd9208db93c0827c6bdad66729a5b521156a7e9d3b22b3ae8944", 9, 0x01},
{"ÅΩṩ", "11b25a101667dd9208db93c0827c6bdad66729a5b521156a7e9d3b22b3ae8944", 9, 0x01}, {"ÅΩṩ", "11b25a101667dd9208db93c0827c6bdad66729a5b521156a7e9d3b22b3ae8944", 9, 0x01},
} { } {
bech32code, err := Encrypt(f.secretkey, f.password, f.logn, f.ksb) sk := nostr.MustSecretKeyFromHex(f.secretkey)
bech32code, err := Encrypt(sk, f.password, f.logn, f.ksb)
assert.NoError(t, err) assert.NoError(t, err)
assert.True(t, strings.HasPrefix(bech32code, "ncryptsec1"), "bech32 code is wrong %d: %s", i, bech32code) assert.True(t, strings.HasPrefix(bech32code, "ncryptsec1"), "bech32 code is wrong %d: %s", i, bech32code)
assert.Equal(t, 162, len(bech32code), "bech32 code is wrong %d: %s", i, bech32code) assert.Equal(t, 162, len(bech32code), "bech32 code is wrong %d: %s", i, bech32code)