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                     UnknownBranchingScheme)
  25
  26 class BranchingSchemeTest(TestCase):
  27     def test_is_branch(self):
  28         self.assertRaises(NotImplementedError, BranchingScheme().is_branch, "")
  29
  30     def test_is_tag(self):
  31         self.assertRaises(NotImplementedError, BranchingScheme().is_tag, "")
  32
  33     def test_is_branch_parent(self):
  34         self.assertRaises(NotImplementedError,
  35                 BranchingScheme().is_branch_parent, "")
  36
  37     def test_is_tag_parent(self):
  38         self.assertRaises(NotImplementedError,
  39                 BranchingScheme().is_tag_parent, "")
  40
  41     def test_unprefix(self):
  42         self.assertRaises(NotImplementedError,
  43                 BranchingScheme().unprefix, "")
  44
  45     def test_guess_empty(self):
  46         self.assertIsInstance(BranchingScheme.guess_scheme(""),
  47                               NoBranchingScheme)
  48
  49     def test_guess_not_convenience(self):
  50         self.assertIsInstance(BranchingScheme.guess_scheme("foo"),
  51                               NoBranchingScheme)
  52
  53     def test_find_scheme_no(self):
  54         self.assertIsInstance(BranchingScheme.find_scheme("none"),
  55                               NoBranchingScheme)
  56
  57     def test_find_scheme_invalid(self):
  58         self.assertRaises(BzrError, lambda: BranchingScheme.find_scheme("foo"))
  59
  60     def test_find_scheme_trunk(self):
  61         scheme = BranchingScheme.find_scheme("trunk")
  62         self.assertIsInstance(scheme, TrunkBranchingScheme)
  63         self.assertEqual(0, scheme.level)
  64
  65     def test_find_scheme_trunk_0(self):
  66         scheme = BranchingScheme.find_scheme("trunk0")
  67         self.assertIsInstance(scheme, TrunkBranchingScheme)
  68         self.assertEqual(0, scheme.level)
  69
  70     def test_find_scheme_trunk_2(self):
  71         scheme = BranchingScheme.find_scheme("trunk2")
  72         self.assertIsInstance(scheme, TrunkBranchingScheme)
  73         self.assertEqual(2, scheme.level)
  74
  75     def test_find_scheme_trunk_invalid(self):
  76         self.assertRaises(BzrError,
  77                           lambda: BranchingScheme.find_scheme("trunkinvalid"))
  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_slashsub(self):
 157         self.assertTrue(self.scheme.is_branch("/foo"))
 158
 159     def test_is_branch_sub(self):
 160         self.assertTrue(self.scheme.is_branch("foo"))
 161
 162     def test_is_branch_sub_sub_slash(self):
 163         self.assertFalse(self.scheme.is_branch("/foo/foo"))
 164
 165     def test_is_branch_sub_sub(self):
 166         self.assertFalse(self.scheme.is_branch("foo/bar"))
 167
 168     def test_is_branch_unknown(self):
 169         self.assertFalse(self.scheme.is_branch("foobla"))
 170
 171     def test_is_branch_doubleslash(self):
 172         self.assertTrue(self.scheme.is_branch("//foo/"))
 173
 174     def test_is_branch_nested(self):
 175         self.assertTrue(self.scheme.is_branch("bar/bloe"))
 176
 177     def test_unprefix_notbranch_empty(self):
 178         self.assertRaises(NotBranchError, self.scheme.unprefix, "")
 179
 180     def test_unprefix_notbranch_slash(self):
 181         self.assertRaises(NotBranchError, self.scheme.unprefix, "/")
 182
 183     def test_unprefix_notbranch_unknown(self):
 184         self.assertRaises(NotBranchError, self.scheme.unprefix, "blie/bloe/bla")
 185
 186     def test_unprefix_branch_slash(self):
 187         self.assertEqual(self.scheme.unprefix("/foo"), ("foo", ""))
 188
 189     def test_unprefix_branch(self):
 190         self.assertEqual(self.scheme.unprefix("foo"), ("foo", ""))
 191
 192     def test_unprefix_nested_slash(self):
 193         self.assertEqual(self.scheme.unprefix("/foo/foo"), ("foo", "foo"))
 194
 195     def test_unprefix_nested(self):
 196         self.assertEqual(self.scheme.unprefix("foo/bar"), ("foo", "bar"))
 197
 198     def test_unprefix_double_nested(self):
 199         self.assertEqual(self.scheme.unprefix("foo/bar/bla"), ("foo", "bar/bla"))
 200
 201     def test_unprefix_double_slash(self):
 202         self.assertEqual(self.scheme.unprefix("//foo/"), ("foo", ""))
 203
 204     def test_unprefix_nested_branch(self):
 205         self.assertEqual(self.scheme.unprefix("bar/bloe"), ("bar/bloe", ""))
 206
 207 class TrunkScheme(TestCase):
 208     def test_is_branch_empty(self):
 209         self.assertFalse(TrunkBranchingScheme().is_branch(""))
 210
 211     def test_is_branch_slash(self):
 212         self.assertFalse(TrunkBranchingScheme().is_branch("/"))
 213
 214     def test_is_branch_unknown_slash(self):
 215         self.assertFalse(TrunkBranchingScheme().is_branch("/foo"))
 216
 217     def test_is_branch_unknown(self):
 218         self.assertFalse(TrunkBranchingScheme().is_branch("foo"))
 219
 220     def test_is_branch_unknown_nested_slash(self):
 221         self.assertFalse(TrunkBranchingScheme().is_branch("/foo/foo"))
 222
 223     def test_is_branch_unknown_nested(self):
 224         self.assertFalse(TrunkBranchingScheme().is_branch("foo/bar"))
 225
 226     def test_is_branch_unknown2(self):
 227         self.assertFalse(TrunkBranchingScheme().is_branch("foobla"))
 228
 229     def test_is_branch_trunk(self):
 230         self.assertTrue(TrunkBranchingScheme().is_branch("/trunk/"))
 231
 232     def test_is_branch_tag(self):
 233         self.assertFalse(TrunkBranchingScheme().is_branch("tags/foo"))
 234
 235     def test_is_branch_trunk_slashes(self):
 236         self.assertTrue(TrunkBranchingScheme().is_branch("////trunk"))
 237
 238     def test_is_branch_branch(self):
 239         self.assertTrue(TrunkBranchingScheme().is_branch("/branches/foo"))
 240
 241     def test_is_branch_typo(self):
 242         self.assertFalse(TrunkBranchingScheme().is_branch("/branche/foo"))
 243
 244     def test_is_branch_missing_slash(self):
 245         self.assertFalse(TrunkBranchingScheme().is_branch("/branchesfoo"))
 246
 247     def test_is_branch_branch_slash(self):
 248         self.assertTrue(TrunkBranchingScheme().is_branch("/branches/foo/"))
 249
 250     def test_is_branch_trunk_missing_slash(self):
 251         self.assertFalse(TrunkBranchingScheme().is_branch("/trunkfoo"))
 252
 253     def test_is_branch_trunk_file(self):
 254         self.assertFalse(TrunkBranchingScheme().is_branch("/trunk/foo"))
 255
 256     def test_is_branch_branches(self):
 257         self.assertFalse(TrunkBranchingScheme().is_branch("/branches"))
 258
 259     def test_is_tag_empty(self):
 260         self.assertFalse(TrunkBranchingScheme().is_tag(""))
 261
 262     def test_is_tag_sub(self):
 263         self.assertFalse(TrunkBranchingScheme().is_tag("foo"))
 264
 265     def test_is_tag_tag(self):
 266         self.assertTrue(TrunkBranchingScheme().is_tag("tags/foo"))
 267
 268     def test_is_tag_tag_slash(self):
 269         self.assertTrue(TrunkBranchingScheme().is_tag("tags/branches/"))
 270
 271     def test_is_tag_nested(self):
 272         self.assertFalse(TrunkBranchingScheme().is_tag("tags/foo/bla"))
 273
 274     def test_is_branch_level(self):
 275         scheme = TrunkBranchingScheme(2)
 276         self.assertFalse(scheme.is_branch("/trunk/"))
 277         self.assertFalse(scheme.is_branch("/foo/trunk"))
 278         self.assertTrue(scheme.is_branch("/foo/bar/trunk"))
 279         self.assertFalse(scheme.is_branch("/branches/trunk"))
 280         self.assertTrue(scheme.is_branch("/bar/branches/trunk"))
 281
 282     def test_unprefix_empty(self):
 283         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "")
 284
 285     def test_unprefix_topdir(self):
 286         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "branches")
 287
 288     def test_unprefix_slash(self):
 289         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "/")
 290
 291     def test_unprefix_unknown_sub(self):
 292         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "blie/bloe/bla")
 293
 294     def test_unprefix_unknown(self):
 295         self.assertRaises(NotBranchError, TrunkBranchingScheme().unprefix, "aa")
 296
 297     def test_unprefix_slash_branch(self):
 298         self.assertEqual(TrunkBranchingScheme().unprefix("/trunk"), ("trunk", ""))
 299
 300     def test_unprefix_nested_branch_sub(self):
 301         self.assertEqual(TrunkBranchingScheme().unprefix("branches/ver1/foo"), ("branches/ver1", "foo"))
 302
 303     def test_unprefix_nested_tag_sub(self):
 304         self.assertEqual(TrunkBranchingScheme().unprefix("tags/ver1"), ("tags/ver1", ""))
 305
 306     def test_unprefix_doubleslash_branch(self):
 307         self.assertEqual(TrunkBranchingScheme().unprefix("//trunk/foo"), ("trunk", "foo"))
 308
 309     def test_unprefix_slash_tag(self):
 310         self.assertEqual(TrunkBranchingScheme().unprefix("/tags/ver2/foo/bar"), ("tags/ver2", "foo/bar"))
 311
 312     def test_unprefix_level(self):
 313         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "trunk")
 314
 315     def test_unprefix_level_wrong_level(self):
 316         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "/branches/foo")
 317
 318     def test_unprefix_level_wrong_level_nested(self):
 319         self.assertRaises(NotBranchError, TrunkBranchingScheme(1).unprefix, "branches/ver1/foo")
 320
 321     def test_unprefix_level_correct_branch(self):
 322         self.assertEqual(TrunkBranchingScheme(1).unprefix("/foo/trunk"), ("foo/trunk", ""))
 323
 324     def test_unprefix_level_correct_nested(self):
 325         self.assertEqual(TrunkBranchingScheme(1).unprefix("data/tags/ver1"), ("data/tags/ver1", ""))
 326
 327     def test_guess_trunk_zero(self):
 328         scheme = BranchingScheme.guess_scheme("trunk")
 329         self.assertIsInstance(scheme, TrunkBranchingScheme)
 330         self.assertEqual(0, scheme.level)
 331
 332     def test_guess_trunk_branch_sub(self):
 333         scheme = BranchingScheme.guess_scheme("branches/foo/bar")
 334         self.assertIsInstance(scheme, TrunkBranchingScheme)
 335         self.assertEqual(0, scheme.level)
 336
 337     def test_guess_trunk_level(self):
 338         scheme = BranchingScheme.guess_scheme("test/branches/foo/bar")
 339         self.assertIsInstance(scheme, TrunkBranchingScheme)
 340         self.assertEqual(1, scheme.level)
 341
 342     def test_guess_trunk_level_sub(self):
 343         scheme = BranchingScheme.guess_scheme("test/bar/branches/foo/bar")
 344         self.assertIsInstance(scheme, TrunkBranchingScheme)
 345         self.assertEqual(2, scheme.level)
 346
 347     def test_guess_level_detection(self):
 348         scheme = BranchingScheme.guess_scheme("branches/trunk")
 349         self.assertIsInstance(scheme, TrunkBranchingScheme)
 350         self.assertEqual(0, scheme.level)
 351
 352     def test_str0(self):
 353         self.assertEqual("trunk0", TrunkBranchingScheme().__str__())
 354
 355     def test_str1(self):
 356         self.assertEqual("trunk1", TrunkBranchingScheme(1).__str__())
 357
 358     def test_is_branch_parent_root(self):
 359         self.assertTrue(TrunkBranchingScheme().is_branch_parent(""))
 360
 361     def test_is_tag_parent_root(self):
 362         self.assertFalse(TrunkBranchingScheme().is_tag_parent(""))
 363
 364     def test_is_branch_parent_branches(self):
 365         self.assertTrue(TrunkBranchingScheme().is_branch_parent("branches"))
 366
 367     def test_is_tagparent_branches(self):
 368         self.assertFalse(TrunkBranchingScheme().is_tag_parent("branches"))
 369
 370     def test_is_tagparent_tags(self):
 371         self.assertTrue(TrunkBranchingScheme().is_tag_parent("tags"))
 372
 373     def test_is_branch_parent_tags(self):
 374         self.assertFalse(TrunkBranchingScheme().is_branch_parent("tags"))
 375
 376     def test_is_branch_parent_trunk(self):
 377         self.assertFalse(TrunkBranchingScheme().is_branch_parent("trunk"))
 378
 379     def test_is_branch_parent_level(self):
 380         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent("anything"))
 381
 382     def test_is_tag_parent_level(self):
 383         self.assertFalse(TrunkBranchingScheme(1).is_tag_parent("anything"))
 384
 385     def test_is_branch_parent_level_root(self):
 386         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent(""))
 387
 388     def test_is_branch_parent_level_strange(self):
 389         self.assertFalse(TrunkBranchingScheme(1).is_branch_parent("trunk/foo"))
 390
 391     def test_is_branch_parent_level_inside(self):
 392         self.assertFalse(TrunkBranchingScheme(1).is_branch_parent("foo/trunk/foo"))
 393
 394     def test_is_branch_parent_level_branches(self):
 395         self.assertTrue(TrunkBranchingScheme(1).is_branch_parent("anything/branches"))
 396
 397     def test_is_tag_parent_level_tags(self):
 398         self.assertTrue(TrunkBranchingScheme(1).is_tag_parent("anything/tags"))
 399
 400     def test_is_branch_parent_other(self):
 401         self.assertFalse(TrunkBranchingScheme().is_branch_parent("trunk/foo"))