/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/plugins/git/tests/test_fetch.py

  • Committer: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-05-15 18:47:57 UTC
  • mfrom: (6964.2.7 python3-git)
  • Revision ID: breezy.the.bot@gmail.com-20180515184757-xozniaj9gztgtom8
Port some of brz-git to python3.

Merged from https://code.launchpad.net/~jelmer/brz/python3-git/+merge/345479

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/plugins/git/tests/test_fetch.py
85
85
    def test_empty(self):
86
86
        self.make_git_repo("d")
87
87
        newrepos = self.clone_git_repo("d", "f")
88
 
        self.assertEquals([], newrepos.all_revision_ids())
 
88
        self.assertEqual([], newrepos.all_revision_ids())
89
89
 
90
90
    def make_onerev_branch(self):
91
91
        self.make_git_repo("d")
102
102
        oldrepo = self.open_git_repo(path)
103
103
        newrepo = self.clone_git_repo(path, "f")
104
104
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
105
 
        self.assertEquals([revid], newrepo.all_revision_ids())
 
105
        self.assertEqual([revid], newrepo.all_revision_ids())
106
106
 
107
107
    def test_single_rev_specific(self):
108
108
        path, gitsha = self.make_onerev_branch()
109
109
        oldrepo = self.open_git_repo(path)
110
110
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
111
111
        newrepo = self.clone_git_repo(path, "f", revision_id=revid)
112
 
        self.assertEquals([revid], newrepo.all_revision_ids())
 
112
        self.assertEqual([revid], newrepo.all_revision_ids())
113
113
 
114
114
    def test_incremental(self):
115
115
        self.make_git_repo("d")
126
126
        oldrepo = self.open_git_repo("d")
127
127
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
128
128
        newrepo = self.clone_git_repo("d", "f", revision_id=revid1)
129
 
        self.assertEquals([revid1], newrepo.all_revision_ids())
 
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.assertEquals(set([revid1, revid2]), set(newrepo.all_revision_ids()))
 
132
        self.assertEqual(set([revid1, revid2]), set(newrepo.all_revision_ids()))
133
133
 
134
134
    def test_dir_becomes_symlink(self):
135
135
        self.make_git_repo("d")
149
149
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
150
150
        tree1 = newrepo.revision_tree(revid1)
151
151
        tree2 = newrepo.revision_tree(revid2)
152
 
        self.assertEquals(revid1, tree1.get_file_revision("mylink"))
153
 
        self.assertEquals("directory", tree1.kind("mylink"))
154
 
        self.assertEquals(None, tree1.get_symlink_target("mylink"))
155
 
        self.assertEquals(revid2, tree2.get_file_revision("mylink"))
156
 
        self.assertEquals("symlink", tree2.kind("mylink"))
157
 
        self.assertEquals("target/", tree2.get_symlink_target("mylink"))
 
152
        self.assertEqual(revid1, tree1.get_file_revision("mylink"))
 
153
        self.assertEqual("directory", tree1.kind("mylink"))
 
154
        self.assertEqual(None, tree1.get_symlink_target("mylink"))
 
155
        self.assertEqual(revid2, tree2.get_file_revision("mylink"))
 
156
        self.assertEqual("symlink", tree2.kind("mylink"))
 
157
        self.assertEqual("target/", tree2.get_symlink_target("mylink"))
158
158
 
159
159
    def test_symlink_becomes_dir(self):
160
160
        self.make_git_repo("d")
174
174
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
175
175
        tree1 = newrepo.revision_tree(revid1)
176
176
        tree2 = newrepo.revision_tree(revid2)
177
 
        self.assertEquals(revid1, tree1.get_file_revision("mylink"))
178
 
        self.assertEquals("symlink", tree1.kind("mylink"))
179
 
        self.assertEquals("target/", tree1.get_symlink_target("mylink"))
180
 
        self.assertEquals(revid2, tree2.get_file_revision("mylink"))
181
 
        self.assertEquals("directory", tree2.kind("mylink"))
