1package identity
2
3import (
4 "encoding/json"
5 "testing"
6
7 "github.com/MichaelMure/git-bug/repository"
8 "github.com/stretchr/testify/assert"
9 "github.com/stretchr/testify/require"
10)
11
12// Test the commit and load of an Identity with multiple versions
13func TestIdentityCommitLoad(t *testing.T) {
14 mockRepo := repository.NewMockRepoForTest()
15
16 // single version
17
18 identity := &Identity{
19 Versions: []*Version{
20 {
21 Name: "René Descartes",
22 Email: "rene.descartes@example.com",
23 },
24 },
25 }
26
27 err := identity.Commit(mockRepo)
28
29 assert.Nil(t, err)
30 assert.NotEmpty(t, identity.id)
31
32 loaded, err := Read(mockRepo, identity.id)
33 assert.Nil(t, err)
34 commitsAreSet(t, loaded)
35 equivalentIdentity(t, identity, loaded)
36
37 // multiple version
38
39 identity = &Identity{
40 Versions: []*Version{
41 {
42 Time: 100,
43 Name: "René Descartes",
44 Email: "rene.descartes@example.com",
45 Keys: []Key{
46 {PubKey: "pubkeyA"},
47 },
48 },
49 {
50 Time: 200,
51 Name: "René Descartes",
52 Email: "rene.descartes@example.com",
53 Keys: []Key{
54 {PubKey: "pubkeyB"},
55 },
56 },
57 {
58 Time: 201,
59 Name: "René Descartes",
60 Email: "rene.descartes@example.com",
61 Keys: []Key{
62 {PubKey: "pubkeyC"},
63 },
64 },
65 },
66 }
67
68 err = identity.Commit(mockRepo)
69
70 assert.Nil(t, err)
71 assert.NotEmpty(t, identity.id)
72
73 loaded, err = Read(mockRepo, identity.id)
74 assert.Nil(t, err)
75 commitsAreSet(t, loaded)
76 equivalentIdentity(t, identity, loaded)
77
78 // add more version
79
80 identity.AddVersion(&Version{
81 Time: 201,
82 Name: "René Descartes",
83 Email: "rene.descartes@example.com",
84 Keys: []Key{
85 {PubKey: "pubkeyD"},
86 },
87 })
88
89 identity.AddVersion(&Version{
90 Time: 300,
91 Name: "René Descartes",
92 Email: "rene.descartes@example.com",
93 Keys: []Key{
94 {PubKey: "pubkeyE"},
95 },
96 })
97
98 err = identity.Commit(mockRepo)
99
100 assert.Nil(t, err)
101 assert.NotEmpty(t, identity.id)
102
103 loaded, err = Read(mockRepo, identity.id)
104 assert.Nil(t, err)
105 commitsAreSet(t, loaded)
106 equivalentIdentity(t, identity, loaded)
107}
108
109func commitsAreSet(t *testing.T, identity *Identity) {
110 for _, version := range identity.Versions {
111 assert.NotEmpty(t, version.commitHash)
112 }
113}
114
115func equivalentIdentity(t *testing.T, expected, actual *Identity) {
116 require.Equal(t, len(expected.Versions), len(actual.Versions))
117
118 for i, version := range expected.Versions {
119 actual.Versions[i].commitHash = version.commitHash
120 }
121
122 assert.Equal(t, expected, actual)
123}
124
125// Test that the correct crypto keys are returned for a given lamport time
126func TestIdentity_ValidKeysAtTime(t *testing.T) {
127 identity := Identity{
128 Versions: []*Version{
129 {
130 Time: 100,
131 Name: "René Descartes",
132 Email: "rene.descartes@example.com",
133 Keys: []Key{
134 {PubKey: "pubkeyA"},
135 },
136 },
137 {
138 Time: 200,
139 Name: "René Descartes",
140 Email: "rene.descartes@example.com",
141 Keys: []Key{
142 {PubKey: "pubkeyB"},
143 },
144 },
145 {
146 Time: 201,
147 Name: "René Descartes",
148 Email: "rene.descartes@example.com",
149 Keys: []Key{
150 {PubKey: "pubkeyC"},
151 },
152 },
153 {
154 Time: 201,
155 Name: "René Descartes",
156 Email: "rene.descartes@example.com",
157 Keys: []Key{
158 {PubKey: "pubkeyD"},
159 },
160 },
161 {
162 Time: 300,
163 Name: "René Descartes",
164 Email: "rene.descartes@example.com",
165 Keys: []Key{
166 {PubKey: "pubkeyE"},
167 },
168 },
169 },
170 }
171
172 assert.Nil(t, identity.ValidKeysAtTime(10))
173 assert.Equal(t, identity.ValidKeysAtTime(100), []Key{{PubKey: "pubkeyA"}})
174 assert.Equal(t, identity.ValidKeysAtTime(140), []Key{{PubKey: "pubkeyA"}})
175 assert.Equal(t, identity.ValidKeysAtTime(200), []Key{{PubKey: "pubkeyB"}})
176 assert.Equal(t, identity.ValidKeysAtTime(201), []Key{{PubKey: "pubkeyD"}})
177 assert.Equal(t, identity.ValidKeysAtTime(202), []Key{{PubKey: "pubkeyD"}})
178 assert.Equal(t, identity.ValidKeysAtTime(300), []Key{{PubKey: "pubkeyE"}})
179 assert.Equal(t, identity.ValidKeysAtTime(3000), []Key{{PubKey: "pubkeyE"}})
180}
181
182// Test the immutable or mutable metadata search
183func TestMetadata(t *testing.T) {
184 mockRepo := repository.NewMockRepoForTest()
185
186 identity := NewIdentity("René Descartes", "rene.descartes@example.com")
187
188 identity.SetMetadata("key1", "value1")
189 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
190 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
191
192 err := identity.Commit(mockRepo)
193 assert.NoError(t, err)
194
195 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
196 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
197
198 // try override
199 identity.AddVersion(&Version{
200 Name: "René Descartes",
201 Email: "rene.descartes@example.com",
202 })
203
204 identity.SetMetadata("key1", "value2")
205 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
206 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value2")
207
208 err = identity.Commit(mockRepo)
209 assert.NoError(t, err)
210
211 // reload
212 loaded, err := Read(mockRepo, identity.id)
213 assert.Nil(t, err)
214
215 assertHasKeyValue(t, loaded.ImmutableMetadata(), "key1", "value1")
216 assertHasKeyValue(t, loaded.MutableMetadata(), "key1", "value2")
217}
218
219func assertHasKeyValue(t *testing.T, metadata map[string]string, key, value string) {
220 val, ok := metadata[key]
221 assert.True(t, ok)
222 assert.Equal(t, val, value)
223}
224
225func TestJSON(t *testing.T) {
226 mockRepo := repository.NewMockRepoForTest()
227
228 identity := &Identity{
229 Versions: []*Version{
230 {
231 Name: "René Descartes",
232 Email: "rene.descartes@example.com",
233 },
234 },
235 }
236
237 // commit to make sure we have an ID
238 err := identity.Commit(mockRepo)
239 assert.Nil(t, err)
240 assert.NotEmpty(t, identity.id)
241
242 // serialize
243 data, err := json.Marshal(identity)
244 assert.NoError(t, err)
245
246 // deserialize, got a IdentityStub with the same id
247 var i Interface
248 i, err = UnmarshalJSON(data)
249 assert.NoError(t, err)
250 assert.Equal(t, identity.id, i.Id())
251
252 // make sure we can load the identity properly
253 i, err = Read(mockRepo, i.Id())
254 assert.NoError(t, err)
255}