pytest-cmake 0.8.4__tar.gz → 0.11.2__tar.gz

{pytest_cmake-0.8.4 → pytest_cmake-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pytest-cmake
-Version: 0.8.4
+Version: 0.11.2
 Summary: Provide CMake module for Pytest
 Project-URL: Documentation, https://python-cmake.github.io/pytest-cmake
 Project-URL: Repository, https://github.com/python-cmake/pytest-cmake

{pytest_cmake-0.8.4 → pytest_cmake-0.11.2}/cmake/FindPytest.cmake

@@ -3,9 +3,9 @@
 # This module defines the following imported targets:
 #     Pytest::Pytest
 #
-# It also exposes the 'pytest_discover_tests' function which adds ctest
-# for each pytest tests. The "BUNDLE_PYTHON_TESTS" environment variable
-# can be used to run all discovered tests all together.
+# It also exposes the 'pytest_discover_tests' function, which adds CTest
+# test for each Pytest test. The "BUNDLE_PYTHON_TESTS" environment variable
+# can be used to run all discovered tests together.
 #
 # Usage:
 #     find_package(Pytest)
@@ -53,14 +53,15 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
         PROPERTIES
             IMPORTED_LOCATION "${PYTEST_EXECUTABLE}")
 
+    # Function to discover pytest tests and add them to CTest.
     function(pytest_discover_tests NAME)
         cmake_parse_arguments(
-            PARSE_ARGV 1 "" ""
-            "WORKING_DIRECTORY;TRIM_FROM_NAME;BUNDLE_TESTS"
-            "LIBRARY_PATH_PREPEND;PYTHON_PATH_PREPEND;ENVIRONMENT;DEPENDS"
+            PARSE_ARGV 1 "" "STRIP_PARAM_BRACKETS;INCLUDE_FILE_PATH;BUNDLE_TESTS"
+            "WORKING_DIRECTORY;TRIM_FROM_NAME;TRIM_FROM_FULL_NAME"
+            "LIBRARY_PATH_PREPEND;PYTHON_PATH_PREPEND;ENVIRONMENT;PROPERTIES;DEPENDS"
         )
 
-        # Identify library path environment name depending on the platform.
+        # Set platform-specific library path environment variable.
         if (CMAKE_SYSTEM_NAME STREQUAL Windows)
             set(LIBRARY_ENV_NAME PATH)
         elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
@@ -69,11 +70,11 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
             set(LIBRARY_ENV_NAME LD_LIBRARY_PATH)
         endif()
 
-        # Sanitize all paths for CMake.
+        # Convert paths to CMake-friendly format.
         cmake_path(CONVERT "$ENV{${LIBRARY_ENV_NAME}}" TO_CMAKE_PATH_LIST LIBRARY_PATH)
         cmake_path(CONVERT "$ENV{PYTHONPATH}" TO_CMAKE_PATH_LIST PYTHON_PATH)
 
-        # Prepend input path to environment variables.
+        # Prepend specified paths to the library and Python paths.
         if (_LIBRARY_PATH_PREPEND)
             list(REVERSE _LIBRARY_PATH_PREPEND)
             foreach (_path ${_LIBRARY_PATH_PREPEND})
@@ -88,7 +89,7 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
             endforeach()
         endif()
 
-        # Default working directory to current build path if none is provided.
+        # Set default working directory if none is specified.
         if (NOT _WORKING_DIRECTORY)
             set(_WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
         endif()
@@ -100,20 +101,13 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
             set(_BUNDLE_TESTS $ENV{BUNDLE_PYTHON_TESTS})
         endif()
 
-	# Serialize environment if necessary.
-	set(ENCODED_ENVIRONMENT "")
-	foreach(env ${_ENVIRONMENT})
-            string(REPLACE [[\]] [\\]] env ${env})
-	    string(REPLACE [[;]] [\\;]] env ${env})
-	    list(APPEND ENCODED_ENVIRONMENT ${env})
-	endforeach()
-
+        # Define file paths for generated CMake include files.
         set(_include_file "${CMAKE_CURRENT_BINARY_DIR}/${NAME}_include.cmake")
         set(_tests_file "${CMAKE_CURRENT_BINARY_DIR}/${NAME}_tests.cmake")
 
