hunterMakesPy 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

hunterMakesPy/pytestForYourUse.py

@@ -1,327 +1,10 @@
 """Pytest tests you can use in your package to test some hunterMakesPy functions.
 
 Each function in this module returns a list of test functions that can be used with `pytest.parametrize`.
-"""
-from collections.abc import Callable, Iterable, Iterator
-from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from typing import Any, NoReturn
-from unittest.mock import Mock, patch
-import pytest
-
-def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = defineConcurrencyLimit, cpuCount: int = 8) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate concurrency limit behavior.
-
-	This function provides a comprehensive test suite for validating concurrency limit parsing
-	and computation, checking both valid and invalid input scenarios.
-
-	Parameters
-	----------
-	callableToTest : Callable[[bool | float | int | None, int], int] = defineConcurrencyLimit
-		The function to test, which should accept various input types and return an integer
-		representing the concurrency limit.
-	cpuCount : int = 8
-		The number of CPUs to simulate in the test environment.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples, each containing a string describing the test case and a callable
-		test function that implements the test case.
-
-	Examples
-	--------
-	Run each test on `hunterMakesPy.defineConcurrencyLimit`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
-
-	listOfTests = PytestFor_defineConcurrencyLimit()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Or, run each test on your function that has a compatible signature:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testDefaults(_mockCpu: Mock) -> None:
-		listOfParameters: list[bool | int | None] = [None, False, 0]
-		for limitParameter in listOfParameters:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == cpuCount
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testDirectIntegers(_mockCpu: Mock) -> None:
-		for limitParameter in [1, 4, 16]:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == limitParameter
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testFractionalFloats(_mockCpu: Mock) -> None:
-		testCases: dict[float, int] = {
-			0.5: cpuCount // 2,
-			0.25: cpuCount // 4,
-			0.75: int(cpuCount * 0.75)
-		}
-		for limit, expected in testCases.items():
-			assert callableToTest(limit=limit, cpuTotal=cpuCount) == expected
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testMinimumOne(_mockCpu: Mock) -> None:
-		listOfParameters: list[float | int] = [-10, -0.99, 0.1]
-		for limitParameter in listOfParameters:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) >= 1
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testBooleanTrue(_mockCpu: Mock) -> None:
-		assert callableToTest(limit=True, cpuTotal=cpuCount) == 1
-		assert callableToTest(limit='True', cpuTotal=cpuCount) == 1  # pyright: ignore[reportArgumentType]
-		assert callableToTest(limit='TRUE', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
-		assert callableToTest(limit=' true ', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testInvalidStrings(_mockCpu: Mock) -> None:
-		for stringInput in ["invalid", "True but not quite", "None of the above"]:
-			with pytest.raises(ValueError, match="must be a number, `True`, `False`, or `None`"):
-				callableToTest(limit=stringInput, cpuTotal=cpuCount) # pyright: ignore[reportArgumentType]
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testStringNumbers(_mockCpu: Mock) -> None:
-		testCases: list[tuple[str, int]] = [
-			("1.51", 2),
-			("-2.51", 5),
-			("4", 4),
-			("0.5", 4),
-			("-0.25", 6),
-		]
-		for stringNumber, expectedLimit in testCases:
-			assert callableToTest(limit=stringNumber, cpuTotal=cpuCount) == expectedLimit # pyright: ignore[reportArgumentType]
-
-	return [
-		('testDefaults', testDefaults),
-		('testDirectIntegers', testDirectIntegers),
-		('testFractionalFloats', testFractionalFloats),
-		('testMinimumOne', testMinimumOne),
-		('testBooleanTrue', testBooleanTrue),
-		('testInvalidStrings', testInvalidStrings),
-		('testStringNumbers', testStringNumbers)
-	]
-
-def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate integer initialization behavior.
-
-	This function provides a comprehensive test suite for validating integer parsing
-	and initialization, checking both valid and invalid input scenarios.
-
-	Parameters
-	----------
-	callableToTest : Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit
-		The function to test. Should accept a sequence of integer-compatible values,
-		an optional parameter name string, and an optional parameter type.
-		Returns a list of validated integers.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples containing a string describing the test case and a callable
-		test function implementing the test case.
-
-	Examples
-	--------
-	Run tests on `hunterMakesPy.intInnit`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
-
-	listOfTests = PytestFor_intInnit()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Run tests on your compatible function:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest",
-		PytestFor_intInnit(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	def testHandlesValidIntegers() -> None:
-		assert callableToTest([2, 3, 5, 8], 'test', None) == [2, 3, 5, 8]
-		assert callableToTest([13.0, 21.0, 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
-		assert callableToTest(['55', '89', '144'], 'test', None) == [55, 89, 144] # pyright: ignore[reportArgumentType]
-		assert callableToTest([' 233 ', '377', '-610'], 'test', None) == [233, 377, -610] # pyright: ignore[reportArgumentType]
-
-	def testRejectsNonWholeNumbers() -> None:
-		listInvalidNumbers: list[float] = [13.7, 21.5, 34.8, -55.9]
-		for invalidNumber in listInvalidNumbers:
-			with pytest.raises(ValueError):
-				callableToTest([invalidNumber], 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsBooleans() -> None:
-		with pytest.raises(TypeError):
-			callableToTest([True, False], 'test', None)
 
-	def testRejectsInvalidStrings() -> None:
-		for invalidString in ['NW', '', ' ', 'SE.SW']:
-			with pytest.raises(ValueError):
-				callableToTest([invalidString], 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsEmptyList() -> None:
-		with pytest.raises(ValueError):
-			callableToTest([], 'test', None)
-
-	def testHandlesMixedValidTypes() -> None:
-		assert callableToTest([13, '21', 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
-
-	def testHandlesBytes() -> None:
-		validCases: list[tuple[list[bytes], str, list[int]]] = [
-			([b'123'], '123', [123]),
-		]
-		for inputData, testName, expected in validCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		extendedCases: list[tuple[list[bytes], str, list[int]]] = [
-			([b'123456789'], '123456789', [123456789]),
-		]
-		for inputData, testName, expected in extendedCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		invalidCases: list[list[bytes]] = [[b'\x00']]
-		for inputData in invalidCases:
-			with pytest.raises(ValueError):
-				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testHandlesMemoryview() -> None:
-		validCases: list[tuple[list[memoryview], str, list[int]]] = [
-			([memoryview(b'123')], '123', [123]),
-		]
-		for inputData, testName, expected in validCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		largeMemoryviewCase: list[memoryview] = [memoryview(b'9999999999')]
-		assert callableToTest(largeMemoryviewCase, 'test', None) == [9999999999] # pyright: ignore[reportArgumentType]
-
-		invalidMemoryviewCases: list[list[memoryview]] = [[memoryview(b'\x00')]]
-		for inputData in invalidMemoryviewCases:
-			with pytest.raises(ValueError):
-				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsMutableSequence() -> None:
-		class MutableList(list[int]):
-			def __iter__(self) -> Iterator[int]:
-				self.append(89)
-				return super().__iter__()
-		with pytest.raises(RuntimeError, match=".*modified during iteration.*"):
-			callableToTest(MutableList([13, 21, 34]), 'test', None)
-
-	def testHandlesComplexIntegers() -> None:
-		testCases: list[tuple[list[complex], list[int]]] = [
-			([13+0j], [13]),
-			([21+0j, 34+0j], [21, 34])
-		]
-		for inputData, expected in testCases:
-			assert callableToTest(inputData, 'test', None) == expected # pyright: ignore[reportArgumentType]
-
-	def testRejectsInvalidComplex() -> None:
-		for invalidComplex in [13+1j, 21+0.5j, 34.5+0j]:
-			with pytest.raises(ValueError):
-				callableToTest([invalidComplex], 'test', None) # pyright: ignore[reportArgumentType]
-
-	return [
-		('testHandlesValidIntegers', testHandlesValidIntegers),
-		('testRejectsNonWholeNumbers', testRejectsNonWholeNumbers),
-		('testRejectsBooleans', testRejectsBooleans),
-		('testRejectsInvalidStrings', testRejectsInvalidStrings),
-		('testRejectsEmptyList', testRejectsEmptyList),
-		('testHandlesMixedValidTypes', testHandlesMixedValidTypes),
-		('testHandlesBytes', testHandlesBytes),
-		('testHandlesMemoryview', testHandlesMemoryview),
-		('testRejectsMutableSequence', testRejectsMutableSequence),
-		('testHandlesComplexIntegers', testHandlesComplexIntegers),
-		('testRejectsInvalidComplex', testRejectsInvalidComplex)
-	]
-
-def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate string-to-boolean/None conversion behavior.
-
-	This function provides a comprehensive test suite for validating string parsing and conversion
-	to boolean or None values, with fallback to the original string when appropriate.
-
-	Parameters
-	----------
-	callableToTest : Callable[[str], bool | None | str] = oopsieKwargsie
-		The function to test, which should accept a string and return either a boolean, None,
-		or the original input.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples, each containing a string describing the test case and a callable
-		test function that implements the test case.
-
-	Examples
-	--------
-	Run each test on `hunterMakesPy.oopsieKwargsie`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
-
-	listOfTests = PytestFor_oopsieKwargsie()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Or, run each test on your function that has a compatible signature:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	def testHandlesTrueVariants() -> None:
-		for variantTrue in ['True', 'TRUE', ' true ', 'TrUe']:
-			assert callableToTest(variantTrue) is True
-
-	def testHandlesFalseVariants() -> None:
-		for variantFalse in ['False', 'FALSE', ' false ', 'FaLsE']:
-			assert callableToTest(variantFalse) is False
-
-	def testHandlesNoneVariants() -> None:
-		for variantNone in ['None', 'NONE', ' none ', 'NoNe']:
-			assert callableToTest(variantNone) is None
-
-	def testReturnsOriginalString() -> None:
-		for stringInput in ['hello', '123', 'True story', 'False alarm']:
-			assert callableToTest(stringInput) == stringInput
-
-	def testHandlesNonStringObjects() -> None:
-		class NeverGonnaStringIt:
-			def __str__(self) -> NoReturn:
-				message = "Cannot be stringified"
-				raise TypeError(message)
-
-		assert callableToTest(123) == "123" # pyright: ignore[reportArgumentType]
-
-		neverGonnaStringIt = NeverGonnaStringIt()
-		result = callableToTest(neverGonnaStringIt) # pyright: ignore[reportArgumentType]
-		assert result is neverGonnaStringIt
+Note: These test functions are now in `hunterMakesPy.tests` with all other tests.
+"""
 
-	return [
-		('testHandlesTrueVariants', testHandlesTrueVariants),
-		('testHandlesFalseVariants', testHandlesFalseVariants),
-		('testHandlesNoneVariants', testHandlesNoneVariants),
-		('testReturnsOriginalString', testReturnsOriginalString),
-		('testHandlesNonStringObjects', testHandlesNonStringObjects)
-	]
+from hunterMakesPy.tests.test_parseParameters import (
+	PytestFor_defineConcurrencyLimit as PytestFor_defineConcurrencyLimit, PytestFor_intInnit as PytestFor_intInnit,
+	PytestFor_oopsieKwargsie as PytestFor_oopsieKwargsie)

hunterMakesPy/tests/__init__.py

@@ -0,0 +1,5 @@
+"""Test modules for hunterMakesPy package.
+
+This module contains comprehensive test suites for all major functions and features in the hunterMakesPy package. Tests can be run
+independently or imported into your project.
+"""

{tests → hunterMakesPy/tests}/conftest.py

@@ -5,8 +5,7 @@ import pathlib
 import pytest
 
 # SSOT for test data paths and filenames
-# SSOT for test data paths and filenames
-pathDataSamples = pathlib.Path("tests/dataSamples")
+pathDataSamples = pathlib.Path("hunterMakesPy/tests/dataSamples")
 
 # Fixture to provide a temporary directory for filesystem tests
 @pytest.fixture

hunterMakesPy/tests/test_coping.py

@@ -0,0 +1,216 @@
+from hunterMakesPy import PackageSettings, raiseIfNone
+from hunterMakesPy.coping import getIdentifierPackagePACKAGING, getPathPackageINSTALLING
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
+from pathlib import Path
+import pytest
+
+@pytest.mark.parametrize(
+    "returnTarget, expected",
+    [
+        (13, 13),
+        (17, 17),
+        ("fibonacci", "fibonacci"),
+        ("prime", "prime"),
+        ([], []),
+        ({}, {}),
+        (False, False),
+        (0, 0),
+    ]
+)
+def testRaiseIfNoneReturnsNonNoneValues(returnTarget: object, expected: object) -> None:
+    actual = raiseIfNone(returnTarget)
+    assert actual == expected, uniformTestFailureMessage(expected, actual, "testRaiseIfNoneReturnsNonNoneValues", returnTarget)
+    assert actual is returnTarget, uniformTestFailureMessage(returnTarget, actual, "testRaiseIfNoneReturnsNonNoneValues identity check", returnTarget)
+
+
+def testRaiseIfNoneRaisesValueErrorWhenGivenNone() -> None:
+    with pytest.raises(ValueError, match="A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`."):
+        raiseIfNone(None)
+
+
+@pytest.mark.parametrize(
+    "customMessage",
+    [
+        "Configuration must include 'host' setting",
+        "Database connection failed",
+        "User input is required",
+        "Network request returned empty response",
+    ]
+)
+def testRaiseIfNoneRaisesValueErrorWithCustomMessage(customMessage: str) -> None:
+    with pytest.raises(ValueError, match=customMessage):
+        raiseIfNone(None, customMessage)
+
+
+def testRaiseIfNoneWithEmptyStringMessage() -> None:
+    with pytest.raises(ValueError, match="A function unexpectedly returned `None`. Hint: look at the traceback immediately before `raiseIfNone`."):
+        raiseIfNone(None, "")
+
+
+def testRaiseIfNonePreservesTypeAnnotations() -> None:
+    integerValue: int = raiseIfNone(23)
+    assert isinstance(integerValue, int), uniformTestFailureMessage(int, type(integerValue), "testRaiseIfNonePreservesTypeAnnotations", integerValue)
+
+    stringValue: str = raiseIfNone("cardinal")
+    assert isinstance(stringValue, str), uniformTestFailureMessage(str, type(stringValue), "testRaiseIfNonePreservesTypeAnnotations", stringValue)
+
+    listValue: list[int] = raiseIfNone([29, 31])
+    assert isinstance(listValue, list), uniformTestFailureMessage(list, type(listValue), "testRaiseIfNonePreservesTypeAnnotations", listValue)
+
+# Tests for PackageSettings dataclass
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, expectedIdentifierPackage",
+    [
+        ("astToolFactory", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("nonExistentPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("customPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+    ]
+)
+def testPackageSettingsWithFallbackUsesProjectToml(identifierPackageFALLBACK: str, expectedIdentifierPackage: str) -> None:
+    """Test that PackageSettings reads package name from pyproject.toml when using fallback."""
+    packageSettings = PackageSettings(identifierPackageFALLBACK)
+    assert packageSettings.identifierPackage == expectedIdentifierPackage, uniformTestFailureMessage(
+        expectedIdentifierPackage, packageSettings.identifierPackage, "PackageSettings fallback", identifierPackageFALLBACK
+    )
+
+@pytest.mark.parametrize(
+    "explicitIdentifierPackage, expectedIdentifierPackage",
+    [
+        ("customPackageName", "customPackageName"),
+        ("fibonacci", "fibonacci"),
+        ("prime", "prime"),
+        ("astToolFactory", "astToolFactory"),
+    ]
+)
+def testPackageSettingsWithExplicitIdentifierPackage(explicitIdentifierPackage: str, expectedIdentifierPackage: str) -> None:
+    """Test that PackageSettings respects explicitly provided identifierPackage."""
+    packageSettings = PackageSettings(identifierPackage=explicitIdentifierPackage)
+    assert packageSettings.identifierPackage == expectedIdentifierPackage, uniformTestFailureMessage(
+        expectedIdentifierPackage, packageSettings.identifierPackage, "PackageSettings explicit identifierPackage", explicitIdentifierPackage
+    )
+
+@pytest.mark.parametrize(
+    "explicitPathPackage, expectedPathPackage",
+    [
+        (Path("C:/fibonacci/path"), Path("C:/fibonacci/path")),
+        (Path("C:/prime/directory"), Path("C:/prime/directory")),
+        (Path("/usr/local/lib/package"), Path("/usr/local/lib/package")),
+        (Path("relative/path"), Path("relative/path")),
+    ]
+)
+def testPackageSettingsWithExplicitPathPackage(explicitPathPackage: Path, expectedPathPackage: Path) -> None:
+    """Test that PackageSettings respects explicitly provided pathPackage."""
+    packageSettings = PackageSettings(pathPackage=explicitPathPackage)
+    assert packageSettings.pathPackage == expectedPathPackage, uniformTestFailureMessage(
+        expectedPathPackage, packageSettings.pathPackage, "PackageSettings explicit pathPackage", explicitPathPackage
+    )
+
+@pytest.mark.parametrize(
+    "fileExtension, expectedFileExtension",
+    [
+        (".fibonacci", ".fibonacci"),
+        (".prime", ".prime"),
+        (".txt", ".txt"),
+        (".md", ".md"),
+        (".json", ".json"),
+    ]
+)
+def testPackageSettingsWithCustomFileExtension(fileExtension: str, expectedFileExtension: str) -> None:
+    """Test that PackageSettings respects custom file extensions."""
+    packageSettings = PackageSettings(fileExtension=fileExtension)
+    assert packageSettings.fileExtension == expectedFileExtension, uniformTestFailureMessage(
+        expectedFileExtension, packageSettings.fileExtension, "PackageSettings custom fileExtension", fileExtension
+    )
+
+def testPackageSettingsDefaultValues() -> None:
+    """Test that PackageSettings has correct default values when no arguments provided."""
+    packageSettings = PackageSettings()
+
+    # Should have default file extension
+    assert packageSettings.fileExtension == '.py', uniformTestFailureMessage(
+        '.py', packageSettings.fileExtension, "PackageSettings default fileExtension"
+    )
+
+    # identifierPackage should be empty when no fallback provided
+    assert packageSettings.identifierPackage == '', uniformTestFailureMessage(
+        '', packageSettings.identifierPackage, "PackageSettings default identifierPackage"
+    )
+
+    # pathPackage should remain as Path() when identifierPackage is empty
+    expectedPath = Path()
+    assert packageSettings.pathPackage == expectedPath, uniformTestFailureMessage(
+        expectedPath, packageSettings.pathPackage, "PackageSettings default pathPackage"
+    )
+
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, identifierPackage, pathPackage, fileExtension",
+    [
+        ("fallback", "custom", Path("C:/custom/path"), ".txt"),
+        ("fibonacci", "prime", Path("C:/fibonacci/lib"), ".md"),
+        ("defaultFallback", "overridePackage", Path("/usr/local/override"), ".json"),
+    ]
+)
+def testPackageSettingsAllParametersCombined(
+    identifierPackageFALLBACK: str,
+    identifierPackage: str,
+    pathPackage: Path,
+    fileExtension: str
+) -> None:
+    """Test PackageSettings with all parameters provided."""
+    packageSettings = PackageSettings(
+        identifierPackageFALLBACK,
+        identifierPackage=identifierPackage,
+        pathPackage=pathPackage,
+        fileExtension=fileExtension
+    )
+
+    assert packageSettings.identifierPackage == identifierPackage, uniformTestFailureMessage(
+        identifierPackage, packageSettings.identifierPackage, "PackageSettings combined identifierPackage"
+    )
+    assert packageSettings.pathPackage == pathPackage, uniformTestFailureMessage(
+        pathPackage, packageSettings.pathPackage, "PackageSettings combined pathPackage"
+    )
+    assert packageSettings.fileExtension == fileExtension, uniformTestFailureMessage(
+        fileExtension, packageSettings.fileExtension, "PackageSettings combined fileExtension"
+    )
+
+def testPackageSettingsFallbackIgnoredWhenExplicitIdentifierProvided() -> None:
+    """Test that fallback is ignored when explicit identifierPackage is provided."""
+    packageSettings = PackageSettings("shouldBeIgnored", identifierPackage="explicit")
+    assert packageSettings.identifierPackage == "explicit", uniformTestFailureMessage(
+        "explicit", packageSettings.identifierPackage, "PackageSettings fallback ignored"
+    )
+
+# Tests for helper functions
+@pytest.mark.parametrize(
+    "identifierPackageFALLBACK, expectedResult",
+    [
+        ("fibonacci", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("prime", "hunterMakesPy"),  # Should read from pyproject.toml
+        ("nonExistentPackage", "hunterMakesPy"),  # Should read from pyproject.toml
+    ]
+)
+def testGetIdentifierPackagePACKAGING(identifierPackageFALLBACK: str, expectedResult: str) -> None:
+    """Test that getIdentifierPackagePACKAGING reads from pyproject.toml correctly."""
+    actual = getIdentifierPackagePACKAGING(identifierPackageFALLBACK)
+    assert actual == expectedResult, uniformTestFailureMessage(
+        expectedResult, actual, "getIdentifierPackagePACKAGING", identifierPackageFALLBACK
+    )
+
+@pytest.mark.parametrize(
+    "identifierPackage",
+    [
+        "hunterMakesPy",  # This package exists
+        "fibonacci",  # Non-existent package should fallback to cwd
+        "prime",  # Non-existent package should fallback to cwd
+    ]
+)
+def testGetPathPackageINSTALLING(identifierPackage: str) -> None:
+    """Test that getPathPackageINSTALLING returns valid Path objects."""
+    actual = getPathPackageINSTALLING(identifierPackage)
+    assert isinstance(actual, Path), uniformTestFailureMessage(
+        Path, type(actual), "getPathPackageINSTALLING type", identifierPackage
+    )
+    assert actual.exists() or actual == Path.cwd(), uniformTestFailureMessage(
+        "existing path or cwd", actual, "getPathPackageINSTALLING existence", identifierPackage
+    )