182
 
        self.assertEquals(None, tree2.get_symlink_target("mylink"))
 
177
        self.assertEqual(revid1, tree1.get_file_revision("mylink"))
 
178
        self.assertEqual("symlink", tree1.kind("mylink"))
 
179
        self.assertEqual("target/", tree1.get_symlink_target("mylink"))
 
180
        self.assertEqual(revid2, tree2.get_file_revision("mylink"))
 
181
        self.assertEqual("directory", tree2.kind("mylink"))
 
182
        self.assertEqual(None, tree2.get_symlink_target("mylink"))
183
183
 
184
184
    def test_changing_symlink(self):
185
185
        self.make_git_repo("d")
199
199
        revid2 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
200
200
        tree1 = newrepo.revision_tree(revid1)
201
201
        tree2 = newrepo.revision_tree(revid2)
202
 
        self.assertEquals(revid1, tree1.get_file_revision("mylink"))
203
 
        self.assertEquals("target", tree1.get_symlink_target("mylink"))
204
 
        self.assertEquals(revid2, tree2.get_file_revision("mylink"))
205
 
        self.assertEquals("target/", tree2.get_symlink_target("mylink"))
 
202
        self.assertEqual(revid1, tree1.get_file_revision("mylink"))
 
203
        self.assertEqual("target", tree1.get_symlink_target("mylink"))
 
204
        self.assertEqual(revid2, tree2.get_file_revision("mylink"))
 
205
        self.assertEqual("target/", tree2.get_symlink_target("mylink"))
206
206
 
207
207
    def test_executable(self):
208
208
        self.make_git_repo("d")
218
218
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
219
219
        tree = newrepo.revision_tree(revid)
220
220
        self.assertTrue(tree.has_filename("foobar"))
221
 
        self.assertEquals(True, tree.is_executable("foobar"))
 
221
        self.assertEqual(True, tree.is_executable("foobar"))
222
222
        self.assertTrue(tree.has_filename("notexec"))
223
 
        self.assertEquals(False, tree.is_executable("notexec"))
 
223
        self.assertEqual(False, tree.is_executable("notexec"))
224
224
 
225
225
    def test_becomes_executable(self):
226
226
        self.make_git_repo("d")
237
237
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha2)
238
238
        tree = newrepo.revision_tree(revid)
239
239
        self.assertTrue(tree.has_filename("foobar"))
240
 
        self.assertEquals(True, tree.is_executable("foobar"))
241
 
        self.assertEquals(revid, tree.get_file_revision("foobar"))
 
240
        self.assertEqual(True, tree.is_executable("foobar"))
 
241
        self.assertEqual(revid, tree.get_file_revision("foobar"))
242
242
 
243
243
    def test_into_stacked_on(self):
244
244
        r = self.make_git_repo("d")
251
251
        stacked_on = self.clone_git_repo("d", "stacked-on")
252
252
        oldrepo = Repository.open("d")
253
253
        revid1 = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha1)
254
 
        self.assertEquals([revid1], stacked_on.all_revision_ids())
 
254
        self.assertEqual([revid1], stacked_on.all_revision_ids())
255
255
        b = stacked_on.controldir.create_branch()
256
256
        b.generate_revision_history(revid1)
257
 
        self.assertEquals(b.last_revision(), revid1)
 
257
        self.assertEqual(b.last_revision(), revid1)
258
258
        tree = self.make_branch_and_tree("stacked")
259
259
        tree.branch.set_stacked_on_url(b.user_url)
260
260
        os.chdir("d")
268
268
        tree.branch.fetch(Branch.open("d"))
269
269
        tree.branch.repository.check()
270
270
        self.addCleanup(tree.lock_read().unlock)
