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