lk/keys_test.go at master · hyperboloide/lk · GitHub

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
package lk_test

import (
	"github.com/hyperboloide/lk"
)

func (s *Suite) TestKeys() {
	k, err := lk.NewPrivateKey()
	s.Require().NoError(err)

	s.Run("should test private key bytes", func() {
		b, err := k.ToBytes()
		s.Require().NoError(err)
		k1, err := lk.PrivateKeyFromBytes(b)
		s.Require().NoError(err)
		s.Require().Equal(k1, k)

		invalidBytes := s.RandomBytes(42)
		k2, err := lk.PrivateKeyFromBytes(invalidBytes)
		s.Require().Error(err)
		s.Require().Nil(k2)
	})

	s.Run("should test private key bytes", func() {
		b, err := k.ToBytes()
		s.Require().NoError(err)
		k1, err := lk.PrivateKeyFromBytes(b)
		s.Require().NoError(err)
		s.Require().Equal(k1, k)

		invalidBytes := s.RandomBytes(42)
		k2, err := lk.PrivateKeyFromBytes(invalidBytes)
		s.Require().Error(err)
		s.Require().Nil(k2)
	})

	tc := []struct {
		name               string
		privateKeyToString func(k *lk.PrivateKey) (string, error)
		publicKeyToString  func(k *lk.PublicKey) string
		fromString         func(string) (*lk.PrivateKey, error)
		fromPubStr         func(string) (*lk.PublicKey, error)
		randomStr          func(int) string
	}{
		{
			name: "b64",
			privateKeyToString: func(k *lk.PrivateKey) (string, error) {
				return k.ToB64String()
			},
			publicKeyToString: func(k *lk.PublicKey) string {
				return k.ToB64String()
			},
			fromString: lk.PrivateKeyFromB64String,
			fromPubStr: lk.PublicKeyFromB64String,
			randomStr:  s.RandomB64String,
		},
		{
			name: "b32",
			privateKeyToString: func(k *lk.PrivateKey) (string, error) {
				return k.ToB32String()
			},
			publicKeyToString: func(k *lk.PublicKey) string {
				return k.ToB32String()
			},
			fromString: lk.PrivateKeyFromB32String,
			fromPubStr: lk.PublicKeyFromB32String,
			randomStr:  s.RandomB32String,
		},
		{
			name: "hex",
			privateKeyToString: func(k *lk.PrivateKey) (string, error) {
				return k.ToHexString()
			},
			publicKeyToString: func(k *lk.PublicKey) string {
				return k.ToHexString()
			},
			fromString: lk.PrivateKeyFromHexString,
			fromPubStr: lk.PublicKeyFromHexString,
			randomStr:  s.RandomHexString,
		},
	}

	for _, tc := range tc {
		s.Run("should test private key "+tc.name, func() {
			b, err := tc.privateKeyToString(k)
			s.Require().NoError(err)
			k1, err := tc.fromString(b)
			s.Require().NoError(err)
			s.Require().Equal(k1, k)

			invalidStr := tc.randomStr(42)
			k2, err := tc.fromString(invalidStr)
			s.Require().Error(err)
			s.Require().Nil(k2)
		})

		s.Run("should test pubic key "+tc.name, func() {
			b := tc.publicKeyToString(k.GetPublicKey())
			k1, err := tc.fromPubStr(b)
			s.Require().NoError(err)
			s.Require().Equal(k1, k.GetPublicKey())

			invalidStr := s.RandomHexString(42)
			k2, err := tc.fromPubStr(invalidStr)
			s.Require().Error(err)
			s.Require().Nil(k2)
		})
	}

}