fix(tests): combine rebase/resolve tests to check idempotence

Author: oesteban

nipype/interfaces/base/tests/test_traits_extension.py

@@ -1,6 +1,6 @@
-# -*- coding: utf-8 -*-
 # emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
+"""Check the resolving/rebasing feature of ``BasePath``s."""
 from __future__ import print_function, unicode_literals
 
 from ... import base as nib
@@ -22,157 +22,161 @@ class _test_spec(nib.TraitedSpec):
                           nib.traits.Dict(nib.Str, nib.File()))
 
 
-def test_rebase_path_traits():
-    """Check rebase_path_traits."""
+def test_rebase_resolve_path_traits():
+    """Check rebase_path_traits and resolve_path_traits and idempotence."""
     spec = _test_spec()
 
-    a = rebase_path_traits(
-        spec.trait('a'), '/some/path/f1.txt', '/some/path')
+    v = '/some/path/f1.txt'
+    a = rebase_path_traits(spec.trait('a'), v, '/some/path')
     assert a == Path('f1.txt')
 
-    a = rebase_path_traits(
-        spec.trait('a'), '/some/path/f1.txt', '/some/other/path')
-    assert a == Path('/some/path/f1.txt')
+    a = resolve_path_traits(spec.trait('a'), a, '/some/path')
+    assert a == Path(v)
 
-    b = rebase_path_traits(
-        spec.trait('b'), ('/some/path/f1.txt', '/some/path/f2.txt'), '/some/path')
+    a = rebase_path_traits(spec.trait('a'), v, '/some/other/path')
+    assert a == Path(v)
+
+    a = resolve_path_traits(spec.trait('a'), a, '/some/path')
+    assert a == Path(v)
+
+    v = ('/some/path/f1.txt', '/some/path/f2.txt')
+    b = rebase_path_traits(spec.trait('b'), v, '/some/path')
     assert b == (Path('f1.txt'), Path('f2.txt'))
 
-    c = rebase_path_traits(
-        spec.trait('c'), ['/some/path/f1.txt', '/some/path/f2.txt', '/some/path/f3.txt'],
-        '/some/path')
+    b = resolve_path_traits(spec.trait('b'), b, '/some/path')
+    assert b == (Path(v[0]), Path(v[1]))
+
+    v = ['/some/path/f1.txt', '/some/path/f2.txt', '/some/path/f3.txt']
+    c = rebase_path_traits(spec.trait('c'), v, '/some/path')
     assert c == [Path('f1.txt'), Path('f2.txt'), Path('f3.txt')]
 
-    d = rebase_path_traits(
-        spec.trait('d'), 2.0, '/some/path')
-    assert d == 2.0
+    c = resolve_path_traits(spec.trait('c'), c, '/some/path')
+    assert c == [Path(vp) for vp in v]
 
-    d = rebase_path_traits(
-        spec.trait('d'), '/some/path/either.txt', '/some/path')
-    assert '%s' % d == 'either.txt'
+    v = 2.0
+    d = rebase_path_traits(spec.trait('d'), v, '/some/path')
+    assert d == v
 
-    e = rebase_path_traits(
-        spec.trait('e'), ['/some/path/f1.txt', '/some/path/f2.txt', '/some/path/f3.txt'],
-        '/some/path')
-    assert e == [Path('f1.txt'), Path('f2.txt'), Path('f3.txt')]
+    d = resolve_path_traits(spec.trait('d'), d, '/some/path')
+    assert d == v
 
-    e = rebase_path_traits(
-        spec.trait('e'), [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]],
-        '/some/path')
-    assert e == [[Path('f1.txt'), Path('f2.txt')], [[Path('f3.txt')]]]
+    v = '/some/path/either.txt'
+    d = rebase_path_traits(spec.trait('d'), v, '/some/path')
+    assert d == Path('either.txt')
 
-    ee = rebase_path_traits(
-        spec.trait('ee'), [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]],
-        '/some/path')
-    assert ee == [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]]
+    d = resolve_path_traits(spec.trait('d'), d, '/some/path')
+    assert d == Path(v)
 
-    f = rebase_path_traits(
-        spec.trait('f'), {'1': '/some/path/f1.txt'}, '/some/path')
-    assert f == {'1': Path('f1.txt')}
+    v = ['/some/path/f1.txt', '/some/path/f2.txt', '/some/path/f3.txt']
+    e = rebase_path_traits(spec.trait('e'), v, '/some/path')
+    assert e == [Path('f1.txt'), Path('f2.txt'), Path('f3.txt')]
 
-    g = rebase_path_traits(
-        spec.trait('g'), 'some/path/either.txt', '/some/path')
-    assert '%s' % g == 'some/path/either.txt'
+    e = resolve_path_traits(spec.trait('e'), e, '/some/path')
+    assert e == [Path(vp) for vp in v]
 
