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