Disabled coverage for hard-to-test elements, and added new tests

Author: domdfcoding

domdf_python_tools/bases.py

@@ -63,7 +63,7 @@ def __deepcopy__(self, memodict={}):
 	@property
 	@abstractmethod
 	def __dict__(self):
-		return dict()
+		return dict()  # pragma: no cover (abc)
 
 	def __eq__(self, other) -> bool:
 		if isinstance(other, self.__class__):

domdf_python_tools/dates.py

@@ -63,7 +63,7 @@ def get_utc_offset(
 		if isinstance(tz, str):
 			timezone = get_timezone(tz, date)
 		else:
-			timezone = tz
+			timezone = tz  # pragma: no cover (hard to test)
 
 		return date.replace(tzinfo=pytz.utc).astimezone(timezone).utcoffset()
 
@@ -81,7 +81,7 @@ def get_timezone(tz: str, date: Optional[datetime.datetime] = None) -> Optional[
 		"""
 
 		if date is None:
-			date = datetime.datetime.utcnow()
+			date = datetime.datetime.utcnow()  # pragma: no cover (hard to test)
 
 		d = date.replace(tzinfo=None)
 
@@ -94,7 +94,7 @@ def current_tzinfo() -> Optional[datetime.tzinfo]:
 		:rtype: :class:`python:datetime.tzinfo`
 		"""
 
-		return datetime.datetime.now().astimezone().tzinfo
+		return datetime.datetime.now().astimezone().tzinfo  # pragma: no cover (hard to test)
 
 	#
 	# def datetime_to_utc_timestamp(datetime, current_tzinfo=None):

tests/test_typing.py

@@ -0,0 +1,114 @@
+"""
+test_typing
+~~~~~~~~~~~~~~~
+
+Test functions in typing.py
+
+"""
+
+# stdlib
+import os
+import pathlib
+
+# 3rd party
+from typing import Dict, List, Sequence, Set, Tuple, Union
+
+import pytest
+
+# this package
+from domdf_python_tools.typing import check_membership, PathLike
+
+
+@pytest.mark.parametrize(
+		"obj, type_",
+		[
+				("abc", Union[str, int, float, bytes]),
+				(1234, Union[str, int, float, bytes]),
+				(12.34, Union[str, int, float, bytes]),
+				(b"\x0F", Union[str, int, float, bytes]),
+				("abc", List[str]),
+				(1234, Sequence[int]),
+				(12.34, Set[float]),
+				(1234, Tuple[int, float, str]),  # todo: Position
+				(12.34, Tuple[int, float, str]),  # todo: Position
+				("abc", Tuple[int, float, str]),  # todo: Position
+				(1234, Dict[int, float]),  # todo: Position
+				(12.34, Dict[int, float]),  # todo: Position
+				]
+		)
+def test_check_membership_true(obj, type_):
+	assert check_membership(obj, type_)
+
+
+@pytest.mark.parametrize(
+		"obj, type_",
+		[
+				("abc", Union[float, bytes]),
+				(1234, Union[str, float, bytes]),
+				(12.34, Union[str, int]),
+				(b"\x0F", Union[str, int, float]),
+				("abc", List[int]),
+				(1234, Sequence[bytes]),
+				(12.34, Set[str]),
+				(1234, Tuple[str, float, bytes]),  # todo: Position
+				(12.34, Tuple[int, bytes, str]),  # todo: Position
+				("abc", Tuple[int, float, bytes]),  # todo: Position
+				(1234, Dict[bytes, float]),  # todo: Position
+				(12.34, Dict[int, str]),  # todo: Position
+				]
+		)
+def test_check_membership_false(obj, type_):
+	assert not check_membership(obj, type_)
+
+
+class MyPathLike(os.PathLike):
+	def __init__(self, directory, filename):
+		self.directory = str(directory)
+		self.filename = str(filename)
+
+	def __fspath__(self):
+		os.path.join(self.directory, self.filename)
+
+
+class MyStr(str):
+	pass
+
+
+class MyPath(type(pathlib.Path())):  # type: ignore
+	pass
+
+
+@pytest.mark.parametrize(
+		"obj",
+		[
+				"/home/domdf/Python",
+				"test_typing.py",
+				pathlib.Path("/home/domdf/Python"),
+				pathlib.Path("test_typing.py"),
+				pathlib.PurePosixPath("test_typing.py"),
+				pathlib.PureWindowsPath("test_typing.py"),
+				MyPath("/home/domdf/Python"),
+				MyPath("test_typing.py"),
+				MyStr("/home/domdf/Python"),
+				MyStr("test_typing.py"),
+				MyPathLike("/home/domdf", "Python"),
+				MyPathLike(".", "test_typing.py"),
+				]
+		)
+def test_pathlike_true(obj):
+	assert check_membership(obj, PathLike)
+
+
+@pytest.mark.parametrize(
+		"obj",
+		[
+				1234,
+				12.34,
+				[1, 2, 3, 4, 5],
+				{1, 2, 3, 4, 5},
+				(1, 2, 3, 4, 5),
+				{"a": 1, "b": 2},
+				]
+		)
+def test_pathlike_false(obj):
+	assert not check_membership(obj, PathLike)

tests/test_utils.py

@@ -376,3 +376,15 @@ def test_enquote_value(obj, expects):
 # def test_enquote_value_errors(obj, expects):
 # 	with pytest.raises(expects):
 # 		utils.enquote_value(obj)
+
+def test_cmp():
+	assert isinstance(utils.cmp(5, 20), int)
+	assert utils.cmp(5, 20) < 0
+	assert utils.cmp(5, 20) == -1
+
+	assert isinstance(utils.cmp(20, 5), int)
+	assert utils.cmp(20, 5) > 0
+	assert utils.cmp(20, 5) == 1
+
+	assert isinstance(utils.cmp(20, 20), int)
+	assert utils.cmp(20, 20) == 0