tests/test_scheme.py

   1 # Copyright (C) 2006-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 """Branching scheme tests."""
  18
  19 from bzrlib.errors import NotBranchError, BzrError
  20
  21 from bzrlib.tests import TestCase
  22 from scheme import (ListBranchingScheme, NoBranchingScheme,
  23                     BranchingScheme, TrunkBranchingScheme,
  24                     SingleBranchingScheme, UnknownBranchingScheme,
  25                     parse_list_scheme_text, find_commit_paths,
  26                     guess_scheme_from_branch_path, guess_scheme_from_history,
  27                     guess_scheme_from_path, scheme_from_branch_list)
  28
  29 class BranchingSchemeTest(TestCase):
  30     def test_is_branch(self):
  31         self.assertRaises(NotImplementedError, BranchingScheme().is_branch, "")
  32
  33     def test_is_tag(self):
  34         self.assertRaises(NotImplementedError, BranchingScheme().is_tag, "")
  35
  36     def test_is_branch_parent(self):
  37         self.assertRaises(NotImplementedError,
  38                 BranchingScheme().is_branch_parent, "")
  39
  40     def test_is_tag_parent(self):
  41         self.assertRaises(NotImplementedError,
  42                 BranchingScheme().is_tag_parent, "")
  43
  44     def test_unprefix(self):
  45         self.assertRaises(NotImplementedError,
  46                 BranchingScheme().unprefix, "")
  47
  48     def test_find_scheme_no(self):
  49         self.assertIsInstance(BranchingScheme.find_scheme("none"),
  50                               NoBranchingScheme)
  51
  52     def test_find_scheme_invalid(self):
  53         self.assertRaises(BzrError, lambda: BranchingScheme.find_scheme("foo"))
  54
  55     def test_find_scheme_trunk(self):
  56         scheme = BranchingScheme.find_scheme("trunk")
  57         self.assertIsInstance(scheme, TrunkBranchingScheme)
  58         self.assertEqual(0, scheme.level)
  59
  60     def test_find_scheme_trunk_0(self):
  61         scheme = BranchingScheme.find_scheme("trunk0")
  62         self.assertIsInstance(scheme, TrunkBranchingScheme)
  63         self.assertEqual(0, scheme.level)
  64
  65     def test_find_scheme_trunk_2(self):
  66         scheme = BranchingScheme.find_scheme("trunk2")
  67         self.assertIsInstance(scheme, TrunkBranchingScheme)
  68         self.assertEqual(2, scheme.level)
  69
  70     def test_find_scheme_trunk_invalid(self):
  71         self.assertRaises(BzrError,
  72                           lambda: BranchingScheme.find_scheme("trunkinvalid"))
  73
  74     def test_find_scheme_single(self):
  75         scheme = BranchingScheme.find_scheme("single-habla")
  76         self.assertIsInstance(scheme, SingleBranchingScheme)
  77         self.assertEqual("habla", scheme.path)
  78
  79     def test_unknownscheme(self):
  80         e = UnknownBranchingScheme("foo")
  81         self.assertEquals("Branching scheme could not be found: foo", str(e))
  82
  83
  84 class NoScheme(TestCase):
  85     def test_str(self):
  86         self.assertEqual("none", NoBranchingScheme().__str__())
  87
  88     def test_is_branch_empty(self):
  89         self.assertTrue(NoBranchingScheme().is_branch(""))
  90
  91     def test_is_branch_slash(self):
  92         self.assertTrue(NoBranchingScheme().is_branch("/"))
  93
  94     def test_is_branch_dir_slash(self):
  95         self.assertFalse(NoBranchingScheme().is_branch("/foo"))
  96
  97     def test_is_branch_dir_slash_nested(self):
  98         self.assertFalse(NoBranchingScheme().is_branch("/foo/foo"))
  99
 100     def test_is_branch_dir(self):
 101         self.assertFalse(NoBranchingScheme().is_branch("foo/bar"))
 102
 103     def test_is_branch_dir_doubleslash(self):
 104         self.assertFalse(NoBranchingScheme().is_branch("//foo/bar"))
 105
 106     def test_is_tag_empty(self):
 107         self.assertFalse(NoBranchingScheme().is_tag(""))
 108
 109     def test_is_tag_slash(self):
 110         self.assertFalse(NoBranchingScheme().is_tag("/"))
 111
 112     def test_unprefix(self):
 113         self.assertEqual(NoBranchingScheme().unprefix(""), ("", ""))
 114
 115     def test_unprefix_slash(self):
 116         self.assertEqual(NoBranchingScheme().unprefix("/"), ("", ""))
 117
 118     def test_unprefix_nested(self):
 119         self.assertEqual(NoBranchingScheme().unprefix("foo/foo"), ("", "foo/foo"))
 120
 121     def test_unprefix_slash_nested(self):
 122         self.assertEqual(NoBranchingScheme().unprefix("/foo/foo"), ("", "foo/foo"))
 123
 124     def test_is_branch_parent_root(self):
 125         self.assertFalse(NoBranchingScheme().is_branch_parent(""))
 126
 127     def test_is_branch_parent_other(self):
 128         self.assertFalse(NoBranchingScheme().is_branch_parent("trunk/foo"))
 129
 130     def test_is_tag_parent_root(self):
 131         self.assertFalse(NoBranchingScheme().is_tag_parent(""))
 132
 133     def test_is_tag_parent_other(self):
 134         self.assertFalse(NoBranchingScheme().is_tag_parent("trunk/foo"))
 135
 136
 137 class ListScheme(TestCase):
 138     def setUp(self):
 139         self.scheme = ListBranchingScheme(["foo", "bar/bloe"])
 140
 141     def test_is_tag_empty(self):
 142         self.assertFalse(self.scheme.is_tag(""))
 143
 144     def test_is_tag_sub(self):
 145         self.assertFalse(self.scheme.is_tag("foo"))
 146
 147     def test_is_tag_tag(self):
 148         self.assertFalse(self.scheme.is_tag("tags/foo"))
 149
 150     def test_is_branch_empty(self):
 151         self.assertFalse(self.scheme.is_branch(""))
 152
 153     def test_is_branch_slash(self):
 154         self.assertFalse(self.scheme.is_branch("/"))
 155
 156     def test_is_branch_wildcard(self):
 157         scheme = ListBranchingScheme(["trunk/*"])
 158         self.assertTrue(scheme.is_branch("trunk/foo"))
 159         self.assertFalse(scheme.is_branch("trunk"))
 160
 161     def test_is_branch_wildcard_root(self):
 162         scheme = ListBranchingScheme(["*/trunk"])
 163         self.assertTrue(scheme.is_branch("bla/trunk"))
 164         self.assertFalse(scheme.is_branch("trunk"))
 165         self.assertFalse(scheme.is_branch("bla"))
 166
 167     def test_is_branch_wildcard_multiple(self):
 168         scheme = ListBranchingScheme(["*/trunk/*"])
 169         self.assertTrue(scheme.is_branch("bla/trunk/bloe"))
 170         self.assertFalse(scheme.is_branch("bla/trunk"))
 171         self.assertFalse(scheme.is_branch("trunk/bloe"))
 172         self.assertFalse(scheme.is_branch("blie/trunk/bloe/bla"))
 173         self.assertFalse(scheme.is_branch("bla"))
 174
 175     def test_is_branch_parent_root_root(self):
 176         self.assertFalse(ListBranchingScheme([""]).is_branch_parent(""))
 177
 178     def test_is_branch_parent_root(self):
 179         self.assertTrue(ListBranchingScheme(["trunk/*"]).is_branch_parent("trunk"))
 180
 181     def test_is_branch_parent_other(self):
 182         self.assertFalse(ListBranchingScheme(["trunk/*"]).is_branch_parent("trunk/foo"))
 183
 184     def test_is_tag_parent_other(self):
 185         self.assertFalse(ListBranchingScheme(["trunk"]).is_tag_parent("trunk/foo"))
 186
 187     def test_is_branch_slashsub(self):
 188         self.assertTrue(self.scheme.is_branch("/foo"))
 189
 190     def test_is_branch_sub(self):
 191         self.assertTrue(self.scheme.is_branch("foo"))
 192
 193     def test_is_branch_sub_sub_slash(self):
 194         self.assertFalse(self.scheme.is_branch("/foo/foo"))
 195
 196     def test_is_branch_sub_sub(self):
 197         self.assertFalse(self.scheme.is_branch("foo/bar"))
 198
 199     def test_is_branch_unknown(self):
 200         self.assertFalse(self.scheme.is_branch("foobla"))
 201
 202     def test_is_branch_doubleslash(self):
 203         self.assertTrue(self.scheme.is_branch("//foo/"))
 204
 205     def test_is_branch_nested(self):
 206         self.assertTrue(self.scheme.is_branch("bar/bloe"))
 207
 208     def test_unprefix_notbranch_empty(self):
 209         self.assertRaises(NotBranchError, self.scheme.unprefix, "")
 210
 211     def test_unprefix_wildcard(self):
 212         scheme = ListBranchingScheme(["*/trunk"])
 213         self.assertEquals(("bla/trunk", "foo"),
 214                           scheme.unprefix("bla/trunk/foo"))
 215
 216     def test_unprefix_wildcard_multiple(self):
 217         scheme = ListBranchingScheme(["trunk/*/*"])
 218         self.assertEquals(("trunk/foo/bar", "bla/blie"),
 219                           scheme.unprefix("trunk/foo/bar/bla/blie"))
 220
 221     def test_unprefix_wildcard_nonexistant(self):
 222         scheme = ListBranchingScheme(["*/trunk"])
 223         self.assertRaises(NotBranchError, self.scheme.unprefix, "bla")
 224         self.assertRaises(NotBranchError, self.scheme.unprefix, "trunk")
 225         self.assertRaises(NotBranchError, self.scheme.unprefix, "trunk/bla")
 226
 227     def test_unprefix_notbranch_slash(self):
 228         self.assertRaises(NotBranchError, self.scheme.unprefix, "/")
 229
 230     def test_unprefix_notbranch_unknown(self):
 231         self.assertRaises(NotBranchError, self.scheme.unprefix, "blie/bloe/bla")
 232
 233     def test_unprefix_branch_slash(self):
 234         self.assertEqual(self.scheme.unprefix("/foo"), ("foo", ""))
 235
 236     def test_unprefix_branch(self):
 237         self.assertEqual(self.scheme.unprefix("foo"), ("foo", ""))
 238
 239     def test_unprefix_nested_slash(self):
 240         self.assertEqual(self.scheme.unprefix("/foo/foo"), ("foo", "foo"))
 241
 242     def test_unprefix_nested(self):
 243         self.assertEqual(self.scheme.unprefix("foo/bar"), ("foo", "bar"))
 244
 245     def test_unprefix_double_nested(self):
 246         self.assertEqual(self.scheme.unprefix("foo/bar/bla"), ("foo", "bar/bla"))
 247
 248     def test_unprefix_double_slash(self):
 249         self.assertEqual(self.scheme.unprefix("//foo/"), ("foo", ""))
 250
 251     def test_unprefix_nested_branch(self):
 252         self.assertEqual(self.scheme.unprefix("bar/bloe"), ("bar/bloe", ""))
 253
 254     def test_str(self):
 255         self.assertEqual("list-QlpoOTFBWSZTWSDz6woAAAPRgAAQAACzBJAAIAAiDRo9QgyYjmbjatAeLuSKcKEgQefWFA..", str(self.scheme))
 256
 257     def test_parse_text(self):
 258         self.assertEqual(["bla/bloe"], parse_list_scheme_text("bla/bloe\n"))
 259
 260     def test_parse_text_no_newline(self):
 261         self.assertEqual(["bla/bloe", "blie"], parse_list_scheme_text("bla/bloe\nblie"))
 262
 263     def test_parse_text_comment(self):
 264         self.assertEqual(["bla/bloe", "blie"], parse_list_scheme_text("bla/bloe\n# comment\nblie"))
 265
 266 class TrunkScheme(TestCase):
 267     def test_is_branch_empty(self):
 268         self.assertFalse(TrunkBranchingScheme().is_branch(""))
 269
 270     def test_is_branch_slash(self):
 271         self.assertFalse(TrunkBranchingScheme().is_branch("/"))
 272
 273     def test_is_branch_unknown_slash(self):
 274         self.assertFalse(TrunkBranchingScheme().is_branch("/foo"))
 275
 276     def test_is_branch_unknown(self):
 277         self.assertFalse(TrunkBranchingScheme().is_branch("foo"))
 278
 279     def test_is_branch_unknown_nested_slash(self):
 280         self.assertFalse(TrunkBranchingScheme().is_branch("/foo/foo"))
 281
 282     def test_is_branch_unknown_nested(self):
 283         self.assertFalse(TrunkBranchingScheme().is_branch("foo/bar"))
 284
 285     def test_is_branch_unknown2(self):
 286         self.assertFalse(TrunkBranchingScheme().is_branch("foobla"))
 287
 288     def test_is_branch_trunk(self):
 289         self.assertTrue(TrunkBranchingScheme().is_branch("/trunk/"))
 290
 291     def test_is_branch_tag(self):
 292         self.assertFalse(TrunkBranchingScheme().is_branch("tags/foo"))
 293
 294     def test_is_branch_trunk_slashes(self):
 295         self.assertTrue(TrunkBranchingScheme().is_branch("////trunk"))
 296
 297     def test_is_branch_branch(self):
 298         self.assertTrue(TrunkBranchingScheme().is_branch("/branches/foo"))
 299
 300     def test_is_branch_typo(self):
 301         self.assertFalse(TrunkBranchingScheme().is_branch("/branche/foo"))
 302
 303     def test_is_branch_missing_slash(self):
 304         self.assertFalse(TrunkBranchingScheme().is_branch("/branchesfoo"))
 305
 306     def test_is_branch_branch_slash(self):
 307         self.assertTrue(TrunkBranchingScheme().is_branch("/branches/foo/"))
 308
 309     def test_is_branch_trunk_missing_slash(self):
 310         self.assertFalse(TrunkBranchingScheme().is_branch("/trunkfoo"))
 311
 312     def test_is_branch_trunk_file(self):
 313         self.assertFalse(TrunkBranchingScheme().is_branch("/trunk/foo"))
 314
 315     def test_is_branch_branches(self):
 316         self.assertFalse(TrunkBranchingScheme().is_branch("/branches"))
 317
 318     def test_is_tag_empty(self):
 319         self.assertFalse(TrunkBranchingScheme().is_tag(""))
 320
 321     def test_is_tag_sub(self):
 322         self.assertFalse(TrunkBranchingScheme().is_tag("foo"))
 323
 324     def test_is_tag_tag(self):
 325         self.assertTrue(TrunkBranchingScheme().is_tag("tags/foo"))
 326
 327     def test_is_tag_tag_slash(self):
 328         self.assertTrue(TrunkBranchingScheme().is_tag("tags/branches/"))
 329
 330     def test_is_tag_nested(self):
 331         self.assertFalse(TrunkBranchingScheme().is_tag("tags/foo/bla"))
 332
 333     def test_is_branch_level(self):
 334         scheme = TrunkBranchingScheme(2)
 335         self.assertFalse(scheme.is_branch("/trunk/"))
 336         self.assertFalse(scheme.is_branch("/foo/trunk"))
 337         self.assertTrue(scheme.is_branch("/foo/bar/trunk"))
 338         self.assertFalse(scheme.is_branch("/branches/trunk"))
 339         self.assertTrue(scheme.is_branch("/bar/branches/trunk"))
 340
 341     def test_unprefix_empty(self):
 342         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "")
 343
 344     def test_unprefix_topdir(self):
 345         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "branches")
 346
 347     def test_unprefix_slash(self):
 348         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "/")
 349
 350     def test_unprefix_unknown_sub(self):
 351         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "blie/bloe/bla")
 352
 353     def test_unprefix_unknown(self):
 354         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "aa")
 355
 356     def test_unprefix_slash_branch(self):
 357         self.assertEqual(TrunkBranchingScheme().unprefix("/trunk"), ("trunk", ""))
 358
 359     def test_unprefix_nested_branch_sub(self):
 360         self.assertEqual(TrunkBranchingScheme().unprefix("branches/ver1/foo"), ("branches/ver1", "foo"))
 361
 362     def test_unprefix_nested_tag_sub(self):
 363         self.assertEqual(TrunkBranchingScheme().unprefix("tags/ver1"), ("tags/ver1", ""))
 364
 365     def test_unprefix_doubleslash_branch(self):
 366         self.assertEqual(TrunkBranchingScheme().unprefix("//trunk/foo"), ("trunk", "foo"))
 367
 368     def test_unprefix_slash_tag(self):
 369         self.assertEqual(TrunkBranchingScheme().unprefix("/tags/ver2/foo/bar"), ("tags/ver2", "foo/bar"))
 370
 371     def test_unprefix_level(self):
 372         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "trunk")
 373
 374     def test_unprefix_level_wrong_level(self):
 375         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "/branches/foo")
 376
 377     def test_unprefix_level_wrong_level_nested(self):
 378         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "branches/ver1/foo")
 379
 380     def test_unprefix_level_correct_branch(self):
 381         self.assertEqual(TrunkBranchingScheme(1).unprefix("/foo/trunk"), ("foo/trunk", ""))
 382
 383     def test_unprefix_level_correct_nested(self):
 384         self.assertEqual(TrunkBranchingScheme(1).unprefix("data/tags/ver1"), ("data/tags/ver1", ""))
 385
 386     def test_str0(self):
 387         self.assertEqual("trunk0", TrunkBranchingScheme().__str__())
 388
 389     def test_str1(self):
 390         self.assertEqual("trunk1", TrunkBranchingScheme(1).__str__())
 391
 392     def test_is_branch_parent_root(self):
 393         self.assertTrue(TrunkBranchingScheme().is_branch_parent(""))
 394
 395     def test_is_tag_parent_root(self):
 396         self.assertFalse(TrunkBranchingScheme().is_tag_parent(""))
 397
 398     def test_is_branch_parent_branches(self):
 399         self.assertTrue(TrunkBranchingScheme().is_branch_parent("branches"))
 400
 401     def test_is_tagparent_branches(self):
 402         self.assertFalse(TrunkBranchingScheme().is_tag_parent("branches"))
 403
 404     def test_is_tagparent_tags(self):
 405         self.assertTrue(TrunkBranchingScheme().is_tag_parent("tags"))
 406
 407     def test_is_branch_parent_tags(self):
 408         self.assertFalse(TrunkBranchingScheme().is_branch_parent("tags"))
 409
 410     def test_is_branch_parent_trunk(self):
 411         self.assertFalse(TrunkBranchingScheme().is_branch_parent("trunk"))
 412
 413     def test_is_branch_parent_level(self):
 414         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent("anything"))
 415
 416     def test_is_tag_parent_level(self):
 417         self.assertFalse(TrunkBranchingScheme(1).is_tag_parent("anything"))
 418
 419     def test_is_branch_parent_level_root(self):
 420         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent(""))
 421
 422     def test_is_branch_parent_level_strange(self):
 423         self.assertFalse(TrunkBranchingScheme(1).is_branch_parent("trunk/foo"))
 424
 425     def test_is_branch_parent_level_inside(self):
 426         self.assertFalse(TrunkBranchingScheme(1).is_branch_parent("foo/trunk/foo"))
 427
 428     def test_is_branch_parent_level_branches(self):
 429         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent("anything/branches"))
 430
 431     def test_is_tag_parent_level_tags(self):
 432         self.assertTrue(TrunkBranchingScheme(1).is_tag_parent("anything/tags"))
 433
 434     def test_is_branch_parent_other(self):
 435         self.assertFalse(TrunkBranchingScheme().is_branch_parent("trunk/foo"))
 436
 437
 438 class SingleBranchingSchemeTests(TestCase):
 439     def test_is_branch(self):
 440         self.assertTrue(SingleBranchingScheme("bla").is_branch("bla"))
 441
 442     def test_is_branch_tooshort(self):
 443         self.assertFalse(SingleBranchingScheme("bla").is_branch("bl"))
 444
 445     def test_is_branch_nested(self):
 446         self.assertTrue(SingleBranchingScheme("bla/bloe").is_branch("bla/bloe"))
 447
 448     def test_is_branch_child(self):
 449         self.assertFalse(SingleBranchingScheme("bla/bloe").is_branch("bla/bloe/blie"))
 450
 451     def test_is_tag(self):
 452         self.assertFalse(SingleBranchingScheme("bla/bloe").is_tag("bla/bloe"))
 453
 454     def test_unprefix(self):
 455         self.assertEquals(("ha", "ho"), SingleBranchingScheme("ha").unprefix("ha/ho"))
 456
 457     def test_unprefix_branch(self):
 458         self.assertEquals(("ha", ""), SingleBranchingScheme("ha").unprefix("ha"))
 459
 460     def test_unprefix_raises(self):
 461         self.assertRaises(NotBranchError, SingleBranchingScheme("ha").unprefix, "bla")
 462
 463     def test_is_branch_parent_not(self):
 464         self.assertFalse(SingleBranchingScheme("ha").is_branch_parent("bla"))
 465
 466     def test_is_branch_parent_branch(self):
 467         self.assertFalse(SingleBranchingScheme("bla/bla").is_branch_parent("bla/bla"))
 468
 469     def test_is_branch_parent(self):
 470         self.assertTrue(SingleBranchingScheme("bla/bla").is_branch_parent("bla"))
 471
 472     def test_is_branch_parent_grandparent(self):
 473         self.assertFalse(
 474             SingleBranchingScheme("bla/bla/bla").is_branch_parent("bla"))
 475
 476     def test_create_empty(self):
 477         self.assertRaises(BzrError, SingleBranchingScheme, "")
 478
 479     def test_str(self):
 480         self.assertEquals("single-ha/bla", str(SingleBranchingScheme("ha/bla")))
 481
 482
 483 class FindCommitPathsTester(TestCase):
 484     def test_simple_trunk_only(self):
 485         self.assertEquals(["trunk"],
 486             list(find_commit_paths([{"trunk": ('M', None, None)}])))
 487
 488     def test_branches(self):
 489         self.assertEquals(["trunk", "branches/bar"],
 490             list(find_commit_paths([{"trunk": ('M', None, None)},
 491                                {"branches/bar": ('A', None, None)}])))
 492
 493     def test_trunk_more_files(self):
 494         self.assertEquals(["trunk"],
 495                 list(find_commit_paths([{
 496                     "trunk/bfile": ('A', None, None),
 497                     "trunk/afile": ('M', None, None),
 498                     "trunk": ('A', None, None)
 499                     }])))
 500
 501     def test_trunk_more_files_no_root(self):
 502         self.assertEquals(["trunk"],
 503                 list(find_commit_paths([{
 504                     "trunk/bfile": ('A', None, None),
 505                     "trunk/afile": ('M', None, None)
 506                     }])))
 507
 508
 509 class TestGuessBranchingSchemeFromBranchpath(TestCase):
 510     def test_guess_empty(self):
 511         self.assertIsInstance(guess_scheme_from_branch_path(""),
 512                               NoBranchingScheme)
 513
 514     def test_guess_not_convenience(self):
 515         self.assertIsInstance(guess_scheme_from_branch_path("foo"),
 516                               SingleBranchingScheme)
 517
 518     def test_guess_trunk_zero(self):
 519         scheme = guess_scheme_from_branch_path("trunk")
 520         self.assertIsInstance(scheme, TrunkBranchingScheme)
 521         self.assertEqual(0, scheme.level)
 522
 523     def test_guess_trunk_branch_sub(self):
 524         scheme = guess_scheme_from_branch_path("branches/bar")
 525         self.assertIsInstance(scheme, TrunkBranchingScheme)
 526         self.assertEqual(0, scheme.level)
 527
 528     def test_guess_trunk_level_sub(self):
 529         scheme = guess_scheme_from_branch_path("test/bar/branches/bla")
 530         self.assertIsInstance(scheme, TrunkBranchingScheme)
 531         self.assertEqual(2, scheme.level)
 532
 533     def test_guess_level_detection(self):
 534         scheme = guess_scheme_from_branch_path("branches/trunk")
 535         self.assertIsInstance(scheme, TrunkBranchingScheme)
 536         self.assertEqual(0, scheme.level)
 537
 538
 539 class TestGuessBranchingSchemeFromPath(TestCase):
 540     def test_guess_empty(self):
 541         self.assertIsInstance(guess_scheme_from_path(""),
 542                               NoBranchingScheme)
 543
 544     def test_guess_not_convenience(self):
 545         self.assertIsInstance(guess_scheme_from_path("foo"),
 546                               NoBranchingScheme)
 547
 548     def test_guess_trunk_zero(self):
 549         scheme = guess_scheme_from_path("trunk")
 550         self.assertIsInstance(scheme, TrunkBranchingScheme)
 551         self.assertEqual(0, scheme.level)
 552
 553     def test_guess_trunk_nested(self):
 554         scheme = guess_scheme_from_path("trunk/child")
 555         self.assertIsInstance(scheme, TrunkBranchingScheme)
 556         self.assertEqual(0, scheme.level)
 557
 558     def test_guess_trunk_branch_sub(self):
 559         scheme = guess_scheme_from_path("branches/bar")
 560         self.assertIsInstance(scheme, TrunkBranchingScheme)
 561         self.assertEqual(0, scheme.level)
 562
 563     def test_guess_trunk_level_sub(self):
 564         scheme = guess_scheme_from_path("test/bar/branches/bla")
 565         self.assertIsInstance(scheme, TrunkBranchingScheme)
 566         self.assertEqual(2, scheme.level)
 567
 568     def test_guess_level_detection(self):
 569         scheme = guess_scheme_from_path("branches/trunk")
 570         self.assertIsInstance(scheme, TrunkBranchingScheme)
 571         self.assertEqual(0, scheme.level)
 572
 573
 574 class TestGuessBranchingSchemeFromHistory(TestCase):
 575     def test_simple(self):
 576         scheme = guess_scheme_from_history([
 577             ("", {"trunk": ('M', None, None)}, 0)], 1)
 578         self.assertIsInstance(scheme, TrunkBranchingScheme)
 579         self.assertEqual(0, scheme.level)
 580
 581     def test_simple_with_relpath(self):
 582         scheme = guess_scheme_from_history([
 583             ("", {"trunk": ('M', None, None)}, 0)], 1,
 584             relpath="trunk")
 585         self.assertIsInstance(scheme, TrunkBranchingScheme)
 586         self.assertEqual(0, scheme.level)
 587
 588     def test_simple_prefer_relpath(self):
 589         scheme = guess_scheme_from_history([
 590             ("", {"trunk": ('M', None, None)}, 1),
 591             ("", {"trunk": ('M', None, None)}, 2),
 592             ("", {"trunk/bar": ('M', None, None)}, 3),
 593             ], 3,
 594             relpath="trunk/bar")
 595         self.assertIsInstance(scheme, SingleBranchingScheme)
 596         self.assertEqual("trunk/bar", scheme.path)
 597
 598     def test_simple_notwant_single(self):
 599         scheme = guess_scheme_from_history([
 600             ("", {"foo": ('M', None, None)}, 1),
 601             ("", {"foo": ('M', None, None)}, 2),
 602             ("", {"foo/bar": ('M', None, None)}, 3),
 603             ], 3)
 604         self.assertIsInstance(scheme, NoBranchingScheme)
 605
 606     def test_simple_no_bp_common(self):
 607         scheme = guess_scheme_from_history([
 608             ("", {"foo": ('M', None, None)}, 1),
 609             ("", {"trunk": ('M', None, None)}, 2),
 610             ("", {"trunk": ('M', None, None)}, 3),
 611             ], 3)
 612         self.assertIsInstance(scheme, TrunkBranchingScheme)
 613
 614     def test_simple_no_history(self):
 615         scheme = guess_scheme_from_history([], 0)
 616         self.assertIsInstance(scheme, NoBranchingScheme)
 617
 618     def test_simple_no_history_bp(self):
 619         scheme = guess_scheme_from_history([], 0, "trunk")
 620         self.assertIsInstance(scheme, TrunkBranchingScheme)
 621
 622 class SchemeFromBranchListTests(TestCase):
 623     def test_nobranchingscheme(self):
 624         self.assertIsInstance(scheme_from_branch_list(["."]), NoBranchingScheme)
 625
 626     def test_listbranchingscheme(self):
 627         self.assertIsInstance(scheme_from_branch_list(["aap/*"]),
 628                               ListBranchingScheme)
 629
 630     def test_trunk(self):
 631         self.assertIsInstance(scheme_from_branch_list(["trunk", "branches/*",
 632                                                        "tags/*"]),
 633                               TrunkBranchingScheme)
 634