128 lines
3.3 KiB
Go
128 lines
3.3 KiB
Go
// package keys_test needs to be a different package name or the implementation
|
|
// types imports will circular
|
|
package keys_test
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"testing"
|
|
|
|
"ratel.mleku.dev/keys"
|
|
"ratel.mleku.dev/keys/createdat"
|
|
"ratel.mleku.dev/keys/id"
|
|
"ratel.mleku.dev/keys/index"
|
|
"ratel.mleku.dev/keys/kinder"
|
|
"ratel.mleku.dev/keys/pubkey"
|
|
"ratel.mleku.dev/keys/serial"
|
|
|
|
"ec.mleku.dev/v2/schnorr"
|
|
"lukechampine.com/frand"
|
|
"nostr.mleku.dev/codec/eventid"
|
|
"nostr.mleku.dev/codec/kind"
|
|
"nostr.mleku.dev/codec/timestamp"
|
|
)
|
|
|
|
func TestElement(t *testing.T) {
|
|
for _ = range 100000 {
|
|
var failed bool
|
|
{ // construct a typical key type of structure
|
|
// a prefix
|
|
np := index.Version
|
|
vp := index.New(byte(np))
|
|
// an id
|
|
fakeIdBytes := frand.Bytes(sha256.Size)
|
|
i := eventid.NewWith(fakeIdBytes)
|
|
vid := id.New(i)
|
|
// a kinder
|
|
n := kind.New(1059)
|
|
vk := kinder.New(n.K)
|
|
// a pubkey
|
|
fakePubkeyBytes := frand.Bytes(schnorr.PubKeyBytesLen)
|
|
var vpk *pubkey.T
|
|
var err error
|
|
vpk, err = pubkey.NewFromBytes(fakePubkeyBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// a createdat
|
|
ts := timestamp.Now()
|
|
vca := createdat.New(ts)
|
|
// a serial
|
|
fakeSerialBytes := frand.Bytes(serial.Len)
|
|
vs := serial.New(fakeSerialBytes)
|
|
// write Element list into buffer
|
|
b := keys.Write(vp, vid, vk, vpk, vca, vs)
|
|
// check that values decoded all correctly
|
|
// we expect the following types, so we must create them:
|
|
var vp2 = index.New(0)
|
|
var vid2 = id.New()
|
|
var vk2 = kinder.New(0)
|
|
var vpk2 *pubkey.T
|
|
vpk2, err = pubkey.New()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var vca2 = createdat.New(timestamp.New())
|
|
var vs2 = serial.New(nil)
|
|
// read it in
|
|
keys.Read(b, vp2, vid2, vk2, vpk2, vca2, vs2)
|
|
// this is a lot of tests, so use switch syntax
|
|
switch {
|
|
case bytes.Compare(vp.Val, vp2.Val) != 0:
|
|
t.Logf("failed to decode correctly got %v expected %v", vp2.Val,
|
|
vp.Val)
|
|
failed = true
|
|
fallthrough
|
|
case bytes.Compare(vid.Val, vid2.Val) != 0:
|
|
t.Logf("failed to decode correctly got %v expected %v", vid2.Val,
|
|
vid.Val)
|
|
failed = true
|
|
fallthrough
|
|
case vk.Val.ToU16() != vk2.Val.ToU16():
|
|
t.Logf("failed to decode correctly got %v expected %v", vk2.Val,
|
|
vk.Val)
|
|
failed = true
|
|
fallthrough
|
|
case !bytes.Equal(vpk.Val, vpk2.Val):
|
|
t.Logf("failed to decode correctly got %v expected %v", vpk2.Val,
|
|
vpk.Val)
|
|
failed = true
|
|
fallthrough
|
|
case vca.Val.I64() != vca2.Val.I64():
|
|
t.Logf("failed to decode correctly got %v expected %v", vca2.Val,
|
|
vca.Val)
|
|
failed = true
|
|
fallthrough
|
|
case !bytes.Equal(vs.Val, vs2.Val):
|
|
t.Logf("failed to decode correctly got %v expected %v", vpk2.Val,
|
|
vpk.Val)
|
|
failed = true
|
|
}
|
|
}
|
|
{ // construct a counter value
|
|
// a createdat
|
|
ts := timestamp.Now()
|
|
vca := createdat.New(ts)
|
|
// a sizer
|
|
// n := uint32(frand.Uint64n(math.MaxUint32))
|
|
// write out values
|
|
b := keys.Write(vca)
|
|
// check that values decoded all correctly
|
|
// we expect the following types, so we must create them:
|
|
var vca2 = createdat.New(timestamp.New())
|
|
// read it in
|
|
keys.Read(b, vca2)
|
|
// check they match
|
|
|
|
if vca.Val.I64() != vca2.Val.I64() {
|
|
t.Logf("failed to decode correctly got %v expected %v", vca2.Val,
|
|
vca.Val)
|
|
failed = true
|
|
}
|
|
}
|
|
if failed {
|
|
t.FailNow()
|
|
}
|
|
}
|
|
}
|