tests/test_logwalker.py

   1 # Copyright (C) 2006 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 from bzrlib.bzrdir import BzrDir
  18 from bzrlib.errors import NoSuchRevision
  19 from bzrlib.inventory import Inventory
  20
  21 import os
  22 import logwalker
  23 from scheme import NoBranchingScheme, TrunkBranchingScheme
  24 from tests import TestCaseWithSubversionRepository
  25 from transport import SvnRaTransport
  26
  27 class TestLogWalker(TestCaseWithSubversionRepository):
  28     def setUp(self):
  29         super(TestLogWalker, self).setUp()
  30
  31         logwalker.cache_dir = os.path.join(self.test_dir, "cache-dir")
  32
  33     def test_create(self):
  34         repos_url = self.make_client("a", "ac")
  35         logwalker.LogWalker(NoBranchingScheme(), transport=SvnRaTransport(repos_url))
  36
  37     def test_get_branch_log(self):
  38         repos_url = self.make_client("a", "dc")
  39         self.build_tree({'dc/foo': "data"})
  40         self.client_add("dc/foo")
  41         self.client_commit("dc", "My Message")
  42
  43         walker = logwalker.LogWalker(NoBranchingScheme(),
  44                                      transport=SvnRaTransport(repos_url))
  45
  46         self.assertEqual(1, len(list(walker.follow_history("", 1))))
  47
  48     def test_get_branch_invalid_revision(self):
  49         repos_url = self.make_client("a", "dc")
  50         walker = logwalker.LogWalker(NoBranchingScheme(),
  51                                      transport=SvnRaTransport(repos_url))
  52         self.assertRaises(NoSuchRevision, list,
  53                           walker.follow_history("/", 20))
  54
  55     def test_invalid_branch_path(self):
  56         repos_url = self.make_client("a", "dc")
  57         walker = logwalker.LogWalker(NoBranchingScheme(),
  58                                      transport=SvnRaTransport(repos_url))
  59
  60         self.assertRaises(logwalker.NotSvnBranchPath, list,
  61                           walker.follow_history("foobar", 0))
  62
  63     def test_branch_log_all(self):
  64         repos_url = self.make_client("a", "dc")
  65         self.build_tree({'dc/trunk/file': "data", "dc/foo/file":"data"})
  66         self.client_add("dc/trunk")
  67         self.client_add("dc/foo")
  68         self.client_commit("dc", "My Message")
  69
  70         walker = logwalker.LogWalker(TrunkBranchingScheme(),
  71                                      transport=SvnRaTransport(repos_url))
  72
  73         self.assertEqual(1, len(list(walker.follow_history(None, 1))))
  74
  75     def test_branch_log_specific(self):
  76         repos_url = self.make_client("a", "dc")
  77         self.build_tree({
  78             'dc/branches': None,
  79             'dc/branches/brancha': None,
  80             'dc/branches/branchab': None,
  81             'dc/branches/brancha/data': "data",
  82             "dc/branches/branchab/data":"data"})
  83         self.client_add("dc/branches")
  84         self.client_commit("dc", "My Message")
  85
  86         walker = logwalker.LogWalker(TrunkBranchingScheme(),
  87                                      transport=SvnRaTransport(repos_url))
  88
  89         self.assertEqual(1, len(list(walker.follow_history("branches/brancha",
  90             1))))
  91
  92     def test_find_branches_no(self):
  93         repos_url = self.make_client("a", "dc")
  94
  95         walker = logwalker.LogWalker(NoBranchingScheme(),
  96                                      transport=SvnRaTransport(repos_url))
  97
  98         self.assertEqual([("", 0, True)], list(walker.find_branches(0)))
  99
 100     def test_find_latest_none(self):
 101         repos_url = self.make_client("a", "dc")
 102         self.build_tree({'dc/branches': None})
 103         self.client_add("dc/branches")
 104         self.client_commit("dc", "My Message")
 105
 106         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 107                                      transport=SvnRaTransport(repos_url))
 108
 109         self.assertEqual(0, walker.find_latest_change("", 1))
 110
 111     def test_find_latest_change(self):
 112         repos_url = self.make_client("a", "dc")
 113         self.build_tree({'dc/branches': None})
 114         self.client_add("dc/branches")
 115         self.client_commit("dc", "My Message")
 116
 117         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 118                                      transport=SvnRaTransport(repos_url))
 119
 120         self.assertEqual(1, walker.find_latest_change("branches", 1))
 121
 122     def test_find_latest_change_children(self):
 123         repos_url = self.make_client("a", "dc")
 124         self.build_tree({'dc/branches': None})
 125         self.client_add("dc/branches")
 126         self.client_commit("dc", "My Message")
 127         self.build_tree({'dc/branches/foo': 'data'})
 128         self.client_add("dc/branches/foo")
 129         self.client_commit("dc", "My Message2")
 130
 131         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 132                                      transport=SvnRaTransport(repos_url))
 133
 134         self.assertEqual(1, walker.find_latest_change("branches", 2))
 135
 136     def test_find_latest_change_prop(self):
 137         repos_url = self.make_client("a", "dc")
 138         self.build_tree({'dc/branches': None})
 139         self.client_add("dc/branches")
 140         self.client_commit("dc", "My Message")
 141         self.build_tree({'dc/branches/foo': 'data'})
 142         self.client_set_prop("dc/branches", "myprop", "mydata")
 143         self.client_commit("dc", "propchange")
 144         self.client_add("dc/branches/foo")
 145         self.client_commit("dc", "My Message2")
 146
 147         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 148                                      transport=SvnRaTransport(repos_url))
 149
 150         self.assertEqual(2, walker.find_latest_change("branches", 3))
 151
 152     def test_find_latest_change_file(self):
 153         repos_url = self.make_client("a", "dc")
 154         self.build_tree({'dc/branches': None})
 155         self.client_add("dc/branches")
 156         self.client_commit("dc", "My Message")
 157         self.build_tree({'dc/branches/foo': 'data'})
 158         self.client_add("dc/branches/foo")
 159         self.client_commit("dc", "propchange")
 160         self.build_tree({'dc/branches/foo': 'data4'})
 161         self.client_commit("dc", "My Message2")
 162
 163         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 164                                      transport=SvnRaTransport(repos_url))
 165
 166         self.assertEqual(3, walker.find_latest_change("branches/foo", 3))
 167
 168     def test_find_latest_change_newer(self):
 169         repos_url = self.make_client("a", "dc")
 170         self.build_tree({'dc/branches': None})
 171         self.client_add("dc/branches")
 172         self.client_commit("dc", "My Message")
 173         self.build_tree({'dc/branches/foo': 'data'})
 174         self.client_add("dc/branches/foo")
 175         self.client_commit("dc", "propchange")
 176         self.build_tree({'dc/branches/foo': 'data4'})
 177         self.client_commit("dc", "My Message2")
 178
 179         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 180                                      transport=SvnRaTransport(repos_url))
 181
 182         self.assertEqual(2, walker.find_latest_change("branches/foo", 2))
 183
 184     def test_find_branches_no_later(self):
 185         repos_url = self.make_client("a", "dc")
 186
 187         walker = logwalker.LogWalker(NoBranchingScheme(),
 188                                      transport=SvnRaTransport(repos_url))
 189
 190         self.assertEqual([("", 0, True)], list(walker.find_branches(0)))
 191
 192     def test_find_branches_trunk_empty(self):
 193         repos_url = self.make_client("a", "dc")
 194
 195         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 196                                      transport=SvnRaTransport(repos_url))
 197
 198         self.assertEqual([], list(walker.find_branches(0)))
 199
 200     def test_find_branches_trunk_one(self):
 201         repos_url = self.make_client("a", "dc")
 202
 203         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 204                                      transport=SvnRaTransport(repos_url))
 205
 206         self.build_tree({'dc/trunk/foo': "data"})
 207         self.client_add("dc/trunk")
 208         self.client_commit("dc", "My Message")
 209
 210         self.assertEqual([("trunk", 1, True)], list(walker.find_branches(1)))
 211
 212     def test_find_branches_removed(self):
 213         repos_url = self.make_client("a", "dc")
 214
 215         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 216                                      transport=SvnRaTransport(repos_url))
 217
 218         self.build_tree({'dc/trunk/foo': "data"})
 219         self.client_add("dc/trunk")
 220         self.client_commit("dc", "My Message")
 221
 222         self.client_delete("dc/trunk")
 223         self.client_commit("dc", "remove")
 224
 225         self.assertEqual([("trunk", 1, True)], list(walker.find_branches(1)))
 226         self.assertEqual([("trunk", 2, False)], list(walker.find_branches(2)))
 227
 228     def test_follow_history(self):
 229         repos_url = self.make_client("a", "dc")
 230         walker = logwalker.LogWalker(NoBranchingScheme(),
 231                                      transport=SvnRaTransport(repos_url))
 232
 233         self.build_tree({'dc/foo': "data"})
 234         self.client_add("dc/foo")
 235         self.client_commit("dc", "My Message")
 236
 237         for (branch, paths, rev) in walker.follow_history("", 1):
 238            self.assertEqual(branch, "")
 239            self.assertTrue(paths.has_key("foo"))
 240            self.assertEqual(rev, 1)
 241
 242     def test_follow_history_nohist(self):
 243         repos_url = self.make_client("a", "dc")
 244         walker = logwalker.LogWalker(NoBranchingScheme(),
 245                                      transport=SvnRaTransport(repos_url))
 246
 247         self.assertEqual([], list(walker.follow_history("", 0)))
 248
 249     def test_later_update(self):
 250         repos_url = self.make_client("a", "dc")
 251
 252         walker = logwalker.LogWalker(NoBranchingScheme(),
 253                                      transport=SvnRaTransport(repos_url))
 254
 255         self.build_tree({'dc/foo': "data"})
 256         self.client_add("dc/foo")
 257         self.client_commit("dc", "My Message")
 258
 259         for (branch, paths, rev) in walker.follow_history("", 1):
 260            self.assertEqual(branch, "")
 261            self.assertTrue(paths.has_key("foo"))
 262            self.assertEqual(rev, 1)
 263
 264         iter = walker.follow_history("", 2)
 265         self.assertRaises(NoSuchRevision, list, iter)
 266
 267     def test_get_branch_log_follow(self):
 268         repos_url = self.make_client("a", "dc")
 269         self.build_tree({'dc/trunk/afile': "data", "dc/branches": None})
 270         self.client_add("dc/trunk")
 271         self.client_add("dc/branches")
 272         self.client_commit("dc", "My Message")
 273
 274         self.client_copy("dc/trunk", "dc/branches/abranch")
 275         self.client_commit("dc", "Create branch")
 276
 277         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 278                                      transport=SvnRaTransport(repos_url))
 279
 280         items = list(walker.follow_history("branches/abranch", 2))
 281         self.assertEqual(2, len(items))
 282
 283     def test_touches_path(self):
 284         repos_url = self.make_client("a", "dc")
 285         self.build_tree({'dc/trunk/afile': "data"})
 286         self.client_add("dc/trunk")
 287         self.client_commit("dc", "My Message")
 288
 289         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 290                                      transport=SvnRaTransport(repos_url))
 291
 292         self.assertTrue(walker.touches_path("trunk", 1))
 293
 294     def test_touches_path_null(self):
 295         repos_url = self.make_client("a", "dc")
 296         self.build_tree({'dc/trunk/afile': "data"})
 297         self.client_add("dc/trunk")
 298         self.client_commit("dc", "My Message")
 299
 300         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 301                                      transport=SvnRaTransport(repos_url))
 302
 303         self.assertTrue(walker.touches_path("", 0))
 304
 305     def test_touches_path_not(self):
 306         repos_url = self.make_client("a", "dc")
 307         self.build_tree({'dc/trunk/afile': "data"})
 308         self.client_add("dc/trunk")
 309         self.client_commit("dc", "My Message")
 310
 311         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 312                                      transport=SvnRaTransport(repos_url))
 313
 314         self.assertFalse(walker.touches_path("", 1))
 315
 316     def test_touches_path_child(self):
 317         repos_url = self.make_client("a", "dc")
 318         self.build_tree({'dc/trunk/afile': "data"})
 319         self.client_add("dc/trunk")
 320         self.client_commit("dc", "My Message")
 321         self.build_tree({'dc/trunk/afile': "data2"})
 322         self.client_commit("dc", "My Message")
 323
 324         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 325                                      transport=SvnRaTransport(repos_url))
 326
 327         self.assertFalse(walker.touches_path("trunk", 2))
 328
 329     def test_get_previous_simple(self):
 330         repos_url = self.make_client("a", "dc")
 331         self.build_tree({'dc/trunk/afile': "data"})
 332         self.client_add("dc/trunk")
 333         self.client_commit("dc", "My Message")
 334         self.build_tree({'dc/trunk/afile': "data2"})
 335         self.client_set_prop("dc/trunk", "myprop", "mydata")
 336         self.client_commit("dc", "My Message")
 337
 338         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 339                                      transport=SvnRaTransport(repos_url))
 340
 341         self.assertEqual(("trunk", 1), walker.get_previous("trunk", 2))
 342
 343     def test_get_previous_copy(self):
 344         repos_url = self.make_client("a", "dc")
 345         self.build_tree({'dc/trunk/afile': "data"})
 346         self.client_add("dc/trunk")
 347         self.client_commit("dc", "My Message")
 348         self.client_copy("dc/trunk", "dc/anotherfile")
 349         self.client_commit("dc", "My Message")
 350
 351         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 352                                      transport=SvnRaTransport(repos_url))
 353
 354         self.assertEqual(("trunk", 1), walker.get_previous("anotherfile", 2))
 355
 356     def test_get_revision_info(self):
 357         repos_url = self.make_client("a", "dc")
 358         self.build_tree({'dc/trunk/afile': "data"})
 359         self.client_add("dc/trunk")
 360         self.client_commit("dc", "My Message")
 361
 362         walker = logwalker.LogWalker(TrunkBranchingScheme(),
 363                                      transport=SvnRaTransport(repos_url))
 364
 365         info = walker.get_revision_info(1)
 366
 367         self.assertEqual("", info[0])
 368         self.assertEqual("My Message", info[1])
 369