edit_integration_test.go
1//go:build integration
2
3package main
4
5import (
6 "os/exec"
7 "strings"
8 "testing"
9
10 "github.com/git-bug/git-bug/entities/bug"
11 "github.com/git-bug/git-bug/entity"
12 "github.com/git-bug/git-bug/repository"
13)
14
15// TestEditCommand_EditIssueTitle edits only the issue title
16func TestEditCommand_EditIssueTitle(t *testing.T) {
17 tmpDir := t.TempDir()
18
19 // Initialize a git repo
20 initCmd := exec.Command("git", "init")
21 initCmd.Dir = tmpDir
22 if err := initCmd.Run(); err != nil {
23 t.Fatalf("failed to init git repo: %v", err)
24 }
25
26 // Initialize git-bug identities
27 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
28 t.Fatalf("failed to create identity: %v", err)
29 }
30
31 // Create a bug
32 title := "Original Title"
33 message := "Original description"
34 if err := runNew(tmpDir, title, message, ""); err != nil {
35 t.Fatalf("runNew failed: %v", err)
36 }
37
38 // Get the bug ID
39 repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
40 if err != nil {
41 t.Fatalf("failed to open repo: %v", err)
42 }
43
44 var bugID string
45 for streamedBug := range bug.ReadAll(repo) {
46 if streamedBug.Err != nil {
47 t.Fatalf("failed to read bug: %v", streamedBug.Err)
48 }
49 b := streamedBug.Entity
50 snap := b.Compile()
51 if snap.Title == title {
52 bugID = b.Id().String()
53 break
54 }
55 }
56 repo.Close()
57
58 if bugID == "" {
59 t.Fatal("could not find created bug")
60 }
61
62 // Edit only the title
63 newTitle := "Updated Title"
64 if err := runEdit(tmpDir, bugID, newTitle, "", ""); err != nil {
65 t.Fatalf("runEdit failed: %v", err)
66 }
67
68 // Verify title was updated
69 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
70 if err != nil {
71 t.Fatalf("failed to open repo: %v", err)
72 }
73 defer repo.Close()
74
75 b, err := bug.Read(repo, entity.Id(bugID))
76 if err != nil {
77 t.Fatalf("failed to read bug: %v", err)
78 }
79
80 snap := b.Compile()
81 if snap.Title != newTitle {
82 t.Errorf("title = %q, want %q", snap.Title, newTitle)
83 }
84 // Description should remain unchanged
85 if len(snap.Comments) == 0 || snap.Comments[0].Message != message {
86 t.Errorf("description was changed unexpectedly")
87 }
88}
89
90// TestEditCommand_EditIssueDescription edits only the issue description
91func TestEditCommand_EditIssueDescription(t *testing.T) {
92 tmpDir := t.TempDir()
93
94 // Initialize a git repo
95 initCmd := exec.Command("git", "init")
96 initCmd.Dir = tmpDir
97 if err := initCmd.Run(); err != nil {
98 t.Fatalf("failed to init git repo: %v", err)
99 }
100
101 // Initialize git-bug identities
102 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
103 t.Fatalf("failed to create identity: %v", err)
104 }
105
106 // Create a bug
107 title := "Original Title"
108 message := "Original description"
109 if err := runNew(tmpDir, title, message, ""); err != nil {
110 t.Fatalf("runNew failed: %v", err)
111 }
112
113 // Get the bug ID
114 repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
115 if err != nil {
116 t.Fatalf("failed to open repo: %v", err)
117 }
118
119 var bugID string
120 for streamedBug := range bug.ReadAll(repo) {
121 if streamedBug.Err != nil {
122 t.Fatalf("failed to read bug: %v", streamedBug.Err)
123 }
124 b := streamedBug.Entity
125 snap := b.Compile()
126 if snap.Title == title {
127 bugID = b.Id().String()
128 break
129 }
130 }
131 repo.Close()
132
133 if bugID == "" {
134 t.Fatal("could not find created bug")
135 }
136
137 // Edit only the description
138 newMessage := "Updated description"
139 if err := runEdit(tmpDir, bugID, "", newMessage, ""); err != nil {
140 t.Fatalf("runEdit failed: %v", err)
141 }
142
143 // Verify description was updated
144 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
145 if err != nil {
146 t.Fatalf("failed to open repo: %v", err)
147 }
148 defer repo.Close()
149
150 b, err := bug.Read(repo, entity.Id(bugID))
151 if err != nil {
152 t.Fatalf("failed to read bug: %v", err)
153 }
154
155 snap := b.Compile()
156 // Title should remain unchanged
157 if snap.Title != title {
158 t.Errorf("title was changed unexpectedly")
159 }
160 if len(snap.Comments) == 0 || snap.Comments[0].Message != newMessage {
161 t.Errorf("description = %q, want %q", snap.Comments[0].Message, newMessage)
162 }
163}
164
165// TestEditCommand_EditIssueBoth edits both title and description
166func TestEditCommand_EditIssueBoth(t *testing.T) {
167 tmpDir := t.TempDir()
168
169 // Initialize a git repo
170 initCmd := exec.Command("git", "init")
171 initCmd.Dir = tmpDir
172 if err := initCmd.Run(); err != nil {
173 t.Fatalf("failed to init git repo: %v", err)
174 }
175
176 // Initialize git-bug identities
177 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
178 t.Fatalf("failed to create identity: %v", err)
179 }
180
181 // Create a bug
182 if err := runNew(tmpDir, "Original Title", "Original description", ""); err != nil {
183 t.Fatalf("runNew failed: %v", err)
184 }
185
186 // Get the bug ID
187 repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
188 if err != nil {
189 t.Fatalf("failed to open repo: %v", err)
190 }
191
192 var bugID string
193 for streamedBug := range bug.ReadAll(repo) {
194 if streamedBug.Err != nil {
195 t.Fatalf("failed to read bug: %v", streamedBug.Err)
196 }
197 b := streamedBug.Entity
198 snap := b.Compile()
199 if snap.Title == "Original Title" {
200 bugID = b.Id().String()
201 break
202 }
203 }
204 repo.Close()
205
206 // Edit both title and description
207 newTitle := "Updated Title"
208 newMessage := "Updated description"
209 if err := runEdit(tmpDir, bugID, newTitle, newMessage, ""); err != nil {
210 t.Fatalf("runEdit failed: %v", err)
211 }
212
213 // Verify both were updated
214 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
215 if err != nil {
216 t.Fatalf("failed to open repo: %v", err)
217 }
218 defer repo.Close()
219
220 b, err := bug.Read(repo, entity.Id(bugID))
221 if err != nil {
222 t.Fatalf("failed to read bug: %v", err)
223 }
224
225 snap := b.Compile()
226 if snap.Title != newTitle {
227 t.Errorf("title = %q, want %q", snap.Title, newTitle)
228 }
229 if len(snap.Comments) == 0 || snap.Comments[0].Message != newMessage {
230 t.Errorf("description = %q, want %q", snap.Comments[0].Message, newMessage)
231 }
232}
233
234// TestEditCommand_EditComment edits a comment
235func TestEditCommand_EditComment(t *testing.T) {
236 tmpDir := t.TempDir()
237
238 // Initialize a git repo
239 initCmd := exec.Command("git", "init")
240 initCmd.Dir = tmpDir
241 if err := initCmd.Run(); err != nil {
242 t.Fatalf("failed to init git repo: %v", err)
243 }
244
245 // Initialize git-bug identities
246 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
247 t.Fatalf("failed to create identity: %v", err)
248 }
249
250 // Create a bug
251 if err := runNew(tmpDir, "Test Bug", "Description", ""); err != nil {
252 t.Fatalf("runNew failed: %v", err)
253 }
254
255 // Get the bug ID
256 repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
257 if err != nil {
258 t.Fatalf("failed to open repo: %v", err)
259 }
260
261 var bugID string
262 for streamedBug := range bug.ReadAll(repo) {
263 if streamedBug.Err != nil {
264 t.Fatalf("failed to read bug: %v", streamedBug.Err)
265 }
266 b := streamedBug.Entity
267 snap := b.Compile()
268 if snap.Title == "Test Bug" {
269 bugID = b.Id().String()
270 break
271 }
272 }
273 repo.Close()
274
275 // Add a comment
276 originalComment := "Original comment text"
277 if err := runComment(tmpDir, bugID, originalComment); err != nil {
278 t.Fatalf("runComment failed: %v", err)
279 }
280
281 // Get the comment ID
282 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
283 if err != nil {
284 t.Fatalf("failed to open repo: %v", err)
285 }
286
287 b, err := bug.Read(repo, entity.Id(bugID))
288 if err != nil {
289 t.Fatalf("failed to read bug: %v", err)
290 }
291 snap := b.Compile()
292 if len(snap.Comments) < 2 {
293 t.Fatal("expected at least 2 comments")
294 }
295 commentID := snap.Comments[1].CombinedId().String()
296 repo.Close()
297
298 // Edit the comment
299 newComment := "Updated comment text"
300 if err := runEdit(tmpDir, commentID, "", newComment, ""); err != nil {
301 t.Fatalf("runEdit failed: %v", err)
302 }
303
304 // Verify comment was updated
305 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
306 if err != nil {
307 t.Fatalf("failed to open repo: %v", err)
308 }
309 defer repo.Close()
310
311 b, err = bug.Read(repo, entity.Id(bugID))
312 if err != nil {
313 t.Fatalf("failed to read bug: %v", err)
314 }
315
316 snap = b.Compile()
317 if len(snap.Comments) < 2 {
318 t.Fatal("expected at least 2 comments")
319 }
320 if snap.Comments[1].Message != newComment {
321 t.Errorf("comment = %q, want %q", snap.Comments[1].Message, newComment)
322 }
323}
324
325// TestEditCommand_InvalidID tests error for invalid ID
326func TestEditCommand_InvalidID(t *testing.T) {
327 tmpDir := t.TempDir()
328
329 // Initialize a git repo
330 initCmd := exec.Command("git", "init")
331 initCmd.Dir = tmpDir
332 if err := initCmd.Run(); err != nil {
333 t.Fatalf("failed to init git repo: %v", err)
334 }
335
336 // Initialize git-bug identities
337 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
338 t.Fatalf("failed to create identity: %v", err)
339 }
340
341 // Try to edit non-existent ID
342 err := runEdit(tmpDir, "nonexistent123", "Title", "Message", "")
343 if err == nil {
344 t.Error("expected error for invalid ID, got nil")
345 }
346
347 if !strings.Contains(err.Error(), "failed to resolve ID") {
348 t.Errorf("expected 'failed to resolve ID' error, got: %v", err)
349 }
350}
351
352// TestEditCommand_WithShortID tests editing using a short ID
353func TestEditCommand_WithShortID(t *testing.T) {
354 tmpDir := t.TempDir()
355
356 // Initialize a git repo
357 initCmd := exec.Command("git", "init")
358 initCmd.Dir = tmpDir
359 if err := initCmd.Run(); err != nil {
360 t.Fatalf("failed to init git repo: %v", err)
361 }
362
363 // Initialize git-bug identities
364 if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
365 t.Fatalf("failed to create identity: %v", err)
366 }
367
368 // Create a bug
369 if err := runNew(tmpDir, "Original Title", "Original description", ""); err != nil {
370 t.Fatalf("runNew failed: %v", err)
371 }
372
373 // Get the bug ID and short ID
374 repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
375 if err != nil {
376 t.Fatalf("failed to open repo: %v", err)
377 }
378
379 var bugID, shortID string
380 for streamedBug := range bug.ReadAll(repo) {
381 if streamedBug.Err != nil {
382 t.Fatalf("failed to read bug: %v", streamedBug.Err)
383 }
384 b := streamedBug.Entity
385 snap := b.Compile()
386 if snap.Title == "Original Title" {
387 bugID = b.Id().String()
388 if len(bugID) > 7 {
389 shortID = bugID[:7]
390 } else {
391 shortID = bugID
392 }
393 break
394 }
395 }
396 repo.Close()
397
398 if shortID == "" {
399 t.Fatal("could not find created bug")
400 }
401
402 // Edit using short ID
403 newTitle := "Updated Title"
404 if err := runEdit(tmpDir, shortID, newTitle, "", ""); err != nil {
405 t.Fatalf("runEdit with short ID failed: %v", err)
406 }
407
408 // Verify title was updated
409 repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
410 if err != nil {
411 t.Fatalf("failed to open repo: %v", err)
412 }
413 defer repo.Close()
414
415 b, err := bug.Read(repo, entity.Id(bugID))
416 if err != nil {
417 t.Fatalf("failed to read bug: %v", err)
418 }
419
420 snap := b.Compile()
421 if snap.Title != newTitle {
422 t.Errorf("title = %q, want %q", snap.Title, newTitle)
423 }
424}
