1package identity
2
3import (
4 "testing"
5
6 "github.com/MichaelMure/git-bug/repository"
7 "github.com/stretchr/testify/assert"
8 "github.com/stretchr/testify/require"
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 := Read(mockRepo, identity.id)
32 assert.Nil(t, err)
33 commitsAreSet(t, loaded)
34 equivalentIdentity(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 = Read(mockRepo, identity.id)
73 assert.Nil(t, err)
74 commitsAreSet(t, loaded)
75 equivalentIdentity(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 = Read(mockRepo, identity.id)
103 assert.Nil(t, err)
104 commitsAreSet(t, loaded)
105 equivalentIdentity(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
114func equivalentIdentity(t *testing.T, expected, actual *Identity) {
115 require.Equal(t, len(expected.Versions), len(actual.Versions))
116
117 for i, version := range expected.Versions {
118 actual.Versions[i].commitHash = version.commitHash
119 }
120
121 assert.Equal(t, expected, actual)
122}
123
124// Test that the correct crypto keys are returned for a given lamport time
125func TestIdentity_ValidKeysAtTime(t *testing.T) {
126 identity := Identity{
127 Versions: []*Version{
128 {
129 Time: 100,
130 Name: "René Descartes",
131 Email: "rene.descartes@example.com",
132 Keys: []Key{
133 {PubKey: "pubkeyA"},
134 },
135 },
136 {
137 Time: 200,
138 Name: "René Descartes",
139 Email: "rene.descartes@example.com",
140 Keys: []Key{
141 {PubKey: "pubkeyB"},
142 },
143 },
144 {
145 Time: 201,
146 Name: "René Descartes",
147 Email: "rene.descartes@example.com",
148 Keys: []Key{
149 {PubKey: "pubkeyC"},
150 },
151 },
152 {
153 Time: 201,
154 Name: "René Descartes",
155 Email: "rene.descartes@example.com",
156 Keys: []Key{
157 {PubKey: "pubkeyD"},
158 },
159 },
160 {
161 Time: 300,
162 Name: "René Descartes",
163 Email: "rene.descartes@example.com",
164 Keys: []Key{
165 {PubKey: "pubkeyE"},
166 },
167 },
168 },
169 }
170
171 assert.Nil(t, identity.ValidKeysAtTime(10))
172 assert.Equal(t, identity.ValidKeysAtTime(100), []Key{{PubKey: "pubkeyA"}})
173 assert.Equal(t, identity.ValidKeysAtTime(140), []Key{{PubKey: "pubkeyA"}})
174 assert.Equal(t, identity.ValidKeysAtTime(200), []Key{{PubKey: "pubkeyB"}})
175 assert.Equal(t, identity.ValidKeysAtTime(201), []Key{{PubKey: "pubkeyD"}})
176 assert.Equal(t, identity.ValidKeysAtTime(202), []Key{{PubKey: "pubkeyD"}})
177 assert.Equal(t, identity.ValidKeysAtTime(300), []Key{{PubKey: "pubkeyE"}})
178 assert.Equal(t, identity.ValidKeysAtTime(3000), []Key{{PubKey: "pubkeyE"}})
179}
180
181// Test the immutable or mutable metadata search
182func TestMetadata(t *testing.T) {
183 mockRepo := repository.NewMockRepoForTest()
184
185 identity := NewIdentity("René Descartes", "rene.descartes@example.com")
186
187 identity.SetMetadata("key1", "value1")
188 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
189 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
190
191 err := identity.Commit(mockRepo)
192 assert.NoError(t, err)
193
194 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
195 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
196
197 // try override
198 identity.AddVersion(&Version{
199 Name: "René Descartes",
200 Email: "rene.descartes@example.com",
201 })
202
203 identity.SetMetadata("key1", "value2")
204 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
205 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value2")
206
207 err = identity.Commit(mockRepo)
208 assert.NoError(t, err)
209
210 // reload
211 loaded, err := Read(mockRepo, identity.id)
212 assert.Nil(t, err)
213
214 assertHasKeyValue(t, loaded.ImmutableMetadata(), "key1", "value1")
215 assertHasKeyValue(t, loaded.MutableMetadata(), "key1", "value2")
216}
217
218func assertHasKeyValue(t *testing.T, metadata map[string]string, key, value string) {
219 val, ok := metadata[key]
220 assert.True(t, ok)
221 assert.Equal(t, val, value)
222}