1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44 package org.eclipse.jgit.internal.storage.file;
45
46 import static org.eclipse.jgit.lib.Constants.HEAD;
47 import static org.eclipse.jgit.lib.Constants.R_HEADS;
48 import static org.eclipse.jgit.lib.Constants.R_TAGS;
49 import static org.eclipse.jgit.lib.Ref.Storage.LOOSE;
50 import static org.eclipse.jgit.lib.Ref.Storage.NEW;
51 import static org.junit.Assert.assertEquals;
52 import static org.junit.Assert.assertFalse;
53 import static org.junit.Assert.assertNotNull;
54 import static org.junit.Assert.assertNotSame;
55 import static org.junit.Assert.assertNull;
56 import static org.junit.Assert.assertSame;
57 import static org.junit.Assert.assertTrue;
58 import static org.junit.Assert.fail;
59
60 import java.io.File;
61 import java.io.IOException;
62 import java.util.ArrayList;
63 import java.util.Arrays;
64 import java.util.List;
65 import java.util.Map;
66 import java.util.concurrent.atomic.AtomicInteger;
67 import java.util.concurrent.atomic.AtomicReference;
68
69 import org.eclipse.jgit.events.ListenerHandle;
70 import org.eclipse.jgit.events.RefsChangedEvent;
71 import org.eclipse.jgit.events.RefsChangedListener;
72 import org.eclipse.jgit.junit.LocalDiskRepositoryTestCase;
73 import org.eclipse.jgit.junit.TestRepository;
74 import org.eclipse.jgit.lib.AnyObjectId;
75 import org.eclipse.jgit.lib.BatchRefUpdate;
76 import org.eclipse.jgit.lib.ProgressMonitor;
77 import org.eclipse.jgit.lib.NullProgressMonitor;
78 import org.eclipse.jgit.lib.Ref;
79 import org.eclipse.jgit.lib.Ref.Storage;
80 import org.eclipse.jgit.lib.RefDatabase;
81 import org.eclipse.jgit.lib.Repository;
82 import org.eclipse.jgit.revwalk.RevCommit;
83 import org.eclipse.jgit.revwalk.RevTag;
84 import org.eclipse.jgit.revwalk.RevWalk;
85 import org.eclipse.jgit.transport.ReceiveCommand;
86 import org.eclipse.jgit.transport.ReceiveCommand.Type;
87 import org.junit.Before;
88 import org.junit.Test;
89
90 public class RefDirectoryTest extends LocalDiskRepositoryTestCase {
91 private Repository diskRepo;
92
93 private TestRepository<Repository> repo;
94
95 private RefDirectory refdir;
96
97 private RevCommit A;
98
99 private RevCommit B;
100
101 private RevTag v1_0;
102
103 @Before
104 public void setUp() throws Exception {
105 super.setUp();
106
107 diskRepo = createBareRepository();
108 refdir = (RefDirectory) diskRepo.getRefDatabase();
109
110 repo = new TestRepository<Repository>(diskRepo);
111 A = repo.commit().create();
112 B = repo.commit(repo.getRevWalk().parseCommit(A));
113 v1_0 = repo.tag("v1_0", B);
114 repo.getRevWalk().parseBody(v1_0);
115 }
116
117 @Test
118 public void testCreate() throws IOException {
119
120 File d = diskRepo.getDirectory();
121 assertSame(diskRepo, refdir.getRepository());
122
123 assertTrue(new File(d, "refs").isDirectory());
124 assertTrue(new File(d, "logs").isDirectory());
125 assertTrue(new File(d, "logs/refs").isDirectory());
126 assertFalse(new File(d, "packed-refs").exists());
127
128 assertTrue(new File(d, "refs/heads").isDirectory());
129 assertTrue(new File(d, "refs/tags").isDirectory());
130 assertEquals(2, new File(d, "refs").list().length);
131 assertEquals(0, new File(d, "refs/heads").list().length);
132 assertEquals(0, new File(d, "refs/tags").list().length);
133
134 assertTrue(new File(d, "logs/refs/heads").isDirectory());
135 assertFalse(new File(d, "logs/HEAD").exists());
136 assertEquals(0, new File(d, "logs/refs/heads").list().length);
137
138 assertEquals("ref: refs/heads/master\n", read(new File(d, HEAD)));
139 }
140
141 @Test
142 public void testGetRefs_EmptyDatabase() throws IOException {
143 Map<String, Ref> all;
144
145 all = refdir.getRefs(RefDatabase.ALL);
146 assertTrue("no references", all.isEmpty());
147
148 all = refdir.getRefs(R_HEADS);
149 assertTrue("no references", all.isEmpty());
150
151 all = refdir.getRefs(R_TAGS);
152 assertTrue("no references", all.isEmpty());
153 }
154
155 @Test
156 public void testGetRefs_HeadOnOneBranch() throws IOException {
157 Map<String, Ref> all;
158 Ref head, master;
159
160 writeLooseRef("refs/heads/master", A);
161
162 all = refdir.getRefs(RefDatabase.ALL);
163 assertEquals(2, all.size());
164 assertTrue("has HEAD", all.containsKey(HEAD));
165 assertTrue("has master", all.containsKey("refs/heads/master"));
166
167 head = all.get(HEAD);
168 master = all.get("refs/heads/master");
169
170 assertEquals(HEAD, head.getName());
171 assertTrue(head.isSymbolic());
172 assertSame(LOOSE, head.getStorage());
173 assertSame("uses same ref as target", master, head.getTarget());
174
175 assertEquals("refs/heads/master", master.getName());
176 assertFalse(master.isSymbolic());
177 assertSame(LOOSE, master.getStorage());
178 assertEquals(A, master.getObjectId());
179 }
180
181 @Test
182 public void testGetRefs_DeatchedHead1() throws IOException {
183 Map<String, Ref> all;
184 Ref head;
185
186 writeLooseRef(HEAD, A);
187
188 all = refdir.getRefs(RefDatabase.ALL);
189 assertEquals(1, all.size());
190 assertTrue("has HEAD", all.containsKey(HEAD));
191
192 head = all.get(HEAD);
193
194 assertEquals(HEAD, head.getName());
195 assertFalse(head.isSymbolic());
196 assertSame(LOOSE, head.getStorage());
197 assertEquals(A, head.getObjectId());
198 }
199
200 @Test
201 public void testGetRefs_DeatchedHead2() throws IOException {
202 Map<String, Ref> all;
203 Ref head, master;
204
205 writeLooseRef(HEAD, A);
206 writeLooseRef("refs/heads/master", B);
207
208 all = refdir.getRefs(RefDatabase.ALL);
209 assertEquals(2, all.size());
210
211 head = all.get(HEAD);
212 master = all.get("refs/heads/master");
213
214 assertEquals(HEAD, head.getName());
215 assertFalse(head.isSymbolic());
216 assertSame(LOOSE, head.getStorage());
217 assertEquals(A, head.getObjectId());
218
219 assertEquals("refs/heads/master", master.getName());
220 assertFalse(master.isSymbolic());
221 assertSame(LOOSE, master.getStorage());
222 assertEquals(B, master.getObjectId());
223 }
224
225 @Test
226 public void testGetRefs_DeeplyNestedBranch() throws IOException {
227 String name = "refs/heads/a/b/c/d/e/f/g/h/i/j/k";
228 Map<String, Ref> all;
229 Ref r;
230
231 writeLooseRef(name, A);
232
233 all = refdir.getRefs(RefDatabase.ALL);
234 assertEquals(1, all.size());
235
236 r = all.get(name);
237 assertEquals(name, r.getName());
238 assertFalse(r.isSymbolic());
239 assertSame(LOOSE, r.getStorage());
240 assertEquals(A, r.getObjectId());
241 }
242
243 @Test
244 public void testGetRefs_HeadBranchNotBorn() throws IOException {
245 Map<String, Ref> all;
246 Ref a, b;
247
248 writeLooseRef("refs/heads/A", A);
249 writeLooseRef("refs/heads/B", B);
250
251 all = refdir.getRefs(RefDatabase.ALL);
252 assertEquals(2, all.size());
253 assertFalse("no HEAD", all.containsKey(HEAD));
254
255 a = all.get("refs/heads/A");
256 b = all.get("refs/heads/B");
257
258 assertEquals(A, a.getObjectId());
259 assertEquals(B, b.getObjectId());
260
261 assertEquals("refs/heads/A", a.getName());
262 assertEquals("refs/heads/B", b.getName());
263 }
264
265 @Test
266 public void testGetRefs_LooseOverridesPacked() throws IOException {
267 Map<String, Ref> heads;
268 Ref a;
269
270 writeLooseRef("refs/heads/master", B);
271 writePackedRef("refs/heads/master", A);
272
273 heads = refdir.getRefs(R_HEADS);
274 assertEquals(1, heads.size());
275
276 a = heads.get("master");
277 assertEquals("refs/heads/master", a.getName());
278 assertEquals(B, a.getObjectId());
279 }
280
281 @Test
282 public void testGetRefs_IgnoresGarbageRef1() throws IOException {
283 Map<String, Ref> heads;
284 Ref a;
285
286 writeLooseRef("refs/heads/A", A);
287 write(new File(diskRepo.getDirectory(), "refs/heads/bad"), "FAIL\n");
288
289 heads = refdir.getRefs(RefDatabase.ALL);
290 assertEquals(1, heads.size());
291
292 a = heads.get("refs/heads/A");
293 assertEquals("refs/heads/A", a.getName());
294 assertEquals(A, a.getObjectId());
295 }
296
297 @Test
298 public void testGetRefs_IgnoresGarbageRef2() throws IOException {
299 Map<String, Ref> heads;
300 Ref a;
301
302 writeLooseRef("refs/heads/A", A);
303 write(new File(diskRepo.getDirectory(), "refs/heads/bad"), "");
304
305 heads = refdir.getRefs(RefDatabase.ALL);
306 assertEquals(1, heads.size());
307
308 a = heads.get("refs/heads/A");
309 assertEquals("refs/heads/A", a.getName());
310 assertEquals(A, a.getObjectId());
311 }
312
313 @Test
314 public void testGetRefs_IgnoresGarbageRef3() throws IOException {
315 Map<String, Ref> heads;
316 Ref a;
317
318 writeLooseRef("refs/heads/A", A);
319 write(new File(diskRepo.getDirectory(), "refs/heads/bad"), "\n");
320
321 heads = refdir.getRefs(RefDatabase.ALL);
322 assertEquals(1, heads.size());
323
324 a = heads.get("refs/heads/A");
325 assertEquals("refs/heads/A", a.getName());
326 assertEquals(A, a.getObjectId());
327 }
328
329 @Test
330 public void testGetRefs_IgnoresGarbageRef4() throws IOException {
331 Map<String, Ref> heads;
332 Ref a, b, c;
333
334 writeLooseRef("refs/heads/A", A);
335 writeLooseRef("refs/heads/B", B);
336 writeLooseRef("refs/heads/C", A);
337 heads = refdir.getRefs(RefDatabase.ALL);
338 assertEquals(3, heads.size());
339 assertTrue(heads.containsKey("refs/heads/A"));
340 assertTrue(heads.containsKey("refs/heads/B"));
341 assertTrue(heads.containsKey("refs/heads/C"));
342
343 writeLooseRef("refs/heads/B", "FAIL\n");
344
345 heads = refdir.getRefs(RefDatabase.ALL);
346 assertEquals(2, heads.size());
347
348 a = heads.get("refs/heads/A");
349 b = heads.get("refs/heads/B");
350 c = heads.get("refs/heads/C");
351
352 assertEquals("refs/heads/A", a.getName());
353 assertEquals(A, a.getObjectId());
354
355 assertNull("no refs/heads/B", b);
356
357 assertEquals("refs/heads/C", c.getName());
358 assertEquals(A, c.getObjectId());
359 }
360
361 @Test
362 public void testFirstExactRef_IgnoresGarbageRef() throws IOException {
363 writeLooseRef("refs/heads/A", A);
364 write(new File(diskRepo.getDirectory(), "refs/heads/bad"), "FAIL\n");
365
366 Ref a = refdir.firstExactRef("refs/heads/bad", "refs/heads/A");
367 assertEquals("refs/heads/A", a.getName());
368 assertEquals(A, a.getObjectId());
369 }
370
371 @Test
372 public void testExactRef_IgnoresGarbageRef() throws IOException {
373 writeLooseRef("refs/heads/A", A);
374 write(new File(diskRepo.getDirectory(), "refs/heads/bad"), "FAIL\n");
375
376 Map<String, Ref> refs =
377 refdir.exactRef("refs/heads/bad", "refs/heads/A");
378
379 assertNull("no refs/heads/bad", refs.get("refs/heads/bad"));
380
381 Ref a = refs.get("refs/heads/A");
382 assertEquals("refs/heads/A", a.getName());
383 assertEquals(A, a.getObjectId());
384
385 assertEquals(1, refs.size());
386 }
387
388 @Test
389 public void testGetRefs_InvalidName() throws IOException {
390 writeLooseRef("refs/heads/A", A);
391
392 assertTrue("empty refs/heads", refdir.getRefs("refs/heads").isEmpty());
393 assertTrue("empty objects", refdir.getRefs("objects").isEmpty());
394 assertTrue("empty objects/", refdir.getRefs("objects/").isEmpty());
395 }
396
397 @Test
398 public void testReadNotExistingBranchConfig() throws IOException {
399 assertNull("find branch config", refdir.getRef("config"));
400 assertNull("find branch config", refdir.getRef("refs/heads/config"));
401 }
402
403 @Test
404 public void testReadBranchConfig() throws IOException {
405 writeLooseRef("refs/heads/config", A);
406
407 assertNotNull("find branch config", refdir.getRef("config"));
408 }
409
410 @Test
411 public void testGetRefs_HeadsOnly_AllLoose() throws IOException {
412 Map<String, Ref> heads;
413 Ref a, b;
414
415 writeLooseRef("refs/heads/A", A);
416 writeLooseRef("refs/heads/B", B);
417 writeLooseRef("refs/tags/v1.0", v1_0);
418
419 heads = refdir.getRefs(R_HEADS);
420 assertEquals(2, heads.size());
421
422 a = heads.get("A");
423 b = heads.get("B");
424
425 assertEquals("refs/heads/A", a.getName());
426 assertEquals("refs/heads/B", b.getName());
427
428 assertEquals(A, a.getObjectId());
429 assertEquals(B, b.getObjectId());
430 }
431
432 @Test
433 public void testGetRefs_HeadsOnly_AllPacked1() throws IOException {
434 Map<String, Ref> heads;
435 Ref a;
436
437 deleteLooseRef(HEAD);
438 writePackedRef("refs/heads/A", A);
439
440 heads = refdir.getRefs(R_HEADS);
441 assertEquals(1, heads.size());
442
443 a = heads.get("A");
444
445 assertEquals("refs/heads/A", a.getName());
446 assertEquals(A, a.getObjectId());
447 }
448
449 @Test
450 public void testGetRefs_HeadsOnly_SymrefToPacked() throws IOException {
451 Map<String, Ref> heads;
452 Ref master, other;
453
454 writeLooseRef("refs/heads/other", "ref: refs/heads/master\n");
455 writePackedRef("refs/heads/master", A);
456
457 heads = refdir.getRefs(R_HEADS);
458 assertEquals(2, heads.size());
459
460 master = heads.get("master");
461 other = heads.get("other");
462
463 assertEquals("refs/heads/master", master.getName());
464 assertEquals(A, master.getObjectId());
465
466 assertEquals("refs/heads/other", other.getName());
467 assertEquals(A, other.getObjectId());
468 assertSame(master, other.getTarget());
469 }
470
471 @Test
472 public void testGetRefs_HeadsOnly_Mixed() throws IOException {
473 Map<String, Ref> heads;
474 Ref a, b;
475
476 writeLooseRef("refs/heads/A", A);
477 writeLooseRef("refs/heads/B", B);
478 writePackedRef("refs/tags/v1.0", v1_0);
479
480 heads = refdir.getRefs(R_HEADS);
481 assertEquals(2, heads.size());
482
483 a = heads.get("A");
484 b = heads.get("B");
485
486 assertEquals("refs/heads/A", a.getName());
487 assertEquals("refs/heads/B", b.getName());
488
489 assertEquals(A, a.getObjectId());
490 assertEquals(B, b.getObjectId());
491 }
492
493 @Test
494 public void testFirstExactRef_Mixed() throws IOException {
495 writeLooseRef("refs/heads/A", A);
496 writePackedRef("refs/tags/v1.0", v1_0);
497
498 Ref a = refdir.firstExactRef("refs/heads/A", "refs/tags/v1.0");
499 Ref one = refdir.firstExactRef("refs/tags/v1.0", "refs/heads/A");
500
501 assertEquals("refs/heads/A", a.getName());
502 assertEquals("refs/tags/v1.0", one.getName());
503
504 assertEquals(A, a.getObjectId());
505 assertEquals(v1_0, one.getObjectId());
506 }
507
508 @Test
509 public void testGetRefs_TagsOnly_AllLoose() throws IOException {
510 Map<String, Ref> tags;
511 Ref a;
512
513 writeLooseRef("refs/heads/A", A);
514 writeLooseRef("refs/tags/v1.0", v1_0);
515
516 tags = refdir.getRefs(R_TAGS);
517 assertEquals(1, tags.size());
518
519 a = tags.get("v1.0");
520
521 assertEquals("refs/tags/v1.0", a.getName());
522 assertEquals(v1_0, a.getObjectId());
523 }
524
525 @Test
526 public void testGetRefs_LooseSortedCorrectly() throws IOException {
527 Map<String, Ref> refs;
528
529 writeLooseRef("refs/heads/project1/A", A);
530 writeLooseRef("refs/heads/project1-B", B);
531
532 refs = refdir.getRefs(RefDatabase.ALL);
533 assertEquals(2, refs.size());
534 assertEquals(A, refs.get("refs/heads/project1/A").getObjectId());
535 assertEquals(B, refs.get("refs/heads/project1-B").getObjectId());
536 }
537
538 @Test
539 public void testGetRefs_LooseSorting_Bug_348834() throws IOException {
540 Map<String, Ref> refs;
541
542 writeLooseRef("refs/heads/my/a+b", A);
543 writeLooseRef("refs/heads/my/a/b/c", B);
544
545 final int[] count = new int[1];
546
547 ListenerHandle listener = Repository.getGlobalListenerList()
548 .addRefsChangedListener(new RefsChangedListener() {
549
550 public void onRefsChanged(RefsChangedEvent event) {
551 count[0]++;
552 }
553 });
554
555 refs = refdir.getRefs(RefDatabase.ALL);
556 refs = refdir.getRefs(RefDatabase.ALL);
557 listener.remove();
558 assertEquals(1, count[0]);
559 assertEquals(2, refs.size());
560 assertEquals(A, refs.get("refs/heads/my/a+b").getObjectId());
561 assertEquals(B, refs.get("refs/heads/my/a/b/c").getObjectId());
562
563 }
564
565 @Test
566 public void testGetRefs_TagsOnly_AllPacked() throws IOException {
567 Map<String, Ref> tags;
568 Ref a;
569
570 deleteLooseRef(HEAD);
571 writePackedRef("refs/tags/v1.0", v1_0);
572
573 tags = refdir.getRefs(R_TAGS);
574 assertEquals(1, tags.size());
575
576 a = tags.get("v1.0");
577
578 assertEquals("refs/tags/v1.0", a.getName());
579 assertEquals(v1_0, a.getObjectId());
580 }
581
582 @Test
583 public void testGetRefs_DiscoversNewLoose1() throws IOException {
584 Map<String, Ref> orig, next;
585 Ref orig_r, next_r;
586
587 writeLooseRef("refs/heads/master", A);
588 orig = refdir.getRefs(RefDatabase.ALL);
589
590 writeLooseRef("refs/heads/next", B);
591 next = refdir.getRefs(RefDatabase.ALL);
592
593 assertEquals(2, orig.size());
594 assertEquals(3, next.size());
595
596 assertFalse(orig.containsKey("refs/heads/next"));
597 assertTrue(next.containsKey("refs/heads/next"));
598
599 orig_r = orig.get("refs/heads/master");
600 next_r = next.get("refs/heads/master");
601 assertEquals(A, orig_r.getObjectId());
602 assertSame("uses cached instance", orig_r, next_r);
603 assertSame("same HEAD", orig_r, orig.get(HEAD).getTarget());
604 assertSame("same HEAD", orig_r, next.get(HEAD).getTarget());
605
606 next_r = next.get("refs/heads/next");
607 assertSame(LOOSE, next_r.getStorage());
608 assertEquals(B, next_r.getObjectId());
609 }
610
611 @Test
612 public void testGetRefs_DiscoversNewLoose2() throws IOException {
613 Map<String, Ref> orig, next, news;
614
615 writeLooseRef("refs/heads/pu", A);
616 orig = refdir.getRefs(RefDatabase.ALL);
617
618 writeLooseRef("refs/heads/new/B", B);
619 news = refdir.getRefs("refs/heads/new/");
620 next = refdir.getRefs(RefDatabase.ALL);
621
622 assertEquals(1, orig.size());
623 assertEquals(2, next.size());
624 assertEquals(1, news.size());
625
626 assertTrue(orig.containsKey("refs/heads/pu"));
627 assertTrue(next.containsKey("refs/heads/pu"));
628 assertFalse(news.containsKey("refs/heads/pu"));
629
630 assertFalse(orig.containsKey("refs/heads/new/B"));
631 assertTrue(next.containsKey("refs/heads/new/B"));
632 assertTrue(news.containsKey("B"));
633 }
634
635 @Test
636 public void testGetRefs_DiscoversModifiedLoose() throws IOException {
637 Map<String, Ref> all;
638
639 writeLooseRef("refs/heads/master", A);
640 all = refdir.getRefs(RefDatabase.ALL);
641 assertEquals(A, all.get(HEAD).getObjectId());
642
643 writeLooseRef("refs/heads/master", B);
644 all = refdir.getRefs(RefDatabase.ALL);
645 assertEquals(B, all.get(HEAD).getObjectId());
646 }
647
648 @Test
649 public void testGetRef_DiscoversModifiedLoose() throws IOException {
650 Map<String, Ref> all;
651
652 writeLooseRef("refs/heads/master", A);
653 all = refdir.getRefs(RefDatabase.ALL);
654 assertEquals(A, all.get(HEAD).getObjectId());
655
656 writeLooseRef("refs/heads/master", B);
657
658 Ref master = refdir.getRef("refs/heads/master");
659 assertEquals(B, master.getObjectId());
660 }
661
662 @Test
663 public void testGetRefs_DiscoversDeletedLoose1() throws IOException {
664 Map<String, Ref> orig, next;
665 Ref orig_r, next_r;
666
667 writeLooseRef("refs/heads/B", B);
668 writeLooseRef("refs/heads/master", A);
669 orig = refdir.getRefs(RefDatabase.ALL);
670
671 deleteLooseRef("refs/heads/B");
672 next = refdir.getRefs(RefDatabase.ALL);
673
674 assertEquals(3, orig.size());
675 assertEquals(2, next.size());
676
677 assertTrue(orig.containsKey("refs/heads/B"));
678 assertFalse(next.containsKey("refs/heads/B"));
679
680 orig_r = orig.get("refs/heads/master");
681 next_r = next.get("refs/heads/master");
682 assertEquals(A, orig_r.getObjectId());
683 assertSame("uses cached instance", orig_r, next_r);
684 assertSame("same HEAD", orig_r, orig.get(HEAD).getTarget());
685 assertSame("same HEAD", orig_r, next.get(HEAD).getTarget());
686
687 orig_r = orig.get("refs/heads/B");
688 assertSame(LOOSE, orig_r.getStorage());
689 assertEquals(B, orig_r.getObjectId());
690 }
691
692 @Test
693 public void testGetRef_DiscoversDeletedLoose() throws IOException {
694 Map<String, Ref> all;
695
696 writeLooseRef("refs/heads/master", A);
697 all = refdir.getRefs(RefDatabase.ALL);
698 assertEquals(A, all.get(HEAD).getObjectId());
699
700 deleteLooseRef("refs/heads/master");
701 assertNull(refdir.getRef("refs/heads/master"));
702 assertTrue(refdir.getRefs(RefDatabase.ALL).isEmpty());
703 }
704
705 @Test
706 public void testGetRefs_DiscoversDeletedLoose2() throws IOException {
707 Map<String, Ref> orig, next;
708
709 writeLooseRef("refs/heads/master", A);
710 writeLooseRef("refs/heads/pu", B);
711 orig = refdir.getRefs(RefDatabase.ALL);
712
713 deleteLooseRef("refs/heads/pu");
714 next = refdir.getRefs(RefDatabase.ALL);
715
716 assertEquals(3, orig.size());
717 assertEquals(2, next.size());
718
719 assertTrue(orig.containsKey("refs/heads/pu"));
720 assertFalse(next.containsKey("refs/heads/pu"));
721 }
722
723 @Test
724 public void testGetRefs_DiscoversDeletedLoose3() throws IOException {
725 Map<String, Ref> orig, next;
726
727 writeLooseRef("refs/heads/master", A);
728 writeLooseRef("refs/heads/next", B);
729 writeLooseRef("refs/heads/pu", B);
730 writeLooseRef("refs/tags/v1.0", v1_0);
731 orig = refdir.getRefs(RefDatabase.ALL);
732
733 deleteLooseRef("refs/heads/pu");
734 deleteLooseRef("refs/heads/next");
735 next = refdir.getRefs(RefDatabase.ALL);
736
737 assertEquals(5, orig.size());
738 assertEquals(3, next.size());
739
740 assertTrue(orig.containsKey("refs/heads/pu"));
741 assertTrue(orig.containsKey("refs/heads/next"));
742 assertFalse(next.containsKey("refs/heads/pu"));
743 assertFalse(next.containsKey("refs/heads/next"));
744 }
745
746 @Test
747 public void testGetRefs_DiscoversDeletedLoose4() throws IOException {
748 Map<String, Ref> orig, next;
749 Ref orig_r, next_r;
750
751 writeLooseRef("refs/heads/B", B);
752 writeLooseRef("refs/heads/master", A);
753 orig = refdir.getRefs(RefDatabase.ALL);
754
755 deleteLooseRef("refs/heads/master");
756 next = refdir.getRefs("refs/heads/");
757
758 assertEquals(3, orig.size());
759 assertEquals(1, next.size());
760
761 assertTrue(orig.containsKey("refs/heads/B"));
762 assertTrue(orig.containsKey("refs/heads/master"));
763 assertTrue(next.containsKey("B"));
764 assertFalse(next.containsKey("master"));
765
766 orig_r = orig.get("refs/heads/B");
767 next_r = next.get("B");
768 assertEquals(B, orig_r.getObjectId());
769 assertSame("uses cached instance", orig_r, next_r);
770 }
771
772 @Test
773 public void testGetRefs_DiscoversDeletedLoose5() throws IOException {
774 Map<String, Ref> orig, next;
775
776 writeLooseRef("refs/heads/master", A);
777 writeLooseRef("refs/heads/pu", B);
778 orig = refdir.getRefs(RefDatabase.ALL);
779
780 deleteLooseRef("refs/heads/pu");
781 writeLooseRef("refs/tags/v1.0", v1_0);
782 next = refdir.getRefs(RefDatabase.ALL);
783
784 assertEquals(3, orig.size());
785 assertEquals(3, next.size());
786
787 assertTrue(orig.containsKey("refs/heads/pu"));
788 assertFalse(orig.containsKey("refs/tags/v1.0"));
789 assertFalse(next.containsKey("refs/heads/pu"));
790 assertTrue(next.containsKey("refs/tags/v1.0"));
791 }
792
793 @Test
794 public void testGetRefs_SkipsLockFiles() throws IOException {
795 Map<String, Ref> all;
796
797 writeLooseRef("refs/heads/master", A);
798 writeLooseRef("refs/heads/pu.lock", B);
799 all = refdir.getRefs(RefDatabase.ALL);
800
801 assertEquals(2, all.size());
802
803 assertTrue(all.containsKey(HEAD));
804 assertTrue(all.containsKey("refs/heads/master"));
805 assertFalse(all.containsKey("refs/heads/pu.lock"));
806 }
807
808 @Test
809 public void testGetRefs_CycleInSymbolicRef() throws IOException {
810 Map<String, Ref> all;
811 Ref r;
812
813 writeLooseRef("refs/1", "ref: refs/2\n");
814 writeLooseRef("refs/2", "ref: refs/3\n");
815 writeLooseRef("refs/3", "ref: refs/4\n");
816 writeLooseRef("refs/4", "ref: refs/5\n");
817 writeLooseRef("refs/5", "ref: refs/end\n");
818 writeLooseRef("refs/end", A);
819
820 all = refdir.getRefs(RefDatabase.ALL);
821 r = all.get("refs/1");
822 assertNotNull("has 1", r);
823
824 assertEquals("refs/1", r.getName());
825 assertEquals(A, r.getObjectId());
826 assertTrue(r.isSymbolic());
827
828 r = r.getTarget();
829 assertEquals("refs/2", r.getName());
830 assertEquals(A, r.getObjectId());
831 assertTrue(r.isSymbolic());
832
833 r = r.getTarget();
834 assertEquals("refs/3", r.getName());
835 assertEquals(A, r.getObjectId());
836 assertTrue(r.isSymbolic());
837
838 r = r.getTarget();
839 assertEquals("refs/4", r.getName());
840 assertEquals(A, r.getObjectId());
841 assertTrue(r.isSymbolic());
842
843 r = r.getTarget();
844 assertEquals("refs/5", r.getName());
845 assertEquals(A, r.getObjectId());
846 assertTrue(r.isSymbolic());
847
848 r = r.getTarget();
849 assertEquals("refs/end", r.getName());
850 assertEquals(A, r.getObjectId());
851 assertFalse(r.isSymbolic());
852
853 writeLooseRef("refs/5", "ref: refs/6\n");
854 writeLooseRef("refs/6", "ref: refs/end\n");
855 all = refdir.getRefs(RefDatabase.ALL);
856 r = all.get("refs/1");
857 assertNull("mising 1 due to cycle", r);
858 }
859
860 @Test
861 public void testGetRef_CycleInSymbolicRef() throws IOException {
862 Ref r;
863
864 writeLooseRef("refs/1", "ref: refs/2\n");
865 writeLooseRef("refs/2", "ref: refs/3\n");
866 writeLooseRef("refs/3", "ref: refs/4\n");
867 writeLooseRef("refs/4", "ref: refs/5\n");
868 writeLooseRef("refs/5", "ref: refs/end\n");
869 writeLooseRef("refs/end", A);
870
871 r = refdir.getRef("1");
872 assertEquals("refs/1", r.getName());
873 assertEquals(A, r.getObjectId());
874 assertTrue(r.isSymbolic());
875
876 writeLooseRef("refs/5", "ref: refs/6\n");
877 writeLooseRef("refs/6", "ref: refs/end\n");
878
879 r = refdir.getRef("1");
880 assertNull("missing 1 due to cycle", r);
881
882 writeLooseRef("refs/heads/1", B);
883
884 r = refdir.getRef("1");
885 assertEquals("refs/heads/1", r.getName());
886 assertEquals(B, r.getObjectId());
887 assertFalse(r.isSymbolic());
888 }
889
890 @Test
891 public void testGetRefs_PackedNotPeeled_Sorted() throws IOException {
892 Map<String, Ref> all;
893
894 writePackedRefs("" +
895 A.name() + " refs/heads/master\n" +
896 B.name() + " refs/heads/other\n" +
897 v1_0.name() + " refs/tags/v1.0\n");
898 all = refdir.getRefs(RefDatabase.ALL);
899
900 assertEquals(4, all.size());
901 final Ref head = all.get(HEAD);
902 final Ref master = all.get("refs/heads/master");
903 final Ref other = all.get("refs/heads/other");
904 final Ref tag = all.get("refs/tags/v1.0");
905
906 assertEquals(A, master.getObjectId());
907 assertFalse(master.isPeeled());
908 assertNull(master.getPeeledObjectId());
909
910 assertEquals(B, other.getObjectId());
911 assertFalse(other.isPeeled());
912 assertNull(other.getPeeledObjectId());
913
914 assertSame(master, head.getTarget());
915 assertEquals(A, head.getObjectId());
916 assertFalse(head.isPeeled());
917 assertNull(head.getPeeledObjectId());
918
919 assertEquals(v1_0, tag.getObjectId());
920 assertFalse(tag.isPeeled());
921 assertNull(tag.getPeeledObjectId());
922 }
923
924 @Test
925 public void testGetRef_PackedNotPeeled_WrongSort() throws IOException {
926 writePackedRefs("" +
927 v1_0.name() + " refs/tags/v1.0\n" +
928 B.name() + " refs/heads/other\n" +
929 A.name() + " refs/heads/master\n");
930
931 final Ref head = refdir.getRef(HEAD);
932 final Ref master = refdir.getRef("refs/heads/master");
933 final Ref other = refdir.getRef("refs/heads/other");
934 final Ref tag = refdir.getRef("refs/tags/v1.0");
935
936 assertEquals(A, master.getObjectId());
937 assertFalse(master.isPeeled());
938 assertNull(master.getPeeledObjectId());
939
940 assertEquals(B, other.getObjectId());
941 assertFalse(other.isPeeled());
942 assertNull(other.getPeeledObjectId());
943
944 assertSame(master, head.getTarget());
945 assertEquals(A, head.getObjectId());
946 assertFalse(head.isPeeled());
947 assertNull(head.getPeeledObjectId());
948
949 assertEquals(v1_0, tag.getObjectId());
950 assertFalse(tag.isPeeled());
951 assertNull(tag.getPeeledObjectId());
952 }
953
954 @Test
955 public void testGetRefs_PackedWithPeeled() throws IOException {
956 Map<String, Ref> all;
957
958 writePackedRefs("# pack-refs with: peeled \n" +
959 A.name() + " refs/heads/master\n" +
960 B.name() + " refs/heads/other\n" +
961 v1_0.name() + " refs/tags/v1.0\n" +
962 "^" + v1_0.getObject().name() + "\n");
963 all = refdir.getRefs(RefDatabase.ALL);
964
965 assertEquals(4, all.size());
966 final Ref head = all.get(HEAD);
967 final Ref master = all.get("refs/heads/master");
968 final Ref other = all.get("refs/heads/other");
969 final Ref tag = all.get("refs/tags/v1.0");
970
971 assertEquals(A, master.getObjectId());
972 assertTrue(master.isPeeled());
973 assertNull(master.getPeeledObjectId());
974
975 assertEquals(B, other.getObjectId());
976 assertTrue(other.isPeeled());
977 assertNull(other.getPeeledObjectId());
978
979 assertSame(master, head.getTarget());
980 assertEquals(A, head.getObjectId());
981 assertTrue(head.isPeeled());
982 assertNull(head.getPeeledObjectId());
983
984 assertEquals(v1_0, tag.getObjectId());
985 assertTrue(tag.isPeeled());
986 assertEquals(v1_0.getObject(), tag.getPeeledObjectId());
987 }
988
989 @Test
990 public void test_repack() throws Exception {
991 Map<String, Ref> all;
992
993 writePackedRefs("# pack-refs with: peeled \n" +
994 A.name() + " refs/heads/master\n" +
995 B.name() + " refs/heads/other\n" +
996 v1_0.name() + " refs/tags/v1.0\n" +
997 "^" + v1_0.getObject().name() + "\n");
998 all = refdir.getRefs(RefDatabase.ALL);
999
1000 assertEquals(4, all.size());
1001 assertEquals(Storage.LOOSE, all.get(HEAD).getStorage());
1002 assertEquals(Storage.PACKED, all.get("refs/heads/master").getStorage());
1003 assertEquals(A.getId(), all.get("refs/heads/master").getObjectId());
1004 assertEquals(Storage.PACKED, all.get("refs/heads/other").getStorage());
1005 assertEquals(Storage.PACKED, all.get("refs/tags/v1.0").getStorage());
1006
1007 repo.update("refs/heads/master", B.getId());
1008 RevTag v0_1 = repo.tag("v0.1", A);
1009 repo.update("refs/tags/v0.1", v0_1);
1010
1011 all = refdir.getRefs(RefDatabase.ALL);
1012 assertEquals(5, all.size());
1013 assertEquals(Storage.LOOSE, all.get(HEAD).getStorage());
1014
1015 assertEquals(Storage.LOOSE, all.get("refs/heads/master")
1016 .getStorage());
1017 assertEquals(B.getId(), all.get("refs/heads/master").getObjectId());
1018 assertEquals(Storage.PACKED, all.get("refs/heads/other").getStorage());
1019 assertEquals(Storage.PACKED, all.get("refs/tags/v1.0").getStorage());
1020 assertEquals(Storage.LOOSE, all.get("refs/tags/v0.1").getStorage());
1021 assertEquals(v0_1.getId(), all.get("refs/tags/v0.1").getObjectId());
1022
1023 all = refdir.getRefs(RefDatabase.ALL);
1024 refdir.pack(new ArrayList<String>(all.keySet()));
1025
1026 all = refdir.getRefs(RefDatabase.ALL);
1027 assertEquals(5, all.size());
1028 assertEquals(Storage.LOOSE, all.get(HEAD).getStorage());
1029
1030 assertEquals(Storage.PACKED, all.get("refs/heads/master").getStorage());
1031 assertEquals(B.getId(), all.get("refs/heads/master").getObjectId());
1032 assertEquals(Storage.PACKED, all.get("refs/heads/other").getStorage());
1033 assertEquals(Storage.PACKED, all.get("refs/tags/v1.0").getStorage());
1034 assertEquals(Storage.PACKED, all.get("refs/tags/v0.1").getStorage());
1035 assertEquals(v0_1.getId(), all.get("refs/tags/v0.1").getObjectId());
1036 }
1037
1038 @Test
1039 public void testGetRef_EmptyDatabase() throws IOException {
1040 Ref r;
1041
1042 r = refdir.getRef(HEAD);
1043 assertTrue(r.isSymbolic());
1044 assertSame(LOOSE, r.getStorage());
1045 assertEquals("refs/heads/master", r.getTarget().getName());
1046 assertSame(NEW, r.getTarget().getStorage());
1047 assertNull(r.getTarget().getObjectId());
1048
1049 assertNull(refdir.getRef("refs/heads/master"));
1050 assertNull(refdir.getRef("refs/tags/v1.0"));
1051 assertNull(refdir.getRef("FETCH_HEAD"));
1052 assertNull(refdir.getRef("NOT.A.REF.NAME"));
1053 assertNull(refdir.getRef("master"));
1054 assertNull(refdir.getRef("v1.0"));
1055 }
1056
1057 @Test
1058 public void testExactRef_EmptyDatabase() throws IOException {
1059 Ref r;
1060
1061 r = refdir.exactRef(HEAD);
1062 assertTrue(r.isSymbolic());
1063 assertSame(LOOSE, r.getStorage());
1064 assertEquals("refs/heads/master", r.getTarget().getName());
1065 assertSame(NEW, r.getTarget().getStorage());
1066 assertNull(r.getTarget().getObjectId());
1067
1068 assertNull(refdir.exactRef("refs/heads/master"));
1069 assertNull(refdir.exactRef("refs/tags/v1.0"));
1070 assertNull(refdir.exactRef("FETCH_HEAD"));
1071 assertNull(refdir.exactRef("NOT.A.REF.NAME"));
1072 assertNull(refdir.exactRef("master"));
1073 assertNull(refdir.exactRef("v1.0"));
1074 }
1075
1076 @Test
1077 public void testGetRef_FetchHead() throws IOException {
1078
1079
1080
1081 write(new File(diskRepo.getDirectory(), "FETCH_HEAD"), A.name()
1082 + "\tnot-for-merge"
1083 + "\tbranch 'master' of git://egit.eclipse.org/jgit\n");
1084
1085 Ref r = refdir.getRef("FETCH_HEAD");
1086 assertFalse(r.isSymbolic());
1087 assertEquals(A, r.getObjectId());
1088 assertEquals("FETCH_HEAD", r.getName());
1089 assertFalse(r.isPeeled());
1090 assertNull(r.getPeeledObjectId());
1091 }
1092
1093 @Test
1094 public void testExactRef_FetchHead() throws IOException {
1095
1096
1097
1098 write(new File(diskRepo.getDirectory(), "FETCH_HEAD"), A.name()
1099 + "\tnot-for-merge"
1100 + "\tbranch 'master' of git://egit.eclipse.org/jgit\n");
1101
1102 Ref r = refdir.exactRef("FETCH_HEAD");
1103 assertFalse(r.isSymbolic());
1104 assertEquals(A, r.getObjectId());
1105 assertEquals("FETCH_HEAD", r.getName());
1106 assertFalse(r.isPeeled());
1107 assertNull(r.getPeeledObjectId());
1108 }
1109
1110 @Test
1111 public void testGetRef_AnyHeadWithGarbage() throws IOException {
1112 write(new File(diskRepo.getDirectory(), "refs/heads/A"), A.name()
1113 + "012345 . this is not a standard reference\n"
1114 + "#and even more junk\n");
1115
1116 Ref r = refdir.getRef("refs/heads/A");
1117 assertFalse(r.isSymbolic());
1118 assertEquals(A, r.getObjectId());
1119 assertEquals("refs/heads/A", r.getName());
1120 assertFalse(r.isPeeled());
1121 assertNull(r.getPeeledObjectId());
1122 }
1123
1124 @Test
1125 public void testGetRefs_CorruptSymbolicReference() throws IOException {
1126 String name = "refs/heads/A";
1127 writeLooseRef(name, "ref: \n");
1128 assertTrue(refdir.getRefs(RefDatabase.ALL).isEmpty());
1129 }
1130
1131 @Test
1132 public void testGetRef_CorruptSymbolicReference() throws IOException {
1133 String name = "refs/heads/A";
1134 writeLooseRef(name, "ref: \n");
1135 try {
1136 refdir.getRef(name);
1137 fail("read an invalid reference");
1138 } catch (IOException err) {
1139 String msg = err.getMessage();
1140 assertEquals("Not a ref: " + name + ": ref:", msg);
1141 }
1142 }
1143
1144 @Test
1145 public void testGetRefs_CorruptObjectIdReference() throws IOException {
1146 String name = "refs/heads/A";
1147 String content = "zoo" + A.name();
1148 writeLooseRef(name, content + "\n");
1149 assertTrue(refdir.getRefs(RefDatabase.ALL).isEmpty());
1150 }
1151
1152 @Test
1153 public void testGetRef_CorruptObjectIdReference() throws IOException {
1154 String name = "refs/heads/A";
1155 String content = "zoo" + A.name();
1156 writeLooseRef(name, content + "\n");
1157 try {
1158 refdir.getRef(name);
1159 fail("read an invalid reference");
1160 } catch (IOException err) {
1161 String msg = err.getMessage();
1162 assertEquals("Not a ref: " + name + ": " + content, msg);
1163 }
1164 }
1165
1166 @Test
1167 public void testIsNameConflicting() throws IOException {
1168 writeLooseRef("refs/heads/a/b", A);
1169 writePackedRef("refs/heads/q", B);
1170
1171
1172 assertTrue(refdir.isNameConflicting("refs"));
1173 assertTrue(refdir.isNameConflicting("refs/heads"));
1174 assertTrue(refdir.isNameConflicting("refs/heads/a"));
1175
1176
1177 assertFalse(refdir.isNameConflicting("refs/heads/a/b"));
1178
1179
1180 assertFalse(refdir.isNameConflicting("refs/heads/a/d"));
1181 assertFalse(refdir.isNameConflicting("refs/heads/master"));
1182
1183
1184 assertTrue(refdir.isNameConflicting("refs/heads/a/b/c"));
1185 assertTrue(refdir.isNameConflicting("refs/heads/q/master"));
1186 }
1187
1188 @Test
1189 public void testPeelLooseTag() throws IOException {
1190 writeLooseRef("refs/tags/v1_0", v1_0);
1191 writeLooseRef("refs/tags/current", "ref: refs/tags/v1_0\n");
1192
1193 final Ref tag = refdir.getRef("refs/tags/v1_0");
1194 final Ref cur = refdir.getRef("refs/tags/current");
1195
1196 assertEquals(v1_0, tag.getObjectId());
1197 assertFalse(tag.isSymbolic());
1198 assertFalse(tag.isPeeled());
1199 assertNull(tag.getPeeledObjectId());
1200
1201 assertEquals(v1_0, cur.getObjectId());
1202 assertTrue(cur.isSymbolic());
1203 assertFalse(cur.isPeeled());
1204 assertNull(cur.getPeeledObjectId());
1205
1206 final Ref tag_p = refdir.peel(tag);
1207 final Ref cur_p = refdir.peel(cur);
1208
1209 assertNotSame(tag, tag_p);
1210 assertFalse(tag_p.isSymbolic());
1211 assertTrue(tag_p.isPeeled());
1212 assertEquals(v1_0, tag_p.getObjectId());
1213 assertEquals(v1_0.getObject(), tag_p.getPeeledObjectId());
1214 assertSame(tag_p, refdir.peel(tag_p));
1215
1216 assertNotSame(cur, cur_p);
1217 assertEquals("refs/tags/current", cur_p.getName());
1218 assertTrue(cur_p.isSymbolic());
1219 assertEquals("refs/tags/v1_0", cur_p.getTarget().getName());
1220 assertTrue(cur_p.isPeeled());
1221 assertEquals(v1_0, cur_p.getObjectId());
1222 assertEquals(v1_0.getObject(), cur_p.getPeeledObjectId());
1223
1224
1225
1226 final Ref tag_p2 = refdir.getRef("refs/tags/v1_0");
1227 assertFalse(tag_p2.isSymbolic());
1228 assertTrue(tag_p2.isPeeled());
1229 assertEquals(v1_0, tag_p2.getObjectId());
1230 assertEquals(v1_0.getObject(), tag_p2.getPeeledObjectId());
1231
1232 assertSame(tag_p2, refdir.getRef("refs/tags/v1_0"));
1233 assertSame(tag_p2, refdir.getRef("refs/tags/current").getTarget());
1234 assertSame(tag_p2, refdir.peel(tag_p2));
1235 }
1236
1237 @Test
1238 public void testPeelCommit() throws IOException {
1239 writeLooseRef("refs/heads/master", A);
1240
1241 Ref master = refdir.getRef("refs/heads/master");
1242 assertEquals(A, master.getObjectId());
1243 assertFalse(master.isPeeled());
1244 assertNull(master.getPeeledObjectId());
1245
1246 Ref master_p = refdir.peel(master);
1247 assertNotSame(master, master_p);
1248 assertEquals(A, master_p.getObjectId());
1249 assertTrue(master_p.isPeeled());
1250 assertNull(master_p.getPeeledObjectId());
1251
1252
1253
1254 Ref master_p2 = refdir.getRef("refs/heads/master");
1255 assertNotSame(master, master_p2);
1256 assertEquals(A, master_p2.getObjectId());
1257 assertTrue(master_p2.isPeeled());
1258 assertNull(master_p2.getPeeledObjectId());
1259 assertSame(master_p2, refdir.peel(master_p2));
1260 }
1261
1262 @Test
1263 public void testRefsChangedStackOverflow() throws Exception {
1264 final FileRepository newRepo = createBareRepository();
1265 final RefDatabase refDb = newRepo.getRefDatabase();
1266 File packedRefs = new File(newRepo.getDirectory(), "packed-refs");
1267 assertTrue(packedRefs.createNewFile());
1268 final AtomicReference<StackOverflowError> error = new AtomicReference<StackOverflowError>();
1269 final AtomicReference<IOException> exception = new AtomicReference<IOException>();
1270 final AtomicInteger changeCount = new AtomicInteger();
1271 newRepo.getListenerList().addRefsChangedListener(
1272 new RefsChangedListener() {
1273
1274 public void onRefsChanged(RefsChangedEvent event) {
1275 try {
1276 refDb.getRefs("ref");
1277 changeCount.incrementAndGet();
1278 } catch (StackOverflowError soe) {
1279 error.set(soe);
1280 } catch (IOException ioe) {
1281 exception.set(ioe);
1282 }
1283 }
1284 });
1285 refDb.getRefs("ref");
1286 refDb.getRefs("ref");
1287 assertNull(error.get());
1288 assertNull(exception.get());
1289 assertEquals(1, changeCount.get());
1290 }
1291
1292 @Test
1293 public void testBatchRefUpdateSimpleNoForce() throws IOException {
1294 writeLooseRef("refs/heads/master", A);
1295 writeLooseRef("refs/heads/masters", B);
1296 List<ReceiveCommand> commands = Arrays.asList(
1297 newCommand(A, B, "refs/heads/master",
1298 ReceiveCommand.Type.UPDATE),
1299 newCommand(B, A, "refs/heads/masters",
1300 ReceiveCommand.Type.UPDATE_NONFASTFORWARD));
1301 BatchRefUpdate batchUpdate = refdir.newBatchUpdate();
1302 batchUpdate.addCommand(commands);
1303 batchUpdate.execute(new RevWalk(diskRepo), new StrictWorkMonitor());
1304 Map<String, Ref> refs = refdir.getRefs(RefDatabase.ALL);
1305 assertEquals(ReceiveCommand.Result.OK, commands.get(0).getResult());
1306 assertEquals(ReceiveCommand.Result.REJECTED_NONFASTFORWARD, commands
1307 .get(1).getResult());
1308 assertEquals("[HEAD, refs/heads/master, refs/heads/masters]", refs
1309 .keySet().toString());
1310 assertEquals(B.getId(), refs.get("refs/heads/master").getObjectId());
1311 assertEquals(B.getId(), refs.get("refs/heads/masters").getObjectId());
1312 }
1313
1314 @Test
1315 public void testBatchRefUpdateSimpleForce() throws IOException {
1316 writeLooseRef("refs/heads/master", A);
1317 writeLooseRef("refs/heads/masters", B);
1318 List<ReceiveCommand> commands = Arrays.asList(
1319 newCommand(A, B, "refs/heads/master",
1320 ReceiveCommand.Type.UPDATE),
1321 newCommand(B, A, "refs/heads/masters",
1322 ReceiveCommand.Type.UPDATE_NONFASTFORWARD));
1323 BatchRefUpdate batchUpdate = refdir.newBatchUpdate();
1324 batchUpdate.setAllowNonFastForwards(true);
1325 batchUpdate.addCommand(commands);
1326 batchUpdate.execute(new RevWalk(diskRepo), new StrictWorkMonitor());
1327 Map<String, Ref> refs = refdir.getRefs(RefDatabase.ALL);
1328 assertEquals(ReceiveCommand.Result.OK, commands.get(0).getResult());
1329 assertEquals(ReceiveCommand.Result.OK, commands.get(1).getResult());
1330 assertEquals("[HEAD, refs/heads/master, refs/heads/masters]", refs
1331 .keySet().toString());
1332 assertEquals(B.getId(), refs.get("refs/heads/master").getObjectId());
1333 assertEquals(A.getId(), refs.get("refs/heads/masters").getObjectId());
1334 }
1335
1336 @Test
1337 public void testBatchRefUpdateNonFastForwardDoesNotDoExpensiveMergeCheck()
1338 throws IOException {
1339 writeLooseRef("refs/heads/master", B);
1340 List<ReceiveCommand> commands = Arrays.asList(
1341 newCommand(B, A, "refs/heads/master",
1342 ReceiveCommand.Type.UPDATE_NONFASTFORWARD));
1343 BatchRefUpdate batchUpdate = refdir.newBatchUpdate();
1344 batchUpdate.setAllowNonFastForwards(true);
1345 batchUpdate.addCommand(commands);
1346 batchUpdate.execute(new RevWalk(diskRepo) {
1347 @Override
1348 public boolean isMergedInto(RevCommit base, RevCommit tip) {
1349 throw new AssertionError("isMergedInto() should not be called");
1350 }
1351 }, new StrictWorkMonitor());
1352 Map<String, Ref> refs = refdir.getRefs(RefDatabase.ALL);
1353 assertEquals(ReceiveCommand.Result.OK, commands.get(0).getResult());
1354 assertEquals(A.getId(), refs.get("refs/heads/master").getObjectId());
1355 }
1356
1357 @Test
1358 public void testBatchRefUpdateConflict() throws IOException {
1359 writeLooseRef("refs/heads/master", A);
1360 writeLooseRef("refs/heads/masters", B);
1361 List<ReceiveCommand> commands = Arrays.asList(
1362 newCommand(A, B, "refs/heads/master",
1363 ReceiveCommand.Type.UPDATE),
1364 newCommand(null, A, "refs/heads/master/x",
1365 ReceiveCommand.Type.CREATE),
1366 newCommand(null, A, "refs/heads", ReceiveCommand.Type.CREATE));
1367 BatchRefUpdate batchUpdate = refdir.newBatchUpdate();
1368 batchUpdate.setAllowNonFastForwards(true);
1369 batchUpdate.addCommand(commands);
1370 batchUpdate
1371 .execute(new RevWalk(diskRepo), NullProgressMonitor.INSTANCE);
1372 Map<String, Ref> refs = refdir.getRefs(RefDatabase.ALL);
1373 assertEquals(ReceiveCommand.Result.OK, commands.get(0).getResult());
1374 assertEquals(ReceiveCommand.Result.LOCK_FAILURE, commands.get(1)
1375 .getResult());
1376 assertEquals(ReceiveCommand.Result.LOCK_FAILURE, commands.get(2)
1377 .getResult());
1378 assertEquals("[HEAD, refs/heads/master, refs/heads/masters]", refs
1379 .keySet().toString());
1380 assertEquals(B.getId(), refs.get("refs/heads/master").getObjectId());
1381 assertEquals(B.getId(), refs.get("refs/heads/masters").getObjectId());
1382 }
1383
1384 @Test
1385 public void testBatchRefUpdateConflictThanksToDelete() throws IOException {
1386 writeLooseRef("refs/heads/master", A);
1387 writeLooseRef("refs/heads/masters", B);
1388 List<ReceiveCommand> commands = Arrays.asList(
1389 newCommand(A, B, "refs/heads/master",
1390 ReceiveCommand.Type.UPDATE),
1391 newCommand(null, A, "refs/heads/masters/x",
1392 ReceiveCommand.Type.CREATE),
1393 newCommand(B, null, "refs/heads/masters",
1394 ReceiveCommand.Type.DELETE));
1395 BatchRefUpdate batchUpdate = refdir.newBatchUpdate();
1396 batchUpdate.setAllowNonFastForwards(true);
1397 batchUpdate.addCommand(commands);
1398 batchUpdate.execute(new RevWalk(diskRepo), new StrictWorkMonitor());
1399 Map<String, Ref> refs = refdir.getRefs(RefDatabase.ALL);
1400 assertEquals(ReceiveCommand.Result.OK, commands.get(0).getResult());
1401 assertEquals(ReceiveCommand.Result.OK, commands.get(1).getResult());
1402 assertEquals(ReceiveCommand.Result.OK, commands.get(2).getResult());
1403 assertEquals("[HEAD, refs/heads/master, refs/heads/masters/x]", refs
1404 .keySet().toString());
1405 assertEquals(A.getId(), refs.get("refs/heads/masters/x").getObjectId());
1406 }
1407
1408 private static ReceiveCommand newCommand(RevCommit a, RevCommit b,
1409 String string, Type update) {
1410 return new ReceiveCommand(a != null ? a.getId() : null,
1411 b != null ? b.getId() : null, string, update);
1412 }
1413
1414 private void writeLooseRef(String name, AnyObjectId id) throws IOException {
1415 writeLooseRef(name, id.name() + "\n");
1416 }
1417
1418 private void writeLooseRef(String name, String content) throws IOException {
1419 write(new File(diskRepo.getDirectory(), name), content);
1420 }
1421
1422 private void writePackedRef(String name, AnyObjectId id) throws IOException {
1423 writePackedRefs(id.name() + " " + name + "\n");
1424 }
1425
1426 private void writePackedRefs(String content) throws IOException {
1427 File pr = new File(diskRepo.getDirectory(), "packed-refs");
1428 write(pr, content);
1429
1430 final long now = System.currentTimeMillis();
1431 final int oneHourAgo = 3600 * 1000;
1432 pr.setLastModified(now - oneHourAgo);
1433 }
1434
1435 private void deleteLooseRef(String name) {
1436 File path = new File(diskRepo.getDirectory(), name);
1437 assertTrue("deleted " + name, path.delete());
1438 }
1439
1440 private static final class StrictWorkMonitor implements ProgressMonitor {
1441 private int lastWork, totalWork;
1442
1443 public void start(int totalTasks) {
1444
1445 }
1446
1447 public void beginTask(String title, int total) {
1448 this.totalWork = total;
1449 lastWork = 0;
1450 }
1451
1452 public void update(int completed) {
1453 lastWork += completed;
1454 }
1455
1456 public void endTask() {
1457 assertEquals("Units of work recorded", totalWork, lastWork);
1458 }
1459
1460 public boolean isCancelled() {
1461 return false;
1462 }
1463 }
1464 }