5cca99bbae
Add more functions and properties to VirtualPath that directly correspond to functions and properties of pathlib.PurePath, except that types are adapted of course, and that for API consistency, VirtualPath methods use mixedCaseStyle whereas those of pathlib.PurePath use underscore_style.
361 lines
13 KiB
Python
361 lines
13 KiB
Python
#! /usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# test_virtual_path.py --- Test module for terrasync.virtual_path
|
|
# Copyright (C) 2018 Florent Rougon
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as
|
|
# published by the Free Software Foundation; either version 2 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful, but
|
|
# WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
# In order to exercise all tests, run the following command from the parent
|
|
# directory (you may omit the 'discover' argument):
|
|
#
|
|
# python3 -m unittest discover
|
|
|
|
import collections
|
|
import unittest
|
|
|
|
from terrasync.virtual_path import VirtualPath, MutableVirtualPath
|
|
|
|
# Hook doctest-based tests into the unittest test discovery mechanism
|
|
import doctest
|
|
import terrasync.virtual_path
|
|
|
|
def load_tests(loader, tests, ignore):
|
|
# Tell unittest to run doctests from terrasync.virtual_path
|
|
tests.addTests(doctest.DocTestSuite(terrasync.virtual_path))
|
|
return tests
|
|
|
|
|
|
class VirtualPathCommonTests:
|
|
"""Common tests to run for both VirtualPath and MutableVirtualPath.
|
|
|
|
The tests inside this class must exercice the class (VirtualPath or
|
|
MutableVirtualPath) stored in the 'cls' class attribute. They must
|
|
work for both VirtualPath and MutableVirtualPath, otherwise they
|
|
don't belong here!
|
|
|
|
"""
|
|
|
|
def test_normalizeStringPath(self):
|
|
self.assertEqual(self.cls.normalizeStringPath("/"), "/")
|
|
self.assertEqual(self.cls.normalizeStringPath(""), "/")
|
|
self.assertEqual(
|
|
self.cls.normalizeStringPath("/abc/Def ijk//l Mn///op/q/rst/"),
|
|
"/abc/Def ijk/l Mn/op/q/rst")
|
|
self.assertEqual(self.cls.normalizeStringPath("abc/def"), "/abc/def")
|
|
self.assertEqual(self.cls.normalizeStringPath("/abc/def"), "/abc/def")
|
|
self.assertEqual(self.cls.normalizeStringPath("//abc/def"),
|
|
"/abc/def")
|
|
self.assertEqual(self.cls.normalizeStringPath("///abc/def"),
|
|
"/abc/def")
|
|
self.assertEqual(self.cls.normalizeStringPath("/abc//def"),
|
|
"/abc/def")
|
|
|
|
# Unless the implementation of VirtualPath.__init__() has changed
|
|
# meanwhile, the following function must be essentially the same as
|
|
# test_normalizeStringPath().
|
|
def test_constructor_and_str(self):
|
|
p = self.cls("/")
|
|
self.assertEqual(str(p), "/")
|
|
|
|
p = self.cls("")
|
|
self.assertEqual(str(p), "/")
|
|
|
|
p = self.cls("/abc/Def ijk//l Mn///op/q/rst/")
|
|
self.assertEqual(str(p), "/abc/Def ijk/l Mn/op/q/rst")
|
|
|
|
p = self.cls("abc/def")
|
|
self.assertEqual(str(p), "/abc/def")
|
|
|
|
p = self.cls("/abc/def")
|
|
self.assertEqual(str(p), "/abc/def")
|
|
|
|
p = self.cls("//abc/def")
|
|
self.assertEqual(str(p), "/abc/def")
|
|
|
|
p = self.cls("///abc/def")
|
|
self.assertEqual(str(p), "/abc/def")
|
|
|
|
p = self.cls("/abc//def")
|
|
self.assertEqual(str(p), "/abc/def")
|
|
|
|
def test_asPosix (self):
|
|
self.assertEqual(self.cls("").asPosix(), "/")
|
|
self.assertEqual(self.cls("/").asPosix(), "/")
|
|
self.assertEqual(self.cls("/abc//def").asPosix(), "/abc/def")
|
|
self.assertEqual(self.cls("/abc//def/").asPosix(), "/abc/def")
|
|
self.assertEqual(self.cls("//abc//def//").asPosix(), "/abc/def")
|
|
self.assertEqual(self.cls("////abc//def//").asPosix(), "/abc/def")
|
|
|
|
def test_samePath(self):
|
|
self.assertTrue(self.cls("").samePath(self.cls("")))
|
|
self.assertTrue(self.cls("").samePath(self.cls("/")))
|
|
self.assertTrue(self.cls("/").samePath(self.cls("")))
|
|
self.assertTrue(self.cls("/").samePath(self.cls("/")))
|
|
|
|
self.assertTrue(
|
|
self.cls("/abc/def").samePath(self.cls("/abc/def")))
|
|
self.assertTrue(
|
|
self.cls("/abc//def").samePath(self.cls("/abc/def")))
|
|
self.assertTrue(
|
|
self.cls("/abc/def/").samePath(self.cls("/abc/def")))
|
|
|
|
def test_comparisons(self):
|
|
self.assertEqual(self.cls("/abc/def"), self.cls("/abc/def"))
|
|
self.assertEqual(self.cls("/abc//def"), self.cls("/abc/def"))
|
|
self.assertEqual(self.cls("/abc/def/"), self.cls("/abc/def"))
|
|
|
|
self.assertNotEqual(self.cls("/abc/dEf"), self.cls("/abc/def"))
|
|
self.assertNotEqual(self.cls("/abc/def "), self.cls("/abc/def"))
|
|
|
|
self.assertLessEqual(self.cls("/foo/bar"), self.cls("/foo/bar"))
|
|
self.assertLessEqual(self.cls("/foo/bar"), self.cls("/foo/bbr"))
|
|
self.assertLess(self.cls("/foo/bar"), self.cls("/foo/bbr"))
|
|
|
|
self.assertGreaterEqual(self.cls("/foo/bar"), self.cls("/foo/bar"))
|
|
self.assertGreaterEqual(self.cls("/foo/bbr"), self.cls("/foo/bar"))
|
|
self.assertGreater(self.cls("/foo/bbr"), self.cls("/foo/bar"))
|
|
|
|
def test_truedivOperators(self):
|
|
"""
|
|
Test operators used to add paths components to a VirtualPath instance."""
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
self.assertEqual(p, self.cls("/") / "foo" / "bar" / "baz/quux/zoot")
|
|
self.assertEqual(p, self.cls("/foo") / "bar" / "baz/quux/zoot")
|
|
self.assertEqual(p, self.cls("/foo/bar") / "baz/quux/zoot")
|
|
|
|
def test_joinpath(self):
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
self.assertEqual(
|
|
p,
|
|
self.cls("/foo").joinpath("bar", "baz", "quux/zoot"))
|
|
|
|
def test_nameAttribute(self):
|
|
self.assertEqual(self.cls("/").name, "")
|
|
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
self.assertEqual(p.name, "zoot")
|
|
|
|
def test_partsAttribute(self):
|
|
self.assertEqual(self.cls("/").parts, ("/",))
|
|
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
self.assertEqual(p.parts, ("/", "foo", "bar", "baz", "quux", "zoot"))
|
|
|
|
def test_parentsAttribute(self):
|
|
def pathify(*args):
|
|
return tuple( (self.cls(s) for s in args) )
|
|
|
|
p = self.cls("/")
|
|
self.assertEqual(tuple(p.parents), pathify()) # empty tuple
|
|
|
|
p = self.cls("/foo")
|
|
self.assertEqual(tuple(p.parents), pathify("/"))
|
|
|
|
p = self.cls("/foo/bar")
|
|
self.assertEqual(tuple(p.parents), pathify("/foo", "/"))
|
|
|
|
p = self.cls("/foo/bar/baz")
|
|
self.assertEqual(tuple(p.parents), pathify("/foo/bar", "/foo", "/"))
|
|
|
|
def test_parentAttribute(self):
|
|
def pathify(s):
|
|
return self.cls(s)
|
|
|
|
p = self.cls("/")
|
|
self.assertEqual(p.parent, pathify("/"))
|
|
|
|
p = self.cls("/foo")
|
|
self.assertEqual(p.parent, pathify("/"))
|
|
|
|
p = self.cls("/foo/bar")
|
|
self.assertEqual(p.parent, pathify("/foo"))
|
|
|
|
p = self.cls("/foo/bar/baz")
|
|
self.assertEqual(p.parent, pathify("/foo/bar"))
|
|
|
|
def test_suffixAttribute(self):
|
|
p = self.cls("/")
|
|
self.assertEqual(p.suffix, '')
|
|
|
|
p = self.cls("/foo/bar/baz.py")
|
|
self.assertEqual(p.suffix, '.py')
|
|
|
|
p = self.cls("/foo/bar/baz.py.bla")
|
|
self.assertEqual(p.suffix, '.bla')
|
|
|
|
p = self.cls("/foo/bar/baz")
|
|
self.assertEqual(p.suffix, '')
|
|
|
|
def test_suffixesAttribute(self):
|
|
p = self.cls("/")
|
|
self.assertEqual(p.suffixes, [])
|
|
|
|
p = self.cls("/foo/bar/baz.py")
|
|
self.assertEqual(p.suffixes, ['.py'])
|
|
|
|
p = self.cls("/foo/bar/baz.py.bla")
|
|
self.assertEqual(p.suffixes, ['.py', '.bla'])
|
|
|
|
p = self.cls("/foo/bar/baz")
|
|
self.assertEqual(p.suffixes, [])
|
|
|
|
def test_stemAttribute(self):
|
|
p = self.cls("/")
|
|
self.assertEqual(p.stem, '')
|
|
|
|
p = self.cls("/foo/bar/baz.py")
|
|
self.assertEqual(p.stem, 'baz')
|
|
|
|
p = self.cls("/foo/bar/baz.py.bla")
|
|
self.assertEqual(p.stem, 'baz.py')
|
|
|
|
def test_asRelative(self):
|
|
self.assertEqual(self.cls("/").asRelative(), "")
|
|
self.assertEqual(self.cls("/foo/bar/baz/quux/zoot").asRelative(),
|
|
"foo/bar/baz/quux/zoot")
|
|
|
|
def test_relativeTo(self):
|
|
self.assertEqual(self.cls("").relativeTo(""), "")
|
|
self.assertEqual(self.cls("").relativeTo("/"), "")
|
|
self.assertEqual(self.cls("/").relativeTo("/"), "")
|
|
self.assertEqual(self.cls("/").relativeTo(""), "")
|
|
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
|
|
self.assertEqual(p.relativeTo(""), "foo/bar/baz/quux/zoot")
|
|
self.assertEqual(p.relativeTo("/"), "foo/bar/baz/quux/zoot")
|
|
|
|
self.assertEqual(p.relativeTo("foo"), "bar/baz/quux/zoot")
|
|
self.assertEqual(p.relativeTo("foo/"), "bar/baz/quux/zoot")
|
|
self.assertEqual(p.relativeTo("/foo"), "bar/baz/quux/zoot")
|
|
self.assertEqual(p.relativeTo("/foo/"), "bar/baz/quux/zoot")
|
|
|
|
self.assertEqual(p.relativeTo("foo/bar/baz"), "quux/zoot")
|
|
self.assertEqual(p.relativeTo("foo/bar/baz/"), "quux/zoot")
|
|
self.assertEqual(p.relativeTo("/foo/bar/baz"), "quux/zoot")
|
|
self.assertEqual(p.relativeTo("/foo/bar/baz/"), "quux/zoot")
|
|
|
|
with self.assertRaises(ValueError):
|
|
p.relativeTo("/foo/ba")
|
|
|
|
with self.assertRaises(ValueError):
|
|
p.relativeTo("/foo/balloon")
|
|
|
|
def test_withName(self):
|
|
p = self.cls("/foo/bar/baz/quux/zoot")
|
|
|
|
self.assertEqual(p.withName(""),
|
|
VirtualPath("/foo/bar/baz/quux"))
|
|
self.assertEqual(p.withName("pouet"),
|
|
VirtualPath("/foo/bar/baz/quux/pouet"))
|
|
self.assertEqual(p.withName("pouet/zdong"),
|
|
VirtualPath("/foo/bar/baz/quux/pouet/zdong"))
|
|
|
|
# The self.cls object has no 'name' (referring to the 'name' property)
|
|
with self.assertRaises(ValueError):
|
|
self.cls("").withName("foobar")
|
|
|
|
with self.assertRaises(ValueError):
|
|
self.cls("/").withName("foobar")
|
|
|
|
def test_withSuffix(self):
|
|
p = self.cls("/foo/bar/baz.tar.gz")
|
|
self.assertEqual(p.withSuffix(".bz2"),
|
|
VirtualPath("/foo/bar/baz.tar.bz2"))
|
|
p = self.cls("/foo/bar/baz")
|
|
self.assertEqual(p.withSuffix(".tar.xz"),
|
|
VirtualPath("/foo/bar/baz.tar.xz"))
|
|
|
|
# The self.cls object has no 'name' (referring to the 'name' property)
|
|
with self.assertRaises(ValueError):
|
|
self.cls("/foo/bar/baz.tar.gz").withSuffix("no-leading-dot")
|
|
|
|
with self.assertRaises(ValueError):
|
|
# The root virtual path ('/') can't be used for this
|
|
self.cls("/").withSuffix(".foobar")
|
|
|
|
|
|
class TestVirtualPath(unittest.TestCase, VirtualPathCommonTests):
|
|
"""Tests for the VirtualPath class.
|
|
|
|
These are the tests using the common infrastructure from
|
|
VirtualPathCommonTests.
|
|
|
|
"""
|
|
|
|
cls = VirtualPath
|
|
|
|
class TestVirtualPathSpecific(unittest.TestCase):
|
|
"""Tests specific to the VirtualPath class."""
|
|
|
|
def test_isHashableType(self):
|
|
p = VirtualPath("/foo")
|
|
self.assertTrue(isinstance(p, collections.Hashable))
|
|
|
|
def test_insideSet(self):
|
|
l1 = [ VirtualPath("/foo/bar"),
|
|
VirtualPath("/foo/baz") ]
|
|
l2 = l1 + [ VirtualPath("/foo/bar") ] # l2 has a duplicate element
|
|
|
|
# Sets allow one to ignore duplicate elements when comparing
|
|
self.assertEqual(set(l1), set(l2))
|
|
self.assertEqual(frozenset(l1), frozenset(l2))
|
|
|
|
|
|
class TestMutableVirtualPath(unittest.TestCase, VirtualPathCommonTests):
|
|
"""Tests for the MutableVirtualPath class.
|
|
|
|
These are the tests using the common infrastructure from
|
|
VirtualPathCommonTests.
|
|
|
|
"""
|
|
|
|
cls = MutableVirtualPath
|
|
|
|
class TestMutableVirtualPathSpecific(unittest.TestCase):
|
|
"""Tests specific to the MutableVirtualPath class."""
|
|
|
|
def test_mixedComparisons(self):
|
|
self.assertTrue(
|
|
VirtualPath("/abc/def").samePath(MutableVirtualPath("/abc/def")))
|
|
self.assertTrue(
|
|
VirtualPath("/abc//def").samePath(MutableVirtualPath("/abc/def")))
|
|
self.assertTrue(
|
|
VirtualPath("/abc/def/").samePath(MutableVirtualPath("/abc/def")))
|
|
|
|
self.assertTrue(
|
|
MutableVirtualPath("/abc/def").samePath(VirtualPath("/abc/def")))
|
|
self.assertTrue(
|
|
MutableVirtualPath("/abc//def").samePath(VirtualPath("/abc/def")))
|
|
self.assertTrue(
|
|
MutableVirtualPath("/abc/def/").samePath(VirtualPath("/abc/def")))
|
|
|
|
def test_inPlacePathConcatenation(self):
|
|
p = VirtualPath("/foo/bar/baz/quux/zoot")
|
|
|
|
q = MutableVirtualPath("/foo")
|
|
q /= "bar"
|
|
q /= "baz/quux/zoot"
|
|
|
|
self.assertTrue(p.samePath(q))
|
|
|
|
def test_isNotHashableType(self):
|
|
p = MutableVirtualPath("/foo")
|
|
self.assertFalse(isinstance(p, collections.Hashable))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|