tests/test_fetch.py

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