- Kind
- Pure package
- Name
- v0
- Namespace
- moul / x / wesh
- Exported functions
- n/a — not supported for pure packages by the node (vm/qfuncs)
- Module
- gno.land/p/moul/x/wesh/v0
- gno
- 0.9
wesh_test.gnogno
1package wesh23import (4 "testing"56 "gno.land/p/nt/uassert/v0"7)8
not supported for pure packages by the node (vm/qfuncs)
Signatures reconstructed verbatim from vm/qfuncs — interface params keep their inline definitions.
9func TestContactValidate(t *testing.T) {
10 cases := []struct {
11 name string
12 in Contact
13 want error
14 }{
15 {"well-formed", Contact{AccountPK: repeat(1, 32), Seed: repeat(2, 32)}, nil},
16 {"with a display name", Contact{AccountPK: repeat(1, 32), Seed: repeat(2, 32), DisplayName: "gno"}, nil},
17 {"seed too short", Contact{AccountPK: repeat(1, 32), Seed: repeat(2, 31)}, ErrBadSeedLen},
18 {"seed too long", Contact{AccountPK: repeat(1, 32), Seed: repeat(2, 33)}, ErrBadSeedLen},
19 {"no seed", Contact{AccountPK: repeat(1, 32)}, ErrBadSeedLen},
20 {"account key too short", Contact{AccountPK: repeat(1, 31), Seed: repeat(2, 32)}, ErrBadAccountPKLen},
21 {"no account key", Contact{Seed: repeat(2, 32)}, ErrBadAccountPKLen},
22 {
23 "display name too long",
24 Contact{AccountPK: repeat(1, 32), Seed: repeat(2, 32), DisplayName: string(make([]byte, MaxDisplayNameLen+1))},
25 ErrDisplayNameTooLong,
26 },
27 }
28 for _, tc := range cases {
29 err := tc.in.Validate()
30 if tc.want == nil {
31 uassert.NoError(t, err, tc.name)
32 continue
33 }
34 uassert.ErrorIs(t, err, tc.want, tc.name)
35 }
36}
37
38func TestSeedCommitment(t *testing.T) {
39 seed := mustHex(t, testSeedHex)
40 salt := []byte("a-16-byte-salt!!")
41
42 c, err := SeedCommitment(seed, salt)
43 uassert.NoError(t, err)
44 uassert.Equal(t, DigestLen, len(c))
45
46 again, err := SeedCommitment(seed, salt)
47 uassert.NoError(t, err)
48 uassert.Equal(t, string(c), string(again), "the commitment is deterministic")
49
50 uassert.True(t, OpenCommitment(c, seed, salt), "the correct opening verifies")
51 uassert.False(t, OpenCommitment(c, seed, []byte("another-salt!!!!")), "a wrong salt does not open it")
52 uassert.False(t, OpenCommitment(c, repeat(0xEE, 32), salt), "a wrong seed does not open it")
53 uassert.False(t, OpenCommitment(c[:31], seed, salt), "a truncated commitment does not open it")
54}
55
56func TestSeedCommitmentRejectsABadSeed(t *testing.T) {
57 _, err := SeedCommitment(repeat(1, 31), []byte("salt"))
58 uassert.ErrorIs(t, err, ErrBadSeedLen)
59}
60
61// TestSeedCommitmentIsSaltSeparated guards the length-extension style
62// ambiguity: without distinct inputs, (seed, "ab") and (seed+"a", "b") would
63// collide. The seed is fixed-length, which resolves it, and this pins that.
64func TestSeedCommitmentDependsOnTheSplit(t *testing.T) {
65 seed := repeat(0xAA, 32)
66 a, _ := SeedCommitment(seed, []byte("ab"))
67 b, _ := SeedCommitment(seed, []byte("abc"))
68 uassert.False(t, string(a) == string(b))
69}
70
71func TestDecodeHelpers(t *testing.T) {
72 cases := []struct {
73 name string
74 fn func(string) ([]byte, error)
75 in string
76 err error
77 }{
78 {"account key", DecodeAccountPK, testAccountPKHex, nil},
79 {"seed", DecodeSeed, testSeedHex, nil},
80 {"device key", DecodeDevicePK, testSeedHex, nil},
81 {"commitment", DecodeCommitment, testSeedHex, nil},
82 {"account key, not hex", DecodeAccountPK, "zzzz", ErrBadHex},
83 {"account key, odd length", DecodeAccountPK, "abc", ErrBadHex},
84 {"account key, wrong length", DecodeAccountPK, "abcd", ErrBadAccountPKLen},
85 {"seed, wrong length", DecodeSeed, "abcd", ErrBadSeedLen},
86 {"device key, wrong length", DecodeDevicePK, "abcd", ErrBadDevicePKLen},
87 {"commitment, wrong length", DecodeCommitment, "abcd", ErrBadCommitmentLen},
88 }
89 for _, tc := range cases {
90 got, err := tc.fn(tc.in)
91 if tc.err == nil {
92 uassert.NoError(t, err, tc.name)
93 uassert.Equal(t, 32, len(got), tc.name)
94 continue
95 }
96 uassert.ErrorIs(t, err, tc.err, tc.name)
97 }
98}
99