# Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
+# *-* coding: utf-8 *-*
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
"""Subversion fetch tests."""
+import shutil
from bzrlib.branch import Branch
from bzrlib.bzrdir import BzrDir
+from bzrlib.osutils import has_symlinks
from bzrlib.repository import Repository
+from bzrlib.revision import NULL_REVISION
+from bzrlib.tests import TestSkipped, KnownFailure
from bzrlib.trace import mutter
-from convert import load_dumpfile
-from fileids import generate_svn_file_id, generate_file_id
-import format
-from scheme import TrunkBranchingScheme, NoBranchingScheme
-from tests import TestCaseWithSubversionRepository
-from transport import SvnRaTransport
+from bzrlib.plugins.svn import format, remote
+from bzrlib.plugins.svn.convert import load_dumpfile
+from bzrlib.plugins.svn.errors import InvalidFileName
+from bzrlib.plugins.svn.mapping3 import set_branching_scheme
+from bzrlib.plugins.svn.mapping3.scheme import TrunkBranchingScheme, NoBranchingScheme
+from bzrlib.plugins.svn.tests import TestCaseWithSubversionRepository
+from bzrlib.plugins.svn.transport import SvnRaTransport
-import os
+import os, sys
class TestFetchWorks(TestCaseWithSubversionRepository):
def test_fetch_fileid_renames(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/test': "data"})
- self.client_add("dc/test")
- self.client_set_prop("dc", "bzr:file-ids", "test\tbla\n")
- self.client_set_prop("dc", "bzr:revision-info", "")
- self.client_commit("dc", "Msg")
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("test", "data")
+ dc.change_dir_prop("", "bzr:file-ids", "test\tbla\n")
+ dc.change_dir_prop("", "bzr:revision-info", "")
+ dc.done()
oldrepos = Repository.open(repos_url)
dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertEqual("bla", newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none")).path2id("test"))
+ oldrepos.generate_revision_id(1, "", mapping)).path2id("test"))
def test_fetch_trunk1(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/proj1/trunk/file': "data"})
- self.client_add("dc/proj1")
- self.client_commit("dc", "My Message")
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("proj1")
+ dc.add_dir("proj1/trunk")
+ dc.add_file("proj1/trunk/file", "data")
+ dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(1))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+
+ def test_replace_from_branch(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_dir("trunk/check")
+ dc.add_dir("trunk/check/debian")
+ dc.add_file("trunk/check/stamp-h.in", "foo")
+ dc.add_dir("tags")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("trunk/check/debian/pl", "bar")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("trunk/check/debian/voo", "bar")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("trunk/check/debian/blie", "oeh")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("trunk/check/debian/bar", "oeh")
+ dc.add_file("trunk/check/bar", "bla")
+ dc.done()
+
+ self.make_checkout(repos_url, "dc")
+
+ self.client_copy("dc/trunk", "dc/tags/R_0_9_2", revnum=2)
+ self.client_delete("dc/tags/R_0_9_2/check/debian")
+ shutil.rmtree("dc/tags/R_0_9_2/check/debian")
+ self.client_copy("dc/trunk/check/debian", "dc/tags/R_0_9_2/check",
+ revnum=5)
+ self.client_delete("dc/tags/R_0_9_2/check/stamp-h.in")
+ self.client_copy("dc/trunk/check/stamp-h.in", "dc/tags/R_0_9_2/check",
+ revnum=4)
+ self.build_tree({"dc/tags/R_0_9_2/check/debian/blie": "oehha"})
+ self.client_update("dc")
+ self.client_commit("dc", "strange revision")
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+
+ def test_fetch_backslash(self):
+ if sys.platform == 'win32':
+ raise TestSkipped("Unable to create filenames with backslash on Windows")
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file("trunk/file\\part", "data")
+ dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ self.assertRaises(InvalidFileName, oldrepos.copy_content_into, newrepos)
+
+ def test_fetch_null(self):
+ repos_url = self.make_repository('d')
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme(1))
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(1))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos, NULL_REVISION)
+
+ def test_fetch_complex_ids_dirs(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("dir")
+ dc.add_dir("dir/adir")
+ dc.change_dir_prop("", "bzr:revision-info", "")
+ dc.change_dir_prop("", "bzr:file-ids", "dir\tbloe\ndir/adir\tbla\n")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("bdir", "dir/adir")
+ dc.delete("dir/adir")
+ dc.change_dir_prop("", "bzr:revision-info", "properties: \n")
+ dc.change_dir_prop("", "bzr:file-ids", "bdir\tbla\n")
+ dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
+ tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", mapping))
+ self.assertEquals("bloe", tree.path2id("dir"))
+ self.assertIs(None, tree.path2id("dir/adir"))
+ self.assertEquals("bla", tree.path2id("bdir"))
- def test_fetch_complex_ids(self):
+ def test_fetch_complex_ids_files(self):
repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/dir/adir': None})
+ self.build_tree({'dc/dir/adir': 'contents'})
self.client_add("dc/dir")
self.client_set_prop("dc", "bzr:revision-info", "")
self.client_set_prop("dc", "bzr:file-ids", "dir\tbloe\ndir/adir\tbla\n")
self.client_update("dc")
self.client_copy("dc/dir/adir", "dc/bdir")
self.client_delete("dc/dir/adir")
- self.client_set_prop("dc", "bzr:revision-info", "\n")
+ self.client_set_prop("dc", "bzr:revision-info", "properties: \n")
self.client_set_prop("dc", "bzr:file-ids", "bdir\tbla\n")
self.client_commit("dc", "My Message")
self.client_update("dc")
oldrepos = Repository.open(repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
- tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", "none"))
+ mapping = oldrepos.get_mapping()
+ tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", mapping))
self.assertEquals("bloe", tree.path2id("dir"))
self.assertIs(None, tree.path2id("dir/adir"))
+ mutter('entries: %r' % tree.inventory.entries())
self.assertEquals("bla", tree.path2id("bdir"))
- self.fail()
- def test_fetch_special_char(self):
+ def test_fetch_copy_remove_old(self):
repos_url = self.make_client('d', 'dc')
- self.build_tree({u'dc/trunk/f\x2cle': "data"})
+ self.build_tree({'dc/trunk/afile': 'foo', 'dc/tags': None,
+ 'dc/branches': None})
self.client_add("dc/trunk")
+ self.client_add("dc/tags")
+ self.client_add("dc/branches")
self.client_commit("dc", "My Message")
+ self.client_update("dc")
+ self.client_copy("dc/trunk", "dc/branches/blal")
+ self.build_tree({'dc/branches/blal/afile': "bar"})
+ self.client_commit("dc", "Msg")
+ self.client_update("dc")
+ self.client_copy("dc/trunk", "dc/tags/bla")
+ self.client_delete("dc/tags/bla/afile")
+ self.client_copy("dc/branches/blal/afile", "dc/tags/bla/afile")
+ self.client_commit("dc", "My Message")
+ self.client_update("dc")
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme(1))
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+
+ def test_fetch_special_char(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file(u"trunk/f\x2cle".encode("utf-8"), "data")
+ dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+
+ def test_fetch_signature(self):
+ repos_url = self.make_repository('d')
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file("trunk/bar", "data")
+ dc.done()
+
+ self.client_set_revprop(repos_url, 1, "bzr:gpg-signature", "SIGNATURE")
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+ self.assertEquals("SIGNATURE", newrepos.get_signature_text(oldrepos.generate_revision_id(1, "trunk", oldrepos.get_mapping())))
+
+ def test_fetch_special_char_edit(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_dir(u'trunk/IöC'.encode("utf-8"))
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file(u'trunk/IöC/bar'.encode("utf-8"), "more data")
+ dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ def test_fetch_special_char_child(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_dir(u"trunk/é".encode("utf-8"))
+ dc.add_file(u'trunk/é/f\x2cle'.encode("utf-8"), "data")
+ dc.done()
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+
+ def test_fetch_special_char_modify(self):
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file(u"trunk/€\x2c".encode("utf-8"), "data")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_file(u"trunk/€\x2c".encode("utf-8"), "bar")
+ revno = dc.done()
+
+ oldrepos = Repository.open(repos_url)
+ set_branching_scheme(oldrepos, TrunkBranchingScheme(0))
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+ self.assertEquals(2, revno)
+
def test_fetch_delete(self):
repos_url = self.make_client('d', 'dc')
self.build_tree({'dc/foo/bla': "data"})
self.client_add("dc/foo")
self.client_commit("dc", "My Message")
oldrepos = Repository.open(repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
self.client_delete("dc/foo/bla")
self.client_commit("dc", "Second Message")
newrepos = Repository.open("f")
oldrepos.copy_content_into(newrepos)
- self.assertTrue(oldrepos.has_revision(oldrepos.generate_revision_id(2, "", "none")))
+ mapping = oldrepos.get_mapping()
+ self.assertTrue(oldrepos.has_revision(oldrepos.generate_revision_id(2, "", mapping)))
def test_fetch_delete_recursive(self):
repos_url = self.make_client('d', 'dc')
dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
- tree = newrepos.revision_tree(oldrepos.generate_revision_id(1, "", "none"))
+ mapping = oldrepos.get_mapping()
+ tree = newrepos.revision_tree(oldrepos.generate_revision_id(1, "", mapping))
self.assertEquals(3, len(tree.inventory))
- tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", "none"))
+ tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", mapping))
self.assertEquals(1, len(tree.inventory))
def test_fetch_local(self):
self.client_add("dc/bar")
self.client_commit("dc", "Second Message")
oldrepos = Repository.open(repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(2, "", "none")))
- tree = newrepos.revision_tree(
- oldrepos.generate_revision_id(2, "", "none"))
- self.assertTrue(tree.has_filename("foo/bla"))
- self.assertTrue(tree.has_filename("foo"))
- self.assertEqual("data", tree.get_file_by_path("foo/bla").read())
+ oldrepos.generate_revision_id(2, "", mapping)))
+ newrepos.lock_read()
+ try:
+ tree = newrepos.revision_tree(
+ oldrepos.generate_revision_id(2, "", mapping))
+ self.assertTrue(tree.has_filename("foo/bla"))
+ self.assertTrue(tree.has_filename("foo"))
+ self.assertEqual("data", tree.get_file_by_path("foo/bla").read())
+ finally:
+ newrepos.unlock()
def test_fetch_replace(self):
repos_url = self.make_client('d', 'dc')
self.client_add("dc/bla")
self.client_commit("dc", "Second Message")
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(2, "", "none")))
+ oldrepos.generate_revision_id(2, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(2, "", "none"))
+ oldrepos.generate_revision_id(2, "", mapping))
self.assertNotEqual(inv1.path2id("bla"), inv2.path2id("bla"))
def test_fetch_copy_subdir(self):
self.client_copy("dc/trunk/mydir", "dc/branches/tmp/abranch")
self.client_commit("dc", "Third Message")
oldrepos = Repository.open("svn+"+repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
self.assertTrue(inv1.has_filename(u"x\xe1"))
def test_fetch_replace_with_subreplace(self):
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(3, "", "none")))
+ oldrepos.generate_revision_id(3, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(3, "", "none"))
+ oldrepos.generate_revision_id(3, "", mapping))
def test_fetch_replace_self(self):
filename = os.path.join(self.test_dir, "dumpfile")
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(3, "", "none")))
+ oldrepos.generate_revision_id(3, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(3, "", "none"))
+ oldrepos.generate_revision_id(3, "", mapping))
self.assertEqual(inv1.path2id("bla"), inv2.path2id("bla"))
def test_fetch_replace_backup(self):
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(3, "", "none")))
+ oldrepos.generate_revision_id(3, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(3, "", "none"))
+ oldrepos.generate_revision_id(3, "", mapping))
self.assertEqual(inv1.path2id("bla"), inv2.path2id("bla"))
def test_fetch_replace_unrelated(self):
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(4, "", "none")))
+ oldrepos.generate_revision_id(4, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(4, "", "none"))
+ oldrepos.generate_revision_id(4, "", mapping))
self.assertNotEqual(inv1.path2id("x"), inv2.path2id("x"))
def test_fetch_replace_related(self):
load_dumpfile("dumpfile", "old")
oldrepos = Repository.open("old")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(5, "", "none")))
+ oldrepos.generate_revision_id(5, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(5, "", "none"))
+ oldrepos.generate_revision_id(5, "", mapping))
self.assertNotEqual(inv1.path2id("y"), inv2.path2id("y"))
def test_fetch_dir_upgrade(self):
- repos_url = self.make_client('d', 'dc')
+ repos_url = self.make_repository('d')
- self.build_tree({'dc/trunk/lib/file': 'data'})
- self.client_add("dc/trunk")
- self.client_commit("dc", "trunk data")
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_dir("trunk/lib")
+ dc.add_file("trunk/lib/file", 'data')
+ dc.done()
- self.build_tree({'dc/branches': None})
- self.client_add("dc/branches")
- self.client_copy("dc/trunk/lib", "dc/branches/mybranch")
- self.client_commit("dc", "split out lib")
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("branches")
+ dc.add_dir("branches/mybranch", "trunk/lib")
+ dc.done()
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
branch = Branch.open("%s/branches/mybranch" % repos_url)
- self.assertEqual([oldrepos.generate_revision_id(2, "branches/mybranch", "trunk0")],
+ mapping = oldrepos.get_mapping()
+ self.assertEqual([oldrepos.generate_revision_id(2, "branches/mybranch", mapping)],
branch.revision_history())
def test_fetch_file_from_non_branch(self):
self.client_commit("dc", "revive old trunk")
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
branch = Branch.open("%s/trunk" % repos_url)
- self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
+ self.assertEqual([oldrepos.generate_revision_id(2, "trunk", oldrepos.get_mapping())],
branch.revision_history())
def test_fetch_dir_from_non_branch(self):
self.client_add("dc/old-trunk")
self.client_commit("dc", "trunk data")
- self.build_tree({'dc/trunk': None})
- self.client_add("dc/trunk")
- self.client_copy("dc/old-trunk/lib", "dc/trunk")
+ self.client_copy("dc/old-trunk", "dc/trunk")
self.client_commit("dc", "revive old trunk")
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
branch = Branch.open("%s/trunk" % repos_url)
- self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
+ self.assertEqual([oldrepos.generate_revision_id(2, "trunk", oldrepos.get_mapping())],
branch.revision_history())
def test_fetch_from_non_branch(self):
- repos_url = self.make_client('d', 'dc')
+ repos_url = self.make_repository('d')
- self.build_tree({'dc/old-trunk/lib/file': 'data'})
- self.client_add("dc/old-trunk")
- self.client_commit("dc", "trunk data")
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("old-trunk")
+ dc.add_dir("old-trunk/lib")
+ dc.add_file("old-trunk/lib/file", "data")
+ dc.done()
- self.client_copy("dc/old-trunk", "dc/trunk")
- self.client_commit("dc", "revive old trunk")
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk", "old-trunk")
+ dc.done()
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
branch = Branch.open("%s/trunk" % repos_url)
- self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
+ self.assertEqual([oldrepos.generate_revision_id(2, "trunk", oldrepos.get_mapping())],
branch.revision_history())
self.client_commit("dc", "split out lib")
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
def test_fetch_all(self):
- repos_url = self.make_client('d', 'dc')
+ repos_url = self.make_repository('d')
- self.build_tree({'dc/trunk': None,
- 'dc/trunk/hosts': 'hej1'})
- self.client_add("dc/trunk")
- self.client_commit("dc", "created trunk and added hosts") #1
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file("trunk/hosts", 'hej1')
+ dc.done()
- self.build_tree({'dc/trunk/hosts': 'hej2'})
- self.client_commit("dc", "rev 2") #2
+ dc = self.commit_editor(repos_url)
+ dc.change_file('trunk/hosts', 'hej2')
+ dc.done()
- self.build_tree({'dc/trunk/hosts': 'hej3'})
- self.client_commit("dc", "rev 3") #3
+ dc = self.commit_editor(repos_url)
+ dc.change_file('trunk/hosts', 'hej3')
+ dc.done()
- self.build_tree({'dc/branches/foobranch/file': 'foohosts'})
- self.client_add("dc/branches")
- self.client_commit("dc", "foohosts") #4
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("branches")
+ dc.add_dir("branches/foobranch")
+ dc.add_file("branches/foobranch/file", 'foohosts')
+ dc.done()
oldrepos = Repository.open(repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
+
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "trunk", "trunk0")))
+ oldrepos.generate_revision_id(1, "trunk", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(2, "trunk", "trunk0")))
+ oldrepos.generate_revision_id(2, "trunk", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(3, "trunk", "trunk0")))
+ oldrepos.generate_revision_id(3, "trunk", mapping)))
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(4, "branches/foobranch", "trunk0")))
+ oldrepos.generate_revision_id(4, "branches/foobranch", mapping)))
self.assertFalse(newrepos.has_revision(
- oldrepos.generate_revision_id(4, "trunk", "trunk0")))
+ oldrepos.generate_revision_id(4, "trunk", mapping)))
self.assertFalse(newrepos.has_revision(
- oldrepos.generate_revision_id(2, "", "trunk0")))
+ oldrepos.generate_revision_id(2, "", mapping)))
def test_fetch_copy_root_id_kept(self):
repos_url = self.make_client('d', 'dc')
self.client_copy("dc/trunk", "dc/branches/foobranch")
self.client_commit("dc", "added branch foobranch") #3
- repos = format.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnFormat()).find_repository()
+ repos = remote.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnRemoteFormat()).find_repository()
+ set_branching_scheme(repos, TrunkBranchingScheme())
+
+ mapping = repos.get_mapping()
tree = repos.revision_tree(
- repos.generate_revision_id(3, "branches/foobranch", "trunk0"))
+ repos.generate_revision_id(3, "branches/foobranch", mapping))
- self.assertEqual(generate_svn_file_id(repos.uuid, 1, "trunk", ""), tree.inventory.root.file_id)
+ self.assertEqual(mapping.generate_file_id(repos.uuid, 1, "trunk", u""), tree.inventory.root.file_id)
def test_fetch_odd(self):
repos_url = self.make_client('d', 'dc')
'dc/trunk/hosts': 'hej1'})
self.client_add("dc/trunk")
self.client_commit("dc", "created trunk and added hosts") #1
+ self.client_update("dc")
self.build_tree({'dc/trunk/hosts': 'hej2'})
self.client_commit("dc", "rev 2") #2
+ self.client_update("dc")
self.build_tree({'dc/trunk/hosts': 'hej3'})
self.client_commit("dc", "rev 3") #3
+ self.client_update("dc")
self.build_tree({'dc/branches': None})
self.client_add("dc/branches")
self.client_commit("dc", "added branches") #4
+ self.client_update("dc")
self.client_copy("dc/trunk", "dc/branches/foobranch")
self.client_commit("dc", "added branch foobranch") #5
+ self.client_update("dc")
self.build_tree({'dc/branches/foobranch/hosts': 'foohosts'})
self.client_commit("dc", "foohosts") #6
- repos = format.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnFormat()).find_repository()
+ repos = remote.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnRemoteFormat()).find_repository()
+ set_branching_scheme(repos, TrunkBranchingScheme())
+
+ mapping = repos.get_mapping()
tree = repos.revision_tree(
- repos.generate_revision_id(6, "branches/foobranch", "trunk0"))
+ repos.generate_revision_id(6, "branches/foobranch", mapping))
def test_fetch_consistent(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/bla': "data"})
- self.client_add("dc/bla")
- self.client_set_prop("dc/bla", "svn:executable", "*")
- self.client_commit("dc", "My Message")
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("bla", "data")
+ dc.change_file_prop("bla", "svn:executable", "*")
+ dc.done()
+
oldrepos = Repository.open("svn+"+repos_url)
- dir1 = BzrDir.create("f",format.get_rich_root_format())
- dir2 = BzrDir.create("g",format.get_rich_root_format())
+ dir1 = BzrDir.create("f", format.get_rich_root_format())
+ dir2 = BzrDir.create("g", format.get_rich_root_format())
newrepos1 = dir1.create_repository()
newrepos2 = dir2.create_repository()
oldrepos.copy_content_into(newrepos1)
oldrepos.copy_content_into(newrepos2)
+ mapping = oldrepos.get_mapping()
inv1 = newrepos1.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
inv2 = newrepos2.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
self.assertEqual(inv1, inv2)
def test_fetch_executable(self):
self.client_set_prop("dc/blie", "svn:executable", "")
self.client_commit("dc", "My Message")
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
self.assertTrue(inv1[inv1.path2id("bla")].executable)
self.assertTrue(inv1[inv1.path2id("blie")].executable)
def test_fetch_symlink(self):
+ if not has_symlinks():
+ return
repos_url = self.make_client('d', 'dc')
self.build_tree({'dc/bla': "data"})
os.symlink('bla', 'dc/mylink')
self.client_add("dc/mylink")
self.client_commit("dc", "My Message")
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
self.assertEqual('symlink', inv1[inv1.path2id("mylink")].kind)
self.assertEqual('bla', inv1[inv1.path2id("mylink")].symlink_target)
+ def test_fetch_symlink_kind_change(self):
+ repos_url = self.make_client('d', 'dc')
+ self.build_tree({'dc/bla': "data", "dc/mylink": "link bla"})
+ self.client_add("dc/bla")
+ self.client_add("dc/mylink")
+ self.client_commit("dc", "My Message")
+ ra = SvnRaTransport(repos_url)
+ def done(info, pool):
+ pass
+ editor = ra.get_commit_editor({"svn:log": "msg"}, done, None, False)
+ root_baton = editor.open_root(1)
+ baton = root_baton.open_file("mylink", 1)
+ baton.change_prop("svn:special", "*")
+ baton.close()
+ root_baton.close()
+ editor.close()
+ oldrepos = Repository.open("svn+"+repos_url)
+ dir = BzrDir.create("f", format.get_rich_root_format())
+ newrepos = dir.create_repository()
+ oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
+ self.assertTrue(newrepos.has_revision(
+ oldrepos.generate_revision_id(1, "", mapping)))
+ inv1 = newrepos.get_inventory(
+ oldrepos.generate_revision_id(1, "", mapping))
+ inv2 = newrepos.get_inventory(
+ oldrepos.generate_revision_id(2, "", mapping))
+ self.assertEqual('file', inv1[inv1.path2id("mylink")].kind)
+ self.assertEqual('symlink', inv2[inv2.path2id("mylink")].kind)
+ self.assertEqual('bla', inv2[inv2.path2id("mylink")].symlink_target)
def test_fetch_executable_separate(self):
repos_url = self.make_client('d', 'dc')
self.client_set_prop("dc/bla", "svn:executable", "*")
self.client_commit("dc", "Make executable")
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertTrue(newrepos.has_revision(
- oldrepos.generate_revision_id(1, "", "none")))
+ oldrepos.generate_revision_id(1, "", mapping)))
inv1 = newrepos.get_inventory(
- oldrepos.generate_revision_id(1, "", "none"))
+ oldrepos.generate_revision_id(1, "", mapping))
self.assertFalse(inv1[inv1.path2id("bla")].executable)
inv2 = newrepos.get_inventory(
- oldrepos.generate_revision_id(2, "", "none"))
+ oldrepos.generate_revision_id(2, "", mapping))
self.assertTrue(inv2[inv2.path2id("bla")].executable)
- self.assertEqual(oldrepos.generate_revision_id(2, "", "none"),
+ self.assertEqual(oldrepos.generate_revision_id(2, "", mapping),
inv2[inv2.path2id("bla")].revision)
def test_fetch_ghosts(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/bla': "data"})
- self.client_add("dc/bla")
- self.client_set_prop("dc", "bzr:ancestry:v3-none", "aghost\n")
- self.client_commit("dc", "My Message")
+ repos_url = self.make_repository('d')
+
+ dc = self.commit_editor(repos_url)
+ dc.add_file("bla", "data")
+ dc.change_dir_prop("", "bzr:ancestry:v3-none", "aghost\n")
+ dc.done()
+
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
- rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", "none"))
+ rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", mapping))
self.assertTrue("aghost" in rev.parent_ids)
def test_fetch_svk_merge(self):
"%s:/branches/foo:2\n" % oldrepos.uuid)
self.client_commit("dc", "Merge")
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
- rev = newrepos.get_revision(oldrepos.generate_revision_id(3, "trunk", "trunk0"))
+ mapping = oldrepos.get_mapping()
+
+ rev = newrepos.get_revision(oldrepos.generate_revision_id(3, "trunk", mapping))
mutter('parent ids: %r' % rev.parent_ids)
- self.assertTrue(oldrepos.generate_revision_id(2, "branches/foo", "trunk0") in rev.parent_ids)
+ self.assertTrue(oldrepos.generate_revision_id(2, "branches/foo", mapping) in rev.parent_ids)
def test_fetch_invalid_ghosts(self):
repos_url = self.make_client('d', 'dc')
self.client_set_prop("dc", "bzr:ancestry:v3-none", "a ghost\n")
self.client_commit("dc", "My Message")
oldrepos = Repository.open("svn+"+repos_url)
- dir = BzrDir.create("f",format.get_rich_root_format())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+
+ mapping = oldrepos.get_mapping()
- rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", "none"))
- self.assertEqual([oldrepos.generate_revision_id(0, "", "none")], rev.parent_ids)
+ rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", mapping))
+ self.assertEqual([oldrepos.generate_revision_id(0, "", mapping)], rev.parent_ids)
def test_fetch_property_change_only(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/trunk/bla': "data"})
- self.client_add("dc/trunk")
- self.client_commit("dc", "My Message") #1
- self.client_set_prop("dc", "some:property", "some data\n")
- self.client_update("dc")
- self.client_commit("dc", "My 3") #2
- self.client_set_prop("dc", "some2:property", "some data\n")
- self.client_commit("dc", "My 2") #3
- self.client_set_prop("dc", "some:property", "some data4\n")
- self.client_commit("dc", "My 4") #4
+ repos_url = self.make_repository('d')
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file("trunk/bla", "data")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("", "some:property", "some data\n")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("", "some2:property", "some data\n")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("", "some:property", "some data4\n")
+ dc.done()
+
oldrepos = Repository.open("svn+"+repos_url)
dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertEquals([
- oldrepos.generate_revision_id(0, "", "none"),
- oldrepos.generate_revision_id(1, "", "none"),
- oldrepos.generate_revision_id(2, "", "none"),
- oldrepos.generate_revision_id(3, "", "none"),
- oldrepos.generate_revision_id(4, "", "none"),
+ oldrepos.generate_revision_id(0, "", mapping),
+ oldrepos.generate_revision_id(1, "", mapping),
+ oldrepos.generate_revision_id(2, "", mapping),
+ oldrepos.generate_revision_id(3, "", mapping),
+ oldrepos.generate_revision_id(4, "", mapping),
], newrepos.all_revision_ids())
def test_fetch_property_change_only_trunk(self):
- repos_url = self.make_client('d', 'dc')
- self.build_tree({'dc/trunk/bla': "data"})
- self.client_add("dc/trunk")
- self.client_commit("dc", "My Message")
- self.client_set_prop("dc/trunk", "some:property", "some data\n")
- self.client_commit("dc", "My 3")
- self.client_set_prop("dc/trunk", "some2:property", "some data\n")
- self.client_commit("dc", "My 2")
- self.client_set_prop("dc/trunk", "some:property", "some data3\n")
- self.client_commit("dc", "My 4")
+ repos_url = self.make_repository('d')
+ dc = self.commit_editor(repos_url)
+ dc.add_dir("trunk")
+ dc.add_file("trunk/bla", "data")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("trunk", "some:property", "some data\n")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("trunk", "some2:property", "some data\n")
+ dc.done()
+
+ dc = self.commit_editor(repos_url)
+ dc.change_dir_prop("trunk", "some:property", "some data3\n")
+ dc.done()
+
oldrepos = Repository.open("svn+"+repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
oldrepos.copy_content_into(newrepos)
+ mapping = oldrepos.get_mapping()
self.assertEquals([
- oldrepos.generate_revision_id(1, "trunk", "trunk0"),
- oldrepos.generate_revision_id(2, "trunk", "trunk0"),
- oldrepos.generate_revision_id(3, "trunk", "trunk0"),
- oldrepos.generate_revision_id(4, "trunk", "trunk0"),
+ oldrepos.generate_revision_id(1, "trunk", mapping),
+ oldrepos.generate_revision_id(2, "trunk", mapping),
+ oldrepos.generate_revision_id(3, "trunk", mapping),
+ oldrepos.generate_revision_id(4, "trunk", mapping),
], newrepos.all_revision_ids())
def test_fetch_crosscopy(self):
self.client_commit("dc", "Change dir")
oldrepos = Repository.open("svn+"+repos_url)
- oldrepos.set_branching_scheme(TrunkBranchingScheme())
- dir = BzrDir.create("f",format.get_rich_root_format())
+ set_branching_scheme(oldrepos, TrunkBranchingScheme())
+ dir = BzrDir.create("f", format.get_rich_root_format())
newrepos = dir.create_repository()
- copyrev = oldrepos.generate_revision_id(2, "branches/abranch", "trunk0")
- prevrev = oldrepos.generate_revision_id(3, "branches/abranch", "trunk0")
- lastrev = oldrepos.generate_revision_id(4, "branches/abranch", "trunk0")
+ mapping = oldrepos.get_mapping()
+ copyrev = oldrepos.generate_revision_id(2, "branches/abranch", mapping)
+ prevrev = oldrepos.generate_revision_id(3, "branches/abranch", mapping)
+ lastrev = oldrepos.generate_revision_id(4, "branches/abranch", mapping)
oldrepos.copy_content_into(newrepos, lastrev)
inventory = newrepos.get_inventory(lastrev)
git.samba.org / jelmer / subvertpy.git / blobdiff