tests/test_fetch.py

   1 # Copyright (C) 2007 Jelmer Vernooij <jelmer@samba.org>
   2 # *-* coding: utf-8 *-*
   3
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2 of the License, or
   7 # (at your option) any later version.
   8
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17
  18 """Subversion fetch tests."""
  19
  20 import shutil
  21 from bzrlib.branch import Branch
  22 from bzrlib.bzrdir import BzrDir
  23 from bzrlib.repository import Repository
  24 from bzrlib.revision import NULL_REVISION
  25 from bzrlib.tests import TestSkipped, KnownFailure
  26 from bzrlib.trace import mutter
  27
  28 from convert import load_dumpfile
  29 from bzrlib.plugins.svn.errors import InvalidFileName
  30 from fileids import generate_file_id
  31 import format
  32 from mapping import default_mapping
  33 import remote
  34 from scheme import TrunkBranchingScheme, NoBranchingScheme
  35 from tests import TestCaseWithSubversionRepository
  36 from transport import SvnRaTransport
  37
  38 import os, sys
  39
  40 class TestFetchWorks(TestCaseWithSubversionRepository):
  41     def test_fetch_fileid_renames(self):
  42         repos_url = self.make_client('d', 'dc')
  43         self.build_tree({'dc/test': "data"})
  44         self.client_add("dc/test")
  45         self.client_set_prop("dc", "bzr:file-ids", "test\tbla\n")
  46         self.client_set_prop("dc", "bzr:revision-info", "")
  47         self.client_commit("dc", "Msg")
  48
  49         oldrepos = Repository.open(repos_url)
  50         dir = BzrDir.create("f", format.get_rich_root_format())
  51         newrepos = dir.create_repository()
  52         oldrepos.copy_content_into(newrepos)
  53         self.assertEqual("bla", newrepos.get_inventory(
  54             oldrepos.generate_revision_id(1, "", "none")).path2id("test"))
  55
  56     def test_fetch_trunk1(self):
  57         repos_url = self.make_client('d', 'dc')
  58         self.build_tree({'dc/proj1/trunk/file': "data"})
  59         self.client_add("dc/proj1")
  60         self.client_commit("dc", "My Message")
  61         oldrepos = Repository.open(repos_url)
  62         oldrepos.set_branching_scheme(TrunkBranchingScheme(1))
  63         dir = BzrDir.create("f",format.get_rich_root_format())
  64         newrepos = dir.create_repository()
  65         oldrepos.copy_content_into(newrepos)
  66
  67     def test_replace_from_branch(self):
  68         repos_url = self.make_client('d', 'dc')
  69         self.build_tree({'dc/trunk/check/debian': None,
  70                          'dc/trunk/check/stamp-h.in': 'foo',
  71                          'dc/tags': None})
  72         self.client_add("dc/trunk")
  73         self.client_add("dc/tags")
  74         self.client_commit("dc", "initial commit") #1
  75         self.client_update("dc")
  76         self.build_tree({'dc/trunk/check/debian/pl': "bar"})
  77         self.client_add("dc/trunk/check/debian/pl")
  78         self.client_commit("dc", "change") #2
  79         self.client_update("dc")
  80         self.build_tree({'dc/trunk/check/debian/voo': "bar"})
  81         self.client_add("dc/trunk/check/debian/voo")
  82         self.client_commit("dc", "change") #3
  83         self.client_update("dc")
  84         self.build_tree({"dc/trunk/check/debian/blie": "oeh"})
  85         self.client_add("dc/trunk/check/debian/blie")
  86         self.client_commit("dc", "second commit") #4
  87         self.client_update("dc")
  88         self.build_tree({"dc/trunk/check/debian/bar": "oeh",
  89                          "dc/trunk/check/bar": "bla"})
  90         self.client_add("dc/trunk/check/debian/bar")
  91         self.client_add("dc/trunk/check/bar")
  92         self.client_commit("dc", "make sure revnums are honored") #5
  93         self.client_update("dc")
  94         self.client_copy("dc/trunk", "dc/tags/R_0_9_2", revnum=2)
  95         self.client_delete("dc/tags/R_0_9_2/check/debian")
  96         shutil.rmtree("dc/tags/R_0_9_2/check/debian")
  97         self.client_copy("dc/trunk/check/debian", "dc/tags/R_0_9_2/check",
  98                          revnum=5)
  99         self.client_delete("dc/tags/R_0_9_2/check/stamp-h.in")
 100         self.client_copy("dc/trunk/check/stamp-h.in", "dc/tags/R_0_9_2/check",
 101                          revnum=4)
 102         self.build_tree({"dc/tags/R_0_9_2/check/debian/blie": "oehha"})
 103         self.client_update("dc")
 104         self.client_commit("dc", "strange revision")
 105         oldrepos = Repository.open(repos_url)
 106         oldrepos.set_branching_scheme(TrunkBranchingScheme(0))
 107         dir = BzrDir.create("f",format.get_rich_root_format())
 108         newrepos = dir.create_repository()
 109         oldrepos.copy_content_into(newrepos)
 110
 111     def test_fetch_backslash(self):
 112         if sys.platform == 'win32':
 113             raise TestSkipped("Unable to create filenames with backslash on Windows")
 114         repos_url = self.make_client('d', 'dc')
 115         self.build_tree({'dc/trunk/file\\part': "data"})
 116         self.client_add("dc/trunk")
 117         self.client_commit("dc", "My Message")
 118         oldrepos = Repository.open(repos_url)
 119         oldrepos.set_branching_scheme(TrunkBranchingScheme())
 120         dir = BzrDir.create("f",format.get_rich_root_format())
 121         newrepos = dir.create_repository()
 122         self.assertRaises(InvalidFileName, oldrepos.copy_content_into, newrepos)
 123
 124     def test_fetch_null(self):
 125         repos_url = self.make_client('d', 'dc')
 126         oldrepos = Repository.open(repos_url)
 127         oldrepos.set_branching_scheme(TrunkBranchingScheme(1))
 128         dir = BzrDir.create("f", format.get_rich_root_format())
 129         newrepos = dir.create_repository()
 130         oldrepos.copy_content_into(newrepos, NULL_REVISION)
 131
 132     def test_fetch_complex_ids_dirs(self):
 133         repos_url = self.make_client('d', 'dc')
 134         self.build_tree({'dc/dir/adir': None})
 135         self.client_add("dc/dir")
 136         self.client_set_prop("dc", "bzr:revision-info", "")
 137         self.client_set_prop("dc", "bzr:file-ids", "dir\tbloe\ndir/adir\tbla\n")
 138         self.client_commit("dc", "My Message")
 139         self.client_update("dc")
 140         self.client_copy("dc/dir/adir", "dc/bdir")
 141         self.client_delete("dc/dir/adir")
 142         self.client_set_prop("dc", "bzr:revision-info", "properties: \n")
 143         self.client_set_prop("dc", "bzr:file-ids", "bdir\tbla\n")
 144         self.client_commit("dc", "My Message")
 145         self.client_update("dc")
 146         oldrepos = Repository.open(repos_url)
 147         dir = BzrDir.create("f",format.get_rich_root_format())
 148         newrepos = dir.create_repository()
 149         oldrepos.copy_content_into(newrepos)
 150         tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", "none"))
 151         self.assertEquals("bloe", tree.path2id("dir"))
 152         self.assertIs(None, tree.path2id("dir/adir"))
 153         self.assertEquals("bla", tree.path2id("bdir"))
 154
 155     def test_fetch_complex_ids_files(self):
 156         repos_url = self.make_client('d', 'dc')
 157         self.build_tree({'dc/dir/adir': 'contents'})
 158         self.client_add("dc/dir")
 159         self.client_set_prop("dc", "bzr:revision-info", "")
 160         self.client_set_prop("dc", "bzr:file-ids", "dir\tbloe\ndir/adir\tbla\n")
 161         self.client_commit("dc", "My Message")
 162         self.client_update("dc")
 163         self.client_copy("dc/dir/adir", "dc/bdir")
 164         self.client_delete("dc/dir/adir")
 165         self.client_set_prop("dc", "bzr:revision-info", "properties: \n")
 166         self.client_set_prop("dc", "bzr:file-ids", "bdir\tbla\n")
 167         self.client_commit("dc", "My Message")
 168         self.client_update("dc")
 169         oldrepos = Repository.open(repos_url)
 170         dir = BzrDir.create("f",format.get_rich_root_format())
 171         newrepos = dir.create_repository()
 172         oldrepos.copy_content_into(newrepos)
 173         tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", "none"))
 174         self.assertEquals("bloe", tree.path2id("dir"))
 175         self.assertIs(None, tree.path2id("dir/adir"))
 176         mutter('entries: %r' % tree.inventory.entries())
 177         self.assertEquals("bla", tree.path2id("bdir"))
 178
 179     def test_fetch_special_char(self):
 180         repos_url = self.make_client('d', 'dc')
 181         self.build_tree({u'dc/trunk/f\x2cle': "data"})
 182         self.client_add("dc/trunk")
 183         self.client_commit("dc", "My Message")
 184         oldrepos = Repository.open(repos_url)
 185         oldrepos.set_branching_scheme(TrunkBranchingScheme(0))
 186         dir = BzrDir.create("f",format.get_rich_root_format())
 187         newrepos = dir.create_repository()
 188         oldrepos.copy_content_into(newrepos)
 189
 190     def test_fetch_special_char_edit(self):
 191         repos_url = self.make_client('d', 'dc')
 192         self.build_tree({u'dc/trunk/IöC': None})
 193         self.client_add("dc/trunk")
 194         self.client_commit("dc", "My Message")
 195         self.client_update("dc")
 196         self.build_tree({u'dc/trunk/IöC/bar': "more data"})
 197         self.client_add(u"dc/trunk/IöC/bar".encode("utf-8"))
 198         self.client_commit("dc", "My Message")
 199         oldrepos = Repository.open(repos_url)
 200         oldrepos.set_branching_scheme(TrunkBranchingScheme(0))
 201         dir = BzrDir.create("f",format.get_rich_root_format())
 202         newrepos = dir.create_repository()
 203         oldrepos.copy_content_into(newrepos)
 204
 205     def test_fetch_special_char_child(self):
 206         repos_url = self.make_client('d', 'dc')
 207         self.build_tree({u'dc/trunk/é/f\x2cle': "data"})
 208         self.client_add("dc/trunk")
 209         self.client_commit("dc", "My Message")
 210         oldrepos = Repository.open(repos_url)
 211         oldrepos.set_branching_scheme(TrunkBranchingScheme(0))
 212         dir = BzrDir.create("f",format.get_rich_root_format())
 213         newrepos = dir.create_repository()
 214         oldrepos.copy_content_into(newrepos)
 215
 216     def test_fetch_special_char_modify(self):
 217         repos_url = self.make_client('d', 'dc')
 218         self.build_tree({u'dc/trunk/€\x2c': "data"})
 219         self.client_add("dc/trunk")
 220         self.client_commit("dc", "My Message")
 221         self.client_update("dc")
 222         self.build_tree({u"dc/trunk/€\x2c": "bar"})
 223         revno = self.client_commit("dc", "My Message2")[0]
 224         oldrepos = Repository.open(repos_url)
 225         oldrepos.set_branching_scheme(TrunkBranchingScheme(0))
 226         dir = BzrDir.create("f",format.get_rich_root_format())
 227         newrepos = dir.create_repository()
 228         oldrepos.copy_content_into(newrepos)
 229         self.assertEquals(2, revno)
 230
 231     def test_fetch_delete(self):
 232         repos_url = self.make_client('d', 'dc')
 233         self.build_tree({'dc/foo/bla': "data"})
 234         self.client_add("dc/foo")
 235         self.client_commit("dc", "My Message")
 236         oldrepos = Repository.open(repos_url)
 237         dir = BzrDir.create("f",format.get_rich_root_format())
 238         newrepos = dir.create_repository()
 239         oldrepos.copy_content_into(newrepos)
 240         self.client_delete("dc/foo/bla")
 241         self.client_commit("dc", "Second Message")
 242         newrepos = Repository.open("f")
 243         oldrepos.copy_content_into(newrepos)
 244         self.assertTrue(oldrepos.has_revision(oldrepos.generate_revision_id(2, "", "none")))
 245
 246     def test_fetch_delete_recursive(self):
 247         repos_url = self.make_client('d', 'dc')
 248         self.build_tree({'dc/foo/bla': "data"})
 249         self.client_add("dc/foo")
 250         self.client_commit("dc", "My Message")
 251         self.client_delete("dc/foo")
 252         self.client_commit("dc", "Second Message")
 253         oldrepos = Repository.open(repos_url)
 254         dir = BzrDir.create("f", format.get_rich_root_format())
 255         newrepos = dir.create_repository()
 256         oldrepos.copy_content_into(newrepos)
 257         tree = newrepos.revision_tree(oldrepos.generate_revision_id(1, "", "none"))
 258         self.assertEquals(3, len(tree.inventory))
 259         tree = newrepos.revision_tree(oldrepos.generate_revision_id(2, "", "none"))
 260         self.assertEquals(1, len(tree.inventory))
 261
 262     def test_fetch_local(self):
 263         repos_url = self.make_client('d', 'dc')
 264         self.build_tree({'dc/foo/bla': "data"})
 265         self.client_add("dc/foo")
 266         self.client_commit("dc", "My Message")
 267         self.build_tree({'dc/foo/blo': "data2", "dc/bar/foo": "data3", 'dc/foo/bla': "data"})
 268         self.client_add("dc/foo/blo")
 269         self.client_add("dc/bar")
 270         self.client_commit("dc", "Second Message")
 271         oldrepos = Repository.open(repos_url)
 272         dir = BzrDir.create("f",format.get_rich_root_format())
 273         newrepos = dir.create_repository()
 274         oldrepos.copy_content_into(newrepos)
 275         self.assertTrue(newrepos.has_revision(
 276             oldrepos.generate_revision_id(1, "", "none")))
 277         self.assertTrue(newrepos.has_revision(
 278             oldrepos.generate_revision_id(2, "", "none")))
 279         newrepos.lock_read()
 280         try:
 281             tree = newrepos.revision_tree(
 282                     oldrepos.generate_revision_id(2, "", "none"))
 283             self.assertTrue(tree.has_filename("foo/bla"))
 284             self.assertTrue(tree.has_filename("foo"))
 285             self.assertEqual("data", tree.get_file_by_path("foo/bla").read())
 286         finally:
 287             newrepos.unlock()
 288
 289     def test_fetch_replace(self):
 290         repos_url = self.make_client('d', 'dc')
 291         self.build_tree({'dc/bla': "data"})
 292         self.client_add("dc/bla")
 293         self.client_commit("dc", "My Message")
 294         self.client_delete("dc/bla")
 295         self.build_tree({'dc/bla': "data2"})
 296         self.client_add("dc/bla")
 297         self.client_commit("dc", "Second Message")
 298         oldrepos = Repository.open("svn+"+repos_url)
 299         dir = BzrDir.create("f",format.get_rich_root_format())
 300         newrepos = dir.create_repository()
 301         oldrepos.copy_content_into(newrepos)
 302         self.assertTrue(newrepos.has_revision(
 303             oldrepos.generate_revision_id(1, "", "none")))
 304         self.assertTrue(newrepos.has_revision(
 305             oldrepos.generate_revision_id(2, "", "none")))
 306         inv1 = newrepos.get_inventory(
 307                 oldrepos.generate_revision_id(1, "", "none"))
 308         inv2 = newrepos.get_inventory(
 309                 oldrepos.generate_revision_id(2, "", "none"))
 310         self.assertNotEqual(inv1.path2id("bla"), inv2.path2id("bla"))
 311
 312     def test_fetch_copy_subdir(self):
 313         repos_url = self.make_client('d', 'dc')
 314         self.build_tree({'dc/trunk/mydir/a': "data"})
 315         self.client_add("dc/trunk")
 316         self.client_commit("dc", "My Message")
 317         self.build_tree({'dc/branches/tmp': None})
 318         self.client_add("dc/branches")
 319         self.client_commit("dc", "Second Message")
 320         self.client_copy("dc/trunk/mydir", "dc/branches/tmp/abranch")
 321         self.client_commit("dc", "Third Message")
 322         oldrepos = Repository.open("svn+"+repos_url)
 323         oldrepos.set_branching_scheme(TrunkBranchingScheme())
 324         dir = BzrDir.create("f",format.get_rich_root_format())
 325         newrepos = dir.create_repository()
 326         oldrepos.copy_content_into(newrepos)
 327
 328     def test_fetch_replace_nordic(self):
 329         filename = os.path.join(self.test_dir, "dumpfile")
 330         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
 331
 332 UUID: 606c7b1f-987c-4826-b37d-eb556ceb87e1
 333
 334 Revision-number: 0
 335 Prop-content-length: 56
 336 Content-length: 56
 337
 338 K 8
 339 svn:date
 340 V 27
 341 2006-12-26T00:04:55.850520Z
 342 PROPS-END
 343
 344 Revision-number: 1
 345 Prop-content-length: 103
 346 Content-length: 103
 347
 348 K 7
 349 svn:log
 350 V 3
 351 add
 352 K 10
 353 svn:author
 354 V 6
 355 jelmer
 356 K 8
 357 svn:date
 358 V 27
 359 2006-12-26T00:05:15.504335Z
 360 PROPS-END
 361
 362 Node-path: x\xc3\xa1
 363 Node-kind: dir
 364 Node-action: add
 365 Prop-content-length: 10
 366 Content-length: 10
 367
 368 PROPS-END
 369
 370 Node-path: u\xc3\xa1
 371 Node-path: bla
 372 Node-kind: file
 373 Node-action: add
 374 Prop-content-length: 10
 375 Text-content-length: 5
 376 Text-content-md5: 49803c8f7913948eb3e30bae749ae6bd
 377 Content-length: 15
 378
 379 PROPS-END
 380 bloe
 381
 382
 383 Revision-number: 2
 384 Prop-content-length: 105
 385 Content-length: 105
 386
 387 K 7
 388 svn:log
 389 V 5
 390 readd
 391 K 10
 392 svn:author
 393 V 6
 394 jelmer
 395 K 8
 396 svn:date
 397 V 27
 398 2006-12-26T00:05:43.584249Z
 399 PROPS-END
 400
 401 Node-path: x\xc3\xa1
 402 Node-action: delete
 403
 404 """)
 405         os.mkdir("old")
 406
 407         load_dumpfile("dumpfile", "old")
 408         oldrepos = Repository.open("old")
 409         dir = BzrDir.create("f",format.get_rich_root_format())
 410         newrepos = dir.create_repository()
 411         oldrepos.copy_content_into(newrepos)
 412         self.assertTrue(newrepos.has_revision(
 413             oldrepos.generate_revision_id(1, "", "none")))
 414         inv1 = newrepos.get_inventory(
 415                 oldrepos.generate_revision_id(1, "", "none"))
 416         self.assertTrue(inv1.has_filename(u"x\xe1"))
 417
 418     def test_fetch_replace_with_subreplace(self):
 419         filename = os.path.join(self.test_dir, "dumpfile")
 420         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
 421
 422 UUID: 606c7b1f-987c-4826-b37d-eb456ceb87e1
 423
 424 Revision-number: 0
 425 Prop-content-length: 56
 426 Content-length: 56
 427
 428 K 8
 429 svn:date
 430 V 27
 431 2006-12-26T00:04:55.850520Z
 432 PROPS-END
 433
 434 Revision-number: 1
 435 Prop-content-length: 103
 436 Content-length: 103
 437
 438 K 7
 439 svn:log
 440 V 3
 441 add
 442 K 10
 443 svn:author
 444 V 6
 445 jelmer
 446 K 8
 447 svn:date
 448 V 27
 449 2006-12-26T00:05:15.504335Z
 450 PROPS-END
 451
 452 Node-path: x
 453 Node-kind: dir
 454 Node-action: add
 455 Prop-content-length: 10
 456 Content-length: 10
 457
 458 PROPS-END
 459
 460 Node-path: x/t
 461 Node-kind: dir
 462 Node-action: add
 463 Prop-content-length: 10
 464 Content-length: 10
 465
 466 PROPS-END
 467
 468 Node-path: u
 469 Node-kind: dir
 470 Node-action: add
 471 Prop-content-length: 10
 472 Content-length: 10
 473
 474 PROPS-END
 475
 476 Revision-number: 2
 477 Prop-content-length: 105
 478 Content-length: 105
 479
 480 K 7
 481 svn:log
 482 V 5
 483 readd
 484 K 10
 485 svn:author
 486 V 6
 487 jelmer
 488 K 8
 489 svn:date
 490 V 27
 491 2006-12-26T00:05:43.584249Z
 492 PROPS-END
 493
 494 Node-path: x
 495 Node-action: delete
 496
 497 Node-path: x
 498 Node-kind: dir
 499 Node-action: add
 500 Prop-content-length: 10
 501 Content-length: 10
 502
 503 PROPS-END
 504
 505
 506 Revision-number: 3
 507 Prop-content-length: 108
 508 Content-length: 108
 509
 510 K 7
 511 svn:log
 512 V 8
 513 Replace
 514
 515 K 10
 516 svn:author
 517 V 6
 518 jelmer
 519 K 8
 520 svn:date
 521 V 27
 522 2006-12-25T04:30:06.383777Z
 523 PROPS-END
 524
 525 Node-path: x
 526 Node-action: delete
 527
 528 Node-path: y
 529 Node-kind: dir
 530 Node-action: add
 531 Node-copyfrom-rev: 1
 532 Node-copyfrom-path: x
 533
 534 Node-path: y/t
 535 Node-action: delete
 536
 537 Node-path: y/t
 538 Node-kind: dir
 539 Node-action: add
 540 Node-copyfrom-rev: 1
 541 Node-copyfrom-path: u
 542
 543
 544 """)
 545         os.mkdir("old")
 546
 547         load_dumpfile("dumpfile", "old")
 548         oldrepos = Repository.open("old")
 549         dir = BzrDir.create("f",format.get_rich_root_format())
 550         newrepos = dir.create_repository()
 551         oldrepos.copy_content_into(newrepos)
 552         self.assertTrue(newrepos.has_revision(
 553             oldrepos.generate_revision_id(1, "", "none")))
 554         self.assertTrue(newrepos.has_revision(
 555             oldrepos.generate_revision_id(3, "", "none")))
 556         inv1 = newrepos.get_inventory(
 557                 oldrepos.generate_revision_id(1, "", "none"))
 558         inv2 = newrepos.get_inventory(
 559                 oldrepos.generate_revision_id(3, "", "none"))
 560
 561     def test_fetch_replace_self(self):
 562         filename = os.path.join(self.test_dir, "dumpfile")
 563         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
 564
 565 UUID: 6dcc86fc-ac21-4df7-a3a3-87616123c853
 566
 567 Revision-number: 0
 568 Prop-content-length: 56
 569 Content-length: 56
 570
 571 K 8
 572 svn:date
 573 V 27
 574 2006-12-25T04:27:54.633666Z
 575 PROPS-END
 576
 577 Revision-number: 1
 578 Prop-content-length: 108
 579 Content-length: 108
 580
 581 K 7
 582 svn:log
 583 V 8
 584 Add dir
 585
 586 K 10
 587 svn:author
 588 V 6
 589 jelmer
 590 K 8
 591 svn:date
 592 V 27
 593 2006-12-25T04:28:17.503039Z
 594 PROPS-END
 595
 596 Node-path: bla
 597 Node-kind: dir
 598 Node-action: add
 599 Prop-content-length: 10
 600 Content-length: 10
 601
 602 PROPS-END
 603
 604
 605 Revision-number: 2
 606 Prop-content-length: 117
 607 Content-length: 117
 608
 609 K 7
 610 svn:log
 611 V 16
 612 Add another dir
 613
 614 K 10
 615 svn:author
 616 V 6
 617 jelmer
 618 K 8
 619 svn:date
 620 V 27
 621 2006-12-25T04:28:30.160663Z
 622 PROPS-END
 623
 624 Node-path: blie
 625 Node-kind: dir
 626 Node-action: add
 627 Prop-content-length: 10
 628 Content-length: 10
 629
 630 PROPS-END
 631
 632
 633 Revision-number: 3
 634 Prop-content-length: 105
 635 Content-length: 105
 636
 637 K 7
 638 svn:log
 639 V 5
 640 Copy
 641
 642 K 10
 643 svn:author
 644 V 6
 645 jelmer
 646 K 8
 647 svn:date
 648 V 27
 649 2006-12-25T04:28:44.996894Z
 650 PROPS-END
 651
 652 Node-path: bloe
 653 Node-kind: dir
 654 Node-action: add
 655 Node-copyfrom-rev: 1
 656 Node-copyfrom-path: bla
 657
 658
 659 Revision-number: 4
 660 Prop-content-length: 108
 661 Content-length: 108
 662
 663 K 7
 664 svn:log
 665 V 8
 666 Replace
 667
 668 K 10
 669 svn:author
 670 V 6
 671 jelmer
 672 K 8
 673 svn:date
 674 V 27
 675 2006-12-25T04:30:06.383777Z
 676 PROPS-END
 677
 678 Node-path: bla
 679 Node-action: delete
 680
 681
 682 Node-path: bla
 683 Node-kind: dir
 684 Node-action: add
 685 Node-copyfrom-rev: 2
 686 Node-copyfrom-path: bla
 687
 688
 689 """)
 690         os.mkdir("old")
 691
 692         load_dumpfile("dumpfile", "old")
 693         oldrepos = Repository.open("old")
 694         dir = BzrDir.create("f",format.get_rich_root_format())
 695         newrepos = dir.create_repository()
 696         oldrepos.copy_content_into(newrepos)
 697         self.assertTrue(newrepos.has_revision(
 698             oldrepos.generate_revision_id(1, "", "none")))
 699         self.assertTrue(newrepos.has_revision(
 700             oldrepos.generate_revision_id(3, "", "none")))
 701         inv1 = newrepos.get_inventory(
 702                 oldrepos.generate_revision_id(1, "", "none"))
 703         inv2 = newrepos.get_inventory(
 704                 oldrepos.generate_revision_id(3, "", "none"))
 705         self.assertEqual(inv1.path2id("bla"), inv2.path2id("bla"))
 706
 707     def test_fetch_replace_backup(self):
 708         filename = os.path.join(self.test_dir, "dumpfile")
 709         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
 710
 711 UUID: 6dcc86fc-ac21-4df7-a3a3-87616123c853
 712
 713 Revision-number: 0
 714 Prop-content-length: 56
 715 Content-length: 56
 716
 717 K 8
 718 svn:date
 719 V 27
 720 2006-12-25T04:27:54.633666Z
 721 PROPS-END
 722
 723 Revision-number: 1
 724 Prop-content-length: 108
 725 Content-length: 108
 726
 727 K 7
 728 svn:log
 729 V 8
 730 Add dir
 731
 732 K 10
 733 svn:author
 734 V 6
 735 jelmer
 736 K 8
 737 svn:date
 738 V 27
 739 2006-12-25T04:28:17.503039Z
 740 PROPS-END
 741
 742 Node-path: bla
 743 Node-kind: dir
 744 Node-action: add
 745 Prop-content-length: 10
 746 Content-length: 10
 747
 748 PROPS-END
 749
 750
 751 Revision-number: 2
 752 Prop-content-length: 117
 753 Content-length: 117
 754
 755 K 7
 756 svn:log
 757 V 16
 758 Add another dir
 759
 760 K 10
 761 svn:author
 762 V 6
 763 jelmer
 764 K 8
 765 svn:date
 766 V 27
 767 2006-12-25T04:28:30.160663Z
 768 PROPS-END
 769
 770 Node-path: blie
 771 Node-kind: dir
 772 Node-action: add
 773 Prop-content-length: 10
 774 Content-length: 10
 775
 776 PROPS-END
 777
 778
 779 Revision-number: 3
 780 Prop-content-length: 105
 781 Content-length: 105
 782
 783 K 7
 784 svn:log
 785 V 5
 786 Copy
 787
 788 K 10
 789 svn:author
 790 V 6
 791 jelmer
 792 K 8
 793 svn:date
 794 V 27
 795 2006-12-25T04:28:44.996894Z
 796 PROPS-END
 797
 798 Node-path: bloe
 799 Node-kind: dir
 800 Node-action: add
 801 Node-copyfrom-rev: 1
 802 Node-copyfrom-path: bla
 803
 804
 805 Revision-number: 4
 806 Prop-content-length: 112
 807 Content-length: 112
 808
 809 K 7
 810 svn:log
 811 V 11
 812 Change bla
 813
 814 K 10
 815 svn:author
 816 V 6
 817 jelmer
 818 K 8
 819 svn:date
 820 V 27
 821 2006-12-25T23:51:09.678679Z
 822 PROPS-END
 823
 824 Node-path: bla
 825 Node-kind: dir
 826 Node-action: change
 827 Prop-content-length: 28
 828 Content-length: 28
 829
 830 K 3
 831 foo
 832 V 5
 833 bloe
 834
 835 PROPS-END
 836
 837
 838 Revision-number: 5
 839 Prop-content-length: 108
 840 Content-length: 108
 841
 842 K 7
 843 svn:log
 844 V 8
 845 Replace
 846
 847 K 10
 848 svn:author
 849 V 6
 850 jelmer
 851 K 8
 852 svn:date
 853 V 27
 854 2006-12-25T04:30:06.383777Z
 855 PROPS-END
 856
 857 Node-path: bla
 858 Node-action: delete
 859
 860
 861 Node-path: bla
 862 Node-kind: dir
 863 Node-action: add
 864 Node-copyfrom-rev: 1
 865 Node-copyfrom-path: bla
 866
 867
 868 """)
 869         os.mkdir("old")
 870
 871         load_dumpfile("dumpfile", "old")
 872         oldrepos = Repository.open("old")
 873         dir = BzrDir.create("f",format.get_rich_root_format())
 874         newrepos = dir.create_repository()
 875         oldrepos.copy_content_into(newrepos)
 876         self.assertTrue(newrepos.has_revision(
 877             oldrepos.generate_revision_id(1, "", "none")))
 878         self.assertTrue(newrepos.has_revision(
 879             oldrepos.generate_revision_id(3, "", "none")))
 880         inv1 = newrepos.get_inventory(
 881                 oldrepos.generate_revision_id(1, "", "none"))
 882         inv2 = newrepos.get_inventory(
 883                 oldrepos.generate_revision_id(3, "", "none"))
 884         self.assertEqual(inv1.path2id("bla"), inv2.path2id("bla"))
 885
 886     def test_fetch_replace_unrelated(self):
 887         filename = os.path.join(self.test_dir, "dumpfile")
 888         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
 889
 890 UUID: 606c7b1f-987c-4826-b37d-eb456ceb87e1
 891
 892 Revision-number: 0
 893 Prop-content-length: 56
 894 Content-length: 56
 895
 896 K 8
 897 svn:date
 898 V 27
 899 2006-12-26T00:04:55.850520Z
 900 PROPS-END
 901
 902 Revision-number: 1
 903 Prop-content-length: 103
 904 Content-length: 103
 905
 906 K 7
 907 svn:log
 908 V 3
 909 add
 910 K 10
 911 svn:author
 912 V 6
 913 jelmer
 914 K 8
 915 svn:date
 916 V 27
 917 2006-12-26T00:05:15.504335Z
 918 PROPS-END
 919
 920 Node-path: x
 921 Node-kind: dir
 922 Node-action: add
 923 Prop-content-length: 10
 924 Content-length: 10
 925
 926 PROPS-END
 927
 928
 929 Revision-number: 2
 930 Prop-content-length: 102
 931 Content-length: 102
 932
 933 K 7
 934 svn:log
 935 V 2
 936 rm
 937 K 10
 938 svn:author
 939 V 6
 940 jelmer
 941 K 8
 942 svn:date
 943 V 27
 944 2006-12-26T00:05:30.775369Z
 945 PROPS-END
 946
 947 Node-path: x
 948 Node-action: delete
 949
 950
 951 Revision-number: 3
 952 Prop-content-length: 105
 953 Content-length: 105
 954
 955 K 7
 956 svn:log
 957 V 5
 958 readd
 959 K 10
 960 svn:author
 961 V 6
 962 jelmer
 963 K 8
 964 svn:date
 965 V 27
 966 2006-12-26T00:05:43.584249Z
 967 PROPS-END
 968
 969 Node-path: x
 970 Node-kind: dir
 971 Node-action: add
 972 Prop-content-length: 10
 973 Content-length: 10
 974
 975 PROPS-END
 976
 977
 978 Revision-number: 4
 979 Prop-content-length: 108
 980 Content-length: 108
 981
 982 K 7
 983 svn:log
 984 V 8
 985 Replace
 986
 987 K 10
 988 svn:author
 989 V 6
 990 jelmer
 991 K 8
 992 svn:date
 993 V 27
 994 2006-12-25T04:30:06.383777Z
 995 PROPS-END
 996
 997 Node-path: x
 998 Node-action: delete
 999