-        add_custom_target(
-            ${NAME} ALL VERBATIM
-            BYPRODUCTS "${_tests_file}"
+        add_custom_command(
+            VERBATIM
+            OUTPUT "${_tests_file}"
             DEPENDS ${_DEPENDS}
             COMMAND ${CMAKE_COMMAND}
             -D "PYTEST_EXECUTABLE=${PYTEST_EXECUTABLE}"
@@ -123,12 +117,18 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
             -D "LIBRARY_PATH=${LIBRARY_PATH}"
             -D "PYTHON_PATH=${PYTHON_PATH}"
             -D "TRIM_FROM_NAME=${_TRIM_FROM_NAME}"
+            -D "TRIM_FROM_FULL_NAME=${_TRIM_FROM_FULL_NAME}"
+            -D "STRIP_PARAM_BRACKETS=${_STRIP_PARAM_BRACKETS}"
+            -D "INCLUDE_FILE_PATH=${_INCLUDE_FILE_PATH}"
             -D "WORKING_DIRECTORY=${_WORKING_DIRECTORY}"
-	    -D "ENVIRONMENT=${ENCODED_ENVIRONMENT}"
-            -D "PROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}"
+            -D "ENVIRONMENT=${_ENVIRONMENT}"
+            -D "TEST_PROPERTIES=${_PROPERTIES}"
             -D "CTEST_FILE=${_tests_file}"
             -P "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/PytestAddTests.cmake")
 
+        # Create a custom target to run the tests.
+        add_custom_target(${NAME} ALL DEPENDS ${_tests_file})
+
           file(WRITE "${_include_file}"
               "if(EXISTS \"${_tests_file}\")\n"
               "    include(\"${_tests_file}\")\n"
@@ -137,7 +137,7 @@ if (Pytest_FOUND AND NOT TARGET Pytest::Pytest)
               "endif()\n"
           )
 
-        # Add discovered tests to directory TEST_INCLUDE_FILES
+        # Register the include file to be processed for tests.
         set_property(DIRECTORY
             APPEND PROPERTY TEST_INCLUDE_FILES "${_include_file}")
 

pytest_cmake-0.11.2/cmake/PytestAddTests.cmake

@@ -0,0 +1,148 @@
+# Wrapper used to create individual CTest tests from Pytest tests.
+cmake_minimum_required(VERSION 3.20...3.30)
+
+if(CMAKE_SCRIPT_MODE_FILE)
+
+    # Initialize content for the CMake test file.
+    set(_content "")
+
+    # Convert library and Python paths to native format.
+    cmake_path(CONVERT "${LIBRARY_PATH}" TO_NATIVE_PATH_LIST LIBRARY_PATH)
+    cmake_path(CONVERT "${PYTHON_PATH}" TO_NATIVE_PATH_LIST PYTHON_PATH)
+
+    # Serialize path values separated by semicolons (required on Windows).
+    string(REPLACE [[;]] [[\\;]] LIBRARY_PATH "${LIBRARY_PATH}")
+    string(REPLACE [[;]] [[\\;]] PYTHON_PATH "${PYTHON_PATH}")
+
+    # Set up the encoded environment with required paths.
+    set(ENCODED_ENVIRONMENT
+        "${LIBRARY_ENV_NAME}=${LIBRARY_PATH}"
+        "PYTHONPATH=${PYTHON_PATH}"
+    )
+
+    # Serialize additional environment variables if any are provided.
+    foreach(env ${ENVIRONMENT})
+        string(REPLACE [[;]] [[\\;]] env "${env}")
+        list(APPEND ENCODED_ENVIRONMENT "${env}")
+    endforeach()
+
+    # Macro to create individual tests with optional test properties.
+    macro(create_test NAME IDENTIFIER)
+        string(APPEND _content
+            "add_test([==[${NAME}]==] \"${PYTEST_EXECUTABLE}\" [==[${IDENTIFIER}]==])\n"
+        )
+
+        # Prepare the properties for the test, including the environment settings.
+        set(args "PROPERTIES ENVIRONMENT [==[${ENCODED_ENVIRONMENT}]==]")
+
+        # Append any additional properties, escaping complex characters if necessary.
+        foreach(property ${TEST_PROPERTIES})
+            if(property MATCHES "[^-./:a-zA-Z0-9_]")
+                string(APPEND args " [==[${property}]==]")
+            else()
+                string(APPEND args " ${property}")
+            endif()
+        endforeach()
+
+        # Append the test properties to the content.
+        string(APPEND _content "set_tests_properties([==[${NAME}]==] ${args})\n")
+    endmacro()
+
+    # If tests are bundled together, create a single test group.
+    if (BUNDLE_TESTS)
+        create_test("\${TEST_GROUP_NAME}" "\${WORKING_DIRECTORY}")
+
+    else()
+        # Set environment variables for collecting tests.
+        set(ENV{${LIBRARY_ENV_NAME}} "${LIBRARY_PATH}")
+        set(ENV{PYTHONPATH} "${PYTHON_PATH}")
+        set(ENV{PYTHONWARNINGS} "ignore")
+
+        # Collect tests.
+        execute_process(
+            COMMAND "${PYTEST_EXECUTABLE}"
+                --collect-only -q
+                --rootdir=${WORKING_DIRECTORY} .
+            OUTPUT_VARIABLE _output_lines
+            ERROR_VARIABLE _output_lines
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+            WORKING_DIRECTORY ${WORKING_DIRECTORY}
+        )
+
+        # Check for errors during test collection.
+        string(REGEX MATCH "=+ ERRORS =+(.*)" _error "${_output_lines}")
+
+        if (_error)
+            message(${_error})
+            message(FATAL_ERROR "An error occurred during the collection of Python tests.")
+        endif()
+
+        # Convert the collected output into a list of lines.
+        string(REPLACE [[;]] [[\;]] _output_lines "${_output_lines}")
+        string(REPLACE "\n" ";" _output_lines "${_output_lines}")
+
+        # Regex pattern to identify pytest test identifiers.
+        set(test_pattern "([^:]+)\.py(::([^:]+))?::([^:]+)")
+
+        # Iterate through each line to identify and process tests.
+        foreach(line ${_output_lines})
+            string(REGEX MATCHALL ${test_pattern} matching "${line}")
+
+            # Skip lines that are not identified as tests.
+            if (NOT matching)
+                continue()
+            endif()
+
+            # Extract file, class, and function names from the test pattern.
+            set(_file ${CMAKE_MATCH_1})
+            set(_class ${CMAKE_MATCH_3})
+            set(_func ${CMAKE_MATCH_4})
+
+            # Optionally trim parts of the class or function name.
+            if (TRIM_FROM_NAME)
+                string(REGEX REPLACE "${TRIM_FROM_NAME}" "" _class "${_class}")
+                string(REGEX REPLACE "${TRIM_FROM_NAME}" "" _func "${_func}")
+            endif()
+
+            # Form the test name using class and function.
+            if (_class)
+                set(test_name "${_class}.${_func}")
+            else()
+                set(test_name "${_func}")
+            endif()
+
+            # Optionally strip parameter brackets from the test name.
+            if (STRIP_PARAM_BRACKETS)
+                string(REGEX REPLACE "\\[(.+)\\]$" ".\\1" test_name "${test_name}")
+            endif()
+
+            # Optionally include the file path in the test name.
+            if (INCLUDE_FILE_PATH)
+                cmake_path(CONVERT "${_file}" TO_CMAKE_PATH_LIST _file)
+                string(REGEX REPLACE "/" "." _file "${_file}")
+                set(test_name "${_file}.${test_name}")
+            endif()
+
+            # Optionally trim parts of the full test name.
+            if (TRIM_FROM_FULL_NAME)
+                string(REGEX REPLACE "${TRIM_FROM_FULL_NAME}" "" test_name "${test_name}")
+            endif()
+
+            # Prefix the test name with the test group name.
+            set(test_name "${TEST_GROUP_NAME}.${test_name}")
+            set(test_case "${WORKING_DIRECTORY}/${line}")
+
+            # Create the test for CTest.
+            create_test("\${test_name}" "\${test_case}")
+        endforeach()
+
+        # Warn if no tests were discovered.
+        if(NOT _content)
+            message(WARNING "No Python tests have been discovered.")
+        endif()
+    endif()
+
+    # Write the generated test content to the specified CTest file.
+    file(WRITE ${CTEST_FILE} ${_content})
+
+endif()

{pytest_cmake-0.8.4 → pytest_cmake-0.11.2}/pyproject.toml

@@ -9,7 +9,7 @@ backend-path = ["."]
 
 [project]
 name = "pytest-cmake"
-version = "0.8.4"
+version = "0.11.2"
 description = "Provide CMake module for Pytest"
 readme = "README.md"
 requires-python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, <4"

{pytest_cmake-0.8.4 → pytest_cmake-0.11.2}/setup.py

@@ -60,7 +60,7 @@ class CreateCmakeConfig(install):
 
 setup(
     name="pytest-cmake",
-    version="0.8.4",
+    version="0.11.2",
     data_files=[
         (
             "share/Pytest/cmake",

pytest_cmake-0.8.4/cmake/PytestAddTests.cmake

@@ -1,137 +0,0 @@
-# Wrapper used to create individual CTest tests from Pytest tests.
-cmake_minimum_required(VERSION 3.20...3.30)
-
-if(CMAKE_SCRIPT_MODE_FILE)
-
-    # Set Cmake test file to execute each test.
-    set(_content "")
-
-    cmake_path(CONVERT "${LIBRARY_PATH}" TO_NATIVE_PATH_LIST LIBRARY_PATH)
-    cmake_path(CONVERT "${PYTHON_PATH}" TO_NATIVE_PATH_LIST PYTHON_PATH)
-
-    # Serialize path values separated by semicolons (required on Windows).
-    macro(encode_value VARIABLE_NAME)
-        string(REPLACE [[\]] [[\\]] ${VARIABLE_NAME} "${${VARIABLE_NAME}}")
-        string(REPLACE [[;]] [[\\;]] ${VARIABLE_NAME} "${${VARIABLE_NAME}}")
-    endmacro()
-
-    encode_value(LIBRARY_PATH)
-    encode_value(PYTHON_PATH)
-
-    if (BUNDLE_TESTS)
-        string(APPEND _content
-            "add_test(\n"
-            "    \"${TEST_GROUP_NAME}\"\n"
-            "    \"${PYTEST_EXECUTABLE}\" \"${WORKING_DIRECTORY}\"\n"
-            ")\n"
-            "set_tests_properties(\n"
-            "     \"${TEST_GROUP_NAME}\" PROPERTIES\n"
-            "     ENVIRONMENT \"${LIBRARY_ENV_NAME}=${LIBRARY_PATH}\"\n"
-            ")\n"
-            "set_tests_properties(\n"
-            "     \"${TEST_GROUP_NAME}\"\n"
-            "     APPEND PROPERTIES\n"
-            "     ENVIRONMENT \"PYTHONPATH=${PYTHON_PATH}\"\n"
-            ")\n"
-        )
-
-        foreach(env ${ENVIRONMENT})
-            string(APPEND _content
-                "set_tests_properties(\n"
-                "     \"${TEST_GROUP_NAME}\"\n"
-                "     APPEND PROPERTIES\n"
-                "     ENVIRONMENT ${env}\n"
-                ")\n"
-            )
-        endforeach()
-
-    else()
-        # Set environment for collecting tests.
-        set(ENV{${LIBRARY_ENV_NAME}} "${LIBRARY_PATH}")
-        set(ENV{PYTHONPATH} "${PYTHON_PATH}")
-        set(ENV{PYTHONWARNINGS} "ignore")
-
-        execute_process(
-            COMMAND "${PYTEST_EXECUTABLE}"
-                --collect-only -q
-                --rootdir=${WORKING_DIRECTORY} .
-            OUTPUT_VARIABLE _output_lines
-            ERROR_VARIABLE _output_lines
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-            WORKING_DIRECTORY ${WORKING_DIRECTORY}
-        )
-
-        string(REGEX MATCH "=+ ERRORS =+(.*)" _error ${_output_lines})
-
-        if (_error)
-            message(${_error})
-            message(FATAL_ERROR "An error occurred during the collection of Python tests.")
-        endif()
-
-        # Convert output into list.
-        string(REPLACE [[;]] [[\;]] _output_lines "${_output_lines}")
-        string(REPLACE "\n" ";" _output_lines "${_output_lines}")
-
-        set(test_pattern "([^:]+)(::([^:]+))?::([^:]+)")
-
-        foreach (line ${_output_lines})
-            string(REGEX MATCHALL ${test_pattern} matching "${line}")
-
-            # Ignore lines not identified as a test.
-            if (NOT matching)
-                continue()
-            endif()
-
-            set(_class ${CMAKE_MATCH_3})
-            set(_func ${CMAKE_MATCH_4})
-
-            if (TRIM_FROM_NAME)
-                set(pattern "${TRIM_FROM_NAME}")
-                string(REGEX REPLACE "${pattern}" "" _class "${_class}")
-                string(REGEX REPLACE "${pattern}" "" _func "${_func}")
-            endif()
-
-            if (_class)
-                set(test_name "${_class}.${_func}")
-            else()
-                set(test_name "${_func}")
-            endif()
-
-            set(test_name "${TEST_GROUP_NAME}.${test_name}")
-            set(test_case "${WORKING_DIRECTORY}/${line}")
-
-            string(APPEND _content
-                "add_test(\n"
-                "    \"${test_name}\"\n"
-                "    \"${PYTEST_EXECUTABLE}\" \"${test_case}\"\n"
-                ")\n"
-                "set_tests_properties(\n"
-                "     \"${test_name}\" PROPERTIES\n"
-                "     ENVIRONMENT \"${LIBRARY_ENV_NAME}=${LIBRARY_PATH}\"\n"
-                ")\n"
-                "set_tests_properties(\n"
-                "     \"${test_name}\"\n"
-                "     APPEND PROPERTIES\n"
-                "     ENVIRONMENT \"PYTHONPATH=${PYTHON_PATH}\"\n"
-                ")\n"
-            )
-
-            foreach(env ${ENVIRONMENT})
-                string(APPEND _content
-                    "set_tests_properties(\n"
-                    "     \"${test_name}\"\n"
-                    "     APPEND PROPERTIES\n"
-                    "     ENVIRONMENT ${env}\n"
-                    ")\n"
-                )
-            endforeach()
-
-        endforeach()
-
-        if(NOT _content)
-            message(WARNING "No Python tests have been discovered.")
-        endif()
-    endif()
-
-    file(WRITE ${CTEST_FILE} ${_content})
-endif()