Added new "testing" module.

Author: domdfcoding

domdf_python_tools/testing.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+#
+#  testing.py
+"""
+Handy functions for testing code.
+
+Requires `pytest <https://docs.pytest.org/en/stable/>`_ to be installed.
+"""
+#
+#  Copyright © 2020 Dominic Davis-Foster <[email protected]>
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation; either version 3 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 Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser 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.
+#
+
+# stdlib
+import itertools
+import random
+from functools import lru_cache
+from typing import List, Sequence
+
+# 3rd party
+import pytest
+from _pytest.mark import MarkDecorator
+
+# this package
+from domdf_python_tools.utils import Len
+
+
+def testing_boolean_values(
+		extra_truthy: Sequence = (),
+		extra_falsy: Sequence = (),
+		) -> MarkDecorator:
+	"""
+	Returns a `pytest.mark.parametrize <https://docs.pytest.org/en/stable/parametrize.html>`_
+	decorator that provides a list of strings, integers and booleans, and the boolean representations of them.
+
+	The parametrized arguments are ``boolean_string`` for the input value,
+	and ``expected_boolean`` for the expected output.
+
+	:param extra_truthy: Additional values that should be considered :py:obj:`True`.
+	:param extra_falsy: Additional values that should be considered :py:obj:`False`.
+	"""
+
+	truthy = [
+			True,
+			"True",
+			"true",
+			"tRUe",
+			'y',
+			'Y',
+			"YES",
+			"yes",
+			"Yes",
+			"yEs",
+			"ON",
+			"on",
+			'1',
+			1,
+			*extra_truthy,
+			]
+
+	falsy = [
+			False,
+			"False",
+			"false",
+			"falSE",
+			'n',
+			'N',
+			"NO",
+			"no",
+			"nO",
+			"OFF",
+			"off",
+			"oFF",
+			'0',
+			0,
+			*extra_falsy,
+			]
+
+	boolean_strings = [
+			*itertools.zip_longest(truthy, [], fillvalue=True),
+			*itertools.zip_longest(falsy, [], fillvalue=False),
+			]
+
+	return pytest.mark.parametrize("boolean_string, expected_boolean", boolean_strings)
+
+
+whitespace = " \t\n\r"
+
+
+@lru_cache(1)
+def whitespace_perms_list() -> List[str]:
+	chain = itertools.chain.from_iterable(itertools.permutations(whitespace, n) for n in Len(whitespace))
+	return list("".join(x) for x in chain)
+
+
+def whitespace_perms(ratio: float = 0.5) -> MarkDecorator:
+	r"""
+	Returns a `pytest.mark.parametrize <https://docs.pytest.org/en/stable/parametrize.html>`_
+	decorator that provides permutations of whitespace (strictly only ``␣\n\t\r``).
+	Not all permutations are returned, as there are a lot of them;
+	instead a random selection of the permutations is returned.
+	By default ½ of the permutations are returned, but this can be configured using the ``ratio`` argument.
+
+	The single parametrized argument is ``char``.
+
+	:param ratio: The ratio of the number of permutations to select to the total number of permutations.
+	"""
+
+	perms = whitespace_perms_list()
+	return pytest.mark.parametrize("char", random.sample(perms, int(len(perms) * ratio)))
+
+
+def count(stop: int, start: int = 0, step: int = 1) -> MarkDecorator:
+	"""
+	Returns a `pytest.mark.parametrize <https://docs.pytest.org/en/stable/parametrize.html>`_
+	decorator that provides a list of numbers between ``start`` and ``stop`` with an interval of ``step``.
+
+	The single parametrized argument is ``count``.
+
+	:param stop: The stop value passed to :class:`range`.
+	:param start: The start value passed to :class:`range`.
+	:param step: The step passed to :class:`range`.
+	"""
+
+	return pytest.mark.parametrize("count", range(start, stop, step))

domdf_python_tools/utils.py

@@ -8,18 +8,6 @@
 #
 #  Copyright © 2018-2020 Dominic Davis-Foster <[email protected]>
 #
-#  check_dependencies based on https://stackoverflow.com/a/29044693/3092681
-#  		Copyright © 2015 TehTechGuy
-# 		Licensed under CC-BY-SA
-#
-#  as_text from https://stackoverflow.com/a/40935194
-# 		Copyright © 2016 User3759685
-# 		Available under the MIT License
-#
-#  chunks from https://stackoverflow.com/a/312464/3092681
-# 		Copytight © 2008 Ned Batchelder
-# 		Licensed under CC-BY-SA
-#
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU Lesser General Public License as published by
 #  the Free Software Foundation; either version 3 of the License, or
@@ -35,6 +23,25 @@
 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 #  MA 02110-1301, USA.
 #
