lib/bup/t/tvfs.py

   1
   2 from __future__ import print_function
   3 from collections import namedtuple
   4 from errno import ELOOP, ENOTDIR
   5 from io import BytesIO
   6 from os import environ, symlink
   7 from stat import S_IFDIR, S_IFREG, S_ISDIR, S_ISREG
   8 from sys import stderr
   9 from time import localtime, strftime
  10
  11 from wvtest import *
  12
  13 from bup import git, metadata, vfs2 as vfs
  14 from bup.git import BUP_CHUNKED
  15 from bup.helpers import exc, exo, shstr
  16 from bup.metadata import Metadata
  17 from bup.repo import LocalRepo
  18 from buptest import no_lingering_errors, test_tempdir
  19
  20 top_dir = '../../..'
  21 bup_tmp = os.path.realpath('../../../t/tmp')
  22 bup_path = top_dir + '/bup'
  23 start_dir = os.getcwd()
  24
  25 def ex(cmd, **kwargs):
  26     print(shstr(cmd), file=stderr)
  27     return exc(cmd, **kwargs)
  28
  29 TreeDictValue = namedtuple('TreeDictValue', ('name', 'oid', 'meta'))
  30
  31 def tree_items(repo, oid):
  32     """Yield (name, entry_oid, meta) for each entry in oid.  meta will be
  33     a Metadata object for any non-directories and for '.', otherwise
  34     None.
  35
  36     """
  37     # This is a simpler approach than the one in the vfs, used to
  38     # cross-check its behavior.
  39     tree_data, bupm_oid = vfs.tree_data_and_bupm(repo, oid)
  40     bupm = vfs._FileReader(repo, bupm_oid) if bupm_oid else None
  41     try:
  42         maybe_meta = lambda : Metadata.read(bupm) if bupm else None
  43         m = maybe_meta()
  44         if m:
  45             m.size = 0
  46         yield TreeDictValue(name='.', oid=oid, meta=m)
  47         tree_ents = vfs.ordered_tree_entries(tree_data, bupm=True)
  48         for name, mangled_name, kind, gitmode, sub_oid in tree_ents:
  49             if mangled_name == '.bupm':
  50                 continue
  51             assert name != '.'
  52             if S_ISDIR(gitmode):
  53                 if kind == BUP_CHUNKED:
  54                     yield TreeDictValue(name=name, oid=sub_oid,
  55                                         meta=maybe_meta())
  56                 else:
  57                     yield TreeDictValue(name=name, oid=sub_oid,
  58                                         meta=vfs.default_dir_mode)
  59             else:
  60                 yield TreeDictValue(name=name, oid=sub_oid, meta=maybe_meta())
  61     finally:
  62         if bupm:
  63             bupm.close()
  64
  65 def tree_dict(repo, oid):
  66     return dict((x.name, x) for x in tree_items(repo, oid))
  67
  68 def run_augment_item_meta_tests(repo,
  69                                 file_path, file_size,
  70                                 link_path, link_target):
  71     _, file_item = vfs.resolve(repo, file_path)[-1]
  72     _, link_item = vfs.lresolve(repo, link_path)[-1]
  73     wvpass(isinstance(file_item.meta, Metadata))
  74     wvpass(isinstance(link_item.meta, Metadata))
  75     # Note: normally, modifying item.meta values is forbidden
  76     file_item.meta.size = file_item.meta.size or vfs.item_size(repo, file_item)
  77     link_item.meta.size = link_item.meta.size or vfs.item_size(repo, link_item)
  78
  79     ## Ensure a fully populated item is left alone
  80     augmented = vfs.augment_item_meta(repo, file_item)
  81     wvpass(augmented is file_item)
  82     wvpass(augmented.meta is file_item.meta)
  83     augmented = vfs.augment_item_meta(repo, file_item, include_size=True)
  84     wvpass(augmented is file_item)
  85     wvpass(augmented.meta is file_item.meta)
  86
  87     ## Ensure a missing size is handled poperly
  88     file_item.meta.size = None
  89     augmented = vfs.augment_item_meta(repo, file_item)
  90     wvpass(augmented is file_item)
  91     wvpass(augmented.meta is file_item.meta)
  92     augmented = vfs.augment_item_meta(repo, file_item, include_size=True)
  93     wvpass(augmented is not file_item)
  94     wvpasseq(file_size, augmented.meta.size)
  95
  96     ## Ensure a meta mode is handled properly
  97     mode_item = file_item._replace(meta=vfs.default_file_mode)
  98     augmented = vfs.augment_item_meta(repo, mode_item)
  99     augmented_w_size = vfs.augment_item_meta(repo, mode_item, include_size=True)
 100     for item in (augmented, augmented_w_size):
 101         meta = item.meta
 102         wvpass(item is not file_item)
 103         wvpass(isinstance(meta, Metadata))
 104         wvpasseq(vfs.default_file_mode, meta.mode)
 105         wvpasseq((0, 0, 0, 0, 0),
 106                  (meta.uid, meta.gid, meta.atime, meta.mtime, meta.ctime))
 107     wvpass(augmented.meta.size is None)
 108     wvpasseq(file_size, augmented_w_size.meta.size)
 109
 110     ## Ensure symlinks are handled properly
 111     mode_item = link_item._replace(meta=vfs.default_symlink_mode)
 112     augmented = vfs.augment_item_meta(repo, mode_item)
 113     wvpass(augmented is not mode_item)
 114     wvpass(isinstance(augmented.meta, Metadata))
 115     wvpasseq(link_target, augmented.meta.symlink_target)
 116     wvpasseq(len(link_target), augmented.meta.size)
 117     augmented = vfs.augment_item_meta(repo, mode_item, include_size=True)
 118     wvpass(augmented is not mode_item)
 119     wvpass(isinstance(augmented.meta, Metadata))
 120     wvpasseq(link_target, augmented.meta.symlink_target)
 121     wvpasseq(len(link_target), augmented.meta.size)
 122
 123
 124 @wvtest
 125 def test_item_mode():
 126     with no_lingering_errors():
 127         mode = S_IFDIR | 0o755
 128         meta = metadata.from_path('.')
 129         oid = '\0' * 20
 130         wvpasseq(mode, vfs.item_mode(vfs.Item(oid=oid, meta=mode)))
 131         wvpasseq(meta.mode, vfs.item_mode(vfs.Item(oid=oid, meta=meta)))
 132
 133 @wvtest
 134 def test_reverse_suffix_duplicates():
 135     suffix = lambda x: tuple(vfs._reverse_suffix_duplicates(x))
 136     wvpasseq(('x',), suffix(('x',)))
 137     wvpasseq(('x', 'y'), suffix(('x', 'y')))
 138     wvpasseq(('x-1', 'x-0'), suffix(('x',) * 2))
 139     wvpasseq(['x-%02d' % n for n in reversed(range(11))],
 140              list(suffix(('x',) * 11)))
 141     wvpasseq(('x-1', 'x-0', 'y'), suffix(('x', 'x', 'y')))
 142     wvpasseq(('x', 'y-1', 'y-0'), suffix(('x', 'y', 'y')))
 143     wvpasseq(('x', 'y-1', 'y-0', 'z'), suffix(('x', 'y', 'y', 'z')))
 144
 145 @wvtest
 146 def test_misc():
 147     with no_lingering_errors():
 148         with test_tempdir('bup-tvfs-') as tmpdir:
 149             bup_dir = tmpdir + '/bup'
 150             environ['GIT_DIR'] = bup_dir
 151             environ['BUP_DIR'] = bup_dir
 152             git.repodir = bup_dir
 153             data_path = tmpdir + '/src'
 154             os.mkdir(data_path)
 155             with open(data_path + '/file', 'w+') as tmpfile:
 156                 tmpfile.write(b'canary\n')
 157             symlink('file', data_path + '/symlink')
 158             ex((bup_path, 'init'))
 159             ex((bup_path, 'index', '-v', data_path))
 160             ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
 161                 data_path))
 162             repo = LocalRepo()
 163
 164             wvstart('readlink')
 165             ls_tree = exo(('git', 'ls-tree', 'test', 'symlink'))
 166             mode, typ, oidx, name = ls_tree[0].strip().split(None, 3)
 167             assert name == 'symlink'
 168             link_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
 169             wvpasseq('file', vfs.readlink(repo, link_item))
 170
 171             ls_tree = exo(('git', 'ls-tree', 'test', 'file'))
 172             mode, typ, oidx, name = ls_tree[0].strip().split(None, 3)
 173             assert name == 'file'
 174             file_item = vfs.Item(oid=oidx.decode('hex'), meta=int(mode, 8))
 175             wvexcept(Exception, vfs.readlink, repo, file_item)
 176
 177             wvstart('item_size')
 178             wvpasseq(4, vfs.item_size(repo, link_item))
 179             wvpasseq(7, vfs.item_size(repo, file_item))
 180             meta = metadata.from_path(__file__)
 181             meta.size = 42
 182             fake_item = file_item._replace(meta=meta)
 183             wvpasseq(42, vfs.item_size(repo, fake_item))
 184
 185             wvstart('augment_item_meta')
 186             run_augment_item_meta_tests(repo,
 187                                         '/test/latest/file', 7,
 188                                         '/test/latest/symlink', 'file')
 189
 190             wvstart('copy_item')
 191             # FIXME: this caused StopIteration
 192             #_, file_item = vfs.resolve(repo, '/file')[-1]
 193             _, file_item = vfs.resolve(repo, '/test/latest/file')[-1]
 194             file_copy = vfs.copy_item(file_item)
 195             wvpass(file_copy is not file_item)
 196             wvpass(file_copy.meta is not file_item.meta)
 197             wvpass(isinstance(file_copy, tuple))
 198             wvpass(file_item.meta.user)
 199             wvpass(file_copy.meta.user)
 200             file_copy.meta.user = None
 201             wvpass(file_item.meta.user)
 202
 203 @wvtest
 204 def test_resolve():
 205     with no_lingering_errors():
 206         with test_tempdir('bup-tvfs-') as tmpdir:
 207             resolve = vfs.resolve
 208             lresolve = vfs.lresolve
 209             bup_dir = tmpdir + '/bup'
 210             environ['GIT_DIR'] = bup_dir
 211             environ['BUP_DIR'] = bup_dir
 212             git.repodir = bup_dir
 213             data_path = tmpdir + '/src'
 214             save_time = 100000
 215             save_time_str = strftime('%Y-%m-%d-%H%M%S', localtime(save_time))
 216             os.mkdir(data_path)
 217             os.mkdir(data_path + '/dir')
 218             with open(data_path + '/file', 'w+') as tmpfile:
 219                 print('canary', file=tmpfile)
 220             symlink('file', data_path + '/file-symlink')
 221             symlink('dir', data_path + '/dir-symlink')
 222             symlink('not-there', data_path + '/bad-symlink')
 223             ex((bup_path, 'init'))
 224             ex((bup_path, 'index', '-v', data_path))
 225             ex((bup_path, 'save', '-d', str(save_time), '-tvvn', 'test',
 226                 '--strip', data_path))
 227             ex((bup_path, 'tag', 'test-tag', 'test'))
 228             repo = LocalRepo()
 229
 230             tip_hash = exo(('git', 'show-ref', 'refs/heads/test'))[0]
 231             tip_oidx = tip_hash.strip().split()[0]
 232             tip_oid = tip_oidx.decode('hex')
 233             tip_tree_oidx = exo(('git', 'log', '--pretty=%T', '-n1',
 234                                  tip_oidx))[0].strip()
 235             tip_tree_oid = tip_tree_oidx.decode('hex')
 236             tip_tree = tree_dict(repo, tip_tree_oid)
 237             test_revlist = vfs.RevList(meta=S_IFDIR | 0o755, oid=tip_oid)
 238             test_revlist_w_meta = vfs.RevList(meta=tip_tree['.'].meta,
 239                                               oid=tip_oid)
 240             expected_latest_item = vfs.Commit(meta=S_IFDIR | 0o755,
 241                                               oid=tip_tree_oid,
 242                                               coid=tip_oid)
 243             expected_test_tag_item = expected_latest_item
 244
 245             wvstart('resolve: /')
 246             res = resolve(repo, '/')
 247             wvpasseq(1, len(res))
 248             wvpasseq((('', vfs._root),), res)
 249             ignore, root_item = res[0]
 250             root_content = frozenset(vfs.contents(repo, root_item))
 251             wvpasseq(frozenset([('.', root_item),
 252                                 ('.tag', vfs._tags),
 253                                 ('test', test_revlist)]),
 254                      root_content)
 255             for path in ('//', '/.', '/./', '/..', '/../',
 256                          '/test/latest/dir/../../..',
 257                          '/test/latest/dir/../../../',
 258                          '/test/latest/dir/../../../.',
 259                          '/test/latest/dir/../../..//',
 260                          '/test//latest/dir/../../..',
 261                          '/test/./latest/dir/../../..',
 262                          '/test/././latest/dir/../../..',
 263                          '/test/.//./latest/dir/../../..',
 264                          '/test//.//.//latest/dir/../../..'
 265                          '/test//./latest/dir/../../..'):
 266                 wvstart('resolve: ' + path)
 267                 res = resolve(repo, path)
 268                 wvpasseq((('', vfs._root),), res)
 269
 270             wvstart('resolve: /.tag')
 271             res = resolve(repo, '/.tag')
 272             wvpasseq(2, len(res))
 273             wvpasseq((('', vfs._root), ('.tag', vfs._tags)),
 274                      res)
 275             ignore, tag_item = res[1]
 276             tag_content = frozenset(vfs.contents(repo, tag_item))
 277             wvpasseq(frozenset([('.', tag_item),
 278                                 ('test-tag', expected_test_tag_item)]),
 279                      tag_content)
 280
 281             wvstart('resolve: /test')
 282             res = resolve(repo, '/test')
 283             wvpasseq(2, len(res))
 284             wvpasseq((('', vfs._root), ('test', test_revlist)), res)
 285             ignore, test_item = res[1]
 286             test_content = frozenset(vfs.contents(repo, test_item))
 287             wvpasseq(frozenset([('.', test_revlist_w_meta),
 288                                 (save_time_str, expected_latest_item),
 289                                 ('latest', expected_latest_item)]),
 290                      test_content)
 291
 292             wvstart('resolve: /test/latest')
 293             res = resolve(repo, '/test/latest')
 294             wvpasseq(3, len(res))
 295             expected_latest_item_w_meta = vfs.Commit(meta=tip_tree['.'].meta,
 296                                                      oid=tip_tree_oid,
 297                                                      coid=tip_oid)
 298             expected = (('', vfs._root),
 299                         ('test', test_revlist),
 300                         ('latest', expected_latest_item_w_meta))
 301             wvpasseq(expected, res)
 302             ignore, latest_item = res[2]
 303             latest_content = frozenset(vfs.contents(repo, latest_item))
 304             expected = frozenset((x.name, vfs.Item(oid=x.oid, meta=x.meta))
 305                                  for x in (tip_tree[name]
 306                                            for name in ('.',
 307                                                         'bad-symlink',
 308                                                         'dir',
 309                                                         'dir-symlink',
 310                                                         'file',
 311                                                         'file-symlink')))
 312             wvpasseq(expected, latest_content)
 313
 314             wvstart('resolve: /test/latest/file')
 315             res = resolve(repo, '/test/latest/file')
 316             wvpasseq(4, len(res))
 317             expected_file_item_w_meta = vfs.Item(meta=tip_tree['file'].meta,
 318                                                  oid=tip_tree['file'].oid)
 319             expected = (('', vfs._root),
 320                         ('test', test_revlist),
 321                         ('latest', expected_latest_item_w_meta),
 322                         ('file', expected_file_item_w_meta))
 323             wvpasseq(expected, res)
 324
 325             wvstart('resolve: /test/latest/bad-symlink')
 326             res = resolve(repo, '/test/latest/bad-symlink')
 327             wvpasseq(4, len(res))
 328             expected = (('', vfs._root),
 329                         ('test', test_revlist),
 330                         ('latest', expected_latest_item_w_meta),
 331                         ('not-there', None))
 332             wvpasseq(expected, res)
 333
 334             wvstart('lresolve: /test/latest/bad-symlink')
 335             res = lresolve(repo, '/test/latest/bad-symlink')
 336             wvpasseq(4, len(res))
 337             bad_symlink_value = tip_tree['bad-symlink']
 338             expected_bad_symlink_item_w_meta = vfs.Item(meta=bad_symlink_value.meta,
 339                                                         oid=bad_symlink_value.oid)
 340             expected = (('', vfs._root),
 341                         ('test', test_revlist),
 342                         ('latest', expected_latest_item_w_meta),
 343                         ('bad-symlink', expected_bad_symlink_item_w_meta))
 344             wvpasseq(expected, res)
 345
 346             wvstart('resolve: /test/latest/file-symlink')
 347             res = resolve(repo, '/test/latest/file-symlink')
 348             wvpasseq(4, len(res))
 349             expected = (('', vfs._root),
 350                         ('test', test_revlist),
 351                         ('latest', expected_latest_item_w_meta),
 352                         ('file', expected_file_item_w_meta))
 353             wvpasseq(expected, res)
 354
 355             wvstart('lresolve: /test/latest/file-symlink')
 356             res = lresolve(repo, '/test/latest/file-symlink')
 357             wvpasseq(4, len(res))
 358             file_symlink_value = tip_tree['file-symlink']
 359             expected_file_symlink_item_w_meta = vfs.Item(meta=file_symlink_value.meta,
 360                                                          oid=file_symlink_value.oid)
 361             expected = (('', vfs._root),
 362                         ('test', test_revlist),
 363                         ('latest', expected_latest_item_w_meta),
 364                         ('file-symlink', expected_file_symlink_item_w_meta))
 365             wvpasseq(expected, res)
 366
 367             wvstart('resolve: /test/latest/missing')
 368             res = resolve(repo, '/test/latest/missing')
 369             wvpasseq(4, len(res))
 370             name, item = res[-1]
 371             wvpasseq('missing', name)
 372             wvpass(item is None)
 373
 374             for path in ('/test/latest/file/',
 375                          '/test/latest/file/.',
 376                          '/test/latest/file/..',
 377                          '/test/latest/file/../',
 378                          '/test/latest/file/../.',
 379                          '/test/latest/file/../..',
 380                          '/test/latest/file/foo'):
 381                 wvstart('resolve: ' + path)
 382                 try:
 383                     resolve(repo, path)
 384                 except vfs.IOError as res_ex:
 385                     wvpasseq(ENOTDIR, res_ex.errno)
 386                     wvpasseq(['', 'test', 'latest', 'file'],
 387                              [name for name, item in res_ex.terminus])
 388
 389             for path in ('/test/latest/file-symlink/',
 390                          '/test/latest/file-symlink/.',
 391                          '/test/latest/file-symlink/..',
 392                          '/test/latest/file-symlink/../',
 393                          '/test/latest/file-symlink/../.',
 394                          '/test/latest/file-symlink/../..'):
 395                 wvstart('lresolve: ' + path)
 396                 try:
 397                     lresolve(repo, path)
 398                 except vfs.IOError as res_ex:
 399                     wvpasseq(ENOTDIR, res_ex.errno)
 400                     wvpasseq(['', 'test', 'latest', 'file'],
 401                              [name for name, item in res_ex.terminus])
 402
 403             wvstart('resolve: non-directory parent')
 404             file_res = resolve(repo, '/test/latest/file')
 405             try:
 406                 resolve(repo, 'foo', parent=file_res)
 407             except vfs.IOError as res_ex:
 408                 wvpasseq(ENOTDIR, res_ex.errno)
 409                 wvpasseq(None, res_ex.terminus)
 410
 411             wvstart('lresolve: /test/latest/dir-symlink')
 412             res = lresolve(repo, '/test/latest/dir-symlink')
 413             wvpasseq(4, len(res))
 414             dir_symlink_value = tip_tree['dir-symlink']
 415             expected_dir_symlink_item_w_meta = vfs.Item(meta=dir_symlink_value.meta,
 416                                                          oid=dir_symlink_value.oid)
 417             expected = (('', vfs._root),
 418                         ('test', test_revlist),
 419                         ('latest', expected_latest_item_w_meta),
 420                         ('dir-symlink', expected_dir_symlink_item_w_meta))
 421             wvpasseq(expected, res)
 422
 423             dir_value = tip_tree['dir']
 424             expected_dir_item = vfs.Item(oid=dir_value.oid,
 425                                          meta=tree_dict(repo, dir_value.oid)['.'].meta)
 426             expected = (('', vfs._root),
 427                         ('test', test_revlist),
 428                         ('latest', expected_latest_item_w_meta),
 429                         ('dir', expected_dir_item))
 430             for resname, resolver in (('resolve', resolve),
 431                                       ('lresolve', lresolve)):
 432                 for path in ('/test/latest/dir-symlink/',
 433                              '/test/latest/dir-symlink/.'):
 434                     wvstart(resname + ': ' + path)
 435                     res = resolver(repo, path)
 436                     wvpasseq(4, len(res))
 437                     wvpasseq(expected, res)
 438             wvstart('resolve: /test/latest/dir-symlink')
 439             res = resolve(repo, path)
 440             wvpasseq(4, len(res))
 441             wvpasseq(expected, res)
 442
 443 @wvtest
 444 def test_resolve_loop():
 445     with no_lingering_errors():
 446         with test_tempdir('bup-tvfs-resloop-') as tmpdir:
 447             resolve = vfs.resolve
 448             lresolve = vfs.lresolve
 449             bup_dir = tmpdir + '/bup'
 450             environ['GIT_DIR'] = bup_dir
 451             environ['BUP_DIR'] = bup_dir
 452             git.repodir = bup_dir
 453             repo = LocalRepo()
 454             data_path = tmpdir + '/src'
 455             os.mkdir(data_path)
 456             symlink('loop', data_path + '/loop')
 457             ex((bup_path, 'init'))
 458             ex((bup_path, 'index', '-v', data_path))
 459             ex((bup_path, 'save', '-d', '100000', '-tvvn', 'test', '--strip',
 460                 data_path))
 461             try:
 462                 resolve(repo, '/test/latest/loop')
 463             except vfs.IOError as res_ex:
 464                 wvpasseq(ELOOP, res_ex.errno)
 465                 wvpasseq(['', 'test', 'latest', 'loop'],
 466                          [name for name, item in res_ex.terminus])
 467
 468 @wvtest
 469 def test_contents_with_mismatched_bupm_git_ordering():
 470     with no_lingering_errors():
 471         with test_tempdir('bup-tvfs-') as tmpdir:
 472             bup_dir = tmpdir + '/bup'
 473             environ['GIT_DIR'] = bup_dir
 474             environ['BUP_DIR'] = bup_dir
 475             git.repodir = bup_dir
 476             data_path = tmpdir + '/src'
 477             os.mkdir(data_path)
 478             os.mkdir(data_path + '/foo')
 479             with open(data_path + '/foo.', 'w+') as tmpfile:
 480                 tmpfile.write(b'canary\n')
 481             ex((bup_path, 'init'))
 482             ex((bup_path, 'index', '-v', data_path))
 483             ex((bup_path, 'save', '-tvvn', 'test', '--strip',
 484                 data_path))
 485             repo = LocalRepo()
 486             tip_sref = exo(('git', 'show-ref', 'refs/heads/test'))[0]
 487             tip_oidx = tip_sref.strip().split()[0]
 488             tip_tree_oidx = exo(('git', 'log', '--pretty=%T', '-n1',
 489                                  tip_oidx))[0].strip()
 490             tip_tree_oid = tip_tree_oidx.decode('hex')
 491             tip_tree = tree_dict(repo, tip_tree_oid)
 492
 493             name, item = vfs.resolve(repo, '/test/latest')[2]
 494             wvpasseq('latest', name)
 495             expected = frozenset((x.name, vfs.Item(oid=x.oid, meta=x.meta))
 496                                  for x in (tip_tree[name]
 497                                            for name in ('.', 'foo', 'foo.')))
 498             contents = tuple(vfs.contents(repo, item))
 499             wvpasseq(expected, frozenset(contents))
 500             # Spot check, in case tree_dict shares too much code with the vfs
 501             name, item = next(((n, i) for n, i in contents if n == 'foo'))
 502             wvpass(S_ISDIR(item.meta))
 503             name, item = next(((n, i) for n, i in contents if n == 'foo.'))
 504             wvpass(S_ISREG(item.meta.mode))
 505
 506 @wvtest
 507 def test_duplicate_save_dates():
 508     with no_lingering_errors():
 509         with test_tempdir('bup-tvfs-') as tmpdir:
 510             bup_dir = tmpdir + '/bup'
 511             environ['GIT_DIR'] = bup_dir
 512             environ['BUP_DIR'] = bup_dir
 513             environ['TZ'] = 'UTC'
 514             git.repodir = bup_dir
 515             data_path = tmpdir + '/src'
 516             os.mkdir(data_path)
 517             with open(data_path + '/file', 'w+') as tmpfile:
 518                 tmpfile.write(b'canary\n')
 519             ex((bup_path, 'init'))
 520             ex((bup_path, 'index', '-v', data_path))
 521             for i in range(11):
 522                 ex((bup_path, 'save', '-d', '100000', '-n', 'test', data_path))
 523             repo = LocalRepo()
 524             res = vfs.resolve(repo, '/test')
 525             wvpasseq(2, len(res))
 526             name, revlist = res[-1]
 527             wvpasseq('test', name)
 528             wvpasseq(('.',
 529                       '1970-01-02-034640-00',
 530                       '1970-01-02-034640-01',
 531                       '1970-01-02-034640-02',
 532                       '1970-01-02-034640-03',
 533                       '1970-01-02-034640-04',
 534                       '1970-01-02-034640-05',
 535                       '1970-01-02-034640-06',
 536                       '1970-01-02-034640-07',
 537                       '1970-01-02-034640-08',
 538                       '1970-01-02-034640-09',
 539                       '1970-01-02-034640-10',
 540                       'latest'),
 541                      tuple(sorted(x[0] for x in vfs.contents(repo, revlist))))
 542
 543 # FIXME: add tests for the want_meta=False cases.