mleku
4 months ago
202 changed files with 12803 additions and 420 deletions
@ -0,0 +1,30 @@ |
|||||||
|
module crypto.orly |
||||||
|
|
||||||
|
go 1.25.0 |
||||||
|
|
||||||
|
require ( |
||||||
|
encoders.orly v0.0.0-00010101000000-000000000000 |
||||||
|
github.com/davecgh/go-spew v1.1.1 |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0 |
||||||
|
github.com/stretchr/testify v1.11.1 |
||||||
|
interfaces.orly v0.0.0-00010101000000-000000000000 |
||||||
|
lol.mleku.dev v1.0.2 |
||||||
|
utils.orly v0.0.0-00010101000000-000000000000 |
||||||
|
) |
||||||
|
|
||||||
|
require ( |
||||||
|
github.com/fatih/color v1.18.0 // indirect |
||||||
|
github.com/mattn/go-colorable v0.1.14 // indirect |
||||||
|
github.com/mattn/go-isatty v0.0.20 // indirect |
||||||
|
github.com/pmezard/go-difflib v1.0.0 // indirect |
||||||
|
github.com/templexxx/cpu v0.0.1 // indirect |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b // indirect |
||||||
|
golang.org/x/sys v0.35.0 // indirect |
||||||
|
gopkg.in/yaml.v3 v3.0.1 // indirect |
||||||
|
) |
||||||
|
|
||||||
|
replace ( |
||||||
|
encoders.orly => ../encoders |
||||||
|
interfaces.orly => ../interfaces |
||||||
|
utils.orly => ../utils |
||||||
|
) |
||||||
@ -0,0 +1,27 @@ |
|||||||
|
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= |
||||||
|
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= |
||||||
|
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= |
||||||
|
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= |
||||||
|
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= |
||||||
|
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= |
||||||
|
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= |
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= |
||||||
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||||
|
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= |
||||||
|
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= |
||||||
|
github.com/templexxx/cpu v0.0.1 h1:hY4WdLOgKdc8y13EYklu9OUTXik80BkxHoWvTO6MQQY= |
||||||
|
github.com/templexxx/cpu v0.0.1/go.mod h1:w7Tb+7qgcAlIyX4NhLuDKt78AHA5SzPmq0Wj6HiEnnk= |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b h1:XeDLE6c9mzHpdv3Wb1+pWBaWv/BlHK0ZYIu/KaL6eHg= |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b/go.mod h1:7rwmCH0wC2fQvNEvPZ3sKXukhyCTyiaZ5VTZMQYpZKQ= |
||||||
|
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= |
||||||
|
golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= |
||||||
|
golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= |
||||||
|
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= |
||||||
|
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= |
||||||
|
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= |
||||||
|
lol.mleku.dev v1.0.2 h1:bSV1hHnkmt1hq+9nSvRwN6wgcI7itbM3XRZ4dMB438c= |
||||||
|
lol.mleku.dev v1.0.2/go.mod h1:DQ0WnmkntA9dPLCXgvtIgYt5G0HSqx3wSTLolHgWeLA= |
||||||
@ -0,0 +1,132 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"context" |
||||||
|
"os" |
||||||
|
"path/filepath" |
||||||
|
"time" |
||||||
|
|
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"github.com/dgraph-io/badger/v4/options" |
||||||
|
"lol.mleku.dev" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"lol.mleku.dev/log" |
||||||
|
"utils.orly/apputil" |
||||||
|
"utils.orly/units" |
||||||
|
) |
||||||
|
|
||||||
|
type D struct { |
||||||
|
ctx context.Context |
||||||
|
cancel context.CancelFunc |
||||||
|
dataDir string |
||||||
|
Logger *logger |
||||||
|
*badger.DB |
||||||
|
seq *badger.Sequence |
||||||
|
} |
||||||
|
|
||||||
|
func New( |
||||||
|
ctx context.Context, cancel context.CancelFunc, dataDir, logLevel string, |
||||||
|
) ( |
||||||
|
d *D, err error, |
||||||
|
) { |
||||||
|
d = &D{ |
||||||
|
ctx: ctx, |
||||||
|
cancel: cancel, |
||||||
|
dataDir: dataDir, |
||||||
|
Logger: NewLogger(lol.GetLogLevel(logLevel), dataDir), |
||||||
|
DB: nil, |
||||||
|
seq: nil, |
||||||
|
} |
||||||
|
|
||||||
|
// Ensure the data directory exists
|
||||||
|
if err = os.MkdirAll(dataDir, 0755); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Also ensure the directory exists using apputil.EnsureDir for any potential subdirectories
|
||||||
|
dummyFile := filepath.Join(dataDir, "dummy.sst") |
||||||
|
if err = apputil.EnsureDir(dummyFile); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
opts := badger.DefaultOptions(d.dataDir) |
||||||
|
opts.BlockCacheSize = int64(units.Gb) |
||||||
|
opts.BlockSize = units.Gb |
||||||
|
opts.CompactL0OnClose = true |
||||||
|
opts.LmaxCompaction = true |
||||||
|
opts.Compression = options.None |
||||||
|
opts.Logger = d.Logger |
||||||
|
if d.DB, err = badger.Open(opts); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
log.T.Ln("getting event sequence lease", d.dataDir) |
||||||
|
if d.seq, err = d.DB.GetSequence([]byte("EVENTS"), 1000); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// run code that updates indexes when new indexes have been added and bumps
|
||||||
|
// the version so they aren't run again.
|
||||||
|
d.RunMigrations() |
||||||
|
// start up the expiration tag processing and shut down and clean up the
|
||||||
|
// database after the context is canceled.
|
||||||
|
go func() { |
||||||
|
expirationTicker := time.NewTicker(time.Minute * 10) |
||||||
|
select { |
||||||
|
case <-expirationTicker.C: |
||||||
|
d.DeleteExpired() |
||||||
|
return |
||||||
|
case <-d.ctx.Done(): |
||||||
|
} |
||||||
|
d.cancel() |
||||||
|
d.seq.Release() |
||||||
|
d.DB.Close() |
||||||
|
}() |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Path returns the path where the database files are stored.
|
||||||
|
func (d *D) Path() string { return d.dataDir } |
||||||
|
|
||||||
|
func (d *D) Wipe() (err error) { |
||||||
|
// TODO implement me
|
||||||
|
panic("implement me") |
||||||
|
} |
||||||
|
|
||||||
|
func (d *D) SetLogLevel(level string) { |
||||||
|
d.Logger.SetLogLevel(lol.GetLogLevel(level)) |
||||||
|
} |
||||||
|
|
||||||
|
func (d *D) EventIdsBySerial(start uint64, count int) ( |
||||||
|
evs []uint64, err error, |
||||||
|
) { |
||||||
|
// TODO implement me
|
||||||
|
panic("implement me") |
||||||
|
} |
||||||
|
|
||||||
|
// Init initializes the database with the given path.
|
||||||
|
func (d *D) Init(path string) (err error) { |
||||||
|
// The database is already initialized in the New function,
|
||||||
|
// so we just need to ensure the path is set correctly.
|
||||||
|
d.dataDir = path |
||||||
|
return nil |
||||||
|
} |
||||||
|
|
||||||
|
// Sync flushes the database buffers to disk.
|
||||||
|
func (d *D) Sync() (err error) { |
||||||
|
d.DB.RunValueLogGC(0.5) |
||||||
|
return d.DB.Sync() |
||||||
|
} |
||||||
|
|
||||||
|
// Close releases resources and closes the database.
|
||||||
|
func (d *D) Close() (err error) { |
||||||
|
if d.seq != nil { |
||||||
|
if err = d.seq.Release(); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
if d.DB != nil { |
||||||
|
if err = d.DB.Close(); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,76 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
// DeleteEvent removes an event from the database identified by `eid`. If
|
||||||
|
// noTombstone is false or not provided, a tombstone is created for the event.
|
||||||
|
func (d *D) DeleteEvent(c context.Context, eid []byte) (err error) { |
||||||
|
d.Logger.Warningf("deleting event %0x", eid) |
||||||
|
|
||||||
|
// Get the serial number for the event ID
|
||||||
|
var ser *types.Uint40 |
||||||
|
ser, err = d.GetSerialById(eid) |
||||||
|
if chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if ser == nil { |
||||||
|
// Event wasn't found, nothing to delete
|
||||||
|
return |
||||||
|
} |
||||||
|
// Fetch the event to get its data
|
||||||
|
var ev *event.E |
||||||
|
ev, err = d.FetchEventBySerial(ser) |
||||||
|
if chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if ev == nil { |
||||||
|
// Event wasn't found, nothing to delete. this shouldn't happen.
|
||||||
|
return |
||||||
|
} |
||||||
|
if err = d.DeleteEventBySerial(c, ser, ev); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (d *D) DeleteEventBySerial( |
||||||
|
c context.Context, ser *types.Uint40, ev *event.E, |
||||||
|
) (err error) { |
||||||
|
// Get all indexes for the event
|
||||||
|
var idxs [][]byte |
||||||
|
idxs, err = GetIndexesForEvent(ev, ser.Get()) |
||||||
|
if chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Get the event key
|
||||||
|
eventKey := new(bytes.Buffer) |
||||||
|
if err = indexes.EventEnc(ser).MarshalWrite(eventKey); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Delete the event and all its indexes in a transaction
|
||||||
|
err = d.Update( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
// Delete the event
|
||||||
|
if err = txn.Delete(eventKey.Bytes()); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Delete all indexes
|
||||||
|
for _, key := range idxs { |
||||||
|
if err = txn.Delete(key); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
) |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,62 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"time" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
func (d *D) DeleteExpired() { |
||||||
|
var err error |
||||||
|
var expiredSerials types.Uint40s |
||||||
|
// make the operation atomic and save on accesses to the system clock by
|
||||||
|
// setting the boundary at the current second
|
||||||
|
now := time.Now().Unix() |
||||||
|
// search the expiration indexes for expiry timestamps that are now past
|
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
exp, ser := indexes.ExpirationVars() |
||||||
|
expPrf := new(bytes.Buffer) |
||||||
|
if _, err = indexes.ExpirationPrefix.Write(expPrf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
it := txn.NewIterator(badger.IteratorOptions{Prefix: expPrf.Bytes()}) |
||||||
|
defer it.Close() |
||||||
|
for it.Rewind(); it.Valid(); it.Next() { |
||||||
|
item := it.Item() |
||||||
|
key := item.Key() |
||||||
|
buf := bytes.NewBuffer(key) |
||||||
|
if err = indexes.ExpirationDec( |
||||||
|
exp, ser, |
||||||
|
).UnmarshalRead(buf); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
if int64(exp.Get()) > now { |
||||||
|
// not expired yet
|
||||||
|
continue |
||||||
|
} |
||||||
|
expiredSerials = append(expiredSerials, ser) |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
} |
||||||
|
// delete the events and their indexes
|
||||||
|
for _, ser := range expiredSerials { |
||||||
|
var ev *event.E |
||||||
|
if ev, err = d.FetchEventBySerial(ser); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
if err = d.DeleteEventBySerial( |
||||||
|
context.Background(), ser, ev, |
||||||
|
); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,106 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"io" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly/units" |
||||||
|
) |
||||||
|
|
||||||
|
// Export the complete database of stored events to an io.Writer in line structured minified
|
||||||
|
// JSON.
|
||||||
|
func (d *D) Export(c context.Context, w io.Writer, pubkeys ...[]byte) { |
||||||
|
var err error |
||||||
|
evB := make([]byte, 0, units.Mb) |
||||||
|
evBuf := bytes.NewBuffer(evB) |
||||||
|
if len(pubkeys) == 0 { |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
buf := new(bytes.Buffer) |
||||||
|
if err = indexes.EventEnc(nil).MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
it := txn.NewIterator(badger.IteratorOptions{Prefix: buf.Bytes()}) |
||||||
|
defer it.Close() |
||||||
|
for it.Rewind(); it.Valid(); it.Next() { |
||||||
|
item := it.Item() |
||||||
|
if err = item.Value( |
||||||
|
func(val []byte) (err error) { |
||||||
|
evBuf.Write(val) |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
ev := event.New() |
||||||
|
if err = ev.UnmarshalBinary(evBuf); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
// Serialize the event to JSON and write it to the output
|
||||||
|
if _, err = w.Write(ev.Serialize()); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if _, err = w.Write([]byte{'\n'}); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
evBuf.Reset() |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
} else { |
||||||
|
for _, pubkey := range pubkeys { |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
pkBuf := new(bytes.Buffer) |
||||||
|
ph := &types.PubHash{} |
||||||
|
if err = ph.FromPubkey(pubkey); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if err = indexes.PubkeyEnc( |
||||||
|
ph, nil, nil, |
||||||
|
).MarshalWrite(pkBuf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
it := txn.NewIterator(badger.IteratorOptions{Prefix: pkBuf.Bytes()}) |
||||||
|
defer it.Close() |
||||||
|
for it.Rewind(); it.Valid(); it.Next() { |
||||||
|
item := it.Item() |
||||||
|
if err = item.Value( |
||||||
|
func(val []byte) (err error) { |
||||||
|
evBuf.Write(val) |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
ev := event.New() |
||||||
|
if err = ev.UnmarshalBinary(evBuf); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
// Serialize the event to JSON and write it to the output
|
||||||
|
if _, err = w.Write(ev.Serialize()); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
if _, err = w.Write([]byte{'\n'}); chk.E(err) { |
||||||
|
continue |
||||||
|
} |
||||||
|
evBuf.Reset() |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,111 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"os" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"encoders.orly/event" |
||||||
|
"encoders.orly/event/examples" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
// TestExport tests the Export function by:
|
||||||
|
// 1. Creating a new database with events from examples.Cache
|
||||||
|
// 2. Checking that all event IDs in the cache are found in the export
|
||||||
|
// 3. Verifying this also works when only a few pubkeys are requested
|
||||||
|
func TestExport(t *testing.T) { |
||||||
|
// Create a temporary directory for the database
|
||||||
|
tempDir, err := os.MkdirTemp("", "test-db-*") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create temporary directory: %v", err) |
||||||
|
} |
||||||
|
defer os.RemoveAll(tempDir) // Clean up after the test
|
||||||
|
|
||||||
|
// Create a context and cancel function for the database
|
||||||
|
ctx, cancel := context.WithCancel(context.Background()) |
||||||
|
defer cancel() |
||||||
|
|
||||||
|
// Initialize the database
|
||||||
|
db, err := New(ctx, cancel, tempDir, "info") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create database: %v", err) |
||||||
|
} |
||||||
|
defer db.Close() |
||||||
|
|
||||||
|
// Create a scanner to read events from examples.Cache
|
||||||
|
scanner := bufio.NewScanner(bytes.NewBuffer(examples.Cache)) |
||||||
|
scanner.Buffer(make([]byte, 0, 1_000_000_000), 1_000_000_000) |
||||||
|
|
||||||
|
// Maps to store event IDs and their associated pubkeys
|
||||||
|
eventIDs := make(map[string]bool) |
||||||
|
pubkeyToEventIDs := make(map[string][]string) |
||||||
|
|
||||||
|
// Process each event
|
||||||
|
for scanner.Scan() { |
||||||
|
chk.E(scanner.Err()) |
||||||
|
b := scanner.Bytes() |
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Unmarshal the event
|
||||||
|
if _, err = ev.Unmarshal(b); chk.E(err) { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
// Save the event to the database
|
||||||
|
if _, _, err = db.SaveEvent(ctx, ev, false, nil); err != nil { |
||||||
|
t.Fatalf("Failed to save event: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Store the event ID
|
||||||
|
eventID := string(ev.ID) |
||||||
|
eventIDs[eventID] = true |
||||||
|
|
||||||
|
// Store the event ID by pubkey
|
||||||
|
pubkey := string(ev.Pubkey) |
||||||
|
pubkeyToEventIDs[pubkey] = append(pubkeyToEventIDs[pubkey], eventID) |
||||||
|
} |
||||||
|
|
||||||
|
// Check for scanner errors
|
||||||
|
if err = scanner.Err(); err != nil { |
||||||
|
t.Fatalf("Scanner error: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("Saved %d events to the database", len(eventIDs)) |
||||||
|
|
||||||
|
// Test 1: Export all events and verify all IDs are in the export
|
||||||
|
var exportBuffer bytes.Buffer |
||||||
|
db.Export(ctx, &exportBuffer) |
||||||
|
|
||||||
|
// Parse the exported events and check that all IDs are present
|
||||||
|
exportedIDs := make(map[string]bool) |
||||||
|
exportScanner := bufio.NewScanner(&exportBuffer) |
||||||
|
exportScanner.Buffer(make([]byte, 0, 1_000_000_000), 1_000_000_000) |
||||||
|
exportCount := 0 |
||||||
|
for exportScanner.Scan() { |
||||||
|
b := exportScanner.Bytes() |
||||||
|
ev := event.New() |
||||||
|
if _, err = ev.Unmarshal(b); chk.E(err) { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
exportedIDs[string(ev.ID)] = true |
||||||
|
exportCount++ |
||||||
|
} |
||||||
|
// Check for scanner errors
|
||||||
|
if err = exportScanner.Err(); err != nil { |
||||||
|
t.Fatalf("Scanner error: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("Found %d events in the export", exportCount) |
||||||
|
|
||||||
|
// Check that all original event IDs are in the export
|
||||||
|
for id := range eventIDs { |
||||||
|
if !exportedIDs[id] { |
||||||
|
t.Errorf("Event ID %s not found in export", id) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("All %d event IDs found in export", len(eventIDs)) |
||||||
|
} |
||||||
@ -0,0 +1,38 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
func (d *D) FetchEventBySerial(ser *types.Uint40) (ev *event.E, err error) { |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
buf := new(bytes.Buffer) |
||||||
|
if err = indexes.EventEnc(ser).MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
var item *badger.Item |
||||||
|
if item, err = txn.Get(buf.Bytes()); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
var v []byte |
||||||
|
if v, err = item.ValueCopy(nil); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
ev = new(event.E) |
||||||
|
if err = ev.UnmarshalBinary(bytes.NewBuffer(v)); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); err != nil { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,156 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"os" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"encoders.orly/event/examples" |
||||||
|
"encoders.orly/filter" |
||||||
|
"encoders.orly/tag" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
) |
||||||
|
|
||||||
|
func TestFetchEventBySerial(t *testing.T) { |
||||||
|
// Create a temporary directory for the database
|
||||||
|
tempDir, err := os.MkdirTemp("", "test-db-*") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create temporary directory: %v", err) |
||||||
|
} |
||||||
|
defer os.RemoveAll(tempDir) // Clean up after the test
|
||||||
|
|
||||||
|
// Create a context and cancel function for the database
|
||||||
|
ctx, cancel := context.WithCancel(context.Background()) |
||||||
|
defer cancel() |
||||||
|
|
||||||
|
// Initialize the database
|
||||||
|
db, err := New(ctx, cancel, tempDir, "info") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create database: %v", err) |
||||||
|
} |
||||||
|
defer db.Close() |
||||||
|
|
||||||
|
// Create a scanner to read events from examples.Cache
|
||||||
|
scanner := bufio.NewScanner(bytes.NewBuffer(examples.Cache)) |
||||||
|
scanner.Buffer(make([]byte, 0, 1_000_000_000), 1_000_000_000) |
||||||
|
|
||||||
|
// Count the number of events processed
|
||||||
|
eventCount := 0 |
||||||
|
|
||||||
|
var events []*event.E |
||||||
|
|
||||||
|
// Process each event
|
||||||
|
for scanner.Scan() { |
||||||
|
chk.E(scanner.Err()) |
||||||
|
b := scanner.Bytes() |
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Unmarshal the event
|
||||||
|
if _, err = ev.Unmarshal(b); chk.E(err) { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
events = append(events, ev) |
||||||
|
|
||||||
|
// Save the event to the database
|
||||||
|
if _, _, err = db.SaveEvent(ctx, ev, false, nil); err != nil { |
||||||
|
t.Fatalf("Failed to save event #%d: %v", eventCount+1, err) |
||||||
|
} |
||||||
|
|
||||||
|
eventCount++ |
||||||
|
} |
||||||
|
|
||||||
|
// Check for scanner errors
|
||||||
|
if err = scanner.Err(); err != nil { |
||||||
|
t.Fatalf("Scanner error: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("Successfully saved %d events to the database", eventCount) |
||||||
|
|
||||||
|
// Instead of trying to find a valid serial directly, let's use QueryForIds
|
||||||
|
// which is known to work from the other tests
|
||||||
|
testEvent := events[3] // Using the same event as in other tests
|
||||||
|
|
||||||
|
// Use QueryForIds to get the IdPkTs for this event
|
||||||
|
var sers types.Uint40s |
||||||
|
sers, err = db.QueryForSerials( |
||||||
|
ctx, &filter.F{ |
||||||
|
Ids: tag.NewFromBytesSlice(testEvent.ID), |
||||||
|
}, |
||||||
|
) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to query for Ids: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got exactly one result
|
||||||
|
if len(sers) != 1 { |
||||||
|
t.Fatalf("Expected 1 IdPkTs, got %d", len(sers)) |
||||||
|
} |
||||||
|
|
||||||
|
// Fetch the event by serial
|
||||||
|
fetchedEvent, err := db.FetchEventBySerial(sers[0]) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to fetch event by serial: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the fetched event is not nil
|
||||||
|
if fetchedEvent == nil { |
||||||
|
t.Fatal("Expected fetched event to be non-nil, but got nil") |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the fetched event has the same ID as the original event
|
||||||
|
if !utils.FastEqual(fetchedEvent.ID, testEvent.ID) { |
||||||
|
t.Fatalf( |
||||||
|
"Fetched event ID doesn't match original event ID. Got %x, expected %x", |
||||||
|
fetchedEvent.ID, testEvent.ID, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify other event properties match
|
||||||
|
if fetchedEvent.Kind != testEvent.Kind { |
||||||
|
t.Fatalf( |
||||||
|
"Fetched event kind doesn't match. Got %d, expected %d", |
||||||
|
fetchedEvent.Kind, testEvent.Kind, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
if !utils.FastEqual(fetchedEvent.Pubkey, testEvent.Pubkey) { |
||||||
|
t.Fatalf( |
||||||
|
"Fetched event pubkey doesn't match. Got %x, expected %x", |
||||||
|
fetchedEvent.Pubkey, testEvent.Pubkey, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
if fetchedEvent.CreatedAt != testEvent.CreatedAt { |
||||||
|
t.Fatalf( |
||||||
|
"Fetched event created_at doesn't match. Got %d, expected %d", |
||||||
|
fetchedEvent.CreatedAt, testEvent.CreatedAt, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with a non-existent serial
|
||||||
|
nonExistentSerial := new(types.Uint40) |
||||||
|
err = nonExistentSerial.Set(uint64(0xFFFFFFFFFF)) // Max value
|
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create non-existent serial: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// This should return an error since the serial doesn't exist
|
||||||
|
fetchedEvent, err = db.FetchEventBySerial(nonExistentSerial) |
||||||
|
if err == nil { |
||||||
|
t.Fatal("Expected error for non-existent serial, but got nil") |
||||||
|
} |
||||||
|
|
||||||
|
// The fetched event should be nil
|
||||||
|
if fetchedEvent != nil { |
||||||
|
t.Fatalf( |
||||||
|
"Expected nil event for non-existent serial, but got: %v", |
||||||
|
fetchedEvent, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,56 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"interfaces.orly/store" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
func (d *D) GetFullIdPubkeyBySerial(ser *types.Uint40) ( |
||||||
|
fidpk *store.IdPkTs, err error, |
||||||
|
) { |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
buf := new(bytes.Buffer) |
||||||
|
if err = indexes.FullIdPubkeyEnc( |
||||||
|
ser, nil, nil, nil, |
||||||
|
).MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
prf := buf.Bytes() |
||||||
|
it := txn.NewIterator( |
||||||
|
badger.IteratorOptions{ |
||||||
|
Prefix: prf, |
||||||
|
}, |
||||||
|
) |
||||||
|
defer it.Close() |
||||||
|
it.Seek(prf) |
||||||
|
if it.Valid() { |
||||||
|
item := it.Item() |
||||||
|
key := item.Key() |
||||||
|
ser, fid, p, ca := indexes.FullIdPubkeyVars() |
||||||
|
buf2 := bytes.NewBuffer(key) |
||||||
|
if err = indexes.FullIdPubkeyDec( |
||||||
|
ser, fid, p, ca, |
||||||
|
).UnmarshalRead(buf2); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idpkts := store.IdPkTs{ |
||||||
|
Id: fid.Bytes(), |
||||||
|
Pub: p.Bytes(), |
||||||
|
Ts: int64(ca.Get()), |
||||||
|
Ser: ser.Get(), |
||||||
|
} |
||||||
|
fidpk = &idpkts |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,74 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
"database.orly/indexes/types" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"interfaces.orly/store" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
// GetFullIdPubkeyBySerials seeks directly to each serial's prefix in the
|
||||||
|
// FullIdPubkey index. The input sers slice is expected to be sorted in
|
||||||
|
// ascending order, allowing efficient forward-only iteration via a single
|
||||||
|
// Badger iterator.
|
||||||
|
func (d *D) GetFullIdPubkeyBySerials(sers []*types.Uint40) ( |
||||||
|
fidpks []*store.IdPkTs, err error, |
||||||
|
) { |
||||||
|
if len(sers) == 0 { |
||||||
|
return |
||||||
|
} |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
// Scope the iterator to the FullIdPubkey table using its 3-byte prefix.
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
if err = indexes.NewPrefix(indexes.FullIdPubkey).MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
tablePrefix := buf.Bytes() |
||||||
|
it := txn.NewIterator(badger.IteratorOptions{Prefix: tablePrefix}) |
||||||
|
defer it.Close() |
||||||
|
|
||||||
|
for _, s := range sers { |
||||||
|
if s == nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
// Build the serial-specific prefix: 3-byte table prefix + 5-byte serial.
|
||||||
|
sbuf := new(bytes.Buffer) |
||||||
|
if err = indexes.FullIdPubkeyEnc( |
||||||
|
s, nil, nil, nil, |
||||||
|
).MarshalWrite(sbuf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
serialPrefix := sbuf.Bytes() |
||||||
|
|
||||||
|
// Seek to the first key for this serial and verify it matches the prefix.
|
||||||
|
it.Seek(serialPrefix) |
||||||
|
if it.ValidForPrefix(serialPrefix) { |
||||||
|
item := it.Item() |
||||||
|
key := item.Key() |
||||||
|
ser, fid, p, ca := indexes.FullIdPubkeyVars() |
||||||
|
if err = indexes.FullIdPubkeyDec( |
||||||
|
ser, fid, p, ca, |
||||||
|
).UnmarshalRead(bytes.NewBuffer(key)); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
fidpks = append( |
||||||
|
fidpks, &store.IdPkTs{ |
||||||
|
Id: fid.Bytes(), |
||||||
|
Pub: p.Bytes(), |
||||||
|
Ts: int64(ca.Get()), |
||||||
|
Ser: ser.Get(), |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,156 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
. "database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
// appendIndexBytes marshals an index to a byte slice and appends it to the idxs slice
|
||||||
|
func appendIndexBytes(idxs *[][]byte, idx *indexes.T) (err error) { |
||||||
|
buf := new(bytes.Buffer) |
||||||
|
// Marshal the index to the buffer
|
||||||
|
if err = idx.MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Copy the buffer's bytes to a new byte slice
|
||||||
|
// Append the byte slice to the idxs slice
|
||||||
|
*idxs = append(*idxs, buf.Bytes()) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// GetIndexesForEvent creates all the indexes for an event.E instance as defined
|
||||||
|
// in keys.go. It returns a slice of byte slices that can be used to store the
|
||||||
|
// event in the database.
|
||||||
|
func GetIndexesForEvent(ev *event.E, serial uint64) ( |
||||||
|
idxs [][]byte, err error, |
||||||
|
) { |
||||||
|
defer func() { |
||||||
|
if chk.E(err) { |
||||||
|
idxs = nil |
||||||
|
} |
||||||
|
}() |
||||||
|
// Convert serial to Uint40
|
||||||
|
ser := new(Uint40) |
||||||
|
if err = ser.Set(serial); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// ID index
|
||||||
|
idHash := new(IdHash) |
||||||
|
if err = idHash.FromId(ev.ID); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idIndex := indexes.IdEnc(idHash, ser) |
||||||
|
if err = appendIndexBytes(&idxs, idIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// FullIdPubkey index
|
||||||
|
fullID := new(Id) |
||||||
|
if err = fullID.FromId(ev.ID); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
pubHash := new(PubHash) |
||||||
|
if err = pubHash.FromPubkey(ev.Pubkey); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
createdAt := new(Uint64) |
||||||
|
createdAt.Set(uint64(ev.CreatedAt)) |
||||||
|
idPubkeyIndex := indexes.FullIdPubkeyEnc( |
||||||
|
ser, fullID, pubHash, createdAt, |
||||||
|
) |
||||||
|
if err = appendIndexBytes(&idxs, idPubkeyIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// CreatedAt index
|
||||||
|
createdAtIndex := indexes.CreatedAtEnc(createdAt, ser) |
||||||
|
if err = appendIndexBytes(&idxs, createdAtIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// PubkeyCreatedAt index
|
||||||
|
pubkeyIndex := indexes.PubkeyEnc(pubHash, createdAt, ser) |
||||||
|
if err = appendIndexBytes(&idxs, pubkeyIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Process tags for tag-related indexes
|
||||||
|
if ev.Tags != nil && ev.Tags.Len() > 0 { |
||||||
|
for _, tag := range ev.Tags.ToSliceOfTags() { |
||||||
|
// only index tags with a value field and the key is a single character
|
||||||
|
if tag.Len() >= 2 { |
||||||
|
// Get the key and value from the tag
|
||||||
|
keyBytes := tag.Key() |
||||||
|
// require single-letter key
|
||||||
|
if len(keyBytes) != 1 { |
||||||
|
continue |
||||||
|
} |
||||||
|
// if the key is not a-zA-Z skip
|
||||||
|
if (keyBytes[0] < 'a' || keyBytes[0] > 'z') && (keyBytes[0] < 'A' || keyBytes[0] > 'Z') { |
||||||
|
continue |
||||||
|
} |
||||||
|
valueBytes := tag.Value() |
||||||
|
// Create tag key and value
|
||||||
|
key := new(Letter) |
||||||
|
key.Set(keyBytes[0]) |
||||||
|
valueHash := new(Ident) |
||||||
|
valueHash.FromIdent(valueBytes) |
||||||
|
// TagPubkey index
|
||||||
|
pubkeyTagIndex := indexes.TagPubkeyEnc( |
||||||
|
key, valueHash, pubHash, createdAt, ser, |
||||||
|
) |
||||||
|
if err = appendIndexBytes( |
||||||
|
&idxs, pubkeyTagIndex, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Tag index
|
||||||
|
tagIndex := indexes.TagEnc( |
||||||
|
key, valueHash, createdAt, ser, |
||||||
|
) |
||||||
|
if err = appendIndexBytes( |
||||||
|
&idxs, tagIndex, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Kind-related tag indexes
|
||||||
|
kind := new(Uint16) |
||||||
|
kind.Set(ev.Kind) |
||||||
|
// TagKind index
|
||||||
|
kindTagIndex := indexes.TagKindEnc( |
||||||
|
key, valueHash, kind, createdAt, ser, |
||||||
|
) |
||||||
|
if err = appendIndexBytes( |
||||||
|
&idxs, kindTagIndex, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// TagKindPubkey index
|
||||||
|
kindPubkeyTagIndex := indexes.TagKindPubkeyEnc( |
||||||
|
key, valueHash, kind, pubHash, createdAt, ser, |
||||||
|
) |
||||||
|
if err = appendIndexBytes( |
||||||
|
&idxs, kindPubkeyTagIndex, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
kind := new(Uint16) |
||||||
|
kind.Set(uint16(ev.Kind)) |
||||||
|
// Kind index
|
||||||
|
kindIndex := indexes.KindEnc(kind, createdAt, ser) |
||||||
|
if err = appendIndexBytes(&idxs, kindIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
// KindPubkey index
|
||||||
|
// Using the correct parameters based on the function signature
|
||||||
|
kindPubkeyIndex := indexes.KindPubkeyEnc( |
||||||
|
kind, pubHash, createdAt, ser, |
||||||
|
) |
||||||
|
if err = appendIndexBytes(&idxs, kindPubkeyIndex); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,304 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"crypto.orly/sha256" |
||||||
|
"database.orly/indexes" |
||||||
|
types2 "database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"encoders.orly/kind" |
||||||
|
"encoders.orly/tag" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
) |
||||||
|
|
||||||
|
func TestGetIndexesForEvent(t *testing.T) { |
||||||
|
t.Run("BasicEvent", testBasicEvent) |
||||||
|
t.Run("EventWithTags", testEventWithTags) |
||||||
|
t.Run("ErrorHandling", testErrorHandling) |
||||||
|
} |
||||||
|
|
||||||
|
// Helper function to verify that a specific index is included in the generated
|
||||||
|
// indexes
|
||||||
|
func verifyIndexIncluded(t *testing.T, idxs [][]byte, expectedIdx *indexes.T) { |
||||||
|
// Marshal the expected index
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := expectedIdx.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal expected index: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
expectedBytes := buf.Bytes() |
||||||
|
found := false |
||||||
|
|
||||||
|
for _, idx := range idxs { |
||||||
|
if utils.FastEqual(idx, expectedBytes) { |
||||||
|
found = true |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if !found { |
||||||
|
t.Errorf("Expected index not found in generated indexes") |
||||||
|
t.Errorf("Expected: %v", expectedBytes) |
||||||
|
t.Errorf("Generated indexes: %d indexes", len(idxs)) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test basic event with minimal fields
|
||||||
|
func testBasicEvent(t *testing.T) { |
||||||
|
// Create a basic event
|
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Set ID
|
||||||
|
id := make([]byte, sha256.Size) |
||||||
|
for i := range id { |
||||||
|
id[i] = byte(i) |
||||||
|
} |
||||||
|
ev.ID = id |
||||||
|
|
||||||
|
// Set Pubkey
|
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i + 1) |
||||||
|
} |
||||||
|
ev.Pubkey = pubkey |
||||||
|
|
||||||
|
// Set CreatedAt
|
||||||
|
ev.CreatedAt = 12345 |
||||||
|
|
||||||
|
// Set Kind
|
||||||
|
ev.Kind = kind.TextNote.K |
||||||
|
|
||||||
|
// Set Content
|
||||||
|
ev.Content = []byte("Test content") |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
serial := uint64(1) |
||||||
|
idxs, err := GetIndexesForEvent(ev, serial) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesForEvent failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the number of indexes (should be 6 for a basic event without tags)
|
||||||
|
if len(idxs) != 6 { |
||||||
|
t.Fatalf("Expected 6 indexes, got %d", len(idxs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Create and verify the expected indexes
|
||||||
|
|
||||||
|
// 1. ID index
|
||||||
|
ser := new(types2.Uint40) |
||||||
|
err = ser.Set(serial) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create Uint40: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
idHash := new(types2.IdHash) |
||||||
|
err = idHash.FromId(ev.ID) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create IdHash: %v", err) |
||||||
|
} |
||||||
|
idIndex := indexes.IdEnc(idHash, ser) |
||||||
|
verifyIndexIncluded(t, idxs, idIndex) |
||||||
|
|
||||||
|
// 2. FullIdPubkey index
|
||||||
|
fullID := new(types2.Id) |
||||||
|
err = fullID.FromId(ev.ID) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create ID: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
pubHash := new(types2.PubHash) |
||||||
|
err = pubHash.FromPubkey(ev.Pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
createdAt := new(types2.Uint64) |
||||||
|
createdAt.Set(uint64(ev.CreatedAt)) |
||||||
|
|
||||||
|
idPubkeyIndex := indexes.FullIdPubkeyEnc(ser, fullID, pubHash, createdAt) |
||||||
|
verifyIndexIncluded(t, idxs, idPubkeyIndex) |
||||||
|
|
||||||
|
// 3. CreatedAt index
|
||||||
|
createdAtIndex := indexes.CreatedAtEnc(createdAt, ser) |
||||||
|
verifyIndexIncluded(t, idxs, createdAtIndex) |
||||||
|
|
||||||
|
// 4. Pubkey index
|
||||||
|
pubkeyIndex := indexes.PubkeyEnc(pubHash, createdAt, ser) |
||||||
|
verifyIndexIncluded(t, idxs, pubkeyIndex) |
||||||
|
|
||||||
|
// 5. Kind index
|
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(ev.Kind) |
||||||
|
|
||||||
|
kindIndex := indexes.KindEnc(kind, createdAt, ser) |
||||||
|
verifyIndexIncluded(t, idxs, kindIndex) |
||||||
|
|
||||||
|
// 6. KindPubkey index
|
||||||
|
kindPubkeyIndex := indexes.KindPubkeyEnc(kind, pubHash, createdAt, ser) |
||||||
|
verifyIndexIncluded(t, idxs, kindPubkeyIndex) |
||||||
|
} |
||||||
|
|
||||||
|
// Test event with tags
|
||||||
|
func testEventWithTags(t *testing.T) { |
||||||
|
// Create an event with tags
|
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Set ID
|
||||||
|
id := make([]byte, sha256.Size) |
||||||
|
for i := range id { |
||||||
|
id[i] = byte(i) |
||||||
|
} |
||||||
|
ev.ID = id |
||||||
|
|
||||||
|
// Set Pubkey
|
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i + 1) |
||||||
|
} |
||||||
|
ev.Pubkey = pubkey |
||||||
|
|
||||||
|
// Set CreatedAt
|
||||||
|
ev.CreatedAt = 12345 |
||||||
|
|
||||||
|
// Set Kind
|
||||||
|
ev.Kind = kind.TextNote.K // TextNote kind
|
||||||
|
|
||||||
|
// Set Content
|
||||||
|
ev.Content = []byte("Test content with tags") |
||||||
|
|
||||||
|
// Add tags
|
||||||
|
ev.Tags = tag.NewS() |
||||||
|
|
||||||
|
// Add e tag (event reference)
|
||||||
|
eTagKey := "e" |
||||||
|
eTagValue := "abcdef1234567890" |
||||||
|
eTag := tag.NewFromAny(eTagKey, eTagValue) |
||||||
|
*ev.Tags = append(*ev.Tags, eTag) |
||||||
|
|
||||||
|
// Add p tag (pubkey reference)
|
||||||
|
pTagKey := "p" |
||||||
|
pTagValue := "0123456789abcdef" |
||||||
|
pTag := tag.NewFromAny(pTagKey, pTagValue) |
||||||
|
*ev.Tags = append(*ev.Tags, pTag) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
serial := uint64(2) |
||||||
|
idxs, err := GetIndexesForEvent(ev, serial) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesForEvent failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the number of indexes (should be 14 for an event with 2 tags)
|
||||||
|
// 6 basic indexes + 4 indexes per tag (TagPubkey, Tag, TagKind, TagKindPubkey)
|
||||||
|
if len(idxs) != 14 { |
||||||
|
t.Fatalf("Expected 14 indexes, got %d", len(idxs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Create and verify the basic indexes (same as in testBasicEvent)
|
||||||
|
ser := new(types2.Uint40) |
||||||
|
err = ser.Set(serial) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create Uint40: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
idHash := new(types2.IdHash) |
||||||
|
err = idHash.FromId(ev.ID) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create IdHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify one of the tag-related indexes (e tag)
|
||||||
|
pubHash := new(types2.PubHash) |
||||||
|
err = pubHash.FromPubkey(ev.Pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
createdAt := new(types2.Uint64) |
||||||
|
createdAt.Set(uint64(ev.CreatedAt)) |
||||||
|
|
||||||
|
// Create tag key and value for e tag
|
||||||
|
eKey := new(types2.Letter) |
||||||
|
eKey.Set('e') |
||||||
|
|
||||||
|
eValueHash := new(types2.Ident) |
||||||
|
eValueHash.FromIdent([]byte("abcdef1234567890")) |
||||||
|
|
||||||
|
// Verify TagPubkey index for e tag
|
||||||
|
pubkeyTagIndex := indexes.TagPubkeyEnc( |
||||||
|
eKey, eValueHash, pubHash, createdAt, ser, |
||||||
|
) |
||||||
|
verifyIndexIncluded(t, idxs, pubkeyTagIndex) |
||||||
|
|
||||||
|
// Verify Tag index for e tag
|
||||||
|
tagIndex := indexes.TagEnc( |
||||||
|
eKey, eValueHash, createdAt, ser, |
||||||
|
) |
||||||
|
verifyIndexIncluded(t, idxs, tagIndex) |
||||||
|
|
||||||
|
// Verify TagKind index for e tag
|
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(ev.Kind) |
||||||
|
|
||||||
|
kindTagIndex := indexes.TagKindEnc(eKey, eValueHash, kind, createdAt, ser) |
||||||
|
verifyIndexIncluded(t, idxs, kindTagIndex) |
||||||
|
|
||||||
|
// Verify TagKindPubkey index for e tag
|
||||||
|
kindPubkeyTagIndex := indexes.TagKindPubkeyEnc( |
||||||
|
eKey, eValueHash, kind, pubHash, createdAt, ser, |
||||||
|
) |
||||||
|
verifyIndexIncluded(t, idxs, kindPubkeyTagIndex) |
||||||
|
} |
||||||
|
|
||||||
|
// Test error handling
|
||||||
|
func testErrorHandling(t *testing.T) { |
||||||
|
// Test with invalid serial number (too large for Uint40)
|
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Set ID
|
||||||
|
id := make([]byte, sha256.Size) |
||||||
|
for i := range id { |
||||||
|
id[i] = byte(i) |
||||||
|
} |
||||||
|
ev.ID = id |
||||||
|
|
||||||
|
// Set Pubkey
|
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i + 1) |
||||||
|
} |
||||||
|
ev.Pubkey = pubkey |
||||||
|
|
||||||
|
// Set CreatedAt
|
||||||
|
ev.CreatedAt = 12345 |
||||||
|
|
||||||
|
// Set Kind
|
||||||
|
ev.Kind = kind.TextNote.K |
||||||
|
|
||||||
|
// Set Content
|
||||||
|
ev.Content = []byte("Test content") |
||||||
|
|
||||||
|
// Use an invalid serial number (too large for Uint40)
|
||||||
|
invalidSerial := uint64(1) << 40 // 2^40, which is too large for Uint40
|
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesForEvent(ev, invalidSerial) |
||||||
|
|
||||||
|
// Verify that an error was returned
|
||||||
|
if err == nil { |
||||||
|
t.Fatalf("Expected error for invalid serial number, got nil") |
||||||
|
} |
||||||
|
|
||||||
|
// Verify that idxs is nil when an error occurs
|
||||||
|
if idxs != nil { |
||||||
|
t.Fatalf("Expected nil idxs when error occurs, got %v", idxs) |
||||||
|
} |
||||||
|
|
||||||
|
// Note: We don't test with nil event as it causes a panic
|
||||||
|
// The function doesn't have nil checks, which is a potential improvement
|
||||||
|
} |
||||||
@ -0,0 +1,388 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"math" |
||||||
|
"sort" |
||||||
|
|
||||||
|
"database.orly/indexes" |
||||||
|
types2 "database.orly/indexes/types" |
||||||
|
"encoders.orly/filter" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
type Range struct { |
||||||
|
Start, End []byte |
||||||
|
} |
||||||
|
|
||||||
|
// IsHexString checks if the byte slice contains only hex characters
|
||||||
|
func IsHexString(data []byte) (isHex bool) { |
||||||
|
if len(data)%2 != 0 { |
||||||
|
return false |
||||||
|
} |
||||||
|
for _, b := range data { |
||||||
|
if !((b >= '0' && b <= '9') || (b >= 'a' && b <= 'f') || (b >= 'A' && b <= 'F')) { |
||||||
|
return false |
||||||
|
} |
||||||
|
} |
||||||
|
return true |
||||||
|
} |
||||||
|
|
||||||
|
// CreateIdHashFromData creates an IdHash from data that could be hex or binary
|
||||||
|
func CreateIdHashFromData(data []byte) (i *types2.IdHash, err error) { |
||||||
|
i = new(types2.IdHash) |
||||||
|
|
||||||
|
// If data looks like hex string and has the right length for hex-encoded
|
||||||
|
// sha256
|
||||||
|
if len(data) == 64 { |
||||||
|
if err = i.FromIdHex(string(data)); chk.E(err) { |
||||||
|
err = nil |
||||||
|
} else { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
// Assume it's binary data
|
||||||
|
if err = i.FromId(data); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// CreatePubHashFromData creates a PubHash from data that could be hex or binary
|
||||||
|
func CreatePubHashFromData(data []byte) (p *types2.PubHash, err error) { |
||||||
|
p = new(types2.PubHash) |
||||||
|
|
||||||
|
// If data looks like hex string and has the right length for hex-encoded
|
||||||
|
// pubkey
|
||||||
|
if len(data) == 64 { |
||||||
|
if err = p.FromPubkeyHex(string(data)); chk.E(err) { |
||||||
|
err = nil |
||||||
|
} else { |
||||||
|
return |
||||||
|
} |
||||||
|
} else { |
||||||
|
// Assume it's binary data
|
||||||
|
if err = p.FromPubkey(data); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// GetIndexesFromFilter returns encoded indexes based on the given filter.
|
||||||
|
//
|
||||||
|
// An error is returned if any input values are invalid during encoding.
|
||||||
|
//
|
||||||
|
// The indexes are designed so that only one table needs to be iterated, being a
|
||||||
|
// complete set of combinations of all fields in the event, thus there is no
|
||||||
|
// need to decode events until they are to be delivered.
|
||||||
|
func GetIndexesFromFilter(f *filter.F) (idxs []Range, err error) { |
||||||
|
// ID eid
|
||||||
|
//
|
||||||
|
// If there is any Ids in the filter, none of the other fields matter. It
|
||||||
|
// should be an error, but convention just ignores it.
|
||||||
|
if f.Ids.Len() > 0 { |
||||||
|
for _, id := range f.Ids.ToSliceOfBytes() { |
||||||
|
if err = func() (err error) { |
||||||
|
var i *types2.IdHash |
||||||
|
if i, err = CreateIdHashFromData(id); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
buf := new(bytes.Buffer) |
||||||
|
idx := indexes.IdEnc(i, nil) |
||||||
|
if err = idx.MarshalWrite(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
b := buf.Bytes() |
||||||
|
r := Range{b, b} |
||||||
|
idxs = append(idxs, r) |
||||||
|
return |
||||||
|
}(); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
|
||||||
|
// Set the start of range (Since or default to zero)
|
||||||
|
if f.Since != nil && f.Since.V != 0 { |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
} else { |
||||||
|
caStart.Set(uint64(0)) |
||||||
|
} |
||||||
|
|
||||||
|
// Set the end of range (Until or default to math.MaxInt64)
|
||||||
|
if f.Until != nil && f.Until.V != 0 { |
||||||
|
caEnd.Set(uint64(f.Until.V)) |
||||||
|
} else { |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
} |
||||||
|
|
||||||
|
if f.Tags != nil && f.Tags.Len() > 0 { |
||||||
|
// sort the tags so they are in iteration order (reverse)
|
||||||
|
tmp := f.Tags.ToSliceOfTags() |
||||||
|
sort.Slice( |
||||||
|
tmp, func(i, j int) bool { |
||||||
|
return bytes.Compare(tmp[i].Key(), tmp[j].Key()) > 0 |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// TagKindPubkey tkp
|
||||||
|
if f.Kinds != nil && f.Kinds.Len() > 0 && f.Authors != nil && f.Authors.Len() > 0 && f.Tags != nil && f.Tags.Len() > 0 { |
||||||
|
for _, k := range f.Kinds.ToUint16() { |
||||||
|
for _, author := range f.Authors.ToSliceOfBytes() { |
||||||
|
for _, tag := range f.Tags.ToSliceOfTags() { |
||||||
|
// accept single-letter keys like "e" or filter-style keys like "#e"
|
||||||
|
if tag.Len() >= 2 && (len(tag.Key()) == 1 || (len(tag.Key()) == 2 && tag.Key()[0] == '#')) { |
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(k) |
||||||
|
var p *types2.PubHash |
||||||
|
if p, err = CreatePubHashFromData(author); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
keyBytes := tag.Key() |
||||||
|
key := new(types2.Letter) |
||||||
|
// If the tag key starts with '#', use the second character as the key
|
||||||
|
if len(keyBytes) == 2 && keyBytes[0] == '#' { |
||||||
|
key.Set(keyBytes[1]) |
||||||
|
} else { |
||||||
|
key.Set(keyBytes[0]) |
||||||
|
} |
||||||
|
for _, valueBytes := range tag.ToSliceOfBytes()[1:] { |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent(valueBytes) |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.TagKindPubkeyEnc( |
||||||
|
key, valueHash, kind, p, caStart, nil, |
||||||
|
) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.TagKindPubkeyEnc( |
||||||
|
key, valueHash, kind, p, caEnd, nil, |
||||||
|
) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{ |
||||||
|
start.Bytes(), end.Bytes(), |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// TagKind tkc
|
||||||
|
if f.Kinds != nil && f.Kinds.Len() > 0 && f.Tags != nil && f.Tags.Len() > 0 { |
||||||
|
for _, k := range f.Kinds.ToUint16() { |
||||||
|
for _, tag := range f.Tags.ToSliceOfTags() { |
||||||
|
if tag.Len() >= 2 && (len(tag.Key()) == 1 || (len(tag.Key()) == 2 && tag.Key()[0] == '#')) { |
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(k) |
||||||
|
keyBytes := tag.Key() |
||||||
|
key := new(types2.Letter) |
||||||
|
// If the tag key starts with '#', use the second character as the key
|
||||||
|
if len(keyBytes) == 2 && keyBytes[0] == '#' { |
||||||
|
key.Set(keyBytes[1]) |
||||||
|
} else { |
||||||
|
key.Set(keyBytes[0]) |
||||||
|
} |
||||||
|
for _, valueBytes := range tag.ToSliceOfBytes()[1:] { |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent(valueBytes) |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.TagKindEnc( |
||||||
|
key, valueHash, kind, caStart, nil, |
||||||
|
) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.TagKindEnc( |
||||||
|
key, valueHash, kind, caEnd, nil, |
||||||
|
) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{ |
||||||
|
start.Bytes(), end.Bytes(), |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// TagPubkey tpc
|
||||||
|
if f.Authors != nil && f.Authors.Len() > 0 && f.Tags != nil && f.Tags.Len() > 0 { |
||||||
|
for _, author := range f.Authors.ToSliceOfBytes() { |
||||||
|
for _, tag := range f.Tags.ToSliceOfTags() { |
||||||
|
if tag.Len() >= 2 && (len(tag.Key()) == 1 || (len(tag.Key()) == 2 && tag.Key()[0] == '#')) { |
||||||
|
var p *types2.PubHash |
||||||
|
if p, err = CreatePubHashFromData(author); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
keyBytes := tag.Key() |
||||||
|
key := new(types2.Letter) |
||||||
|
// If the tag key starts with '#', use the second character as the key
|
||||||
|
if len(keyBytes) == 2 && keyBytes[0] == '#' { |
||||||
|
key.Set(keyBytes[1]) |
||||||
|
} else { |
||||||
|
key.Set(keyBytes[0]) |
||||||
|
} |
||||||
|
for _, valueBytes := range tag.ToSliceOfBytes()[1:] { |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent(valueBytes) |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.TagPubkeyEnc( |
||||||
|
key, valueHash, p, caStart, nil, |
||||||
|
) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.TagPubkeyEnc( |
||||||
|
key, valueHash, p, caEnd, nil, |
||||||
|
) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Tag tc-
|
||||||
|
if f.Tags != nil && f.Tags.Len() > 0 && (f.Authors == nil || f.Authors.Len() == 0) && (f.Kinds == nil || f.Kinds.Len() == 0) { |
||||||
|
for _, tag := range f.Tags.ToSliceOfTags() { |
||||||
|
if tag.Len() >= 2 && (len(tag.Key()) == 1 || (len(tag.Key()) == 2 && tag.Key()[0] == '#')) { |
||||||
|
keyBytes := tag.Key() |
||||||
|
key := new(types2.Letter) |
||||||
|
// If the tag key starts with '#', use the second character as the key
|
||||||
|
if len(keyBytes) == 2 && keyBytes[0] == '#' { |
||||||
|
key.Set(keyBytes[1]) |
||||||
|
} else { |
||||||
|
key.Set(keyBytes[0]) |
||||||
|
} |
||||||
|
for _, valueBytes := range tag.ToSliceOfBytes()[1:] { |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent(valueBytes) |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.TagEnc(key, valueHash, caStart, nil) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.TagEnc(key, valueHash, caEnd, nil) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// KindPubkey kpc
|
||||||
|
if f.Kinds != nil && f.Kinds.Len() > 0 && f.Authors != nil && f.Authors.Len() > 0 { |
||||||
|
for _, k := range f.Kinds.ToUint16() { |
||||||
|
for _, author := range f.Authors.ToSliceOfBytes() { |
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(k) |
||||||
|
p := new(types2.PubHash) |
||||||
|
if err = p.FromPubkey(author); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.KindPubkeyEnc(kind, p, caStart, nil) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.KindPubkeyEnc(kind, p, caEnd, nil) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Kind kc-
|
||||||
|
if f.Kinds != nil && f.Kinds.Len() > 0 && (f.Authors == nil || f.Authors.Len() == 0) && (f.Tags == nil || f.Tags.Len() == 0) { |
||||||
|
for _, k := range f.Kinds.ToUint16() { |
||||||
|
kind := new(types2.Uint16) |
||||||
|
kind.Set(k) |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.KindEnc(kind, caStart, nil) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.KindEnc(kind, caEnd, nil) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Pubkey pc-
|
||||||
|
if f.Authors != nil && f.Authors.Len() > 0 { |
||||||
|
for _, author := range f.Authors.ToSliceOfBytes() { |
||||||
|
p := new(types2.PubHash) |
||||||
|
if err = p.FromPubkey(author); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.PubkeyEnc(p, caStart, nil) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.PubkeyEnc(p, caEnd, nil) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// CreatedAt c--
|
||||||
|
start, end := new(bytes.Buffer), new(bytes.Buffer) |
||||||
|
idxS := indexes.CreatedAtEnc(caStart, nil) |
||||||
|
if err = idxS.MarshalWrite(start); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxE := indexes.CreatedAtEnc(caEnd, nil) |
||||||
|
if err = idxE.MarshalWrite(end); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
idxs = append( |
||||||
|
idxs, Range{start.Bytes(), end.Bytes()}, |
||||||
|
) |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,587 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"math" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"crypto.orly/sha256" |
||||||
|
"database.orly/indexes" |
||||||
|
types2 "database.orly/indexes/types" |
||||||
|
"encoders.orly/filter" |
||||||
|
"encoders.orly/kind" |
||||||
|
"encoders.orly/tag" |
||||||
|
"encoders.orly/timestamp" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
) |
||||||
|
|
||||||
|
// TestGetIndexesFromFilter tests the GetIndexesFromFilter function
|
||||||
|
func TestGetIndexesFromFilter(t *testing.T) { |
||||||
|
t.Run("ID", testIdFilter) |
||||||
|
t.Run("Pubkey", testPubkeyFilter) |
||||||
|
t.Run("CreatedAt", testCreatedAtFilter) |
||||||
|
t.Run("CreatedAtUntil", testCreatedAtUntilFilter) |
||||||
|
t.Run("TagPubkey", testPubkeyTagFilter) |
||||||
|
t.Run("Tag", testTagFilter) |
||||||
|
t.Run("Kind", testKindFilter) |
||||||
|
t.Run("KindPubkey", testKindPubkeyFilter) |
||||||
|
t.Run("MultipleKindPubkey", testMultipleKindPubkeyFilter) |
||||||
|
t.Run("TagKind", testKindTagFilter) |
||||||
|
t.Run("TagKindPubkey", testKindPubkeyTagFilter) |
||||||
|
} |
||||||
|
|
||||||
|
// Helper function to verify that the generated index matches the expected indexes
|
||||||
|
func verifyIndex( |
||||||
|
t *testing.T, idxs []Range, expectedStartIdx, expectedEndIdx *indexes.T, |
||||||
|
) { |
||||||
|
if len(idxs) != 1 { |
||||||
|
t.Fatalf("Expected 1 index, got %d", len(idxs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Marshal the expected start index
|
||||||
|
startBuf := new(bytes.Buffer) |
||||||
|
err := expectedStartIdx.MarshalWrite(startBuf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal expected start index: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Compare the generated start index with the expected start index
|
||||||
|
if !utils.FastEqual(idxs[0].Start, startBuf.Bytes()) { |
||||||
|
t.Errorf("Generated start index does not match expected start index") |
||||||
|
t.Errorf("Generated: %v", idxs[0].Start) |
||||||
|
t.Errorf("Expected: %v", startBuf.Bytes()) |
||||||
|
} |
||||||
|
|
||||||
|
// If expectedEndIdx is nil, use expectedStartIdx
|
||||||
|
endIdx := expectedEndIdx |
||||||
|
if endIdx == nil { |
||||||
|
endIdx = expectedStartIdx |
||||||
|
} |
||||||
|
|
||||||
|
// Marshal the expected end index
|
||||||
|
endBuf := new(bytes.Buffer) |
||||||
|
err = endIdx.MarshalWrite(endBuf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal expected End index: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Compare the generated end index with the expected end index
|
||||||
|
if !utils.FastEqual(idxs[0].End, endBuf.Bytes()) { |
||||||
|
t.Errorf("Generated End index does not match expected End index") |
||||||
|
t.Errorf("Generated: %v", idxs[0].End) |
||||||
|
t.Errorf("Expected: %v", endBuf.Bytes()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test ID filter
|
||||||
|
func testIdFilter(t *testing.T) { |
||||||
|
// Create a filter with an ID
|
||||||
|
f := filter.New() |
||||||
|
id := make([]byte, sha256.Size) |
||||||
|
for i := range id { |
||||||
|
id[i] = byte(i) |
||||||
|
} |
||||||
|
f.Ids.T = append(f.Ids.T, id) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected index
|
||||||
|
idHash := new(types2.IdHash) |
||||||
|
err = idHash.FromId(id) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create IdHash: %v", err) |
||||||
|
} |
||||||
|
expectedIdx := indexes.IdEnc(idHash, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
// For ID filter, both start and end indexes are the same
|
||||||
|
verifyIndex(t, idxs, expectedIdx, expectedIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test Pubkey filter
|
||||||
|
func testPubkeyFilter(t *testing.T) { |
||||||
|
// Create a filter with an Author, Since, and Until
|
||||||
|
f := filter.New() |
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i) |
||||||
|
} |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey) |
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
f.Until = timestamp.FromUnix(67890) // Added Until field
|
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
p := new(types2.PubHash) |
||||||
|
err = p.FromPubkey(pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.PubkeyEnc(p, caStart, nil) |
||||||
|
|
||||||
|
// End index uses Until
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(f.Until.V)) |
||||||
|
expectedEndIdx := indexes.PubkeyEnc(p, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test CreatedAt filter
|
||||||
|
func testCreatedAtFilter(t *testing.T) { |
||||||
|
// Create a filter with Since
|
||||||
|
f := filter.New() |
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected start index (using Since)
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.CreatedAtEnc(caStart, nil) |
||||||
|
|
||||||
|
// Create the expected end index (using math.MaxInt64 since Until is not specified)
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.CreatedAtEnc(caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test CreatedAt filter with Until
|
||||||
|
func testCreatedAtUntilFilter(t *testing.T) { |
||||||
|
// Create a filter with Until
|
||||||
|
f := filter.New() |
||||||
|
f.Until = timestamp.FromUnix(67890) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected start index (using 0 since Since is not specified)
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(0)) |
||||||
|
expectedStartIdx := indexes.CreatedAtEnc(caStart, nil) |
||||||
|
|
||||||
|
// Create the expected end index (using Until)
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(f.Until.V)) |
||||||
|
expectedEndIdx := indexes.CreatedAtEnc(caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagPubkey filter
|
||||||
|
func testPubkeyTagFilter(t *testing.T) { |
||||||
|
// Create a filter with an Author, a Tag, and Since
|
||||||
|
f := filter.New() |
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i) |
||||||
|
} |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey) |
||||||
|
// Create a tag
|
||||||
|
tagKey := "e" |
||||||
|
tagValue := "test-value" |
||||||
|
tagT := tag.NewFromAny(tagKey, tagValue) |
||||||
|
*f.Tags = append(*f.Tags, tagT) |
||||||
|
|
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
p := new(types2.PubHash) |
||||||
|
err = p.FromPubkey(pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
key := new(types2.Letter) |
||||||
|
key.Set(tagKey[0]) |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent([]byte(tagValue)) |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.TagPubkeyEnc(key, valueHash, p, caStart, nil) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.TagPubkeyEnc(key, valueHash, p, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test Tag filter
|
||||||
|
func testTagFilter(t *testing.T) { |
||||||
|
// Create a filter with a Tag and Since
|
||||||
|
f := filter.New() |
||||||
|
|
||||||
|
// Create a tag
|
||||||
|
tagKey := "e" |
||||||
|
tagValue := "test-value" |
||||||
|
tagT := tag.NewFromAny(tagKey, tagValue) |
||||||
|
*f.Tags = append(*f.Tags, tagT) |
||||||
|
|
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
key := new(types2.Letter) |
||||||
|
key.Set(tagKey[0]) |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent([]byte(tagValue)) |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.TagEnc(key, valueHash, caStart, nil) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.TagEnc(key, valueHash, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test Kind filter
|
||||||
|
func testKindFilter(t *testing.T) { |
||||||
|
// Create a filter with a Kind and Since
|
||||||
|
f := filter.New() |
||||||
|
f.Kinds = kind.NewS(kind.TextNote) |
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
k := new(types2.Uint16) |
||||||
|
k.Set(1) |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.KindEnc(k, caStart, nil) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.KindEnc(k, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test KindPubkey filter
|
||||||
|
func testKindPubkeyFilter(t *testing.T) { |
||||||
|
// Create a filter with a Kind, an Author, and Since
|
||||||
|
f := filter.New() |
||||||
|
f.Kinds = kind.NewS(kind.TextNote) |
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i) |
||||||
|
} |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey) |
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
k := new(types2.Uint16) |
||||||
|
k.Set(1) |
||||||
|
p := new(types2.PubHash) |
||||||
|
err = p.FromPubkey(pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.KindPubkeyEnc(k, p, caStart, nil) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.KindPubkeyEnc(k, p, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagKind filter
|
||||||
|
func testKindTagFilter(t *testing.T) { |
||||||
|
// Create a filter with a Kind, a Tag, and Since
|
||||||
|
f := filter.New() |
||||||
|
f.Kinds = kind.NewS(kind.TextNote) |
||||||
|
|
||||||
|
// Create a tag
|
||||||
|
tagKey := "e" |
||||||
|
tagValue := "test-value" |
||||||
|
tagT := tag.NewFromAny(tagKey, tagValue) |
||||||
|
*f.Tags = append(*f.Tags, tagT) |
||||||
|
|
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
k := new(types2.Uint16) |
||||||
|
k.Set(1) |
||||||
|
key := new(types2.Letter) |
||||||
|
key.Set(tagKey[0]) |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent([]byte(tagValue)) |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.TagKindEnc(key, valueHash, k, caStart, nil) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.TagKindEnc(key, valueHash, k, caEnd, nil) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
|
|
||||||
|
// Test Multiple KindPubkey filter
|
||||||
|
func testMultipleKindPubkeyFilter(t *testing.T) { |
||||||
|
// Create a filter with multiple Kinds and multiple Authors
|
||||||
|
f := filter.New() |
||||||
|
f.Kinds = kind.NewS(kind.New(1), kind.New(2)) |
||||||
|
|
||||||
|
// Create two pubkeys
|
||||||
|
pubkey1 := make([]byte, 32) |
||||||
|
pubkey2 := make([]byte, 32) |
||||||
|
for i := range pubkey1 { |
||||||
|
pubkey1[i] = byte(i) |
||||||
|
pubkey2[i] = byte(i + 100) |
||||||
|
} |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey1) |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey2) |
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// We should have 4 indexes (2 kinds * 2 pubkeys)
|
||||||
|
if len(idxs) != 4 { |
||||||
|
t.Fatalf("Expected 4 indexes, got %d", len(idxs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
k1 := new(types2.Uint16) |
||||||
|
k1.Set(1) |
||||||
|
k2 := new(types2.Uint16) |
||||||
|
k2.Set(2) |
||||||
|
|
||||||
|
p1 := new(types2.PubHash) |
||||||
|
err = p1.FromPubkey(pubkey1) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
p2 := new(types2.PubHash) |
||||||
|
err = p2.FromPubkey(pubkey2) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
|
||||||
|
// Create all expected combinations
|
||||||
|
expectedIdxs := make([][]byte, 8) // 4 combinations * 2 (start/end)
|
||||||
|
|
||||||
|
// Kind 1, Pubkey 1
|
||||||
|
startBuf1 := new(bytes.Buffer) |
||||||
|
idxS1 := indexes.KindPubkeyEnc(k1, p1, caStart, nil) |
||||||
|
if err = idxS1.MarshalWrite(startBuf1); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[0] = startBuf1.Bytes() |
||||||
|
|
||||||
|
endBuf1 := new(bytes.Buffer) |
||||||
|
idxE1 := indexes.KindPubkeyEnc(k1, p1, caEnd, nil) |
||||||
|
if err = idxE1.MarshalWrite(endBuf1); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[1] = endBuf1.Bytes() |
||||||
|
|
||||||
|
// Kind 1, Pubkey 2
|
||||||
|
startBuf2 := new(bytes.Buffer) |
||||||
|
idxS2 := indexes.KindPubkeyEnc(k1, p2, caStart, nil) |
||||||
|
if err = idxS2.MarshalWrite(startBuf2); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[2] = startBuf2.Bytes() |
||||||
|
|
||||||
|
endBuf2 := new(bytes.Buffer) |
||||||
|
idxE2 := indexes.KindPubkeyEnc(k1, p2, caEnd, nil) |
||||||
|
if err = idxE2.MarshalWrite(endBuf2); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[3] = endBuf2.Bytes() |
||||||
|
|
||||||
|
// Kind 2, Pubkey 1
|
||||||
|
startBuf3 := new(bytes.Buffer) |
||||||
|
idxS3 := indexes.KindPubkeyEnc(k2, p1, caStart, nil) |
||||||
|
if err = idxS3.MarshalWrite(startBuf3); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[4] = startBuf3.Bytes() |
||||||
|
|
||||||
|
endBuf3 := new(bytes.Buffer) |
||||||
|
idxE3 := indexes.KindPubkeyEnc(k2, p1, caEnd, nil) |
||||||
|
if err = idxE3.MarshalWrite(endBuf3); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[5] = endBuf3.Bytes() |
||||||
|
|
||||||
|
// Kind 2, Pubkey 2
|
||||||
|
startBuf4 := new(bytes.Buffer) |
||||||
|
idxS4 := indexes.KindPubkeyEnc(k2, p2, caStart, nil) |
||||||
|
if err = idxS4.MarshalWrite(startBuf4); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[6] = startBuf4.Bytes() |
||||||
|
|
||||||
|
endBuf4 := new(bytes.Buffer) |
||||||
|
idxE4 := indexes.KindPubkeyEnc(k2, p2, caEnd, nil) |
||||||
|
if err = idxE4.MarshalWrite(endBuf4); chk.E(err) { |
||||||
|
t.Fatalf("Failed to marshal index: %v", err) |
||||||
|
} |
||||||
|
expectedIdxs[7] = endBuf4.Bytes() |
||||||
|
|
||||||
|
// Verify that all expected combinations are present
|
||||||
|
foundCombinations := 0 |
||||||
|
for _, idx := range idxs { |
||||||
|
for i := 0; i < len(expectedIdxs); i += 2 { |
||||||
|
if utils.FastEqual(idx.Start, expectedIdxs[i]) && utils.FastEqual( |
||||||
|
idx.End, expectedIdxs[i+1], |
||||||
|
) { |
||||||
|
foundCombinations++ |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
if foundCombinations != 4 { |
||||||
|
t.Fatalf("Expected to find 4 combinations, found %d", foundCombinations) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagKindPubkey filter
|
||||||
|
func testKindPubkeyTagFilter(t *testing.T) { |
||||||
|
// Create a filter with a Kind, an Author, a Tag, and Since
|
||||||
|
f := filter.New() |
||||||
|
f.Kinds = kind.NewS(kind.New(1)) |
||||||
|
pubkey := make([]byte, 32) |
||||||
|
for i := range pubkey { |
||||||
|
pubkey[i] = byte(i) |
||||||
|
} |
||||||
|
f.Authors.T = append(f.Authors.T, pubkey) |
||||||
|
|
||||||
|
// Create a tag
|
||||||
|
tagKey := "e" |
||||||
|
tagValue := "test-value" |
||||||
|
tagT := tag.NewFromAny(tagKey, tagValue) |
||||||
|
*f.Tags = append(*f.Tags, tagT) |
||||||
|
|
||||||
|
f.Since = timestamp.FromUnix(12345) |
||||||
|
|
||||||
|
// Generate indexes
|
||||||
|
idxs, err := GetIndexesFromFilter(f) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("GetIndexesFromFilter failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create the expected indexes
|
||||||
|
k := new(types2.Uint16) |
||||||
|
k.Set(1) |
||||||
|
p := new(types2.PubHash) |
||||||
|
err = p.FromPubkey(pubkey) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Failed to create PubHash: %v", err) |
||||||
|
} |
||||||
|
key := new(types2.Letter) |
||||||
|
key.Set(tagKey[0]) |
||||||
|
valueHash := new(types2.Ident) |
||||||
|
valueHash.FromIdent([]byte(tagValue)) |
||||||
|
|
||||||
|
// Start index uses Since
|
||||||
|
caStart := new(types2.Uint64) |
||||||
|
caStart.Set(uint64(f.Since.V)) |
||||||
|
expectedStartIdx := indexes.TagKindPubkeyEnc( |
||||||
|
key, valueHash, k, p, caStart, nil, |
||||||
|
) |
||||||
|
|
||||||
|
// End index uses math.MaxInt64 since Until is not specified
|
||||||
|
caEnd := new(types2.Uint64) |
||||||
|
caEnd.Set(uint64(math.MaxInt64)) |
||||||
|
expectedEndIdx := indexes.TagKindPubkeyEnc( |
||||||
|
key, valueHash, k, p, caEnd, nil, |
||||||
|
) |
||||||
|
|
||||||
|
// Verify the generated index
|
||||||
|
verifyIndex(t, idxs, expectedStartIdx, expectedEndIdx) |
||||||
|
} |
||||||
@ -0,0 +1,77 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/filter" |
||||||
|
"encoders.orly/tag" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"lol.mleku.dev/errorf" |
||||||
|
) |
||||||
|
|
||||||
|
func (d *D) GetSerialById(id []byte) (ser *types.Uint40, err error) { |
||||||
|
var idxs []Range |
||||||
|
if idxs, err = GetIndexesFromFilter(&filter.F{Ids: tag.NewFromBytesSlice(id)}); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if len(idxs) == 0 { |
||||||
|
err = errorf.E("no indexes found for id %0x", id) |
||||||
|
} |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
it := txn.NewIterator(badger.DefaultIteratorOptions) |
||||||
|
var key []byte |
||||||
|
defer it.Close() |
||||||
|
it.Seek(idxs[0].Start) |
||||||
|
if it.ValidForPrefix(idxs[0].Start) { |
||||||
|
item := it.Item() |
||||||
|
key = item.Key() |
||||||
|
ser = new(types.Uint40) |
||||||
|
buf := bytes.NewBuffer(key[len(key)-5:]) |
||||||
|
if err = ser.UnmarshalRead(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} else { |
||||||
|
// just don't return what we don't have? others may be
|
||||||
|
// found tho.
|
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
//
|
||||||
|
// func (d *D) GetSerialBytesById(id []byte) (ser []byte, err error) {
|
||||||
|
// var idxs []Range
|
||||||
|
// if idxs, err = GetIndexesFromFilter(&filter.F{Ids: tag.New(id)}); chk.E(err) {
|
||||||
|
// return
|
||||||
|
// }
|
||||||
|
// if len(idxs) == 0 {
|
||||||
|
// err = errorf.E("no indexes found for id %0x", id)
|
||||||
|
// }
|
||||||
|
// if err = d.View(
|
||||||
|
// func(txn *badger.Txn) (err error) {
|
||||||
|
// it := txn.NewIterator(badger.DefaultIteratorOptions)
|
||||||
|
// var key []byte
|
||||||
|
// defer it.Close()
|
||||||
|
// it.Seek(idxs[0].Start)
|
||||||
|
// if it.ValidForPrefix(idxs[0].Start) {
|
||||||
|
// item := it.Item()
|
||||||
|
// key = item.Key()
|
||||||
|
// ser = key[len(key)-5:]
|
||||||
|
// } else {
|
||||||
|
// // just don't return what we don't have? others may be
|
||||||
|
// // found tho.
|
||||||
|
// }
|
||||||
|
// return
|
||||||
|
// },
|
||||||
|
// ); chk.E(err) {
|
||||||
|
// return
|
||||||
|
// }
|
||||||
|
// return
|
||||||
|
// }
|
||||||
@ -0,0 +1,101 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"os" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"encoders.orly/event" |
||||||
|
"encoders.orly/event/examples" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
func TestGetSerialById(t *testing.T) { |
||||||
|
// Create a temporary directory for the database
|
||||||
|
tempDir, err := os.MkdirTemp("", "test-db-*") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create temporary directory: %v", err) |
||||||
|
} |
||||||
|
defer os.RemoveAll(tempDir) // Clean up after the test
|
||||||
|
|
||||||
|
// Create a context and cancel function for the database
|
||||||
|
ctx, cancel := context.WithCancel(context.Background()) |
||||||
|
defer cancel() |
||||||
|
|
||||||
|
// Initialize the database
|
||||||
|
db, err := New(ctx, cancel, tempDir, "info") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create database: %v", err) |
||||||
|
} |
||||||
|
defer db.Close() |
||||||
|
|
||||||
|
// Create a scanner to read events from examples.Cache
|
||||||
|
scanner := bufio.NewScanner(bytes.NewBuffer(examples.Cache)) |
||||||
|
scanner.Buffer(make([]byte, 0, 1_000_000_000), 1_000_000_000) |
||||||
|
|
||||||
|
// Count the number of events processed
|
||||||
|
eventCount := 0 |
||||||
|
|
||||||
|
var events []*event.E |
||||||
|
|
||||||
|
// Process each event
|
||||||
|
for scanner.Scan() { |
||||||
|
chk.E(scanner.Err()) |
||||||
|
b := scanner.Bytes() |
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Unmarshal the event
|
||||||
|
if _, err = ev.Unmarshal(b); chk.E(err) { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
events = append(events, ev) |
||||||
|
|
||||||
|
// Save the event to the database
|
||||||
|
if _, _, err = db.SaveEvent(ctx, ev, false, nil); err != nil { |
||||||
|
t.Fatalf("Failed to save event #%d: %v", eventCount+1, err) |
||||||
|
} |
||||||
|
|
||||||
|
eventCount++ |
||||||
|
} |
||||||
|
|
||||||
|
// Check for scanner errors
|
||||||
|
if err = scanner.Err(); err != nil { |
||||||
|
t.Fatalf("Scanner error: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("Successfully saved %d events to the database", eventCount) |
||||||
|
|
||||||
|
// Test GetSerialById with a known event ID
|
||||||
|
testEvent := events[3] // Using the same event as in QueryForIds test
|
||||||
|
|
||||||
|
// Get the serial by ID
|
||||||
|
serial, err := db.GetSerialById(testEvent.ID) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get serial by ID: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the serial is not nil
|
||||||
|
if serial == nil { |
||||||
|
t.Fatal("Expected serial to be non-nil, but got nil") |
||||||
|
} |
||||||
|
|
||||||
|
// Test with a non-existent ID
|
||||||
|
nonExistentId := make([]byte, len(testEvent.ID)) |
||||||
|
// Ensure it's different from any real ID
|
||||||
|
for i := range nonExistentId { |
||||||
|
nonExistentId[i] = ^testEvent.ID[i] |
||||||
|
} |
||||||
|
|
||||||
|
serial, err = db.GetSerialById(nonExistentId) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Expected no error for non-existent ID, but got: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// For non-existent Ids, the function should return nil serial
|
||||||
|
if serial != nil { |
||||||
|
t.Fatalf("Expected nil serial for non-existent ID, but got: %v", serial) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,51 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"sort" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"github.com/dgraph-io/badger/v4" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
func (d *D) GetSerialsByRange(idx Range) ( |
||||||
|
sers types.Uint40s, err error, |
||||||
|
) { |
||||||
|
if err = d.View( |
||||||
|
func(txn *badger.Txn) (err error) { |
||||||
|
it := txn.NewIterator( |
||||||
|
badger.IteratorOptions{ |
||||||
|
Reverse: true, |
||||||
|
}, |
||||||
|
) |
||||||
|
defer it.Close() |
||||||
|
for it.Seek(idx.End); it.Valid(); it.Next() { |
||||||
|
item := it.Item() |
||||||
|
var key []byte |
||||||
|
key = item.Key() |
||||||
|
if bytes.Compare( |
||||||
|
key[:len(key)-5], idx.Start, |
||||||
|
) < 0 { |
||||||
|
// didn't find it within the timestamp range
|
||||||
|
return |
||||||
|
} |
||||||
|
ser := new(types.Uint40) |
||||||
|
buf := bytes.NewBuffer(key[len(key)-5:]) |
||||||
|
if err = ser.UnmarshalRead(buf); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
sers = append(sers, ser) |
||||||
|
} |
||||||
|
return |
||||||
|
}, |
||||||
|
); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
sort.Slice( |
||||||
|
sers, func(i, j int) bool { |
||||||
|
return sers[i].Get() < sers[j].Get() |
||||||
|
}, |
||||||
|
) |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,232 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"bytes" |
||||||
|
"context" |
||||||
|
"os" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"encoders.orly/event" |
||||||
|
"encoders.orly/event/examples" |
||||||
|
"encoders.orly/filter" |
||||||
|
"encoders.orly/kind" |
||||||
|
"encoders.orly/tag" |
||||||
|
"encoders.orly/timestamp" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
) |
||||||
|
|
||||||
|
func TestGetSerialsByRange(t *testing.T) { |
||||||
|
// Create a temporary directory for the database
|
||||||
|
tempDir, err := os.MkdirTemp("", "test-db-*") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create temporary directory: %v", err) |
||||||
|
} |
||||||
|
defer os.RemoveAll(tempDir) // Clean up after the test
|
||||||
|
|
||||||
|
// Create a context and cancel function for the database
|
||||||
|
ctx, cancel := context.WithCancel(context.Background()) |
||||||
|
defer cancel() |
||||||
|
|
||||||
|
// Initialize the database
|
||||||
|
db, err := New(ctx, cancel, tempDir, "info") |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to create database: %v", err) |
||||||
|
} |
||||||
|
defer db.Close() |
||||||
|
|
||||||
|
// Create a scanner to read events from examples.Cache
|
||||||
|
scanner := bufio.NewScanner(bytes.NewBuffer(examples.Cache)) |
||||||
|
scanner.Buffer(make([]byte, 0, 1_000_000_000), 1_000_000_000) |
||||||
|
|
||||||
|
// Count the number of events processed
|
||||||
|
eventCount := 0 |
||||||
|
|
||||||
|
var events []*event.E |
||||||
|
var eventSerials = make(map[string]*types.Uint40) // Map event ID (hex) to serial
|
||||||
|
|
||||||
|
// Process each event
|
||||||
|
for scanner.Scan() { |
||||||
|
chk.E(scanner.Err()) |
||||||
|
b := scanner.Bytes() |
||||||
|
ev := event.New() |
||||||
|
|
||||||
|
// Unmarshal the event
|
||||||
|
if _, err = ev.Unmarshal(b); chk.E(err) { |
||||||
|
t.Fatal(err) |
||||||
|
} |
||||||
|
|
||||||
|
events = append(events, ev) |
||||||
|
|
||||||
|
// Save the event to the database
|
||||||
|
if _, _, err = db.SaveEvent(ctx, ev, false, nil); err != nil { |
||||||
|
t.Fatalf("Failed to save event #%d: %v", eventCount+1, err) |
||||||
|
} |
||||||
|
|
||||||
|
// Get the serial for this event
|
||||||
|
serial, err := db.GetSerialById(ev.ID) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf( |
||||||
|
"Failed to get serial for event #%d: %v", eventCount+1, err, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
if serial != nil { |
||||||
|
eventSerials[string(ev.ID)] = serial |
||||||
|
} |
||||||
|
|
||||||
|
eventCount++ |
||||||
|
} |
||||||
|
|
||||||
|
// Check for scanner errors
|
||||||
|
if err = scanner.Err(); err != nil { |
||||||
|
t.Fatalf("Scanner error: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
t.Logf("Successfully saved %d events to the database", eventCount) |
||||||
|
|
||||||
|
// Test GetSerialsByRange with a time range filter
|
||||||
|
// Use the timestamp from the middle event as a reference
|
||||||
|
middleIndex := len(events) / 2 |
||||||
|
middleEvent := events[middleIndex] |
||||||
|
|
||||||
|
// Create a timestamp range that includes events before and after the middle event
|
||||||
|
sinceTime := new(timestamp.T) |
||||||
|
sinceTime.V = middleEvent.CreatedAt - 3600 // 1 hour before middle event
|
||||||
|
|
||||||
|
untilTime := new(timestamp.T) |
||||||
|
untilTime.V = middleEvent.CreatedAt + 3600 // 1 hour after middle event
|
||||||
|
|
||||||
|
// Create a filter with the time range
|
||||||
|
timeFilter := &filter.F{ |
||||||
|
Since: sinceTime, |
||||||
|
Until: untilTime, |
||||||
|
} |
||||||
|
|
||||||
|
// Get the indexes from the filter
|
||||||
|
ranges, err := GetIndexesFromFilter(timeFilter) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get indexes from filter: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got at least one range
|
||||||
|
if len(ranges) == 0 { |
||||||
|
t.Fatal("Expected at least one range from filter, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Test GetSerialsByRange with the first range
|
||||||
|
serials, err := db.GetSerialsByRange(ranges[0]) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get serials by range: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got results
|
||||||
|
if len(serials) == 0 { |
||||||
|
t.Fatal("Expected serials for events in time range, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the serials correspond to events within the time range
|
||||||
|
for i, serial := range serials { |
||||||
|
// Fetch the event using the serial
|
||||||
|
ev, err := db.FetchEventBySerial(serial) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to fetch event for serial %d: %v", i, err) |
||||||
|
} |
||||||
|
|
||||||
|
if ev.CreatedAt < sinceTime.V || ev.CreatedAt > untilTime.V { |
||||||
|
t.Fatalf( |
||||||
|
"Event %d is outside the time range. Got %d, expected between %d and %d", |
||||||
|
i, ev.CreatedAt, sinceTime.V, untilTime.V, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test GetSerialsByRange with a kind filter
|
||||||
|
testKind := kind.New(1) // Kind 1 is typically text notes
|
||||||
|
kindFilter := &filter.F{ |
||||||
|
Kinds: kind.NewS(testKind), |
||||||
|
} |
||||||
|
|
||||||
|
// Get the indexes from the filter
|
||||||
|
ranges, err = GetIndexesFromFilter(kindFilter) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get indexes from filter: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got at least one range
|
||||||
|
if len(ranges) == 0 { |
||||||
|
t.Fatal("Expected at least one range from filter, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Test GetSerialsByRange with the first range
|
||||||
|
serials, err = db.GetSerialsByRange(ranges[0]) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get serials by range: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got results
|
||||||
|
if len(serials) == 0 { |
||||||
|
t.Fatal("Expected serials for events with kind 1, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the serials correspond to events with the correct kind
|
||||||
|
for i, serial := range serials { |
||||||
|
// Fetch the event using the serial
|
||||||
|
ev, err := db.FetchEventBySerial(serial) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to fetch event for serial %d: %v", i, err) |
||||||
|
} |
||||||
|
|
||||||
|
if ev.Kind != testKind.K { |
||||||
|
t.Fatalf( |
||||||
|
"Event %d has incorrect kind. Got %d, expected %d", |
||||||
|
i, ev.Kind, testKind.K, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test GetSerialsByRange with an author filter
|
||||||
|
authorFilter := &filter.F{ |
||||||
|
Authors: tag.NewFromBytesSlice(events[1].Pubkey), |
||||||
|
} |
||||||
|
|
||||||
|
// Get the indexes from the filter
|
||||||
|
ranges, err = GetIndexesFromFilter(authorFilter) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get indexes from filter: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got at least one range
|
||||||
|
if len(ranges) == 0 { |
||||||
|
t.Fatal("Expected at least one range from filter, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Test GetSerialsByRange with the first range
|
||||||
|
serials, err = db.GetSerialsByRange(ranges[0]) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to get serials by range: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify we got results
|
||||||
|
if len(serials) == 0 { |
||||||
|
t.Fatal("Expected serials for events from author, but got none") |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the serials correspond to events with the correct author
|
||||||
|
for i, serial := range serials { |
||||||
|
// Fetch the event using the serial
|
||||||
|
ev, err := db.FetchEventBySerial(serial) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to fetch event for serial %d: %v", i, err) |
||||||
|
} |
||||||
|
|
||||||
|
if !utils.FastEqual(ev.Pubkey, events[1].Pubkey) { |
||||||
|
t.Fatalf( |
||||||
|
"Event %d has incorrect author. Got %x, expected %x", |
||||||
|
i, ev.Pubkey, events[1].Pubkey, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,51 @@ |
|||||||
|
module database.orly |
||||||
|
|
||||||
|
go 1.25.0 |
||||||
|
|
||||||
|
replace ( |
||||||
|
crypto.orly => ../crypto |
||||||
|
encoders.orly => ../encoders |
||||||
|
interfaces.orly => ../interfaces |
||||||
|
next.orly.dev => ../../ |
||||||
|
protocol.orly => ../protocol |
||||||
|
utils.orly => ../utils |
||||||
|
) |
||||||
|
|
||||||
|
require ( |
||||||
|
crypto.orly v0.0.0-00010101000000-000000000000 |
||||||
|
encoders.orly v0.0.0-00010101000000-000000000000 |
||||||
|
github.com/dgraph-io/badger/v4 v4.8.0 |
||||||
|
go.uber.org/atomic v1.11.0 |
||||||
|
interfaces.orly v0.0.0-00010101000000-000000000000 |
||||||
|
lol.mleku.dev v1.0.2 |
||||||
|
lukechampine.com/frand v1.5.1 |
||||||
|
utils.orly v0.0.0-00010101000000-000000000000 |
||||||
|
) |
||||||
|
|
||||||
|
require ( |
||||||
|
github.com/adrg/xdg v0.5.3 // indirect |
||||||
|
github.com/cespare/xxhash/v2 v2.3.0 // indirect |
||||||
|
github.com/davecgh/go-spew v1.1.1 // indirect |
||||||
|
github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect |
||||||
|
github.com/dustin/go-humanize v1.0.1 // indirect |
||||||
|
github.com/fatih/color v1.18.0 // indirect |
||||||
|
github.com/go-logr/logr v1.4.3 // indirect |
||||||
|
github.com/go-logr/stdr v1.2.2 // indirect |
||||||
|
github.com/google/flatbuffers v25.2.10+incompatible // indirect |
||||||
|
github.com/klauspost/compress v1.18.0 // indirect |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0 // indirect |
||||||
|
github.com/mattn/go-colorable v0.1.14 // indirect |
||||||
|
github.com/mattn/go-isatty v0.0.20 // indirect |
||||||
|
github.com/templexxx/cpu v0.0.1 // indirect |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b // indirect |
||||||
|
go-simpler.org/env v0.12.0 // indirect |
||||||
|
go.opentelemetry.io/auto/sdk v1.1.0 // indirect |
||||||
|
go.opentelemetry.io/otel v1.37.0 // indirect |
||||||
|
go.opentelemetry.io/otel/metric v1.37.0 // indirect |
||||||
|
go.opentelemetry.io/otel/trace v1.37.0 // indirect |
||||||
|
golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b // indirect |
||||||
|
golang.org/x/net v0.41.0 // indirect |
||||||
|
golang.org/x/sys v0.35.0 // indirect |
||||||
|
google.golang.org/protobuf v1.36.6 // indirect |
||||||
|
next.orly.dev v0.0.0-00010101000000-000000000000 // indirect |
||||||
|
) |
||||||
@ -0,0 +1,68 @@ |
|||||||
|
github.com/adrg/xdg v0.5.3 h1:xRnxJXne7+oWDatRhR1JLnvuccuIeCoBu2rtuLqQB78= |
||||||
|
github.com/adrg/xdg v0.5.3/go.mod h1:nlTsY+NNiCBGCK2tpm09vRqfVzrc2fLmXGpBLF0zlTQ= |
||||||
|
github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= |
||||||
|
github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= |
||||||
|
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= |
||||||
|
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= |
||||||
|
github.com/dgraph-io/badger/v4 v4.8.0 h1:JYph1ChBijCw8SLeybvPINizbDKWZ5n/GYbz2yhN/bs= |
||||||
|
github.com/dgraph-io/badger/v4 v4.8.0/go.mod h1:U6on6e8k/RTbUWxqKR0MvugJuVmkxSNc79ap4917h4w= |
||||||
|
github.com/dgraph-io/ristretto/v2 v2.2.0 h1:bkY3XzJcXoMuELV8F+vS8kzNgicwQFAaGINAEJdWGOM= |
||||||
|
github.com/dgraph-io/ristretto/v2 v2.2.0/go.mod h1:RZrm63UmcBAaYWC1DotLYBmTvgkrs0+XhBd7Npn7/zI= |
||||||
|
github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= |
||||||
|
github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= |
||||||
|
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= |
||||||
|
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= |
||||||
|
github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= |
||||||
|
github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= |
||||||
|
github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= |
||||||
|
github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= |
||||||
|
github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= |
||||||
|
github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= |
||||||
|
github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= |
||||||
|
github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q= |
||||||
|
github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= |
||||||
|
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= |
||||||
|
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= |
||||||
|
github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= |
||||||
|
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= |
||||||
|
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= |
||||||
|
github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= |
||||||
|
github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= |
||||||
|
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= |
||||||
|
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= |
||||||
|
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= |
||||||
|
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= |
||||||
|
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= |
||||||
|
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= |
||||||
|
github.com/templexxx/cpu v0.0.1 h1:hY4WdLOgKdc8y13EYklu9OUTXik80BkxHoWvTO6MQQY= |
||||||
|
github.com/templexxx/cpu v0.0.1/go.mod h1:w7Tb+7qgcAlIyX4NhLuDKt78AHA5SzPmq0Wj6HiEnnk= |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b h1:XeDLE6c9mzHpdv3Wb1+pWBaWv/BlHK0ZYIu/KaL6eHg= |
||||||
|
github.com/templexxx/xhex v0.0.0-20200614015412-aed53437177b/go.mod h1:7rwmCH0wC2fQvNEvPZ3sKXukhyCTyiaZ5VTZMQYpZKQ= |
||||||
|
go-simpler.org/env v0.12.0 h1:kt/lBts0J1kjWJAnB740goNdvwNxt5emhYngL0Fzufs= |
||||||
|
go-simpler.org/env v0.12.0/go.mod h1:cc/5Md9JCUM7LVLtN0HYjPTDcI3Q8TDaPlNTAlDU+WI= |
||||||
|
go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA= |
||||||
|
go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A= |
||||||
|
go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ= |
||||||
|
go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I= |
||||||
|
go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE= |
||||||
|
go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E= |
||||||
|
go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4= |
||||||
|
go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0= |
||||||
|
go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= |
||||||
|
go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= |
||||||
|
golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b h1:DXr+pvt3nC887026GRP39Ej11UATqWDmWuS99x26cD0= |
||||||
|
golang.org/x/exp v0.0.0-20250819193227-8b4c13bb791b/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4= |
||||||
|
golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw= |
||||||
|
golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA= |
||||||
|
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= |
||||||
|
golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= |
||||||
|
golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= |
||||||
|
google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= |
||||||
|
google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= |
||||||
|
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= |
||||||
|
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= |
||||||
|
lol.mleku.dev v1.0.2 h1:bSV1hHnkmt1hq+9nSvRwN6wgcI7itbM3XRZ4dMB438c= |
||||||
|
lol.mleku.dev v1.0.2/go.mod h1:DQ0WnmkntA9dPLCXgvtIgYt5G0HSqx3wSTLolHgWeLA= |
||||||
|
lukechampine.com/frand v1.5.1 h1:fg0eRtdmGFIxhP5zQJzM1lFDbD6CUfu/f+7WgAZd5/w= |
||||||
|
lukechampine.com/frand v1.5.1/go.mod h1:4VstaWc2plN4Mjr10chUD46RAVGWhpkZ5Nja8+Azp0Q= |
||||||
@ -0,0 +1,83 @@ |
|||||||
|
package database |
||||||
|
|
||||||
|
import ( |
||||||
|
"bufio" |
||||||
|
"io" |
||||||
|
"os" |
||||||
|
"runtime/debug" |
||||||
|
|
||||||
|
"encoders.orly/event" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"lol.mleku.dev/log" |
||||||
|
) |
||||||
|
|
||||||
|
const maxLen = 500000000 |
||||||
|
|
||||||
|
// Import a collection of events in line structured minified JSON format (JSONL).
|
||||||
|
func (d *D) Import(rr io.Reader) { |
||||||
|
// store to disk so we can return fast
|
||||||
|
tmpPath := os.TempDir() + string(os.PathSeparator) + "orly" |
||||||
|
os.MkdirAll(tmpPath, 0700) |
||||||
|
tmp, err := os.CreateTemp(tmpPath, "") |
||||||
|
if chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
log.I.F("buffering upload to %s", tmp.Name()) |
||||||
|
if _, err = io.Copy(tmp, rr); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
if _, err = tmp.Seek(0, 0); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
go func() { |
||||||
|
var err error |
||||||
|
// Create a scanner to read the buffer line by line
|
||||||
|
scan := bufio.NewScanner(tmp) |
||||||
|
scanBuf := make([]byte, maxLen) |
||||||
|
scan.Buffer(scanBuf, maxLen) |
||||||
|
|
||||||
|
var count, total int |
||||||
|
for scan.Scan() { |
||||||
|
select { |
||||||
|
case <-d.ctx.Done(): |
||||||
|
log.I.F("context closed") |
||||||
|
return |
||||||
|
default: |
||||||
|
} |
||||||
|
|
||||||
|
b := scan.Bytes() |
||||||
|
total += len(b) + 1 |
||||||
|
if len(b) < 1 { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
ev := &event.E{} |
||||||
|
if _, err = ev.Unmarshal(b); err != nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
if _, _, err = d.SaveEvent(d.ctx, ev, false, nil); err != nil { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
b = nil |
||||||
|
ev = nil |
||||||
|
count++ |
||||||
|
if count%100 == 0 { |
||||||
|
log.I.F("received %d events", count) |
||||||
|
debug.FreeOSMemory() |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
log.I.F("read %d bytes and saved %d events", total, count) |
||||||
|
err = scan.Err() |
||||||
|
if chk.E(err) { |
||||||
|
} |
||||||
|
|
||||||
|
// Help garbage collection
|
||||||
|
tmp = nil |
||||||
|
}() |
||||||
|
|
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,439 @@ |
|||||||
|
package indexes |
||||||
|
|
||||||
|
import ( |
||||||
|
"io" |
||||||
|
"reflect" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"interfaces.orly/codec" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
) |
||||||
|
|
||||||
|
var counter int |
||||||
|
|
||||||
|
func init() { |
||||||
|
// Initialize the counter to ensure it starts from 0
|
||||||
|
counter = 0 |
||||||
|
} |
||||||
|
|
||||||
|
func next() int { counter++; return counter - 1 } |
||||||
|
|
||||||
|
type P struct { |
||||||
|
val []byte |
||||||
|
} |
||||||
|
|
||||||
|
func NewPrefix(prf ...int) (p *P) { |
||||||
|
if len(prf) > 0 { |
||||||
|
prefix := Prefix(prf[0]) |
||||||
|
if prefix == "" { |
||||||
|
panic("unknown prefix") |
||||||
|
} |
||||||
|
return &P{[]byte(prefix)} |
||||||
|
} else { |
||||||
|
return &P{[]byte{0, 0, 0}} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func (p *P) Bytes() (b []byte) { return p.val } |
||||||
|
|
||||||
|
func (p *P) MarshalWrite(w io.Writer) (err error) { |
||||||
|
_, err = w.Write(p.val) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (p *P) UnmarshalRead(r io.Reader) (err error) { |
||||||
|
// Allocate a buffer for val if it's nil or empty
|
||||||
|
if p.val == nil || len(p.val) == 0 { |
||||||
|
p.val = make([]byte, 3) // Prefixes are 3 bytes
|
||||||
|
} |
||||||
|
_, err = r.Read(p.val) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
type I string |
||||||
|
|
||||||
|
func (i I) Write(w io.Writer) (n int, err error) { return w.Write([]byte(i)) } |
||||||
|
|
||||||
|
const ( |
||||||
|
EventPrefix = I("evt") |
||||||
|
IdPrefix = I("eid") |
||||||
|
FullIdPubkeyPrefix = I("fpc") // full id, pubkey, created at
|
||||||
|
|
||||||
|
CreatedAtPrefix = I("c--") // created at
|
||||||
|
KindPrefix = I("kc-") // kind, created at
|
||||||
|
PubkeyPrefix = I("pc-") // pubkey, created at
|
||||||
|
KindPubkeyPrefix = I("kpc") // kind, pubkey, created at
|
||||||
|
|
||||||
|
TagPrefix = I("tc-") // tag, created at
|
||||||
|
TagKindPrefix = I("tkc") // tag, kind, created at
|
||||||
|
TagPubkeyPrefix = I("tpc") // tag, pubkey, created at
|
||||||
|
TagKindPubkeyPrefix = I("tkp") // tag, kind, pubkey, created at
|
||||||
|
|
||||||
|
ExpirationPrefix = I("exp") // timestamp of expiration
|
||||||
|
VersionPrefix = I("ver") // database version number, for triggering reindexes when new keys are added (policy is add-only).
|
||||||
|
) |
||||||
|
|
||||||
|
// Prefix returns the three byte human-readable prefixes that go in front of
|
||||||
|
// database indexes.
|
||||||
|
func Prefix(prf int) (i I) { |
||||||
|
switch prf { |
||||||
|
case Event: |
||||||
|
return EventPrefix |
||||||
|
case Id: |
||||||
|
return IdPrefix |
||||||
|
case FullIdPubkey: |
||||||
|
return FullIdPubkeyPrefix |
||||||
|
|
||||||
|
case CreatedAt: |
||||||
|
return CreatedAtPrefix |
||||||
|
case Kind: |
||||||
|
return KindPrefix |
||||||
|
case Pubkey: |
||||||
|
return PubkeyPrefix |
||||||
|
case KindPubkey: |
||||||
|
return KindPubkeyPrefix |
||||||
|
|
||||||
|
case Tag: |
||||||
|
return TagPrefix |
||||||
|
case TagKind: |
||||||
|
return TagKindPrefix |
||||||
|
case TagPubkey: |
||||||
|
return TagPubkeyPrefix |
||||||
|
case TagKindPubkey: |
||||||
|
return TagKindPubkeyPrefix |
||||||
|
|
||||||
|
case Expiration: |
||||||
|
return ExpirationPrefix |
||||||
|
case Version: |
||||||
|
return VersionPrefix |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func Identify(r io.Reader) (i int, err error) { |
||||||
|
// this is here for completeness; however, searches don't need to identify
|
||||||
|
// this as they work via generated prefixes made using Prefix.
|
||||||
|
var b [3]byte |
||||||
|
_, err = r.Read(b[:]) |
||||||
|
if err != nil { |
||||||
|
i = -1 |
||||||
|
return |
||||||
|
} |
||||||
|
switch I(b[:]) { |
||||||
|
case EventPrefix: |
||||||
|
i = Event |
||||||
|
case IdPrefix: |
||||||
|
i = Id |
||||||
|
case FullIdPubkeyPrefix: |
||||||
|
i = FullIdPubkey |
||||||
|
|
||||||
|
case CreatedAtPrefix: |
||||||
|
i = CreatedAt |
||||||
|
case KindPrefix: |
||||||
|
i = Kind |
||||||
|
case PubkeyPrefix: |
||||||
|
i = Pubkey |
||||||
|
case KindPubkeyPrefix: |
||||||
|
i = KindPubkey |
||||||
|
|
||||||
|
case TagPrefix: |
||||||
|
i = Tag |
||||||
|
case TagKindPrefix: |
||||||
|
i = TagKind |
||||||
|
case TagPubkeyPrefix: |
||||||
|
i = TagPubkey |
||||||
|
case TagKindPubkeyPrefix: |
||||||
|
i = TagKindPubkey |
||||||
|
|
||||||
|
case ExpirationPrefix: |
||||||
|
i = Expiration |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
type Encs []codec.I |
||||||
|
|
||||||
|
// T is a wrapper around an array of codec.I. The caller provides the Encs so
|
||||||
|
// they can then call the accessor methods of the codec.I implementation.
|
||||||
|
type T struct{ Encs } |
||||||
|
|
||||||
|
// New creates a new indexes.T. The helper functions below have an encode and
|
||||||
|
// decode variant, the decode variant doesn't add the prefix encoder because it
|
||||||
|
// has been read by Identify or just is being read, and found because it was
|
||||||
|
// written for the prefix in the iteration.
|
||||||
|
func New(encoders ...codec.I) (i *T) { return &T{encoders} } |
||||||
|
func (t *T) MarshalWrite(w io.Writer) (err error) { |
||||||
|
for _, e := range t.Encs { |
||||||
|
if e == nil || reflect.ValueOf(e).IsNil() { |
||||||
|
// Skip nil encoders instead of returning early. This enables
|
||||||
|
// generating search prefixes.
|
||||||
|
continue |
||||||
|
} |
||||||
|
if err = e.MarshalWrite(w); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
func (t *T) UnmarshalRead(r io.Reader) (err error) { |
||||||
|
for _, e := range t.Encs { |
||||||
|
if err = e.UnmarshalRead(r); chk.E(err) { |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
// Event is the whole event stored in binary format
|
||||||
|
//
|
||||||
|
// prefix|5 serial - event in binary format
|
||||||
|
var Event = next() |
||||||
|
|
||||||
|
func EventVars() (ser *types.Uint40) { return new(types.Uint40) } |
||||||
|
func EventEnc(ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(Event), ser) |
||||||
|
} |
||||||
|
func EventDec(ser *types.Uint40) (enc *T) { return New(NewPrefix(), ser) } |
||||||
|
|
||||||
|
// Id contains a truncated 8-byte hash of an event index. This is the secondary
|
||||||
|
// key of an event, the primary key is the serial found in the Event.
|
||||||
|
//
|
||||||
|
// 3 prefix|8 ID hash|5 serial
|
||||||
|
var Id = next() |
||||||
|
|
||||||
|
func IdVars() (id *types.IdHash, ser *types.Uint40) { |
||||||
|
return new(types.IdHash), new(types.Uint40) |
||||||
|
} |
||||||
|
func IdEnc(id *types.IdHash, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(Id), id, ser) |
||||||
|
} |
||||||
|
func IdDec(id *types.IdHash, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(), id, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// FullIdPubkey is an index designed to enable sorting and filtering of
|
||||||
|
// results found via other indexes, without having to decode the event.
|
||||||
|
//
|
||||||
|
// 3 prefix|5 serial|32 ID|8 pubkey hash|8 timestamp
|
||||||
|
var FullIdPubkey = next() |
||||||
|
|
||||||
|
func FullIdPubkeyVars() ( |
||||||
|
ser *types.Uint40, fid *types.Id, p *types.PubHash, ca *types.Uint64, |
||||||
|
) { |
||||||
|
return new(types.Uint40), new(types.Id), new(types.PubHash), new(types.Uint64) |
||||||
|
} |
||||||
|
func FullIdPubkeyEnc( |
||||||
|
ser *types.Uint40, fid *types.Id, p *types.PubHash, ca *types.Uint64, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(FullIdPubkey), ser, fid, p, ca) |
||||||
|
} |
||||||
|
func FullIdPubkeyDec( |
||||||
|
ser *types.Uint40, fid *types.Id, p *types.PubHash, ca *types.Uint64, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), ser, fid, p, ca) |
||||||
|
} |
||||||
|
|
||||||
|
// CreatedAt is an index that allows search for the timestamp on the event.
|
||||||
|
//
|
||||||
|
// 3 prefix|8 timestamp|5 serial
|
||||||
|
var CreatedAt = next() |
||||||
|
|
||||||
|
func CreatedAtVars() (ca *types.Uint64, ser *types.Uint40) { |
||||||
|
return new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func CreatedAtEnc(ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(CreatedAt), ca, ser) |
||||||
|
} |
||||||
|
func CreatedAtDec(ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(), ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// Kind
|
||||||
|
//
|
||||||
|
// 3 prefix|2 kind|8 timestamp|5 serial
|
||||||
|
var Kind = next() |
||||||
|
|
||||||
|
func KindVars() (ki *types.Uint16, ca *types.Uint64, ser *types.Uint40) { |
||||||
|
return new(types.Uint16), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func KindEnc(ki *types.Uint16, ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(Kind), ki, ca, ser) |
||||||
|
} |
||||||
|
func KindDec(ki *types.Uint16, ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(), ki, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// Pubkey is a composite index that allows search by pubkey
|
||||||
|
// filtered by timestamp.
|
||||||
|
//
|
||||||
|
// 3 prefix|8 pubkey hash|8 timestamp|5 serial
|
||||||
|
var Pubkey = next() |
||||||
|
|
||||||
|
func PubkeyVars() (p *types.PubHash, ca *types.Uint64, ser *types.Uint40) { |
||||||
|
return new(types.PubHash), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func PubkeyEnc(p *types.PubHash, ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(Pubkey), p, ca, ser) |
||||||
|
} |
||||||
|
func PubkeyDec(p *types.PubHash, ca *types.Uint64, ser *types.Uint40) (enc *T) { |
||||||
|
return New(NewPrefix(), p, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// KindPubkey
|
||||||
|
//
|
||||||
|
// 3 prefix|2 kind|8 pubkey hash|8 timestamp|5 serial
|
||||||
|
var KindPubkey = next() |
||||||
|
|
||||||
|
func KindPubkeyVars() ( |
||||||
|
ki *types.Uint16, p *types.PubHash, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Uint16), new(types.PubHash), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func KindPubkeyEnc( |
||||||
|
ki *types.Uint16, p *types.PubHash, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(KindPubkey), ki, p, ca, ser) |
||||||
|
} |
||||||
|
func KindPubkeyDec( |
||||||
|
ki *types.Uint16, p *types.PubHash, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), ki, p, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// Tag allows searching for a tag and filter by timestamp.
|
||||||
|
//
|
||||||
|
// 3 prefix|1 key letter|8 value hash|8 timestamp|5 serial
|
||||||
|
var Tag = next() |
||||||
|
|
||||||
|
func TagVars() ( |
||||||
|
k *types.Letter, v *types.Ident, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Letter), new(types.Ident), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func TagEnc( |
||||||
|
k *types.Letter, v *types.Ident, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(Tag), k, v, ca, ser) |
||||||
|
} |
||||||
|
func TagDec( |
||||||
|
k *types.Letter, v *types.Ident, ca *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), k, v, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// TagKind
|
||||||
|
//
|
||||||
|
// 3 prefix|1 key letter|8 value hash|2 kind|8 timestamp|5 serial
|
||||||
|
var TagKind = next() |
||||||
|
|
||||||
|
func TagKindVars() ( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Letter), new(types.Ident), new(types.Uint16), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func TagKindEnc( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(TagKind), ki, k, v, ca, ser) |
||||||
|
} |
||||||
|
func TagKindDec( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), ki, k, v, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// TagPubkey allows searching for a pubkey, tag and timestamp.
|
||||||
|
//
|
||||||
|
// 3 prefix|1 key letter|8 value hash|8 pubkey hash|8 timestamp|5 serial
|
||||||
|
var TagPubkey = next() |
||||||
|
|
||||||
|
func TagPubkeyVars() ( |
||||||
|
k *types.Letter, v *types.Ident, p *types.PubHash, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Letter), new(types.Ident), new(types.PubHash), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func TagPubkeyEnc( |
||||||
|
k *types.Letter, v *types.Ident, p *types.PubHash, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(TagPubkey), p, k, v, ca, ser) |
||||||
|
} |
||||||
|
func TagPubkeyDec( |
||||||
|
k *types.Letter, v *types.Ident, p *types.PubHash, ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), p, k, v, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// TagKindPubkey
|
||||||
|
//
|
||||||
|
// 3 prefix|1 key letter|8 value hash|2 kind|8 pubkey hash|8 bytes timestamp|5 serial
|
||||||
|
var TagKindPubkey = next() |
||||||
|
|
||||||
|
func TagKindPubkeyVars() ( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, p *types.PubHash, |
||||||
|
ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Letter), new(types.Ident), new(types.Uint16), new(types.PubHash), new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func TagKindPubkeyEnc( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, p *types.PubHash, |
||||||
|
ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(TagKindPubkey), ki, p, k, v, ca, ser) |
||||||
|
} |
||||||
|
func TagKindPubkeyDec( |
||||||
|
k *types.Letter, v *types.Ident, ki *types.Uint16, p *types.PubHash, |
||||||
|
ca *types.Uint64, |
||||||
|
ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), ki, p, k, v, ca, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// Expiration
|
||||||
|
//
|
||||||
|
// 3 prefix|8 timestamp|5 serial
|
||||||
|
var Expiration = next() |
||||||
|
|
||||||
|
func ExpirationVars() ( |
||||||
|
exp *types.Uint64, ser *types.Uint40, |
||||||
|
) { |
||||||
|
return new(types.Uint64), new(types.Uint40) |
||||||
|
} |
||||||
|
func ExpirationEnc( |
||||||
|
exp *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(Expiration), exp, ser) |
||||||
|
} |
||||||
|
func ExpirationDec( |
||||||
|
exp *types.Uint64, ser *types.Uint40, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), exp, ser) |
||||||
|
} |
||||||
|
|
||||||
|
// Version
|
||||||
|
//
|
||||||
|
// 3 prefix|4 version
|
||||||
|
var Version = next() |
||||||
|
|
||||||
|
func VersionVars() ( |
||||||
|
ver *types.Uint32, |
||||||
|
) { |
||||||
|
return new(types.Uint32) |
||||||
|
} |
||||||
|
func VersionEnc( |
||||||
|
ver *types.Uint32, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(Version), ver) |
||||||
|
} |
||||||
|
func VersionDec( |
||||||
|
ver *types.Uint32, |
||||||
|
) (enc *T) { |
||||||
|
return New(NewPrefix(), ver) |
||||||
|
} |
||||||
@ -0,0 +1,981 @@ |
|||||||
|
package indexes |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"io" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"database.orly/indexes/types" |
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
) |
||||||
|
|
||||||
|
// TestNewPrefix tests the NewPrefix function with and without arguments
|
||||||
|
func TestNewPrefix(t *testing.T) { |
||||||
|
// Test with no arguments (default prefix)
|
||||||
|
defaultPrefix := NewPrefix() |
||||||
|
if len(defaultPrefix.Bytes()) != 3 { |
||||||
|
t.Errorf( |
||||||
|
"Default prefix should be 3 bytes, got %d", |
||||||
|
len(defaultPrefix.Bytes()), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with a valid prefix index
|
||||||
|
validPrefix := NewPrefix(Event) |
||||||
|
if string(validPrefix.Bytes()) != string(EventPrefix) { |
||||||
|
t.Errorf("Expected prefix %q, got %q", EventPrefix, validPrefix.Bytes()) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with an invalid prefix index (should panic)
|
||||||
|
defer func() { |
||||||
|
if r := recover(); r == nil { |
||||||
|
t.Errorf("NewPrefix should panic with invalid prefix index") |
||||||
|
} |
||||||
|
}() |
||||||
|
_ = NewPrefix(-1) // This should panic
|
||||||
|
} |
||||||
|
|
||||||
|
// TestPrefixMethods tests the methods of the P struct
|
||||||
|
func TestPrefixMethods(t *testing.T) { |
||||||
|
// Create a prefix
|
||||||
|
prefix := NewPrefix(Event) |
||||||
|
|
||||||
|
// Test Bytes method
|
||||||
|
if !utils.FastEqual(prefix.Bytes(), []byte(EventPrefix)) { |
||||||
|
t.Errorf( |
||||||
|
"Bytes method returned %v, expected %v", prefix.Bytes(), |
||||||
|
[]byte(EventPrefix), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test MarshalWrite method
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := prefix.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
if !utils.FastEqual(buf.Bytes(), []byte(EventPrefix)) { |
||||||
|
t.Errorf( |
||||||
|
"MarshalWrite wrote %v, expected %v", buf.Bytes(), |
||||||
|
[]byte(EventPrefix), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test UnmarshalRead method
|
||||||
|
newPrefix := &P{} |
||||||
|
err = newPrefix.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newPrefix.Bytes(), []byte(EventPrefix)) { |
||||||
|
t.Errorf( |
||||||
|
"UnmarshalRead read %v, expected %v", newPrefix.Bytes(), |
||||||
|
[]byte(EventPrefix), |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestPrefixFunction tests the Prefix function
|
||||||
|
func TestPrefixFunction(t *testing.T) { |
||||||
|
testCases := []struct { |
||||||
|
name string |
||||||
|
index int |
||||||
|
expected I |
||||||
|
}{ |
||||||
|
{"Event", Event, EventPrefix}, |
||||||
|
{"ID", Id, IdPrefix}, |
||||||
|
{"FullIdPubkey", FullIdPubkey, FullIdPubkeyPrefix}, |
||||||
|
{"Pubkey", Pubkey, PubkeyPrefix}, |
||||||
|
{"CreatedAt", CreatedAt, CreatedAtPrefix}, |
||||||
|
{"TagPubkey", TagPubkey, TagPubkeyPrefix}, |
||||||
|
{"Tag", Tag, TagPrefix}, |
||||||
|
{"Kind", Kind, KindPrefix}, |
||||||
|
{"KindPubkey", KindPubkey, KindPubkeyPrefix}, |
||||||
|
{"TagKind", TagKind, TagKindPrefix}, |
||||||
|
{ |
||||||
|
"TagKindPubkey", TagKindPubkey, |
||||||
|
TagKindPubkeyPrefix, |
||||||
|
}, |
||||||
|
{"Invalid", -1, ""}, |
||||||
|
} |
||||||
|
|
||||||
|
for _, tc := range testCases { |
||||||
|
t.Run( |
||||||
|
tc.name, func(t *testing.T) { |
||||||
|
result := Prefix(tc.index) |
||||||
|
if result != tc.expected { |
||||||
|
t.Errorf( |
||||||
|
"Prefix(%d) = %q, expected %q", tc.index, result, |
||||||
|
tc.expected, |
||||||
|
) |
||||||
|
} |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestIdentify tests the Identify function
|
||||||
|
func TestIdentify(t *testing.T) { |
||||||
|
testCases := []struct { |
||||||
|
name string |
||||||
|
prefix I |
||||||
|
expected int |
||||||
|
}{ |
||||||
|
{"Event", EventPrefix, Event}, |
||||||
|
{"ID", IdPrefix, Id}, |
||||||
|
{"FullIdPubkey", FullIdPubkeyPrefix, FullIdPubkey}, |
||||||
|
{"Pubkey", PubkeyPrefix, Pubkey}, |
||||||
|
{"CreatedAt", CreatedAtPrefix, CreatedAt}, |
||||||
|
{"TagPubkey", TagPubkeyPrefix, TagPubkey}, |
||||||
|
{"Tag", TagPrefix, Tag}, |
||||||
|
{"Kind", KindPrefix, Kind}, |
||||||
|
{"KindPubkey", KindPubkeyPrefix, KindPubkey}, |
||||||
|
{"TagKind", TagKindPrefix, TagKind}, |
||||||
|
{ |
||||||
|
"TagKindPubkey", TagKindPubkeyPrefix, |
||||||
|
TagKindPubkey, |
||||||
|
}, |
||||||
|
} |
||||||
|
|
||||||
|
for _, tc := range testCases { |
||||||
|
t.Run( |
||||||
|
tc.name, func(t *testing.T) { |
||||||
|
result, err := Identify(bytes.NewReader([]byte(tc.prefix))) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Identify failed: %v", err) |
||||||
|
} |
||||||
|
if result != tc.expected { |
||||||
|
t.Errorf( |
||||||
|
"Identify(%q) = %d, expected %d", tc.prefix, result, |
||||||
|
tc.expected, |
||||||
|
) |
||||||
|
} |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with invalid data
|
||||||
|
t.Run( |
||||||
|
"Invalid", func(t *testing.T) { |
||||||
|
result, err := Identify(bytes.NewReader([]byte("xyz"))) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("Identify failed: %v", err) |
||||||
|
} |
||||||
|
if result != 0 { |
||||||
|
t.Errorf( |
||||||
|
"Identify with invalid prefix should return 0, got %d", |
||||||
|
result, |
||||||
|
) |
||||||
|
} |
||||||
|
}, |
||||||
|
) |
||||||
|
|
||||||
|
// Test with error from reader
|
||||||
|
t.Run( |
||||||
|
"ReaderError", func(t *testing.T) { |
||||||
|
errReader := &errorReader{} |
||||||
|
result, err := Identify(errReader) |
||||||
|
if err == nil { |
||||||
|
t.Errorf("Identify should return error with failing reader") |
||||||
|
} |
||||||
|
if result != -1 { |
||||||
|
t.Errorf( |
||||||
|
"Identify with reader error should return -1, got %d", |
||||||
|
result, |
||||||
|
) |
||||||
|
} |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// errorReader is a mock reader that always returns an error
|
||||||
|
type errorReader struct{} |
||||||
|
|
||||||
|
func (e *errorReader) Read(p []byte) (n int, err error) { |
||||||
|
return 0, io.ErrUnexpectedEOF |
||||||
|
} |
||||||
|
|
||||||
|
// TestTStruct tests the T struct and its methods
|
||||||
|
func TestTStruct(t *testing.T) { |
||||||
|
// Create some test encoders
|
||||||
|
prefix := NewPrefix(Event) |
||||||
|
ser := new(types.Uint40) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test New function
|
||||||
|
enc := New(prefix, ser) |
||||||
|
if len(enc.Encs) != 2 { |
||||||
|
t.Errorf("New should create T with 2 encoders, got %d", len(enc.Encs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Test MarshalWrite
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Test UnmarshalRead
|
||||||
|
dec := New(NewPrefix(), new(types.Uint40)) |
||||||
|
err = dec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
decodedPrefix := dec.Encs[0].(*P) |
||||||
|
decodedSer := dec.Encs[1].(*types.Uint40) |
||||||
|
if !utils.FastEqual(decodedPrefix.Bytes(), prefix.Bytes()) { |
||||||
|
t.Errorf( |
||||||
|
"Decoded prefix %v, expected %v", decodedPrefix.Bytes(), |
||||||
|
prefix.Bytes(), |
||||||
|
) |
||||||
|
} |
||||||
|
if decodedSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", decodedSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with nil encoder
|
||||||
|
encWithNil := New(prefix, nil, ser) |
||||||
|
buf.Reset() |
||||||
|
err = encWithNil.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite with nil encoder failed: %v", err) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestEventFunctions tests the Event-related functions
|
||||||
|
func TestEventFunctions(t *testing.T) { |
||||||
|
// Test EventVars
|
||||||
|
ser := EventVars() |
||||||
|
if ser == nil { |
||||||
|
t.Fatalf("EventVars should return non-nil *types.Uint40") |
||||||
|
} |
||||||
|
|
||||||
|
// Set a value
|
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test EventEnc
|
||||||
|
enc := EventEnc(ser) |
||||||
|
if len(enc.Encs) != 2 { |
||||||
|
t.Errorf( |
||||||
|
"EventEnc should create T with 2 encoders, got %d", len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test EventDec
|
||||||
|
dec := EventDec(ser) |
||||||
|
if len(dec.Encs) != 2 { |
||||||
|
t.Errorf( |
||||||
|
"EventDec should create T with 2 encoders, got %d", len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newSer := new(types.Uint40) |
||||||
|
newDec := EventDec(newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded value
|
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestIdFunctions tests the Id-related functions
|
||||||
|
func TestIdFunctions(t *testing.T) { |
||||||
|
// Test IdVars
|
||||||
|
id, ser := IdVars() |
||||||
|
if id == nil || ser == nil { |
||||||
|
t.Fatalf("IdVars should return non-nil *types.IdHash and *types.Uint40") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
id.Set([]byte{1, 2, 3, 4, 5, 6, 7, 8}) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test IdEnc
|
||||||
|
enc := IdEnc(id, ser) |
||||||
|
if len(enc.Encs) != 3 { |
||||||
|
t.Errorf("IdEnc should create T with 3 encoders, got %d", len(enc.Encs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Test IdDec
|
||||||
|
dec := IdDec(id, ser) |
||||||
|
if len(dec.Encs) != 3 { |
||||||
|
t.Errorf("IdDec should create T with 3 encoders, got %d", len(dec.Encs)) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newId, newSer := IdVars() |
||||||
|
newDec := IdDec(newId, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if !utils.FastEqual(newId.Bytes(), id.Bytes()) { |
||||||
|
t.Errorf("Decoded id %v, expected %v", newId.Bytes(), id.Bytes()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestIdPubkeyFunctions tests the FullIdPubkey-related functions
|
||||||
|
func TestIdPubkeyFunctions(t *testing.T) { |
||||||
|
// Test FullIdPubkeyVars
|
||||||
|
ser, fid, p, ca := FullIdPubkeyVars() |
||||||
|
if ser == nil || fid == nil || p == nil || ca == nil { |
||||||
|
t.Fatalf("FullIdPubkeyVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ser.Set(12345) |
||||||
|
err := fid.FromId( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromId failed: %v", err) |
||||||
|
} |
||||||
|
err = p.FromPubkey( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromPubkey failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
|
||||||
|
// Test FullIdPubkeyEnc
|
||||||
|
enc := FullIdPubkeyEnc(ser, fid, p, ca) |
||||||
|
if len(enc.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"FullIdPubkeyEnc should create T with 5 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test FullIdPubkeyDec
|
||||||
|
dec := FullIdPubkeyDec(ser, fid, p, ca) |
||||||
|
if len(dec.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"FullIdPubkeyDec should create T with 5 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newSer, newFid, newP, newCa := FullIdPubkeyVars() |
||||||
|
newDec := FullIdPubkeyDec(newSer, newFid, newP, newCa) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newFid.Bytes(), fid.Bytes()) { |
||||||
|
t.Errorf("Decoded id %v, expected %v", newFid.Bytes(), fid.Bytes()) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newP.Bytes(), p.Bytes()) { |
||||||
|
t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestCreatedAtFunctions tests the CreatedAt-related functions
|
||||||
|
func TestCreatedAtFunctions(t *testing.T) { |
||||||
|
// Test CreatedAtVars
|
||||||
|
ca, ser := CreatedAtVars() |
||||||
|
if ca == nil || ser == nil { |
||||||
|
t.Fatalf("CreatedAtVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test CreatedAtEnc
|
||||||
|
enc := CreatedAtEnc(ca, ser) |
||||||
|
if len(enc.Encs) != 3 { |
||||||
|
t.Errorf( |
||||||
|
"CreatedAtEnc should create T with 3 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test CreatedAtDec
|
||||||
|
dec := CreatedAtDec(ca, ser) |
||||||
|
if len(dec.Encs) != 3 { |
||||||
|
t.Errorf( |
||||||
|
"CreatedAtDec should create T with 3 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newCa, newSer := CreatedAtVars() |
||||||
|
newDec := CreatedAtDec(newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestPubkeyFunctions tests the Pubkey-related functions
|
||||||
|
func TestPubkeyFunctions(t *testing.T) { |
||||||
|
// Test PubkeyVars
|
||||||
|
p, ca, ser := PubkeyVars() |
||||||
|
if p == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("PubkeyVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
err := p.FromPubkey( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromPubkey failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test PubkeyEnc
|
||||||
|
enc := PubkeyEnc(p, ca, ser) |
||||||
|
if len(enc.Encs) != 4 { |
||||||
|
t.Errorf( |
||||||
|
"PubkeyEnc should create T with 4 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test PubkeyDec
|
||||||
|
dec := PubkeyDec(p, ca, ser) |
||||||
|
if len(dec.Encs) != 4 { |
||||||
|
t.Errorf( |
||||||
|
"PubkeyDec should create T with 4 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newP, newCa, newSer := PubkeyVars() |
||||||
|
newDec := PubkeyDec(newP, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if !utils.FastEqual(newP.Bytes(), p.Bytes()) { |
||||||
|
t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestPubkeyTagFunctions tests the TagPubkey-related functions
|
||||||
|
func TestPubkeyTagFunctions(t *testing.T) { |
||||||
|
// Test TagPubkeyVars
|
||||||
|
k, v, p, ca, ser := TagPubkeyVars() |
||||||
|
if p == nil || k == nil || v == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("TagPubkeyVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
err := p.FromPubkey( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromPubkey failed: %v", err) |
||||||
|
} |
||||||
|
k.Set('e') |
||||||
|
v.FromIdent([]byte("test-value")) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromIdent failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test TagPubkeyEnc
|
||||||
|
enc := TagPubkeyEnc(k, v, p, ca, ser) |
||||||
|
if len(enc.Encs) != 6 { |
||||||
|
t.Errorf( |
||||||
|
"TagPubkeyEnc should create T with 6 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagPubkeyDec
|
||||||
|
dec := TagPubkeyDec(k, v, p, ca, ser) |
||||||
|
if len(dec.Encs) != 6 { |
||||||
|
t.Errorf( |
||||||
|
"TagPubkeyDec should create T with 6 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newK, newV, newP, newCa, newSer := TagPubkeyVars() |
||||||
|
newDec := TagPubkeyDec(newK, newV, newP, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if !utils.FastEqual(newP.Bytes(), p.Bytes()) { |
||||||
|
t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes()) |
||||||
|
} |
||||||
|
if newK.Letter() != k.Letter() { |
||||||
|
t.Errorf( |
||||||
|
"Decoded key letter %c, expected %c", newK.Letter(), k.Letter(), |
||||||
|
) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newV.Bytes(), v.Bytes()) { |
||||||
|
t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestTagFunctions tests the Tag-related functions
|
||||||
|
func TestTagFunctions(t *testing.T) { |
||||||
|
var err error |
||||||
|
// Test TagVars
|
||||||
|
k, v, ca, ser := TagVars() |
||||||
|
if k == nil || v == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("TagVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
k.Set('e') |
||||||
|
v.FromIdent([]byte("test-value")) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromIdent failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test TagEnc
|
||||||
|
enc := TagEnc(k, v, ca, ser) |
||||||
|
if len(enc.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"TagEnc should create T with 5 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagDec
|
||||||
|
dec := TagDec(k, v, ca, ser) |
||||||
|
if len(dec.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"TagDec should create T with 5 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newK, newV, newCa, newSer := TagVars() |
||||||
|
newDec := TagDec(newK, newV, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newK.Letter() != k.Letter() { |
||||||
|
t.Errorf( |
||||||
|
"Decoded key letter %c, expected %c", newK.Letter(), k.Letter(), |
||||||
|
) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newV.Bytes(), v.Bytes()) { |
||||||
|
t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestKindFunctions tests the Kind-related functions
|
||||||
|
func TestKindFunctions(t *testing.T) { |
||||||
|
// Test KindVars
|
||||||
|
ki, ca, ser := KindVars() |
||||||
|
if ki == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("KindVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ki.Set(1234) |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test KindEnc
|
||||||
|
enc := KindEnc(ki, ca, ser) |
||||||
|
if len(enc.Encs) != 4 { |
||||||
|
t.Errorf( |
||||||
|
"KindEnc should create T with 4 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test KindDec
|
||||||
|
dec := KindDec(ki, ca, ser) |
||||||
|
if len(dec.Encs) != 4 { |
||||||
|
t.Errorf( |
||||||
|
"KindDec should create T with 4 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newKi, newCa, newSer := KindVars() |
||||||
|
newDec := KindDec(newKi, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newKi.Get() != ki.Get() { |
||||||
|
t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestKindTagFunctions tests the TagKind-related functions
|
||||||
|
func TestKindTagFunctions(t *testing.T) { |
||||||
|
var err error |
||||||
|
// Test TagKindVars
|
||||||
|
k, v, ki, ca, ser := TagKindVars() |
||||||
|
if ki == nil || k == nil || v == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("TagKindVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ki.Set(1234) |
||||||
|
k.Set('e') |
||||||
|
v.FromIdent([]byte("test-value")) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromIdent failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test TagKindEnc
|
||||||
|
enc := TagKindEnc(k, v, ki, ca, ser) |
||||||
|
if len(enc.Encs) != 6 { |
||||||
|
t.Errorf( |
||||||
|
"TagKindEnc should create T with 6 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagKindDec
|
||||||
|
dec := TagKindDec(k, v, ki, ca, ser) |
||||||
|
if len(dec.Encs) != 6 { |
||||||
|
t.Errorf( |
||||||
|
"TagKindDec should create T with 6 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newK, newV, newKi, newCa, newSer := TagKindVars() |
||||||
|
newDec := TagKindDec(newK, newV, newKi, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newKi.Get() != ki.Get() { |
||||||
|
t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get()) |
||||||
|
} |
||||||
|
if newK.Letter() != k.Letter() { |
||||||
|
t.Errorf( |
||||||
|
"Decoded key letter %c, expected %c", newK.Letter(), k.Letter(), |
||||||
|
) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newV.Bytes(), v.Bytes()) { |
||||||
|
t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestKindPubkeyFunctions tests the KindPubkey-related functions
|
||||||
|
func TestKindPubkeyFunctions(t *testing.T) { |
||||||
|
// Test KindPubkeyVars
|
||||||
|
ki, p, ca, ser := KindPubkeyVars() |
||||||
|
if ki == nil || p == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("KindPubkeyVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ki.Set(1234) |
||||||
|
err := p.FromPubkey( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromPubkey failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test KindPubkeyEnc
|
||||||
|
enc := KindPubkeyEnc(ki, p, ca, ser) |
||||||
|
if len(enc.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"KindPubkeyEnc should create T with 5 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test KindPubkeyDec
|
||||||
|
dec := KindPubkeyDec(ki, p, ca, ser) |
||||||
|
if len(dec.Encs) != 5 { |
||||||
|
t.Errorf( |
||||||
|
"KindPubkeyDec should create T with 5 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newKi, newP, newCa, newSer := KindPubkeyVars() |
||||||
|
newDec := KindPubkeyDec(newKi, newP, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newKi.Get() != ki.Get() { |
||||||
|
t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get()) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newP.Bytes(), p.Bytes()) { |
||||||
|
t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestKindPubkeyTagFunctions tests the TagKindPubkey-related functions
|
||||||
|
func TestKindPubkeyTagFunctions(t *testing.T) { |
||||||
|
// Test TagKindPubkeyVars
|
||||||
|
k, v, ki, p, ca, ser := TagKindPubkeyVars() |
||||||
|
if ki == nil || p == nil || k == nil || v == nil || ca == nil || ser == nil { |
||||||
|
t.Fatalf("TagKindPubkeyVars should return non-nil values") |
||||||
|
} |
||||||
|
|
||||||
|
// Set values
|
||||||
|
ki.Set(1234) |
||||||
|
err := p.FromPubkey( |
||||||
|
[]byte{ |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, |
||||||
|
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, |
||||||
|
}, |
||||||
|
) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromPubkey failed: %v", err) |
||||||
|
} |
||||||
|
k.Set('e') |
||||||
|
v.FromIdent([]byte("test-value")) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromIdent failed: %v", err) |
||||||
|
} |
||||||
|
ca.Set(98765) |
||||||
|
ser.Set(12345) |
||||||
|
|
||||||
|
// Test TagKindPubkeyEnc
|
||||||
|
enc := TagKindPubkeyEnc(k, v, ki, p, ca, ser) |
||||||
|
if len(enc.Encs) != 7 { |
||||||
|
t.Errorf( |
||||||
|
"TagKindPubkeyEnc should create T with 7 encoders, got %d", |
||||||
|
len(enc.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test TagKindPubkeyDec
|
||||||
|
dec := TagKindPubkeyDec(k, v, ki, p, ca, ser) |
||||||
|
if len(dec.Encs) != 7 { |
||||||
|
t.Errorf( |
||||||
|
"TagKindPubkeyDec should create T with 7 encoders, got %d", |
||||||
|
len(dec.Encs), |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test marshaling and unmarshaling
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = enc.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create new variables for decoding
|
||||||
|
newK, newV, newKi, newP, newCa, newSer := TagKindPubkeyVars() |
||||||
|
newDec := TagKindPubkeyDec(newK, newV, newKi, newP, newCa, newSer) |
||||||
|
|
||||||
|
err = newDec.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the decoded values
|
||||||
|
if newKi.Get() != ki.Get() { |
||||||
|
t.Errorf("Decoded kind %d, expected %d", newKi.Get(), ki.Get()) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newP.Bytes(), p.Bytes()) { |
||||||
|
t.Errorf("Decoded pubkey hash %v, expected %v", newP.Bytes(), p.Bytes()) |
||||||
|
} |
||||||
|
if newK.Letter() != k.Letter() { |
||||||
|
t.Errorf( |
||||||
|
"Decoded key letter %c, expected %c", newK.Letter(), k.Letter(), |
||||||
|
) |
||||||
|
} |
||||||
|
if !utils.FastEqual(newV.Bytes(), v.Bytes()) { |
||||||
|
t.Errorf("Decoded value hash %v, expected %v", newV.Bytes(), v.Bytes()) |
||||||
|
} |
||||||
|
if newCa.Get() != ca.Get() { |
||||||
|
t.Errorf("Decoded created at %d, expected %d", newCa.Get(), ca.Get()) |
||||||
|
} |
||||||
|
if newSer.Get() != ser.Get() { |
||||||
|
t.Errorf("Decoded serial %d, expected %d", newSer.Get(), ser.Get()) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,419 @@ |
|||||||
|
package types |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"encoding/binary" |
||||||
|
"testing" |
||||||
|
) |
||||||
|
|
||||||
|
// TestTypesSortLexicographically tests if the numeric types sort lexicographically
|
||||||
|
// when using bytes.Compare after marshaling.
|
||||||
|
func TestTypesSortLexicographically(t *testing.T) { |
||||||
|
// Test Uint16
|
||||||
|
t.Run("Uint16", func(t *testing.T) { |
||||||
|
testUint16Sorting(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint24
|
||||||
|
t.Run("Uint24", func(t *testing.T) { |
||||||
|
testUint24Sorting(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint32
|
||||||
|
t.Run("Uint32", func(t *testing.T) { |
||||||
|
testUint32Sorting(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint40
|
||||||
|
t.Run("Uint40", func(t *testing.T) { |
||||||
|
testUint40Sorting(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint64
|
||||||
|
t.Run("Uint64", func(t *testing.T) { |
||||||
|
testUint64Sorting(t) |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
// TestEdgeCases tests sorting with edge cases like zero, max values, and adjacent values
|
||||||
|
func TestEdgeCases(t *testing.T) { |
||||||
|
// Test Uint16 edge cases
|
||||||
|
t.Run("Uint16EdgeCases", func(t *testing.T) { |
||||||
|
testUint16EdgeCases(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint24 edge cases
|
||||||
|
t.Run("Uint24EdgeCases", func(t *testing.T) { |
||||||
|
testUint24EdgeCases(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint32 edge cases
|
||||||
|
t.Run("Uint32EdgeCases", func(t *testing.T) { |
||||||
|
testUint32EdgeCases(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint40 edge cases
|
||||||
|
t.Run("Uint40EdgeCases", func(t *testing.T) { |
||||||
|
testUint40EdgeCases(t) |
||||||
|
}) |
||||||
|
|
||||||
|
// Test Uint64 edge cases
|
||||||
|
t.Run("Uint64EdgeCases", func(t *testing.T) { |
||||||
|
testUint64EdgeCases(t) |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
func testUint16Sorting(t *testing.T) { |
||||||
|
values := []uint16{1, 10, 100, 1000, 10000, 65535} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint16) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint16 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint16 values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint24Sorting(t *testing.T) { |
||||||
|
values := []uint32{1, 10, 100, 1000, 10000, 100000, 1000000, 16777215} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint24) |
||||||
|
err := u.Set(val) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to set Uint24 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint24 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint24 values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint32Sorting(t *testing.T) { |
||||||
|
values := []uint32{1, 10, 100, 1000, 10000, 100000, 1000000, 4294967295} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint32) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint32 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint32 values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint40Sorting(t *testing.T) { |
||||||
|
values := []uint64{1, 10, 100, 1000, 10000, 100000, 1000000, 1099511627775} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint40) |
||||||
|
err := u.Set(val) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to set Uint40 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint40 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint40 values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint64Sorting(t *testing.T) { |
||||||
|
values := []uint64{1, 10, 100, 1000, 10000, 100000, 1000000, 18446744073709551615} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint64) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint64 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint64 values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Edge case test functions
|
||||||
|
|
||||||
|
func testUint16EdgeCases(t *testing.T) { |
||||||
|
// Test edge cases: 0, max value, and adjacent values
|
||||||
|
values := []uint16{0, 1, 2, 65534, 65535} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint16) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint16 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint16 edge case values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint24EdgeCases(t *testing.T) { |
||||||
|
// Test edge cases: 0, max value, and adjacent values
|
||||||
|
values := []uint32{0, 1, 2, 16777214, 16777215} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint24) |
||||||
|
err := u.Set(val) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to set Uint24 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint24 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint24 edge case values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint32EdgeCases(t *testing.T) { |
||||||
|
// Test edge cases: 0, max value, and adjacent values
|
||||||
|
values := []uint32{0, 1, 2, 4294967294, 4294967295} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint32) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint32 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint32 edge case values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint40EdgeCases(t *testing.T) { |
||||||
|
// Test edge cases: 0, max value, and adjacent values
|
||||||
|
values := []uint64{0, 1, 2, 1099511627774, 1099511627775} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint40) |
||||||
|
err := u.Set(val) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to set Uint40 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint40 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint40 edge case values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func testUint64EdgeCases(t *testing.T) { |
||||||
|
// Test edge cases: 0, max value, and adjacent values
|
||||||
|
values := []uint64{0, 1, 2, 18446744073709551614, 18446744073709551615} |
||||||
|
|
||||||
|
// Marshal each value
|
||||||
|
marshaledValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
u := new(Uint64) |
||||||
|
u.Set(val) |
||||||
|
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err := u.MarshalWrite(buf) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("Failed to marshal Uint64 %d: %v", val, err) |
||||||
|
} |
||||||
|
|
||||||
|
marshaledValues[i] = buf.Bytes() |
||||||
|
} |
||||||
|
|
||||||
|
// Check if they sort correctly with bytes.Compare
|
||||||
|
for i := 0; i < len(marshaledValues)-1; i++ { |
||||||
|
if bytes.Compare(marshaledValues[i], marshaledValues[i+1]) >= 0 { |
||||||
|
t.Errorf("Uint64 edge case values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", marshaledValues[i], marshaledValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// TestEndianness demonstrates why BigEndian is used instead of LittleEndian
|
||||||
|
// for lexicographical sorting with bytes.Compare
|
||||||
|
func TestEndianness(t *testing.T) { |
||||||
|
// Test with uint32 values
|
||||||
|
values := []uint32{1, 10, 100, 1000, 10000} |
||||||
|
|
||||||
|
// Marshal each value using BigEndian
|
||||||
|
bigEndianValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
buf := make([]byte, 4) |
||||||
|
binary.BigEndian.PutUint32(buf, val) |
||||||
|
bigEndianValues[i] = buf |
||||||
|
} |
||||||
|
|
||||||
|
// Marshal each value using LittleEndian
|
||||||
|
littleEndianValues := make([][]byte, len(values)) |
||||||
|
for i, val := range values { |
||||||
|
buf := make([]byte, 4) |
||||||
|
binary.LittleEndian.PutUint32(buf, val) |
||||||
|
littleEndianValues[i] = buf |
||||||
|
} |
||||||
|
|
||||||
|
// Check if BigEndian values sort correctly with bytes.Compare
|
||||||
|
t.Log("Testing BigEndian sorting:") |
||||||
|
for i := 0; i < len(bigEndianValues)-1; i++ { |
||||||
|
result := bytes.Compare(bigEndianValues[i], bigEndianValues[i+1]) |
||||||
|
t.Logf("Compare %d with %d: result = %d", values[i], values[i+1], result) |
||||||
|
if result >= 0 { |
||||||
|
t.Errorf("BigEndian values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", bigEndianValues[i], bigEndianValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Check if LittleEndian values sort correctly with bytes.Compare
|
||||||
|
t.Log("Testing LittleEndian sorting:") |
||||||
|
correctOrder := true |
||||||
|
for i := 0; i < len(littleEndianValues)-1; i++ { |
||||||
|
result := bytes.Compare(littleEndianValues[i], littleEndianValues[i+1]) |
||||||
|
t.Logf("Compare %d with %d: result = %d", values[i], values[i+1], result) |
||||||
|
if result >= 0 { |
||||||
|
correctOrder = false |
||||||
|
t.Logf("LittleEndian values don't sort correctly: %v should be less than %v", |
||||||
|
values[i], values[i+1]) |
||||||
|
t.Logf("Bytes representation: %v vs %v", littleEndianValues[i], littleEndianValues[i+1]) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// We expect LittleEndian to NOT sort correctly
|
||||||
|
if correctOrder { |
||||||
|
t.Error("LittleEndian values unexpectedly sorted correctly") |
||||||
|
} else { |
||||||
|
t.Log("As expected, LittleEndian values don't sort correctly with bytes.Compare") |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,38 @@ |
|||||||
|
package types |
||||||
|
|
||||||
|
import ( |
||||||
|
"io" |
||||||
|
|
||||||
|
"crypto.orly/sha256" |
||||||
|
"lol.mleku.dev/errorf" |
||||||
|
) |
||||||
|
|
||||||
|
const IdLen = sha256.Size |
||||||
|
|
||||||
|
type Id struct { |
||||||
|
val [IdLen]byte |
||||||
|
} |
||||||
|
|
||||||
|
func (fi *Id) FromId(id []byte) (err error) { |
||||||
|
if len(id) != IdLen { |
||||||
|
err = errorf.E( |
||||||
|
"fullid.FromId: invalid ID length, got %d require %d", len(id), |
||||||
|
IdLen, |
||||||
|
) |
||||||
|
return |
||||||
|
} |
||||||
|
copy(fi.val[:], id) |
||||||
|
return |
||||||
|
} |
||||||
|
func (fi *Id) Bytes() (b []byte) { return fi.val[:] } |
||||||
|
|
||||||
|
func (fi *Id) MarshalWrite(w io.Writer) (err error) { |
||||||
|
_, err = w.Write(fi.val[:]) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (fi *Id) UnmarshalRead(r io.Reader) (err error) { |
||||||
|
copy(fi.val[:], fi.val[:IdLen]) |
||||||
|
_, err = r.Read(fi.val[:]) |
||||||
|
return |
||||||
|
} |
||||||
@ -0,0 +1,115 @@ |
|||||||
|
package types |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"lol.mleku.dev/chk" |
||||||
|
"utils.orly" |
||||||
|
|
||||||
|
"crypto.orly/sha256" |
||||||
|
) |
||||||
|
|
||||||
|
func TestFromId(t *testing.T) { |
||||||
|
// Create a valid ID (32 bytes)
|
||||||
|
validId := make([]byte, sha256.Size) |
||||||
|
for i := 0; i < sha256.Size; i++ { |
||||||
|
validId[i] = byte(i) |
||||||
|
} |
||||||
|
|
||||||
|
// Create an invalid ID (wrong size)
|
||||||
|
invalidId := make([]byte, sha256.Size-1) |
||||||
|
|
||||||
|
// Test with valid ID
|
||||||
|
fi := &Id{} |
||||||
|
err := fi.FromId(validId) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromId failed with valid ID: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the ID was set correctly
|
||||||
|
if !utils.FastEqual(fi.Bytes(), validId) { |
||||||
|
t.Errorf( |
||||||
|
"FromId did not set the ID correctly: got %v, want %v", fi.Bytes(), |
||||||
|
validId, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Test with invalid ID
|
||||||
|
fi = &Id{} |
||||||
|
err = fi.FromId(invalidId) |
||||||
|
if err == nil { |
||||||
|
t.Errorf("FromId should have failed with invalid ID size") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestIdMarshalWriteUnmarshalRead(t *testing.T) { |
||||||
|
// Create a ID with a known value
|
||||||
|
fi1 := &Id{} |
||||||
|
validId := make([]byte, sha256.Size) |
||||||
|
for i := 0; i < sha256.Size; i++ { |
||||||
|
validId[i] = byte(i) |
||||||
|
} |
||||||
|
err := fi1.FromId(validId) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromId failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Test MarshalWrite
|
||||||
|
buf := new(bytes.Buffer) |
||||||
|
err = fi1.MarshalWrite(buf) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("MarshalWrite failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the written bytes
|
||||||
|
if !utils.FastEqual(buf.Bytes(), validId) { |
||||||
|
t.Errorf("MarshalWrite wrote %v, want %v", buf.Bytes(), validId) |
||||||
|
} |
||||||
|
|
||||||
|
// Test UnmarshalRead
|
||||||
|
fi2 := &Id{} |
||||||
|
err = fi2.UnmarshalRead(bytes.NewBuffer(buf.Bytes())) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("UnmarshalRead failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Verify the read value
|
||||||
|
if !utils.FastEqual(fi2.Bytes(), validId) { |
||||||
|
t.Errorf("UnmarshalRead read %v, want %v", fi2.Bytes(), validId) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func TestIdUnmarshalReadWithCorruptedData(t *testing.T) { |
||||||
|
// Create a ID with a known value
|
||||||
|
fi1 := &Id{} |
||||||
|
validId := make([]byte, sha256.Size) |
||||||
|
for i := 0; i < sha256.Size; i++ { |
||||||
|
validId[i] = byte(i) |
||||||
|
} |
||||||
|
err := fi1.FromId(validId) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromId failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Create a second ID with a different value
|
||||||
|
fi2 := &Id{} |
||||||
|
differentId := make([]byte, sha256.Size) |
||||||
|
for i := 0; i < sha256.Size; i++ { |
||||||
|
differentId[i] = byte(sha256.Size - i - 1) |
||||||
|
} |
||||||
|
err = fi2.FromId(differentId) |
||||||
|
if chk.E(err) { |
||||||
|
t.Fatalf("FromId failed: %v", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Test UnmarshalRead with corrupted data (less than Len bytes)
|
||||||
|
corruptedData := make([]byte, sha256.Size/2) |
||||||
|
fi2.UnmarshalRead(bytes.NewBuffer(corruptedData)) |
||||||
|
|
||||||
|
// The UnmarshalRead method should not have copied the original data to itself
|
||||||
|
// before reading, so the value should be partially overwritten
|
||||||
|
if utils.FastEqual(fi2.Bytes(), differentId) { |
||||||
|
t.Errorf("UnmarshalRead did not modify the value as expected") |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,31 @@ |
|||||||
|
package types |
||||||
|
|
||||||
|
import ( |
||||||
|
"io" |
||||||
|
|
||||||
|
"crypto.orly/sha256" |
||||||
|
) |
||||||
|
|
||||||
|
const IdentLen = 8 |
||||||
|
|
||||||
|
type Ident struct{ val [IdentLen]byte } |
||||||
|
|
||||||
|
func (i *Ident) FromIdent(id []byte) { |
||||||
|
idh := sha256.Sum256(id) |
||||||
|
copy(i.val[:], idh[:IdentLen]) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (i *Ident) Bytes() (b []byte) { return i.val[:] } |
||||||
|
|
||||||
|
func (i *Ident) MarshalWrite(w io.Writer) (err error) { |
||||||
|
_, err = w.Write(i.val[:]) |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
func (i *Ident) UnmarshalRead(r io.Reader) (err error) { |
||||||
|
|
||||||
|
copy(i.val[:], i.val[:IdentLen]) |
||||||
|
_, err = r.Read(i.val[:]) |
||||||
|
return |
||||||
|
} |
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue