Rearranged tests and added some new ones.

Author: domdfcoding

domdf_python_tools/utils.py

@@ -35,7 +35,7 @@
 
 def as_text(value: Any) -> str:
 	"""
-	Convert the given value to a string.
+	Convert the given value to a string. ``None`` is converted to ``''``.
 
 	:param value: Value to convert to a string
 
@@ -126,7 +126,7 @@ def list2str(the_list: Iterable, sep: str = ",") -> str:
 	return sep.join([str(x) for x in the_list])
 
 
-list2string = list2str
+tuple2str = list2string = list2str
 
 
 def permutations(data: Iterable[Any], n: int = 2) -> List[Tuple[Any]]:
@@ -206,16 +206,3 @@ def str2tuple(input_string: str, sep: str = ",") -> Tuple[int]:
 
 	return tuple(int(x) for x in input_string.split(sep))
 
-
-def tuple2str(input_tuple: Iterable[Any], sep: str = ",") -> str:
-	"""
-	Convert an iterable, such as a tuple into a comma-separated string.
-
-	:param input_tuple: The iterable to be joined into a string
-	:param sep: The separator in the string. Default `,`
-	:type sep: str
-
-	:rtype: str
-	"""
-
-	return sep.join([str(x) for x in input_tuple])

tests/test_bases.py

@@ -7,12 +7,17 @@
 
 """
 
+# stdlib
 import copy
 import pickle
+from collections import UserList
 
+# 3rd party
 import pytest
 
-from domdf_python_tools.bases import Dictable
+# this package
+from domdf_python_tools.bases import Dictable, namedlist
+from domdf_python_tools.utils import printr, printt
 
 
 class Person(Dictable):
@@ -90,3 +95,23 @@ def test_subclass(self):
 		child = Child("Bob", 12, "Big School")
 		assert person == child
 		assert "School" not in person.__dict__
+
+
+def test_namedlist(capsys):
+	mylist = namedlist()
+	assert isinstance(mylist(), UserList)
+
+	ShoppingList = namedlist("ShoppingList")
+	shopping_list = ShoppingList(["egg and bacon", "egg sausage and bacon", "egg and spam", "egg bacon and spam"])
+	assert isinstance(shopping_list, UserList)
+	assert shopping_list[0] == "egg and bacon"
+
+	printt(shopping_list)
+	printr(shopping_list)
+	print(shopping_list)
+
+	captured = capsys.readouterr()
+	stdout = captured.out.split("\n")
+	assert stdout[0] == "<class 'domdf_python_tools.bases.namedlist.<locals>.NamedList'>"
+	assert stdout[1] == "['egg and bacon', 'egg sausage and bacon', 'egg and spam', 'egg bacon and spam']"
+	assert stdout[2] == "ShoppingList['egg and bacon', 'egg sausage and bacon', 'egg and spam', 'egg bacon and spam']"

tests/test_paths.py

@@ -8,12 +8,17 @@
 """
 
 # stdlib
+import contextlib
 import pathlib
 from tempfile import TemporaryDirectory
 
+# 3rd party
+import pytest
+
 # this package
 from domdf_python_tools import paths
 
+
 # TODO: Still need tests for copytree, relpath, relpath2, delete, write,
 #  read and append.
 #  Some of those might want deprecating in favour of pathlib
@@ -62,3 +67,51 @@ def test_parent_path():
 		assert paths.parent_path(dir2) == dir1
 		assert paths.parent_path(dir3) == dir2
 		assert str(paths.parent_path("spam/spam/spam")) == "spam/spam"
+
+
+@pytest.mark.parametrize("relto, relpath", [
+		("/home/username/Documents/games/chess.py", "/home/username/Documents/letter.doc"),
+		("/home/username/Documents", "letter.doc"),
+		(pathlib.Path("/home/username/Documents/games/chess.py"), "/home/username/Documents/letter.doc"),
+		(pathlib.Path("/home/username/Documents"), "letter.doc"),
+		])
+def test_relpath(relto, relpath):
+	path = "/home/username/Documents/letter.doc"
+	assert paths.relpath(path, relative_to=relto) == pathlib.Path(relpath)
+	assert isinstance(paths.relpath(path, relative_to=relto), pathlib.Path)
+
+
+class TestCurrentDirOperations:
+	def test_append(self):
+		file = pathlib.Path("paths_append_test_file.txt")
+		file.write_text("initial content\n")
+		paths.append("appended content", str(file))
+		assert file.read_text() == "initial content\nappended content"
+		file.unlink()
+
+	def test_delete(self):
+		file = pathlib.Path("paths_delete_test_file.txt")
+		file.write_text("initial content\n")
+		paths.delete(str(file))
+		assert not file.exists()
+
+	def test_read(self):
+		file = pathlib.Path("paths_read_test_file.txt")
+		file.write_text("initial content\n")
+		assert paths.read(str(file)) == "initial content\n"
+		file.unlink()
+
+	def test_write(self):
+		file = pathlib.Path("paths_write_test_file.txt")
+		file.write_text("initial content\n")
+		paths.write("overwritten content", str(file))
+		assert paths.read(str(file)) == "overwritten content"
+		file.unlink()
+
+	@classmethod
+	def teardown_class(cls):
+		with contextlib.suppress(FileNotFoundError):
+			pathlib.Path("paths_append_test_file.txt").unlink()
+			pathlib.Path("paths_delete_test_file.txt").unlink()
+			pathlib.Path("paths_read_test_file.txt").unlink()
+			pathlib.Path("paths_write_test_file.txt").unlink()

tests/test_utils.py

@@ -21,68 +21,87 @@ def test_pyversion():
 	assert isinstance(pyversion, int)
 
 
-def test_str2tuple():
-	assert isinstance(str2tuple("1,2,3"), tuple)  # tests without spaces
-	assert isinstance(str2tuple("1, 2, 3"), tuple)  # tests with spaces
-	assert isinstance(str2tuple("1; 2; 3", sep=";"), tuple)  # tests with semicolon
-	assert str2tuple("1,2,3") == (1, 2, 3)
-
-
-def test_tuple2str():
-	assert isinstance(tuple2str(("1", "2", "3")), str)
-	assert tuple2str((1, 2, 3)) == "1,2,3"
-
-	assert isinstance(tuple2str((1, 2, 3), sep=";"), str)  # tests with semicolon
-	assert tuple2str((1, 2, 3), sep=";") == "1;2;3"
+@pytest.mark.parametrize("value, expects", [
+		(12345, "12345"),
+		(123.45, "123.45"),
+		([123.45], "[123.45]"),
+		({123.45}, "{123.45}"),
+		((123.45, ), "(123.45,)"),
+		(None, ""),
+		(pathlib.Path("."), "."),
+		(decimal.Decimal("1234"), "1234"),
+		])
+def test_as_text(value, expects):
+	assert utils.as_text(value) == expects
+
+
+def test_check_dependencies(capsys):
+	deps = ["pytest", "domdf_python_tools", "madeup_module"]
+
+	missing_deps = utils.check_dependencies(deps, False)
+	assert isinstance(missing_deps, list)
+	assert len(missing_deps) == 1
+	assert missing_deps == ["madeup_module"]
+
+	missing_deps = utils.check_dependencies(deps)
+	captured = capsys.readouterr()
+	stdout = captured.out.split("\n")
+	assert stdout[0] == "The following modules are missing."
+	assert stdout[1] == "['madeup_module']"
+	assert stdout[2] == "Please check the documentation."
+	assert stdout[3] == ""
+	assert isinstance(missing_deps, list)
+	assert len(missing_deps) == 1
+	assert missing_deps == ["madeup_module"]
+
+	missing_deps = utils.check_dependencies(["pytest"])
+	captured = capsys.readouterr()
+	stdout = captured.out.split("\n")
+	assert stdout[0] == "All modules installed"
+	assert stdout[1] == ""
+	assert isinstance(missing_deps, list)
+	assert len(missing_deps) == 0
+	assert missing_deps == []
 
 
 def test_chunks():
 	assert isinstance(chunks(list(range(100)), 5), types.GeneratorType)
 	assert list(chunks(list(range(100)), 5))[0] == [0, 1, 2, 3, 4]
+	assert list(chunks(["a", "b", "c"], 1)) == [["a"], ["b"], ["c"]]
 
-
-def test_list2str():
-	assert isinstance(list2str([1, 2, 3]), str)
-	assert list2str([1, 2, 3]) == "1,2,3"
-
-	assert isinstance(list2str([1, 2, 3], sep=";"), str)  # tests with semicolon
-	assert list2str((1, 2, 3), sep=";") == "1;2;3"
-
-	assert isinstance(list2string([1, 2, 3]), str)
-	assert list2string([1, 2, 3]) == "1,2,3"
-
-	assert isinstance(list2string([1, 2, 3], sep=";"), str)  # tests with semicolon
-	assert list2string((1, 2, 3), sep=";") == "1;2;3"
+# TODO: cmp
 
 
-#
-#
-# def test_bdict_errors():
-# 	new_dict = bdict([("Key1", "Value1"), ("Key2", "Value2"), ("Key3", "Value3")])
-#
-# 	with pytest.raises(ValueError):
-# 		new_dict["Key1"] = 1234
-# 	with pytest.raises(ValueError):
-# 		new_dict["Value1"] = 1234
-# 	new_dict["Key1"] = "Value1"
-# 	new_dict["Value1"] = "Key1"
-#
-#
+@pytest.mark.parametrize("value, expects", [
+		([1, 2, 3], "1,2,3"),
+		(["a", "b", "c"], "a,b,c"),
+		(["a", "b", 1, 2], "a,b,1,2"),
+		(["a", 2, pathlib.Path("foo.txt")], "a,2,foo.txt"),
+		])
+def test_list2str(value, expects):
+	str_representation = list2str(value)
+	assert isinstance(str_representation, str)
+	assert str_representation == expects
 
+	str_representation = list2string(value)
+	assert isinstance(str_representation, str)
+	assert str_representation == expects
 
-def test_as_text():
-	assert utils.as_text(12345) == "12345"
-	assert utils.as_text(123.45) == "123.45"
-	assert utils.as_text([123.45]) == "[123.45]"
-	assert utils.as_text({123.45}) == "{123.45}"
-	assert utils.as_text((123.45, )) == "(123.45,)"
-	assert utils.as_text(None) == ""
-	assert utils.as_text(pathlib.Path(".")) == "."
-	assert utils.as_text(decimal.Decimal("1234")) == "1234"
 
+@pytest.mark.parametrize("value, expects", [
+		([1, 2, 3], "1;2;3"),
+		(["a", "b", "c"], "a;b;c"),
+		(["a", "b", 1, 2], "a;b;1;2"),
+		(["a", 2, pathlib.Path("foo.txt")], "a;2;foo.txt"),
+		])
+def test_list2str_semicolon(value, expects):
+	str_representation = list2str(value, sep=";")
+	assert isinstance(str_representation, str)
+	assert str_representation == expects
 
-def test_split_len():
-	assert utils.split_len("Spam Spam Spam Spam Spam Spam Spam Spam ", 5) == ["Spam "] * 8
+	str_representation = list2string(value, sep=";")
+	assert isinstance(str_representation, str)
+	assert str_representation == expects
 
 
 def test_permutations():
@@ -137,3 +156,74 @@ def test_permutations():
 
 	with pytest.raises(ValueError):
 		utils.permutations(data, 0)
+
+
+class CustomRepr:
+	def __init__(self):
+		pass
+
+	def __repr__(self):
+		return "This is my custom __repr__!"
+
+
+class NoRepr:
+	def __init__(self):
+		pass
+
+
+def test_printr(capsys):
+	utils.printr("This is a test")
+	utils.printr(pathlib.PurePosixPath("foo.txt"))
+	utils.printr(1234)
+	utils.printr(12.34)
+	utils.printr(CustomRepr())
+	utils.printr(NoRepr())
+
+	captured = capsys.readouterr()
+	stdout = captured.out.split("\n")
+	assert stdout[0] == "'This is a test'"
+	assert stdout[1] == "PurePosixPath('foo.txt')"
+	assert stdout[2] == "1234"
+	assert stdout[3] == "12.34"
+	assert stdout[4] == "This is my custom __repr__!"
+	assert stdout[5].startswith('')
+
+
+def test_printt(capsys):
+	utils.printt("This is a test")
+	utils.printt(pathlib.PurePosixPath("foo.txt"))
+	utils.printt(1234)
+	utils.printt(12.34)
+	utils.printt(CustomRepr())
+	utils.printt(NoRepr())
+
+	captured = capsys.readouterr()
+	stdout = captured.out.split("\n")
+	assert stdout[0] == "<class 'str'>"
+	assert stdout[1] == "<class 'pathlib.PurePosixPath'>"
+	assert stdout[2] == "<class 'int'>"
+	assert stdout[3] == "<class 'float'>"
+	assert stdout[4] == "<class 'tests.test_utils.CustomRepr'>"
+	assert stdout[5] == "<class 'tests.test_utils.NoRepr'>"
+
+
+def test_split_len():
+	assert utils.split_len("Spam Spam Spam Spam Spam Spam Spam Spam ", 5) == ["Spam "] * 8
+
+
+@pytest.mark.parametrize("value, expects", [
+		("1,2,3", (1, 2, 3)),  # tests without spaces
+		("1, 2, 3", (1, 2, 3)),  # tests with spaces
+		])
+def test_str2tuple(value, expects):
+	assert isinstance(str2tuple(value), tuple)
+	assert str2tuple(value) == expects
+
+
+@pytest.mark.parametrize("value, expects", [
+		("1;2;3", (1, 2, 3)),  # tests without semicolon
+		("1; 2; 3", (1, 2, 3)),  # tests with semicolon
+		])
+def test_str2tuple_semicolon(value, expects):
+	assert isinstance(str2tuple(value, sep=";"), tuple)
+	assert str2tuple(value, sep=";") == expects