lib/bup/t/tvfs.py

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