-    g = rebase_path_traits(
-        spec.trait('g'), '/some/path/either.txt', '/some')
-    assert '%s' % g == 'path/either.txt'
+    v = [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]]
+    e = rebase_path_traits(spec.trait('e'), v, '/some/path')
+    assert e == [[Path('f1.txt'), Path('f2.txt')], [[Path('f3.txt')]]]
 
-    g = rebase_path_traits(spec.trait('g'), 'string', '/some')
-    assert '%s' % g == 'string'
+    e = resolve_path_traits(spec.trait('e'), e, '/some/path')
+    assert e == [[[Path(vpp) for vpp in vp] if isinstance(vp, list) else Path(vp) for vp in inner]
+                 for inner in v]
 
-    g = rebase_path_traits(spec.trait('g'), '2', '/some/path')
-    assert g == '2'  # You dont want this one to be a Path
+    # These are Str - no rebasing/resolving should happen
+    v = [['/some/path/f1.txt', '/some/path/f2.txt'], [['/some/path/f3.txt']]]
+    ee = rebase_path_traits(spec.trait('ee'), v, '/some/path')
+    assert ee == v
 
-    h = rebase_path_traits(spec.trait('h'), '2', '/some/path')
-    assert h == '2'
+    ee = resolve_path_traits(spec.trait('ee'), [['f1.txt', 'f2.txt'], [['f3.txt']]], '/some/path')
+    assert ee == [['f1.txt', 'f2.txt'], [['f3.txt']]]
 
-    i = rebase_path_traits(spec.trait('i'), '/some/path/either/file.txt', '/some/path')
-    assert '%s' % i == 'either/file.txt'
+    v = {'1': '/some/path/f1.txt'}
+    f = rebase_path_traits(spec.trait('f'), v, '/some')
+    assert f == {'1': Path('path/f1.txt')}
 
-    i = rebase_path_traits(spec.trait('i'), ('/some/path/either/tuple/file.txt', 2), '/some/path')
-    assert ('%s' % i[0], i[1]) == ('either/tuple/file.txt', 2)
+    f = resolve_path_traits(spec.trait('f'), f, '/some')
+    assert f == {k: Path(val) for k, val in v.items()}
 
-    j = rebase_path_traits(spec.trait('j'), '/some/path/either/file.txt', '/some/path')
-    assert '%s' % j == 'either/file.txt'
+    # Either(Str, File): passing in path-like apply manipulation
+    v = '/some/path/either.txt'
+    g = rebase_path_traits(spec.trait('g'), v, '/some/path')
+    assert g == Path('either.txt')
 
-    j = rebase_path_traits(spec.trait('j'), ('/some/path/either/tuple/file.txt', 2), '/some/path')
-    assert ('%s' % j[0], j[1]) == ('either/tuple/file.txt', 2)
+    g = resolve_path_traits(spec.trait('g'), g, '/some/path')
+    assert g == Path(v)
 
-    j = rebase_path_traits(spec.trait('j'), {'a': '/some/path/either/dict/file.txt'},
-                           '/some/path')
-    assert j == {'a': Path('either/dict/file.txt')}
+    g = rebase_path_traits(spec.trait('g'), v, '/some')
+    assert g == Path('path/either.txt')
 
+    g = resolve_path_traits(spec.trait('g'), g, '/some')
+    assert g == Path(v)
 
-def test_resolve_path_traits():
-    """Check resolve_path_traits."""
-    spec = _test_spec()
+    # Either(Str, File): passing str discards File
+    v = 'either.txt'
+    g = rebase_path_traits(spec.trait('g'), v, '/some/path')
+    assert g == v
+
+    # This is a problematic case, it is impossible to know whether this
+    # was meant to be a string or a file.
+    # In this implementation, strings take precedence
+    g = resolve_path_traits(spec.trait('g'), g, '/some/path')
+    assert g == v
 
-    a = resolve_path_traits(
-        spec.trait('a'), 'f1.txt', '/some/path')
-    assert a == Path('/some/path/f1.txt')
+    v = 'string'
+    g = rebase_path_traits(spec.trait('g'), v, '/some')
+    assert g == v
 
-    a = resolve_path_traits(
-        spec.trait('a'), '/already/absolute/f1.txt', '/some/path')
-    assert a == Path('/already/absolute/f1.txt')
+    # This is a problematic case, it is impossible to know whether this
+    # was meant to be a string or a file.
+    g = resolve_path_traits(spec.trait('g'), v, '/some')
+    assert g == v
 
-    b = resolve_path_traits(
-        spec.trait('b'), ('f1.txt', 'f2.txt'), '/some/path')
-    assert b == (Path('/some/path/f1.txt'), Path('/some/path/f2.txt'))
+    v = v
+    g = rebase_path_traits(spec.trait('g'), v, '/some/path')
+    assert g == v  # You dont want this one to be a Path
 
