You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
210 lines
6.8 KiB
210 lines
6.8 KiB
package datekey_test
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"errors"
|
|
"math/rand/v2"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
datekeys "github.com/datekeys/datekeys-go"
|
|
"github.com/datekeys/datekeys-go/datekey"
|
|
"github.com/datekeys/datekeys-go/internal/testkit"
|
|
"github.com/datekeys/datekeys-go/profile"
|
|
)
|
|
|
|
func TestNormativeRoundVector(t *testing.T) {
|
|
// Spec §16, stated literally.
|
|
p := profile.Quicknet()
|
|
d, err := datekey.Resolve(p, time.Date(2030, 1, 1, 0, 0, 0, 0, time.UTC))
|
|
if err != nil || d.Round != 66884212 {
|
|
t.Fatalf("2030-01-01 resolved to %+v, %v", d, err)
|
|
}
|
|
if got := d.UnlockAt(p).Format(time.RFC3339); got != "2030-01-01T00:00:00Z" {
|
|
t.Fatalf("round time %s", got)
|
|
}
|
|
rt, err := datekey.RoundTime(p, 66432123)
|
|
if err != nil || rt.Format(time.RFC3339) != "2029-12-16T07:15:33Z" {
|
|
t.Fatalf("round 66432123 at %s, %v", rt, err)
|
|
}
|
|
if got := d.Compact(); got != "dk1_eyJ2ZXJzaW9uIjoxLCJuZXR3b3JrIjoiZGF0ZWtleXM6cXVpY2tuZXQ6djEiLCJyb3VuZCI6NjY4ODQyMTJ9" {
|
|
t.Fatalf("dk1_ %s", got)
|
|
}
|
|
if got := string(d.CanonicalJSON()); got != `{"version":1,"network":"datekeys:quicknet:v1","round":66884212}` {
|
|
t.Fatalf("canonical JSON %s", got)
|
|
}
|
|
}
|
|
|
|
func TestGoldenRoundVectors(t *testing.T) {
|
|
var golden testkit.RoundVectorFile
|
|
if err := testkit.ReadJSON("../testdata/vectors/quicknet_rounds.json", &golden); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := testkit.RoundVectors(); !reflect.DeepEqual(got, golden) {
|
|
t.Fatalf("round vectors changed:\n got %+v\nwant %+v", got, golden)
|
|
}
|
|
p := profile.Quicknet()
|
|
for _, v := range golden.Vectors {
|
|
at, err := time.Parse(time.RFC3339Nano, v.Requested)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, err := datekey.Resolve(p, at)
|
|
if v.Error != "" {
|
|
if datekeys.Code(err) != v.Error {
|
|
t.Errorf("%s: got %v, want %s", v.Name, err, v.Error)
|
|
}
|
|
continue
|
|
}
|
|
if err != nil || d.Round != v.Round || d.UnlockAt(p).Format(time.RFC3339Nano) != v.Effective {
|
|
t.Errorf("%s: got %+v %v", v.Name, d, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGoldenDK1Vectors(t *testing.T) {
|
|
var golden testkit.DK1VectorFile
|
|
if err := testkit.ReadJSON("../testdata/vectors/dk1.json", &golden); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := testkit.DK1Vectors(); !reflect.DeepEqual(got, golden) {
|
|
t.Fatalf("dk1_ vectors changed")
|
|
}
|
|
for _, v := range golden.Vectors {
|
|
if v.DK1 != "" {
|
|
d, err := datekey.Parse(v.DK1)
|
|
if err != nil || d.ProfileID != v.Network || d.Round != v.Round {
|
|
t.Errorf("%s: %+v %v", v.Name, d, err)
|
|
}
|
|
if string(d.CanonicalJSON()) != v.CanonicalJSON || base64.RawURLEncoding.EncodeToString(d.CanonicalJSON()) != v.Base64URL {
|
|
t.Errorf("%s: intermediate encodings differ", v.Name)
|
|
}
|
|
continue
|
|
}
|
|
if v.Error == "accepted" {
|
|
t.Errorf("%s: a rejected-encoding vector is accepted", v.Name)
|
|
}
|
|
if _, err := datekey.Parse(v.Input); datekeys.Code(err) != v.Error {
|
|
t.Errorf("%s: got %v, want %s", v.Name, err, v.Error)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Kept from the prototype: resolution never picks a round that opens early.
|
|
func TestRoundNeverOpensEarly(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
g := time.Unix(p.GenesisTime, 0).UTC()
|
|
for _, tc := range []struct {
|
|
offset time.Duration
|
|
want uint64
|
|
}{
|
|
{0, 1}, {time.Nanosecond, 2}, {time.Second, 2}, {3 * time.Second, 2}, {3*time.Second + time.Nanosecond, 3}, {2997 * time.Second, 1000},
|
|
} {
|
|
requested := g.Add(tc.offset)
|
|
d, err := datekey.Resolve(p, requested)
|
|
if err != nil || d.Round != tc.want {
|
|
t.Fatalf("offset %s: %+v, %v", tc.offset, d, err)
|
|
}
|
|
if u := d.UnlockAt(p); u.Before(requested) || u.Sub(requested) >= p.Period {
|
|
t.Fatal("unsafe rounding")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolveProperty(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
r := rand.New(rand.NewPCG(3, 4))
|
|
for range 20000 {
|
|
secs := p.GenesisTime + r.Int64N(profile.MaxUnixTime-p.GenesisTime-3)
|
|
at := time.Unix(secs, r.Int64N(int64(time.Second)))
|
|
d, err := datekey.Resolve(p, at)
|
|
if err != nil {
|
|
t.Fatalf("%s: %v", at, err)
|
|
}
|
|
u := d.UnlockAt(p)
|
|
// The first round whose time is >= at: never earlier, and the previous
|
|
// round is strictly earlier.
|
|
if u.Before(at) {
|
|
t.Fatalf("%s resolves to round %d at %s, before the request", at, d.Round, u)
|
|
}
|
|
if d.Round > 1 {
|
|
prev, _ := datekey.RoundTime(p, d.Round-1)
|
|
if !prev.Before(at) {
|
|
t.Fatalf("%s: round %d at %s would already satisfy the request", at, d.Round-1, prev)
|
|
}
|
|
}
|
|
parsed, err := datekey.Parse(d.Compact())
|
|
if err != nil || parsed != d {
|
|
t.Fatalf("Parse(Compact(d)) != d for %+v: %v", d, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTimezoneIndependence(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
a, _ := time.Parse(time.RFC3339Nano, "2026-10-22T19:00:00.001+02:00")
|
|
b, _ := time.Parse(time.RFC3339Nano, "2026-10-22T17:00:00.001Z")
|
|
da, _ := datekey.Resolve(p, a)
|
|
db, _ := datekey.Resolve(p, b)
|
|
if da != db {
|
|
t.Fatal("timezone changed the DateKey")
|
|
}
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
p := profile.Quicknet()
|
|
if err := (datekey.DateKey{ProfileID: "datekeys:evmnet:v1", Round: 5}).Validate(p); !errors.Is(err, datekeys.ErrProfileMismatch) {
|
|
t.Fatalf("other profile: %v", err)
|
|
}
|
|
for _, r := range []uint64{0, p.MaxRound() + 1} {
|
|
if err := (datekey.DateKey{ProfileID: p.ID, Round: r}).Validate(p); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Fatalf("round %d: %v", r, err)
|
|
}
|
|
}
|
|
if !(datekey.DateKey{ProfileID: p.ID, Round: 0}).UnlockAt(p).IsZero() {
|
|
t.Fatal("invalid DateKey has an unlock time")
|
|
}
|
|
if (datekey.DateKey{ProfileID: `bad"id`, Round: 1}).Compact() != "" {
|
|
t.Fatal("invalid DateKey has a dk1_ form")
|
|
}
|
|
if _, err := datekey.Resolve(p, time.Time{}); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Fatalf("zero time: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNumberSpellings(t *testing.T) {
|
|
enc := func(round string) string {
|
|
return datekey.Prefix + base64.RawURLEncoding.EncodeToString([]byte(`{"version":1,"network":"datekeys:quicknet:v1","round":`+round+`}`))
|
|
}
|
|
for _, s := range []string{"1000.0", "1e3", "1E3", "10e2", "1000e0", "100000e-2", "0.1e4"} {
|
|
if _, err := datekey.Parse(enc(s)); !errors.Is(err, datekeys.ErrDateKeyNonCanonical) {
|
|
t.Errorf("%s: %v, want non-canonical", s, err)
|
|
}
|
|
}
|
|
for _, s := range []string{"1.5", "-1000", "1e-3", "1e400", "18446744073709551616", "0", "-0", "0e5"} {
|
|
if _, err := datekey.Parse(enc(s)); !errors.Is(err, datekeys.ErrDateKeyInvalid) {
|
|
t.Errorf("%s: %v, want invalid", s, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func FuzzParse(f *testing.F) {
|
|
d := datekey.DateKey{ProfileID: profile.QuicknetID, Round: 1000}
|
|
f.Add(d.Compact())
|
|
f.Add("dk1_invalid")
|
|
f.Add(datekey.Prefix + base64.RawURLEncoding.EncodeToString([]byte(`{"version":1,"network":"a","round":1e3}`)))
|
|
f.Fuzz(func(t *testing.T, s string) {
|
|
d, err := datekey.Parse(s)
|
|
if err != nil {
|
|
if c := datekeys.Code(err); c != "ERR_DATEKEY_INVALID" && c != "ERR_DATEKEY_NON_CANONICAL" {
|
|
t.Fatalf("unexpected error %v", err)
|
|
}
|
|
return
|
|
}
|
|
if d.Compact() != s {
|
|
t.Fatal("accepted a non-canonical DateKey")
|
|
}
|
|
})
|
|
}
|