271
 
        self.assertEquals(
 
271
        self.assertEqual(
272
272
            set([(revid2,)]),
273
273
            tree.branch.repository.revisions.without_fallbacks().keys())
274
 
        self.assertEquals(
 
274
        self.assertEqual(
275
275
            set([revid1, revid2]),
276
276
            set(tree.branch.repository.all_revision_ids()))
277
277
 
310
310
        oldrepo = self.open_git_repo("d")
311
311
        revid = oldrepo.get_mapping().revision_id_foreign_to_bzr(gitsha)
312
312
        newrepo = self.clone_git_repo("d", "f")
313
 
        self.assertEquals(set([revid]), set(newrepo.all_revision_ids()))
 
313
        self.assertEqual(set([revid]), set(newrepo.all_revision_ids()))
314
314
 
315
315
 
316
316
class LocalRepositoryFetchTests(RepositoryFetchTests, TestCaseWithTransport):
345
345
            base_inv, None, "somerevid", [], objs.__getitem__, 
346
346
            (None, DEFAULT_FILE_MODE), DummyStoreUpdater(),
347
347
            self._mapping.generate_file_id)
348
 
        self.assertEquals(set([('git:bla', 'somerevid')]), self._texts.keys())
349
 
        self.assertEquals(self._texts.get_record_stream([('git:bla', 'somerevid')],
 
348
        self.assertEqual(set([('git:bla', 'somerevid')]), self._texts.keys())
 
349
        self.assertEqual(self._texts.get_record_stream([('git:bla', 'somerevid')],
350
350
            "unordered", True).next().get_bytes_as("fulltext"), "bar")
351
 
        self.assertEquals(1, len(ret)) 
352
 
        self.assertEquals(None, ret[0][0])
353
 
        self.assertEquals("bla", ret[0][1])
 
351
        self.assertEqual(1, len(ret)) 
 
352
        self.assertEqual(None, ret[0][0])
 
353
        self.assertEqual("bla", ret[0][1])
354
354
        ie = ret[0][3]
355
 
        self.assertEquals(False, ie.executable)
356
 
        self.assertEquals("file", ie.kind)
357
 
        self.assertEquals("somerevid", ie.revision)
358
 
        self.assertEquals(osutils.sha_strings(["bar"]), ie.text_sha1)
 
355
        self.assertEqual(False, ie.executable)
 
356
        self.assertEqual("file", ie.kind)
 
357
        self.assertEqual("somerevid", ie.revision)
 
358
        self.assertEqual(osutils.sha_strings(["bar"]), ie.text_sha1)
359
359
 
360
360
    def test_import_tree_empty_root(self):
361
361
        base_inv = Inventory(root_id=None)
365
365
               None, "somerevid", [], {tree.id: tree}.__getitem__,
366
366
               (None, stat.S_IFDIR), DummyStoreUpdater(),
367
367
               self._mapping.generate_file_id)
368
 
        self.assertEquals(child_modes, {})
369
 
        self.assertEquals(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
370
 
        self.assertEquals(1, len(ret))
371
 
        self.assertEquals(None, ret[0][0])
372
 
        self.assertEquals("", ret[0][1])
 
368
        self.assertEqual(child_modes, {})
 
369
        self.assertEqual(set([("TREE_ROOT", 'somerevid')]), self._texts.keys())
 
370
        self.assertEqual(1, len(ret))
 
371
        self.assertEqual(None, ret[0][0])
 
372
        self.assertEqual("", ret[0][1])
373
373
        ie = ret[0][3]
374
 
        self.assertEquals(False, ie.executable)
375
 
        self.assertEquals("directory", ie.kind)
376
 
        self.assertEquals({}, ie.children)
377
 
        self.assertEquals("somerevid", ie.revision)
378
 
        self.assertEquals(None, ie.text_sha1)
 
374
        self.assertEqual(False, ie.executable)
 
375
        self.assertEqual("directory", ie.kind)
 
376
        self.assertEqual({}, ie.children)
 
377
        self.assertEqual("somerevid", ie.revision)
 
378
        self.assertEqual(None, ie.text_sha1)
379
379
 
380
380
    def test_import_tree_empty(self):
381
381
        base_inv = Inventory()
385
385
           { tree.id: tree }.__getitem__,
386
386
           (None, stat.S_IFDIR), DummyStoreUpdater(),
387
387
           self._mapping.generate_file_id)
388
 
        self.assertEquals(child_modes, {})
389
 
        self.assertEquals(set([("git:bla", 'somerevid')]), self._texts.keys())
390
 
        self.assertEquals(1, len(ret))
391
 
        self.assertEquals(None, ret[0][0])
392
 
        self.assertEquals("bla", ret[0][1])
 
388
        self.assertEqual(child_modes, {})
 
389
        self.assertEqual(set([("git:bla", 'somerevid')]), self._texts.keys())
 
390
        self.assertEqual(1, len(ret))
 
391
        self.assertEqual(None, ret[0][0])
 
392
        self.assertEqual("bla", ret[0][1])
393
393
        ie = ret[0][3]
394
 
        self.assertEquals("directory", ie.kind)
395
 
        self.assertEquals(False, ie.executable)
396
 
        self.assertEquals({}, ie.children)
397
 
        self.assertEquals("somerevid", ie.revision)
398
 
        self.assertEquals(None, ie.text_sha1)
 
394
        self.assertEqual("directory", ie.kind)
 
395
        self.assertEqual(False, ie.executable)
 
396
        self.assertEqual({}, ie.children)
 
397
        self.assertEqual("somerevid", ie.revision)
 
398
        self.assertEqual(None, ie.text_sha1)
399
399
 
400
400
    def test_import_tree_with_file(self):
401
401
        base_inv = Inventory()
402
402
        blob = Blob.from_string("bar1")
403
403
        tree = Tree()
404
 
        tree.add("foo", stat.S_IFREG | 0644, blob.id)
 
404
        tree.add("foo", stat.S_IFREG | 0o644, blob.id)
405
405
        objects = { blob.id: blob, tree.id: tree }
406
406
        ret, child_modes = import_git_tree(self._texts, self._mapping, "bla", "bla",
407
407
                (None, tree.id), base_inv, None, "somerevid", [],
408
408
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
409
409
            self._mapping.generate_file_id)
410
 
        self.assertEquals(child_modes, {})
411
 
        self.assertEquals(2, len(ret))
412
 
        self.assertEquals(None, ret[0][0])
413
 
        self.assertEquals("bla", ret[0][1])
414
 
        self.assertEquals(None, ret[1][0])
415
 
        self.assertEquals("bla/foo", ret[1][1])
 
410
        self.assertEqual(child_modes, {})
 
411
        self.assertEqual(2, len(ret))
 
412
        self.assertEqual(None, ret[0][0])
 
413
        self.assertEqual("bla", ret[0][1])
 
414
        self.assertEqual(None, ret[1][0])
 
415
        self.assertEqual("bla/foo", ret[1][1])
416
416
        ie = ret[0][3]
417
 
        self.assertEquals("directory", ie.kind)
 
417
        self.assertEqual("directory", ie.kind)
418
418
        ie = ret[1][3]
419
 
        self.assertEquals("file", ie.kind)
420
 
        self.assertEquals("git:bla/foo", ie.file_id)
421
 
        self.assertEquals("somerevid", ie.revision)
422
 
        self.assertEquals(osutils.sha_strings(["bar1"]), ie.text_sha1)
423
 
        self.assertEquals(False, ie.executable)
 
419
        self.assertEqual("file", ie.kind)
 
420
        self.assertEqual("git:bla/foo", ie.file_id)
 
421
        self.assertEqual("somerevid", ie.revision)
 
422
        self.assertEqual(osutils.sha_strings(["bar1"]), ie.text_sha1)
 
423
        self.assertEqual(False, ie.executable)
424
424
 
425
425
    def test_import_tree_with_unusual_mode_file(self):
426
426
        base_inv = Inventory()
427
427
        blob = Blob.from_string("bar1")
428
428
        tree = Tree()
429
 
        tree.add("foo", stat.S_IFREG | 0664, blob.id)
 
429
        tree.add("foo", stat.S_IFREG | 0o664, blob.id)
430
430
        objects = { blob.id: blob, tree.id: tree }
431
431
        ret, child_modes = import_git_tree(self._texts, self._mapping,
432
432
            "bla", "bla", (None, tree.id), base_inv, None, "somerevid", [],
433
433
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
434
434
            self._mapping.generate_file_id)
435
 
        self.assertEquals(child_modes, { "bla/foo": stat.S_IFREG | 0664 })
 
435
        self.assertEqual(child_modes, { "bla/foo": stat.S_IFREG | 0o664 })
436
436
 
437
437
    def test_import_tree_with_file_exe(self):
438
438
        base_inv = Inventory(root_id=None)
439
439
        blob = Blob.from_string("bar")
440
440
        tree = Tree()
441
 
        tree.add("foo", 0100755, blob.id)
 
441
        tree.add("foo", 0o100755, blob.id)
442
442
        objects = { blob.id: blob, tree.id: tree }
443
443
        ret, child_modes = import_git_tree(self._texts, self._mapping, "", "",
444
444
                (None, tree.id), base_inv, None, "somerevid", [],
445
445
            objects.__getitem__, (None, stat.S_IFDIR), DummyStoreUpdater(),
446
446
            self._mapping.generate_file_id)
447
 
        self.assertEquals(child_modes, {})
448
 
        self.assertEquals(2, len(ret))
449
 
        self.assertEquals(None, ret[0][0])
450
 
        self.assertEquals("", ret[0][1])
451
 
        self.assertEquals(None, ret[1][0])
452
 
        self.assertEquals("foo", ret[1][1])
 
447
        self.assertEqual(child_modes, {})
 
448
        self.assertEqual(2, len(ret))
 
449
        self.assertEqual(None, ret[0][0])
 
450
        self.assertEqual("", ret[0][1])
 
451
        self.assertEqual(None, ret[1][0])
 
452
        self.assertEqual("foo", ret[1][1])
453
453
        ie = ret[0][3]
454
 
        self.assertEquals("directory", ie.kind)
 
454
        self.assertEqual("directory", ie.kind)
455
455
        ie = ret[1][3]
456
 
        self.assertEquals("file", ie.kind)
457
 
        self.assertEquals(True, ie.executable)
 
456
        self.assertEqual("file", ie.kind)
 
457
        self.assertEqual(True, ie.executable)
458
458
 
459
459
    def test_directory_converted_to_submodule(self):
460
460
        base_inv = Inventory()
463
463
        othertree = Blob.from_string("someotherthing")
464
464
        blob = Blob.from_string("bar")
465
465
        tree = Tree()
466
 
        tree.add("bar", 0160000, blob.id)
 
466
        tree.add("bar", 0o160000, blob.id)
467
467
        objects = { tree.id: tree }
468
468
        ret, child_modes = import_git_submodule(self._texts, self._mapping, "foo", "foo",
469
469
                (tree.id, othertree.id), base_inv, base_inv.root.file_id, "somerevid", [],
470
 
                objects.__getitem__, (stat.S_IFDIR | 0755, S_IFGITLINK), DummyStoreUpdater(),
 
470
                objects.__getitem__, (stat.S_IFDIR | 0o755, S_IFGITLINK), DummyStoreUpdater(),
471
471
                self._mapping.generate_file_id)
472
 
        self.assertEquals(child_modes, {})
473
 
        self.assertEquals(2, len(ret))
474
 
        self.assertEquals(ret[0], ("foo/bar", None, base_inv.path2id("foo/bar"), None))
475
 
        self.assertEquals(ret[1][:3], ("foo", "foo", self._mapping.generate_file_id("foo")))
 
472
        self.assertEqual(child_modes, {})
 
473
        self.assertEqual(2, len(ret))
 
474
        self.assertEqual(ret[0], ("foo/bar", None, base_inv.path2id("foo/bar"), None))
 
475
        self.assertEqual(ret[1][:3], ("foo", "foo", self._mapping.generate_file_id("foo")))
476
476
        ie = ret[1][3]
477
 
        self.assertEquals(ie.kind, "tree-reference")
 
477
        self.assertEqual(ie.kind, "tree-reference")