-    c = resolve_path_traits(
-        spec.trait('c'), ['f1.txt', 'f2.txt', 'f3.txt'],
-        '/some/path')
-    assert c == [Path('/some/path/f1.txt'), Path('/some/path/f2.txt'), Path('/some/path/f3.txt')]
+    # This is a problematic case, it is impossible to know whether this
+    # was meant to be a string or a file.
+    g = resolve_path_traits(spec.trait('g'), g, '/some/path')
+    assert g == v  # You dont want this one to be a Path
 
-    d = resolve_path_traits(
-        spec.trait('d'), 2.0, '/some/path')
-    assert d == 2.0
+    h = rebase_path_traits(spec.trait('h'), v, '/some/path')
+    assert h == v
 
-    d = resolve_path_traits(
-        spec.trait('d'), 'either.txt', '/some/path')
-    assert '%s' % d == '/some/path/either.txt'
+    h = resolve_path_traits(spec.trait('h'), h, '/some/path')
+    assert h == v
 
-    e = resolve_path_traits(
-        spec.trait('e'), ['f1.txt', 'f2.txt', 'f3.txt'],
-        '/some/path')
-    assert e == [Path('/some/path/f1.txt'), Path('/some/path/f2.txt'), Path('/some/path/f3.txt')]
+    v = '/some/path/either/file.txt'
+    i = rebase_path_traits(spec.trait('i'), v, '/some/path')
+    assert i == Path('either/file.txt')
 
-    e = resolve_path_traits(
-        spec.trait('e'), [['f1.txt', 'f2.txt'], [['f3.txt']]],
-        '/some/path')
-    assert e == [[Path('/some/path/f1.txt'), Path('/some/path/f2.txt')],
-                 [[Path('/some/path/f3.txt')]]]
+    i = resolve_path_traits(spec.trait('i'), i, '/some/path')
+    assert i == Path(v)
 
-    f = resolve_path_traits(
-        spec.trait('f'), {'1': 'path/f1.txt'}, '/some')
-    assert f == {'1': Path('/some/path/f1.txt')}
+    v = ('/some/path/either/tuple/file.txt', 2)
+    i = rebase_path_traits(spec.trait('i'), v, '/some/path')
+    assert i == (Path('either/tuple/file.txt'), 2)
 
-    g = resolve_path_traits(
-        spec.trait('g'), '/either.txt', '/some/path')
-    assert g == Path('/either.txt')
+    i = resolve_path_traits(spec.trait('i'), i, '/some/path')
+    assert i == (Path(v[0]), v[1])
 
-    # This is a problematic case, it is impossible to know whether this
-    # was meant to be a string or a file.
-    # In this implementation, strings take precedence
-    g = resolve_path_traits(
-        spec.trait('g'), 'path/either.txt', '/some')
-    assert g == 'path/either.txt'
+    v = '/some/path/either/file.txt'
+    j = rebase_path_traits(spec.trait('j'), v, '/some/path')
+    assert j == Path('either/file.txt')
 
-    # This is a problematic case, it is impossible to know whether this
-    # was meant to be a string or a file.
-    g = resolve_path_traits(spec.trait('g'), 'string', '/some')
-    assert g == 'string'
+    j = resolve_path_traits(spec.trait('j'), j, '/some/path')
+    assert j == Path(v)
 
-    # This is a problematic case, it is impossible to know whether this
-    # was meant to be a string or a file.
-    g = resolve_path_traits(spec.trait('g'), '2', '/some/path')
-    assert g == '2'  # You dont want this one to be a Path
+    v = ('/some/path/either/tuple/file.txt', 2)
+    j = rebase_path_traits(spec.trait('j'), ('/some/path/either/tuple/file.txt', 2), '/some/path')
+    assert j == (Path('either/tuple/file.txt'), 2)
 
-    h = resolve_path_traits(spec.trait('h'), '2', '/some/path')
-    assert h == '2'
+    j = resolve_path_traits(spec.trait('j'), j, '/some/path')
+    assert j == (Path(v[0]), v[1])
 
-    ee = resolve_path_traits(
-        spec.trait('ee'), [['f1.txt', 'f2.txt'], [['f3.txt']]],
-        '/some/path')
-    assert ee == [['f1.txt', 'f2.txt'], [['f3.txt']]]
+    v = {'a': '/some/path/either/dict/file.txt'}
+    j = rebase_path_traits(spec.trait('j'), v, '/some/path')
+    assert j == {'a': Path('either/dict/file.txt')}
+
+    j = resolve_path_traits(spec.trait('j'), j, '/some/path')
+    assert j == {k: Path(val) for k, val in v.items()}