/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/git/tests/test_fetch.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-02 02:35:46 UTC
  • mfrom: (7309 work)
  • mto: This revision was merged to the branch mainline in revision 7319.
  • Revision ID: jelmer@jelmer.uk-20190602023546-lqco868tnv26d8ow
merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/tests/test_fetch.py
129
129
        self.assertEqual([revid1], newrepo.all_revision_ids())
130
130
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
131
131
        newrepo.fetch(oldrepo, revision_id=revid2)
132
 
        self.assertEqual(set([revid1, revid2]), set(newrepo.all_revision_ids()))
 
132
        self.assertEqual(set([revid1, revid2]),
 
133
                         set(newrepo.all_revision_ids()))
133
134
 
134
135
    def test_dir_becomes_symlink(self):
135
136
        self.make_git_repo("d")
350
351
        branch = builder.get_branch()
351
352
 
352
353
        blob = Blob.from_string(b"bar")
353
 
        objs = { "blobname": blob}
 
354
        objs = {"blobname": blob}
354
355
        ret = import_git_blob(self._texts, self._mapping, b"bla", b"bla",
355
 
            (None, "blobname"),
356
 
            branch.repository.revision_tree(rev1), b'rootid', b"somerevid",
357
 
            [branch.repository.revision_tree(r) for r in [rev1, rev2]],
358
 
            objs.__getitem__,
359
 
            (None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
360
 
            self._mapping.generate_file_id)
 
356
                              (None, "blobname"),
 
357
                              branch.repository.revision_tree(
 
358
                                  rev1), b'rootid', b"somerevid",
 
359
                              [branch.repository.revision_tree(r) for r in [
 
360
                                  rev1, rev2]],
 
361
                              objs.__getitem__,
 
362
                              (None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
 
363
                              self._mapping.generate_file_id)
361
364
        self.assertEqual(set([(b'git:bla', b'somerevid')]), self._texts.keys())
362
365
 
363
366
    def test_import_blob_simple(self):
364
367
        blob = Blob.from_string(b"bar")
365
 
        objs = { "blobname": blob}
 
368
        objs = {"blobname": blob}
366
369
        ret = import_git_blob(self._texts, self._mapping, b"bla", b"bla",
367
 
            (None, "blobname"),
368
 
            None, None, b"somerevid", [], objs.__getitem__,
369
 
            (None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
370
 
            self._mapping.generate_file_id)
 
370
                              (None, "blobname"),
 
371
                              None, None, b"somerevid", [], objs.__getitem__,
 
372
                              (None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
 
373
                              self._mapping.generate_file_id)
371
374
        self.assertEqual(set([(b'git:bla', b'somerevid')]), self._texts.keys())
372
375
        self.assertEqual(next(self._texts.get_record_stream([(b'git:bla', b'somerevid')],
373
 
            "unordered", True)).get_bytes_as("fulltext"), b"bar")
 
376
                                                            "unordered", True)).get_bytes_as("fulltext"), b"bar")
374
377
        self.assertEqual(1, len(ret))
375
378
        self.assertEqual(None, ret[0][0])
376
379
        self.assertEqual("bla", ret[0][1])
383
386
    def test_import_tree_empty_root(self):
384
387
        tree = Tree()
385
388
        ret, child_modes = import_git_tree(self._texts, self._mapping, b"", b"",
386
 
               (None, tree.id), None,
387
 
               None, b"somerevid", [], {tree.id: tree}.__getitem__,
388
 
               (None, stat.S_IFDIR), DummyStoreUpdater(),
389
 
               self._mapping.generate_file_id)
 
389
                                           (None, tree.id), None,
 
390
                                           None, b"somerevid", [], {
 
391
                                               tree.id: tree}.__getitem__,
 
392
                                           (None, stat.S_IFDIR), DummyStoreUpdater(),
 
393
                                           self._mapping.generate_file_id)
390
394
        self.assertEqual(child_modes, {})
391
 
        self.assertEqual(set([(b"TREE_ROOT", b'somerevid')]), self._texts.keys())
 
395
        self.assertEqual(
 
396
            set([(b"TREE_ROOT", b'somerevid')]), self._texts.keys())
392
397
        self.assertEqual(1, len(ret))
393
398
        self.assertEqual(None, ret[0][0])
394
399
        self.assertEqual("", ret[0][1])
402
407
    def test_import_tree_empty(self):
403
408
        tree = Tree()
404
409
        ret, child_modes = import_git_tree(self._texts, self._mapping, b"bla", b"bla",
405
 
           (None, tree.id), None, None, b"somerevid", [],
406
 
           { tree.id: tree }.__getitem__,
407
 
           (None, stat.S_IFDIR), DummyStoreUpdater(),
408
 
           self._mapping.generate_file_id)
 
410
                                           (None, tree.id), None, None, b"somerevid", [],
 
411
                                           {tree.id: tree}.__getitem__,
 