+#  check_dependencies based on https://stackoverflow.com/a/29044693/3092681
+#  		Copyright © 2015 TehTechGuy
+# 		Licensed under CC-BY-SA
+#
+#  as_text from https://stackoverflow.com/a/40935194
+# 		Copyright © 2016 User3759685
+# 		Available under the MIT License
+#
+#  chunks from https://stackoverflow.com/a/312464/3092681
+# 		Copytight © 2008 Ned Batchelder
+# 		Licensed under CC-BY-SA
+#
+#  strtobool based on the "distutils" module from CPython
+#  Licensed under the Python Software Foundation License Version 2.
+#  Copyright © 2001-2020 Python Software Foundation. All rights reserved.
+#  Copyright © 2000 BeOpen.com. All rights reserved.
+#  Copyright © 1995-2000 Corporation for National Research Initiatives. All rights reserved.
+#  Copyright © 1991-1995 Stichting Mathematisch Centrum. All rights reserved.
+#
 
 # stdlib
 import itertools
@@ -250,8 +257,6 @@ def strtobool(val: Union[str, bool]) -> bool:
 	:py:obj:`False` values are ``'n'``, ``'no'``, ``'f'``, ``'false'``, ``'off'``, ``'0'``, and ``0``.
 
 	:raises: :py:exc:`ValueError` if 'val' is anything else.
-
-	Based on distutils
 	"""
 
 	if isinstance(val, int):

tests/test_testing.py

@@ -0,0 +1,55 @@
+# stdlib
+import random
+
+# 3rd party
+from _pytest.mark import Mark, MarkDecorator
+
+# this package
+from domdf_python_tools.testing import count, testing_boolean_values, whitespace_perms
+from domdf_python_tools.utils import strtobool
+
+
+def test_count():
+	assert isinstance(count(100), MarkDecorator)
+	assert isinstance(count(100).mark, Mark)
+	assert "count" in count(100).mark.args
+	assert count(100).mark.args[0] == "count"
+	assert count(100).mark.args[1] == range(0, 100)
+
+	assert count(10).mark.args[1] == range(0, 10)
+	assert count(10, 5).mark.args[1] == range(5, 10)  # order of count is "stop, start, step"
+	assert count(10, 5, 2).mark.args[1] == range(5, 10, 2)  # order of count is "stop, start, step"
+
+
+def test_whitespace_perms():
+	random.seed(1234)
+
+	assert isinstance(whitespace_perms(), MarkDecorator)
+	assert isinstance(whitespace_perms().mark, Mark)
+	assert "char" in whitespace_perms().mark.args
+	assert whitespace_perms().mark.args[0] == "char"
+	assert len(whitespace_perms().mark.args[1]) == 20
+	assert len(whitespace_perms(1).mark.args[1]) == 41
+	assert len(whitespace_perms(.1).mark.args[1]) == 4
+
+	assert isinstance(whitespace_perms(.1).mark.args[1], list)
+	assert isinstance(whitespace_perms(.1).mark.args[1][0], str)
+
+	assert whitespace_perms(.1).mark.args[1] == ['\n\t\r', '\r\t', '\t \n', '\n\r']
+	# TODO: some test that they're all whitespace
+
+
+def test_testing_boolean_strings():
+	assert isinstance(testing_boolean_values(), MarkDecorator)
+	assert isinstance(testing_boolean_values().mark, Mark)
+	assert "boolean_string, expected_boolean" in testing_boolean_values().mark.args
+	assert testing_boolean_values().mark.args[0] == "boolean_string, expected_boolean"
+	assert len(testing_boolean_values().mark.args[1]) == 28
+	assert isinstance(testing_boolean_values().mark.args[1], list)
+	assert isinstance(testing_boolean_values().mark.args[1][0], tuple)
+	assert len(testing_boolean_values().mark.args[1][0]) == 2
+	assert isinstance(testing_boolean_values().mark.args[1][0][0], bool)
+	assert isinstance(testing_boolean_values().mark.args[1][0][1], bool)
+
+	for value, expects in testing_boolean_values().mark.args[1]:
+		assert strtobool(value) is expects

tests/test_utils.py

@@ -19,6 +19,7 @@
 
 # this package
 from domdf_python_tools import utils
+from domdf_python_tools.testing import testing_boolean_values
 from domdf_python_tools.utils import Len, chunks, double_chain, list2str, list2string, pyversion, str2tuple
 
 
@@ -283,43 +284,9 @@ def test_str2tuple_semicolon(value, expects):
 	assert str2tuple(value, sep=';') == expects
 
 
-@pytest.mark.parametrize(
-		"obj, expects",
-		[
-				(True, True),
-				("True", True),
-				("true", True),
-				("tRUe", True),
-				('y', True),
-				('Y', True),
-				("YES", True),
-				("yes", True),
-				("Yes", True),
-				("yEs", True),
-				("ON", True),
-				("on", True),
-				('1', True),
-				(1, True),
-				(50, True),
-				(-1, True),
-				(False, False),
-				("False", False),
-				("false", False),
-				("falSE", False),
-				('n', False),
-				('N', False),
-				("NO", False),
-				("no", False),
-				("nO", False),
-				("OFF", False),
-				("off", False),
-				("oFF", False),
-				('0', False),
-				(0, False),
-				],
-		)
-def test_strtobool(obj, expects):
-	assert utils.strtobool(obj) == expects
+@testing_boolean_values(extra_truthy=[50, -1])
+def test_strtobool(boolean_string, expected_boolean):
+	assert utils.strtobool(boolean_string) == expected_boolean
 
 
 @pytest.mark.parametrize(