1000
1001 Node-path: x
1002 Node-kind: dir
1003 Node-action: add
1004 Node-copyfrom-rev: 1
1005 Node-copyfrom-path: x
1006
1007
1008 """)
1009         os.mkdir("old")
1010
1011         load_dumpfile("dumpfile", "old")
1012         oldrepos = Repository.open("old")
1013         dir = BzrDir.create("f",format.get_rich_root_format())
1014         newrepos = dir.create_repository()
1015         oldrepos.copy_content_into(newrepos)
1016         self.assertTrue(newrepos.has_revision(
1017             oldrepos.generate_revision_id(1, "", "none")))
1018         self.assertTrue(newrepos.has_revision(
1019             oldrepos.generate_revision_id(4, "", "none")))
1020         inv1 = newrepos.get_inventory(
1021                 oldrepos.generate_revision_id(1, "", "none"))
1022         inv2 = newrepos.get_inventory(
1023                 oldrepos.generate_revision_id(4, "", "none"))
1024         self.assertNotEqual(inv1.path2id("x"), inv2.path2id("x"))
1025
1026     def test_fetch_replace_related(self):
1027         filename = os.path.join(self.test_dir, "dumpfile")
1028         open(filename, 'w').write("""SVN-fs-dump-format-version: 2
1029
1030 UUID: 606c7b1f-987c-4826-b37d-eb456ceb87e1
1031
1032 Revision-number: 0
1033 Prop-content-length: 56
1034 Content-length: 56
1035
1036 K 8
1037 svn:date
1038 V 27
1039 2006-12-26T00:04:55.850520Z
1040 PROPS-END
1041
1042 Revision-number: 1
1043 Prop-content-length: 103
1044 Content-length: 103
1045
1046 K 7
1047 svn:log
1048 V 3
1049 add
1050 K 10
1051 svn:author
1052 V 6
1053 jelmer
1054 K 8
1055 svn:date
1056 V 27
1057 2006-12-26T00:05:15.504335Z
1058 PROPS-END
1059
1060 Node-path: x
1061 Node-kind: dir
1062 Node-action: add
1063 Prop-content-length: 10
1064 Content-length: 10
1065
1066 PROPS-END
1067
1068
1069 Revision-number: 2
1070 Prop-content-length: 102
1071 Content-length: 102
1072
1073 K 7
1074 svn:log
1075 V 2
1076 rm
1077 K 10
1078 svn:author
1079 V 6
1080 jelmer
1081 K 8
1082 svn:date
1083 V 27
1084 2006-12-26T00:05:30.775369Z
1085 PROPS-END
1086
1087 Node-path: x
1088 Node-action: delete
1089
1090
1091 Revision-number: 3
1092 Prop-content-length: 105
1093 Content-length: 105
1094
1095 K 7
1096 svn:log
1097 V 5
1098 readd
1099 K 10
1100 svn:author
1101 V 6
1102 jelmer
1103 K 8
1104 svn:date
1105 V 27
1106 2006-12-26T00:05:43.584249Z
1107 PROPS-END
1108
1109 Node-path: y
1110 Node-kind: dir
1111 Node-action: add
1112 Node-copyfrom-rev: 1
1113 Node-copyfrom-path: x
1114 Prop-content-length: 10
1115 Content-length: 10
1116
1117 PROPS-END
1118
1119
1120 Revision-number: 4
1121 Prop-content-length: 108
1122 Content-length: 108
1123
1124 K 7
1125 svn:log
1126 V 8
1127 Replace
1128
1129 K 10
1130 svn:author
1131 V 6
1132 jelmer
1133 K 8
1134 svn:date
1135 V 27
1136 2006-12-25T04:30:06.383777Z
1137 PROPS-END
1138
1139 Node-path: y
1140 Node-action: delete
1141
1142
1143 Revision-number: 5
1144 Prop-content-length: 108
1145 Content-length: 108
1146
1147 K 7
1148 svn:log
1149 V 8
1150 Replace
1151
1152 K 10
1153 svn:author
1154 V 6
1155 jelmer
1156 K 8
1157 svn:date
1158 V 27
1159 2006-12-25T04:30:06.383777Z
1160 PROPS-END
1161
1162
1163 Node-path: y
1164 Node-kind: dir
1165 Node-action: add
1166 Node-copyfrom-rev: 1
1167 Node-copyfrom-path: x
1168
1169
1170 """)
1171         os.mkdir("old")
1172
1173         load_dumpfile("dumpfile", "old")
1174         oldrepos = Repository.open("old")
1175         dir = BzrDir.create("f",format.get_rich_root_format())
1176         newrepos = dir.create_repository()
1177         oldrepos.copy_content_into(newrepos)
1178         self.assertTrue(newrepos.has_revision(
1179             oldrepos.generate_revision_id(1, "", "none")))
1180         self.assertTrue(newrepos.has_revision(
1181             oldrepos.generate_revision_id(5, "", "none")))
1182         inv1 = newrepos.get_inventory(
1183                 oldrepos.generate_revision_id(1, "", "none"))
1184         inv2 = newrepos.get_inventory(
1185                 oldrepos.generate_revision_id(5, "", "none"))
1186         self.assertNotEqual(inv1.path2id("y"), inv2.path2id("y"))
1187
1188     def test_fetch_dir_upgrade(self):
1189         repos_url = self.make_client('d', 'dc')
1190
1191         self.build_tree({'dc/trunk/lib/file': 'data'})
1192         self.client_add("dc/trunk")
1193         self.client_commit("dc", "trunk data")
1194
1195         self.build_tree({'dc/branches': None})
1196         self.client_add("dc/branches")
1197         self.client_copy("dc/trunk/lib", "dc/branches/mybranch")
1198         self.client_commit("dc", "split out lib")
1199
1200         oldrepos = Repository.open(repos_url)
1201         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1202         dir = BzrDir.create("f",format.get_rich_root_format())
1203         newrepos = dir.create_repository()
1204         oldrepos.copy_content_into(newrepos)
1205
1206         branch = Branch.open("%s/branches/mybranch" % repos_url)
1207         self.assertEqual([oldrepos.generate_revision_id(2, "branches/mybranch", "trunk0")],
1208                          branch.revision_history())
1209
1210     def test_fetch_file_from_non_branch(self):
1211         repos_url = self.make_client('d', 'dc')
1212
1213         self.build_tree({'dc/old-trunk/lib/file': 'data'})
1214         self.client_add("dc/old-trunk")
1215         self.client_commit("dc", "trunk data")
1216
1217         self.build_tree({'dc/trunk/lib': None})
1218         self.client_add("dc/trunk")
1219         self.client_copy("dc/old-trunk/lib/file", "dc/trunk/lib/file")
1220         self.client_commit("dc", "revive old trunk")
1221
1222         oldrepos = Repository.open(repos_url)
1223         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1224         dir = BzrDir.create("f",format.get_rich_root_format())
1225         newrepos = dir.create_repository()
1226         oldrepos.copy_content_into(newrepos)
1227
1228         branch = Branch.open("%s/trunk" % repos_url)
1229         self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
1230                          branch.revision_history())
1231
1232     def test_fetch_dir_from_non_branch(self):
1233         repos_url = self.make_client('d', 'dc')
1234
1235         self.build_tree({'dc/old-trunk/lib/file': 'data'})
1236         self.client_add("dc/old-trunk")
1237         self.client_commit("dc", "trunk data")
1238
1239         self.build_tree({'dc/trunk': None})
1240         self.client_add("dc/trunk")
1241         self.client_copy("dc/old-trunk/lib", "dc/trunk")
1242         self.client_commit("dc", "revive old trunk")
1243
1244         oldrepos = Repository.open(repos_url)
1245         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1246         dir = BzrDir.create("f",format.get_rich_root_format())
1247         newrepos = dir.create_repository()
1248         oldrepos.copy_content_into(newrepos)
1249
1250         branch = Branch.open("%s/trunk" % repos_url)
1251         self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
1252                          branch.revision_history())
1253
1254     def test_fetch_from_non_branch(self):
1255         repos_url = self.make_client('d', 'dc')
1256
1257         self.build_tree({'dc/old-trunk/lib/file': 'data'})
1258         self.client_add("dc/old-trunk")
1259         self.client_commit("dc", "trunk data")
1260
1261         self.client_copy("dc/old-trunk", "dc/trunk")
1262         self.client_commit("dc", "revive old trunk")
1263
1264         oldrepos = Repository.open(repos_url)
1265         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1266         dir = BzrDir.create("f",format.get_rich_root_format())
1267         newrepos = dir.create_repository()
1268         oldrepos.copy_content_into(newrepos)
1269
1270         branch = Branch.open("%s/trunk" % repos_url)
1271         self.assertEqual([oldrepos.generate_revision_id(2, "trunk", "trunk0")],
1272                          branch.revision_history())
1273
1274
1275
1276     def test_fetch_branch_downgrade(self):
1277         repos_url = self.make_client('d', 'dc')
1278
1279         self.build_tree({'dc/trunk/file': 'data'})
1280         self.client_add("dc/trunk")
1281         self.client_commit("dc", "trunk data")
1282
1283         self.build_tree({'dc/branches/mybranch': None})
1284         self.client_add("dc/branches")
1285         self.client_copy("dc/trunk", "dc/branches/mybranch/lib")
1286         self.client_commit("dc", "split out lib")
1287
1288         oldrepos = Repository.open(repos_url)
1289         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1290         dir = BzrDir.create("f",format.get_rich_root_format())
1291         newrepos = dir.create_repository()
1292         oldrepos.copy_content_into(newrepos)
1293
1294     def test_fetch_all(self):
1295         repos_url = self.make_client('d', 'dc')
1296
1297         self.build_tree({'dc/trunk': None,
1298                          'dc/trunk/hosts': 'hej1'})
1299         self.client_add("dc/trunk")
1300         self.client_commit("dc", "created trunk and added hosts") #1
1301
1302         self.build_tree({'dc/trunk/hosts': 'hej2'})
1303         self.client_commit("dc", "rev 2") #2
1304
1305         self.build_tree({'dc/trunk/hosts': 'hej3'})
1306         self.client_commit("dc", "rev 3") #3
1307
1308         self.build_tree({'dc/branches/foobranch/file': 'foohosts'})
1309         self.client_add("dc/branches")
1310         self.client_commit("dc", "foohosts") #4
1311
1312         oldrepos = Repository.open(repos_url)
1313         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1314         dir = BzrDir.create("f",format.get_rich_root_format())
1315         newrepos = dir.create_repository()
1316         oldrepos.copy_content_into(newrepos)
1317
1318         self.assertTrue(newrepos.has_revision(
1319             oldrepos.generate_revision_id(1, "trunk", "trunk0")))
1320         self.assertTrue(newrepos.has_revision(
1321             oldrepos.generate_revision_id(2, "trunk", "trunk0")))
1322         self.assertTrue(newrepos.has_revision(
1323             oldrepos.generate_revision_id(3, "trunk", "trunk0")))
1324         self.assertTrue(newrepos.has_revision(
1325             oldrepos.generate_revision_id(4, "branches/foobranch", "trunk0")))
1326         self.assertFalse(newrepos.has_revision(
1327             oldrepos.generate_revision_id(4, "trunk", "trunk0")))
1328         self.assertFalse(newrepos.has_revision(
1329             oldrepos.generate_revision_id(2, "", "trunk0")))
1330
1331     def test_fetch_copy_root_id_kept(self):
1332         repos_url = self.make_client('d', 'dc')
1333
1334         self.build_tree({'dc/trunk': None,
1335                          'dc/trunk/hosts': 'hej1'})
1336         self.client_add("dc/trunk")
1337         self.client_commit("dc", "created trunk and added hosts") #1
1338
1339         self.build_tree({'dc/branches': None})
1340         self.client_add("dc/branches")
1341         self.client_commit("dc", "added branches") #2
1342
1343         self.client_copy("dc/trunk", "dc/branches/foobranch")
1344         self.client_commit("dc", "added branch foobranch") #3
1345
1346         repos = remote.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnRemoteFormat()).find_repository()
1347
1348         tree = repos.revision_tree(
1349              repos.generate_revision_id(3, "branches/foobranch", "trunk0"))
1350
1351         self.assertEqual(default_mapping.generate_file_id(repos.uuid, 1, "trunk", u""), tree.inventory.root.file_id)
1352
1353     def test_fetch_odd(self):
1354         repos_url = self.make_client('d', 'dc')
1355
1356         self.build_tree({'dc/trunk': None,
1357                          'dc/trunk/hosts': 'hej1'})
1358         self.client_add("dc/trunk")
1359         self.client_commit("dc", "created trunk and added hosts") #1
1360         self.client_update("dc")
1361
1362         self.build_tree({'dc/trunk/hosts': 'hej2'})
1363         self.client_commit("dc", "rev 2") #2
1364         self.client_update("dc")
1365
1366         self.build_tree({'dc/trunk/hosts': 'hej3'})
1367         self.client_commit("dc", "rev 3") #3
1368         self.client_update("dc")
1369
1370         self.build_tree({'dc/branches': None})
1371         self.client_add("dc/branches")
1372         self.client_commit("dc", "added branches") #4
1373         self.client_update("dc")
1374
1375         self.client_copy("dc/trunk", "dc/branches/foobranch")
1376         self.client_commit("dc", "added branch foobranch") #5
1377         self.client_update("dc")
1378
1379         self.build_tree({'dc/branches/foobranch/hosts': 'foohosts'})
1380         self.client_commit("dc", "foohosts") #6
1381
1382         repos = remote.SvnRemoteAccess(SvnRaTransport("svn+"+repos_url), format.SvnRemoteFormat()).find_repository()
1383
1384         tree = repos.revision_tree(
1385              repos.generate_revision_id(6, "branches/foobranch", "trunk0"))
1386
1387     def test_fetch_consistent(self):
1388         repos_url = self.make_client('d', 'dc')
1389         self.build_tree({'dc/bla': "data"})
1390         self.client_add("dc/bla")
1391         self.client_set_prop("dc/bla", "svn:executable", "*")
1392         self.client_commit("dc", "My Message")
1393         oldrepos = Repository.open("svn+"+repos_url)
1394         dir1 = BzrDir.create("f",format.get_rich_root_format())
1395         dir2 = BzrDir.create("g",format.get_rich_root_format())
1396         newrepos1 = dir1.create_repository()
1397         newrepos2 = dir2.create_repository()
1398         oldrepos.copy_content_into(newrepos1)
1399         oldrepos.copy_content_into(newrepos2)
1400         inv1 = newrepos1.get_inventory(
1401                 oldrepos.generate_revision_id(1, "", "none"))
1402         inv2 = newrepos2.get_inventory(
1403                 oldrepos.generate_revision_id(1, "", "none"))
1404         self.assertEqual(inv1, inv2)
1405
1406     def test_fetch_executable(self):
1407         repos_url = self.make_client('d', 'dc')
1408         self.build_tree({'dc/bla': "data", 'dc/blie': "data2"})
1409         self.client_add("dc/bla")
1410         self.client_add("dc/blie")
1411         self.client_set_prop("dc/bla", "svn:executable", "*")
1412         self.client_set_prop("dc/blie", "svn:executable", "")
1413         self.client_commit("dc", "My Message")
1414         oldrepos = Repository.open("svn+"+repos_url)
1415         dir = BzrDir.create("f",format.get_rich_root_format())
1416         newrepos = dir.create_repository()
1417         oldrepos.copy_content_into(newrepos)
1418         self.assertTrue(newrepos.has_revision(
1419             oldrepos.generate_revision_id(1, "", "none")))
1420         inv1 = newrepos.get_inventory(
1421                 oldrepos.generate_revision_id(1, "", "none"))
1422         self.assertTrue(inv1[inv1.path2id("bla")].executable)
1423         self.assertTrue(inv1[inv1.path2id("blie")].executable)
1424
1425     def test_fetch_symlink(self):
1426         repos_url = self.make_client('d', 'dc')
1427         self.build_tree({'dc/bla': "data"})
1428         os.symlink('bla', 'dc/mylink')
1429         self.client_add("dc/bla")
1430         self.client_add("dc/mylink")
1431         self.client_commit("dc", "My Message")
1432         oldrepos = Repository.open("svn+"+repos_url)
1433         dir = BzrDir.create("f",format.get_rich_root_format())
1434         newrepos = dir.create_repository()
1435         oldrepos.copy_content_into(newrepos)
1436         self.assertTrue(newrepos.has_revision(
1437             oldrepos.generate_revision_id(1, "", "none")))
1438         inv1 = newrepos.get_inventory(
1439                 oldrepos.generate_revision_id(1, "", "none"))
1440         self.assertEqual('symlink', inv1[inv1.path2id("mylink")].kind)
1441         self.assertEqual('bla', inv1[inv1.path2id("mylink")].symlink_target)
1442
1443     def test_fetch_symlink_kind_change(self):
1444         repos_url = self.make_client('d', 'dc')
1445         self.build_tree({'dc/bla': "data", "dc/mylink": "link bla"})
1446         self.client_add("dc/bla")
1447         self.client_add("dc/mylink")
1448         self.client_commit("dc", "My Message")
1449         ra = SvnRaTransport(repos_url)
1450         def done(rev, date, author):
1451             pass
1452         editor = ra.get_commit_editor({"svn:log": "msg"}, done, None, False)
1453         root_baton = editor.open_root(1)
1454         baton = editor.open_file("mylink", root_baton, 1)
1455         editor.change_file_prop(baton, "svn:special", "*")
1456         editor.close_file(baton, None)
1457         editor.close_directory(root_baton)
1458         editor.close()
1459         oldrepos = Repository.open("svn+"+repos_url)
1460         dir = BzrDir.create("f",format.get_rich_root_format())
1461         newrepos = dir.create_repository()
1462         oldrepos.copy_content_into(newrepos)
1463         self.assertTrue(newrepos.has_revision(
1464             oldrepos.generate_revision_id(1, "", "none")))
1465         inv1 = newrepos.get_inventory(
1466                 oldrepos.generate_revision_id(1, "", "none"))
1467         inv2 = newrepos.get_inventory(
1468                 oldrepos.generate_revision_id(2, "", "none"))
1469         self.assertEqual('file', inv1[inv1.path2id("mylink")].kind)
1470         self.assertEqual('symlink', inv2[inv2.path2id("mylink")].kind)
1471         self.assertEqual('bla', inv2[inv2.path2id("mylink")].symlink_target)
1472
1473     def test_fetch_executable_separate(self):
1474         repos_url = self.make_client('d', 'dc')
1475         self.build_tree({'dc/bla': "data"})
1476         self.client_add("dc/bla")
1477         self.client_commit("dc", "My Message")
1478         self.client_set_prop("dc/bla", "svn:executable", "*")
1479         self.client_commit("dc", "Make executable")
1480         oldrepos = Repository.open("svn+"+repos_url)
1481         dir = BzrDir.create("f",format.get_rich_root_format())
1482         newrepos = dir.create_repository()
1483         oldrepos.copy_content_into(newrepos)
1484         self.assertTrue(newrepos.has_revision(
1485             oldrepos.generate_revision_id(1, "", "none")))
1486         inv1 = newrepos.get_inventory(
1487                 oldrepos.generate_revision_id(1, "", "none"))
1488         self.assertFalse(inv1[inv1.path2id("bla")].executable)
1489         inv2 = newrepos.get_inventory(
1490                 oldrepos.generate_revision_id(2, "", "none"))
1491         self.assertTrue(inv2[inv2.path2id("bla")].executable)
1492         self.assertEqual(oldrepos.generate_revision_id(2, "", "none"),
1493                          inv2[inv2.path2id("bla")].revision)
1494
1495     def test_fetch_ghosts(self):
1496         repos_url = self.make_client('d', 'dc')
1497         self.build_tree({'dc/bla': "data"})
1498         self.client_add("dc/bla")
1499         self.client_set_prop("dc", "bzr:ancestry:v3-none", "aghost\n")
1500         self.client_commit("dc", "My Message")
1501         oldrepos = Repository.open("svn+"+repos_url)
1502         dir = BzrDir.create("f",format.get_rich_root_format())
1503         newrepos = dir.create_repository()
1504         oldrepos.copy_content_into(newrepos)
1505
1506         rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", "none"))
1507         self.assertTrue("aghost" in rev.parent_ids)
1508
1509     def test_fetch_svk_merge(self):
1510         repos_url = self.make_client('d', 'dc')
1511         self.build_tree({'dc/trunk/bla': "data", "dc/branches": None})
1512         self.client_add("dc/trunk")
1513         self.client_commit("dc", "My Message")
1514
1515         self.client_add("dc/branches")
1516         self.client_copy("dc/trunk", "dc/branches/foo")
1517         self.build_tree({'dc/branches/foo/bla': "more data"})
1518         self.client_commit("dc", "Branch")
1519
1520         oldrepos = Repository.open("svn+"+repos_url)
1521         self.client_set_prop("dc/trunk", "svk:merge",
1522                              "%s:/branches/foo:2\n" % oldrepos.uuid)
1523         self.client_commit("dc", "Merge")
1524
1525         dir = BzrDir.create("f",format.get_rich_root_format())
1526         newrepos = dir.create_repository()
1527         oldrepos.copy_content_into(newrepos)
1528
1529         rev = newrepos.get_revision(oldrepos.generate_revision_id(3, "trunk", "trunk0"))
1530         mutter('parent ids: %r' % rev.parent_ids)
1531         self.assertTrue(oldrepos.generate_revision_id(2, "branches/foo", "trunk0") in rev.parent_ids)
1532
1533     def test_fetch_invalid_ghosts(self):
1534         repos_url = self.make_client('d', 'dc')
1535         self.build_tree({'dc/bla': "data"})
1536         self.client_add("dc/bla")
1537         self.client_set_prop("dc", "bzr:ancestry:v3-none", "a ghost\n")
1538         self.client_commit("dc", "My Message")
1539         oldrepos = Repository.open("svn+"+repos_url)
1540         dir = BzrDir.create("f",format.get_rich_root_format())
1541         newrepos = dir.create_repository()
1542         oldrepos.copy_content_into(newrepos)
1543
1544         rev = newrepos.get_revision(oldrepos.generate_revision_id(1, "", "none"))
1545         self.assertEqual([oldrepos.generate_revision_id(0, "", "none")], rev.parent_ids)
1546
1547     def test_fetch_property_change_only(self):
1548         repos_url = self.make_client('d', 'dc')
1549         self.build_tree({'dc/trunk/bla': "data"})
1550         self.client_add("dc/trunk")
1551         self.client_commit("dc", "My Message") #1
1552         self.client_set_prop("dc", "some:property", "some data\n")
1553         self.client_update("dc")
1554         self.client_commit("dc", "My 3") #2
1555         self.client_set_prop("dc", "some2:property", "some data\n")
1556         self.client_commit("dc", "My 2") #3
1557         self.client_set_prop("dc", "some:property", "some data4\n")
1558         self.client_commit("dc", "My 4") #4
1559         oldrepos = Repository.open("svn+"+repos_url)
1560         dir = BzrDir.create("f", format.get_rich_root_format())
1561         newrepos = dir.create_repository()
1562         oldrepos.copy_content_into(newrepos)
1563         self.assertEquals([
1564             oldrepos.generate_revision_id(0, "", "none"),
1565             oldrepos.generate_revision_id(1, "", "none"),
1566             oldrepos.generate_revision_id(2, "", "none"),
1567             oldrepos.generate_revision_id(3, "", "none"),
1568             oldrepos.generate_revision_id(4, "", "none"),
1569             ], newrepos.all_revision_ids())
1570
1571     def test_fetch_property_change_only_trunk(self):
1572         repos_url = self.make_client('d', 'dc')
1573         self.build_tree({'dc/trunk/bla': "data"})
1574         self.client_add("dc/trunk")
1575         self.client_commit("dc", "My Message")
1576         self.client_set_prop("dc/trunk", "some:property", "some data\n")
1577         self.client_commit("dc", "My 3")
1578         self.client_set_prop("dc/trunk", "some2:property", "some data\n")
1579         self.client_commit("dc", "My 2")
1580         self.client_set_prop("dc/trunk", "some:property", "some data3\n")
1581         self.client_commit("dc", "My 4")
1582         oldrepos = Repository.open("svn+"+repos_url)
1583         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1584         dir = BzrDir.create("f", format.get_rich_root_format())
1585         newrepos = dir.create_repository()
1586         oldrepos.copy_content_into(newrepos)
1587         self.assertEquals([
1588             oldrepos.generate_revision_id(1, "trunk", "trunk0"),
1589             oldrepos.generate_revision_id(2, "trunk", "trunk0"),
1590             oldrepos.generate_revision_id(3, "trunk", "trunk0"),
1591             oldrepos.generate_revision_id(4, "trunk", "trunk0"),
1592             ], newrepos.all_revision_ids())
1593
1594     def test_fetch_crosscopy(self):
1595         repos_url = self.make_client('d', 'dc')
1596         self.build_tree({'dc/trunk/adir/afile': "data",
1597                          'dc/trunk/adir/stationary': None,
1598                          'dc/branches/abranch': None})
1599         self.client_add("dc/trunk")
1600         self.client_add("dc/branches")
1601         self.client_commit("dc", "Initial commit")
1602
1603         # copyrev
1604         self.client_copy("dc/trunk/adir", "dc/branches/abranch/bdir")
1605         self.client_commit("dc", "Cross copy commit")
1606
1607         # prevrev
1608         self.build_tree({"dc/branches/abranch/bdir/afile": "otherdata"})
1609         self.client_commit("dc", "Change data")
1610
1611         # lastrev
1612         self.build_tree({"dc/branches/abranch/bdir/bfile": "camel",
1613                       "dc/branches/abranch/bdir/stationary/traveller": "data"})
1614         self.client_add("dc/branches/abranch/bdir/bfile")
1615         self.client_add("dc/branches/abranch/bdir/stationary/traveller")
1616         self.client_commit("dc", "Change dir")
1617
1618         oldrepos = Repository.open("svn+"+repos_url)
1619         oldrepos.set_branching_scheme(TrunkBranchingScheme())
1620         dir = BzrDir.create("f",format.get_rich_root_format())
1621         newrepos = dir.create_repository()
1622         copyrev = oldrepos.generate_revision_id(2, "branches/abranch", "trunk0")
1623         prevrev = oldrepos.generate_revision_id(3, "branches/abranch", "trunk0")
1624         lastrev = oldrepos.generate_revision_id(4, "branches/abranch", "trunk0")
1625         oldrepos.copy_content_into(newrepos, lastrev)
1626
1627         inventory = newrepos.get_inventory(lastrev)
1628         self.assertEqual(prevrev,
1629                          inventory[inventory.path2id("bdir/afile")].revision)
1630
1631         inventory = newrepos.get_inventory(prevrev)
1632         self.assertEqual(copyrev,
1633                          inventory[inventory.path2id("bdir/stationary")].revision)
1634
1635