412
                                           (None, stat.S_IFDIR), DummyStoreUpdater(),
 
413
                                           self._mapping.generate_file_id)
409
414
        self.assertEqual(child_modes, {})
410
415
        self.assertEqual(set([(b"git:bla", b'somerevid')]), self._texts.keys())
411
416
        self.assertEqual(1, len(ret))
422
427
        blob = Blob.from_string(b"bar1")
423
428
        tree = Tree()
424
429
        tree.add(b"foo", stat.S_IFREG | 0o644, blob.id)
425
 
        objects = { blob.id: blob, tree.id: tree }
 
430
        objects = {blob.id: blob, tree.id: tree}
426
431
        ret, child_modes = import_git_tree(self._texts, self._mapping, b"bla", b"bla",
427
 
                (None, tree.id), None, None, b"somerevid", [],
428
 
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
429
 
            self._mapping.generate_file_id)
 
432
                                           (None, tree.id), None, None, b"somerevid", [],
 
433
                                           objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(
 
434
                                           ),
 
435
                                           self._mapping.generate_file_id)
430
436
        self.assertEqual(child_modes, {})
431
437
        self.assertEqual(2, len(ret))
432
438
        self.assertEqual(None, ret[0][0])
446
452
        blob = Blob.from_string(b"bar1")
447
453
        tree = Tree()
448
454
        tree.add(b"foo", stat.S_IFREG | 0o664, blob.id)
449
 
        objects = { blob.id: blob, tree.id: tree }
 
455
        objects = {blob.id: blob, tree.id: tree}
450
456
        ret, child_modes = import_git_tree(self._texts, self._mapping,
451
 
            b"bla", b"bla", (None, tree.id), None, None, b"somerevid", [],
452
 
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
453
 
            self._mapping.generate_file_id)
454
 
        self.assertEqual(child_modes, { b"bla/foo": stat.S_IFREG | 0o664 })
 
457
                                           b"bla", b"bla", (None, tree.id), None, None, b"somerevid", [
 
458
                                               ],
 
459
                                           objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(
 
460
                                           ),
 
461
                                           self._mapping.generate_file_id)
 
462
        self.assertEqual(child_modes, {b"bla/foo": stat.S_IFREG | 0o664})
455
463
 
456
464
    def test_import_tree_with_file_exe(self):
457
465
        blob = Blob.from_string(b"bar")
458
466
        tree = Tree()
459
467
        tree.add(b"foo", 0o100755, blob.id)
460
 
        objects = { blob.id: blob, tree.id: tree }
 
468
        objects = {blob.id: blob, tree.id: tree}
461
469
        ret, child_modes = import_git_tree(self._texts, self._mapping, b"", b"",
462
 
                (None, tree.id), None, None, b"somerevid", [],
463
 
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
464
 
            self._mapping.generate_file_id)
 
470
                                           (None, tree.id), None, None, b"somerevid", [],
 
471
                                           objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(
 
472
                                           ),
 
473
                                           self._mapping.generate_file_id)
465
474
        self.assertEqual(child_modes, {})
466
475
        self.assertEqual(2, len(ret))
467
476
        self.assertEqual(None, ret[0][0])
482
491
        blob = Blob.from_string(b"bar")
483
492
        tree = Tree()
484
493
        tree.add(b"bar", 0o160000, blob.id)
485
 
        objects = { tree.id: tree }
 
494
        objects = {tree.id: tree}
486
495
        ret, child_modes = import_git_submodule(self._texts, self._mapping, b"foo", b"foo",
487
 
                (tree.id, othertree.id), base_inv, base_inv.root.file_id, b"somerevid", [],
488
 
                objects.__getitem__, (stat.S_IFDIR | 0o755, S_IFGITLINK), DummyStoreUpdater(),
489
 
                self._mapping.generate_file_id)
 
496
                                                (tree.id, othertree.id), base_inv, base_inv.root.file_id, b"somerevid", [
 
497
                                                    ],
 
498
                                                objects.__getitem__, (stat.S_IFDIR | 0o755, S_IFGITLINK), DummyStoreUpdater(
 
499
                                                ),
 
500
                                                self._mapping.generate_file_id)
490
501
        self.assertEqual(child_modes, {})
491
502
        self.assertEqual(2, len(ret))
492
 
        self.assertEqual(ret[0], ("foo/bar", None, base_inv.path2id("foo/bar"), None))
493
 
        self.assertEqual(ret[1][:3], ("foo", b"foo", self._mapping.generate_file_id("foo")))
 
503
        self.assertEqual(
 
504
            ret[0], ("foo/bar", None, base_inv.path2id("foo/bar"), None))
 
505
        self.assertEqual(ret[1][:3], ("foo", b"foo",
 
506
                                      self._mapping.generate_file_id("foo")))
494
507
        ie = ret[1][3]
495
508
        self.assertEqual(ie.kind, "tree-reference")