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
11func TestIdentityCommitLoad(t *testing.T) {
12 mockRepo := repository.NewMockRepoForTest()
13
14 // single version
15
16 identity := Identity{
17 Versions: []*Version{
18 {
19 Name: "René Descartes",
20 Email: "rene.descartes@example.com",
21 },
22 },
23 }
24
25 err := identity.Commit(mockRepo)
26
27 assert.Nil(t, err)
28 assert.NotEmpty(t, identity.id)
29
30 loaded, err := Read(mockRepo, identity.id)
31 assert.Nil(t, err)
32 commitsAreSet(t, loaded)
33 equivalentIdentity(t, &identity, loaded)
34
35 // multiple version
36
37 identity = Identity{
38 Versions: []*Version{
39 {
40 Time: 100,
41 Name: "René Descartes",
42 Email: "rene.descartes@example.com",
43 Keys: []Key{
44 {PubKey: "pubkeyA"},
45 },
46 },
47 {
48 Time: 200,
49 Name: "René Descartes",
50 Email: "rene.descartes@example.com",
51 Keys: []Key{
52 {PubKey: "pubkeyB"},
53 },
54 },
55 {
56 Time: 201,
57 Name: "René Descartes",
58 Email: "rene.descartes@example.com",
59 Keys: []Key{
60 {PubKey: "pubkeyC"},
61 },
62 },
63 },
64 }
65
66 err = identity.Commit(mockRepo)
67
68 assert.Nil(t, err)
69 assert.NotEmpty(t, identity.id)
70
71 loaded, err = Read(mockRepo, identity.id)
72 assert.Nil(t, err)
73 commitsAreSet(t, loaded)
74 equivalentIdentity(t, &identity, loaded)
75
76 // add more version
77
78 identity.AddVersion(&Version{
79 Time: 201,
80 Name: "René Descartes",
81 Email: "rene.descartes@example.com",
82 Keys: []Key{
83 {PubKey: "pubkeyD"},
84 },
85 })
86
87 identity.AddVersion(&Version{
88 Time: 300,
89 Name: "René Descartes",
90 Email: "rene.descartes@example.com",
91 Keys: []Key{
92 {PubKey: "pubkeyE"},
93 },
94 })
95
96 err = identity.Commit(mockRepo)
97
98 assert.Nil(t, err)
99 assert.NotEmpty(t, identity.id)
100
101 loaded, err = Read(mockRepo, identity.id)
102 assert.Nil(t, err)
103 commitsAreSet(t, loaded)
104 equivalentIdentity(t, &identity, loaded)
105}
106
107func commitsAreSet(t *testing.T, identity *Identity) {
108 for _, version := range identity.Versions {
109 assert.NotEmpty(t, version.commitHash)
110 }
111}
112
113func equivalentIdentity(t *testing.T, expected, actual *Identity) {
114 require.Equal(t, len(expected.Versions), len(actual.Versions))
115
116 for i, version := range expected.Versions {
117 actual.Versions[i].commitHash = version.commitHash
118 }
119
120 assert.Equal(t, expected, actual)
121}
122
123func TestIdentity_ValidKeysAtTime(t *testing.T) {
124 identity := Identity{
125 Versions: []*Version{
126 {
127 Time: 100,
128 Name: "René Descartes",
129 Email: "rene.descartes@example.com",
130 Keys: []Key{
131 {PubKey: "pubkeyA"},
132 },
133 },
134 {
135 Time: 200,
136 Name: "René Descartes",
137 Email: "rene.descartes@example.com",
138 Keys: []Key{
139 {PubKey: "pubkeyB"},
140 },
141 },
142 {
143 Time: 201,
144 Name: "René Descartes",
145 Email: "rene.descartes@example.com",
146 Keys: []Key{
147 {PubKey: "pubkeyC"},
148 },
149 },
150 {
151 Time: 201,
152 Name: "René Descartes",
153 Email: "rene.descartes@example.com",
154 Keys: []Key{
155 {PubKey: "pubkeyD"},
156 },
157 },
158 {
159 Time: 300,
160 Name: "René Descartes",
161 Email: "rene.descartes@example.com",
162 Keys: []Key{
163 {PubKey: "pubkeyE"},
164 },
165 },
166 },
167 }
168
169 assert.Nil(t, identity.ValidKeysAtTime(10))
170 assert.Equal(t, identity.ValidKeysAtTime(100), []Key{{PubKey: "pubkeyA"}})
171 assert.Equal(t, identity.ValidKeysAtTime(140), []Key{{PubKey: "pubkeyA"}})
172 assert.Equal(t, identity.ValidKeysAtTime(200), []Key{{PubKey: "pubkeyB"}})
173 assert.Equal(t, identity.ValidKeysAtTime(201), []Key{{PubKey: "pubkeyD"}})
174 assert.Equal(t, identity.ValidKeysAtTime(202), []Key{{PubKey: "pubkeyD"}})
175 assert.Equal(t, identity.ValidKeysAtTime(300), []Key{{PubKey: "pubkeyE"}})
176 assert.Equal(t, identity.ValidKeysAtTime(3000), []Key{{PubKey: "pubkeyE"}})
177}
178
179func TestMetadata(t *testing.T) {
180 mockRepo := repository.NewMockRepoForTest()
181
182 identity := NewIdentity("René Descartes", "rene.descartes@example.com")
183
184 identity.SetMetadata("key1", "value1")
185 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
186 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
187
188 err := identity.Commit(mockRepo)
189 assert.NoError(t, err)
190
191 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
192 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value1")
193
194 // try override
195 identity.AddVersion(&Version{
196 Name: "René Descartes",
197 Email: "rene.descartes@example.com",
198 })
199
200 identity.SetMetadata("key1", "value2")
201 assertHasKeyValue(t, identity.ImmutableMetadata(), "key1", "value1")
202 assertHasKeyValue(t, identity.MutableMetadata(), "key1", "value2")
203
204 err = identity.Commit(mockRepo)
205 assert.NoError(t, err)
206
207 // reload
208 loaded, err := Read(mockRepo, identity.id)
209 assert.Nil(t, err)
210
211 assertHasKeyValue(t, loaded.ImmutableMetadata(), "key1", "value1")
212 assertHasKeyValue(t, loaded.MutableMetadata(), "key1", "value2")
213}
214
215func assertHasKeyValue(t *testing.T, metadata map[string]string, key, value string) {
216 val, ok := metadata[key]
217 assert.True(t, ok)
218 assert.Equal(t, val, value)
219}