diff --git a/BA_PACKAGE.cmake b/BA_PACKAGE.cmake index e730c1f..08596c7 100644 --- a/BA_PACKAGE.cmake +++ b/BA_PACKAGE.cmake @@ -21,6 +21,11 @@ FIND_PACKAGE(CMLIB COMPONENTS CMUTIL CMDEF) # # OUTPUT_PATH_VAR - name of the variable where the absolute path of the package root will be stored. # +# Wrapper around BA_PACKAGE +# - adds package path to CMAKE_PREFIX_PATH +# - propagates output variables +# - manage prefixes and suffixes +# # ( # # @@ -45,7 +50,7 @@ FUNCTION(BA_PACKAGE_LIBRARY package_name version_tag) SET(suffix "d") ENDIF() - _BRINGAUTO_PACKAGE(${package_name} ${version_tag} "lib" "${suffix}-dev" output_var + BA_PACKAGE(${package_name} ${version_tag} "lib" "${suffix}-dev" output_var CACHE_ONLY ${__CACHE_ONLY} NO_DEBUG ${__NO_DEBUG} ) @@ -64,7 +69,20 @@ ENDFUNCTION() ## # -# Download, cache and populate Executable package +# Download, cache and populate Executable package. +# +# CACHE_ONLY - if specified no download is performed. The package +# must be cached by a previous call to BA_PACKAGE_EXECUTABLE() without CACHE_ONLY switch. +# +# NO_DEBUG - use release, not debug version of the package (can be used if release and debug +# variant are equal) +# +# OUTPUT_PATH_VAR - name of the variable where the absolute path of the package root will be stored. +# +# Wrapper around BA_PACKAGE +# - adds package path to CMAKE_PREFIX_PATH +# - propagates output variables +# - manage prefixes and suffixes # # ( # @@ -90,7 +108,7 @@ FUNCTION(BA_PACKAGE_EXECUTABLE package_name version_tag) SET(suffix "d") ENDIF() - _BRINGAUTO_PACKAGE(${package_name} ${version_tag} "" "${suffix}" output_var + BA_PACKAGE(${package_name} ${version_tag} "" "${suffix}" output_var CACHE_ONLY ${__CACHE_ONLY} NO_DEBUG ${__NO_DEBUG} ) @@ -107,7 +125,7 @@ ENDFUNCTION() -## Helper +## # # Download, cache and populate package represented by 'package_name' # and concretized by 'prefix' and 'suffix'. @@ -120,7 +138,7 @@ ENDFUNCTION() # [NO_DEBUG {ON|OFF}] # ) # -FUNCTION(_BRINGAUTO_PACKAGE package_name version_tag prefix suffix output_var) +FUNCTION(BA_PACKAGE package_name version_tag prefix suffix output_var) CMLIB_PARSE_ARGUMENTS( OPTIONS CACHE_ONLY @@ -141,28 +159,51 @@ FUNCTION(_BRINGAUTO_PACKAGE package_name version_tag prefix suffix output_var) SET(package_string "${package_name_expanded}_${version_tag}_${platform_string}.zip") BA_PACKAGE_VARS_GET(REVISION revision_var) + SET(git_path "${CMDEF_DISTRO_ID}/${CMDEF_DISTRO_VERSION_ID}/${machine}") + + _BA_PACKAGE_URL_ENCODE_IF_ENABLED("${revision_var}" revision_var_norm) + _BA_PACKAGE_URL_ENCODE_IF_ENABLED("${git_path}" git_path_norm) + _BA_PACKAGE_URL_ENCODE_IF_ENABLED("${package_string}" package_string_norm) + _BA_PACKAGE_URL_ENCODE_IF_ENABLED("${package_name}" package_name_norm) + SET(revision_arg) - IF(revision_var) - SET(revision_arg REVISION "${revision_var}") + IF(revision_var_norm) + SET(revision_arg REVISION "${revision_var_norm}") ENDIF() - SET(git_path "${CMDEF_DISTRO_ID}/${CMDEF_DISTRO_VERSION_ID}/${machine}") + BA_PACKAGE_VARS_GET(URI_TEMPLATE template_var) CMLIB_STORAGE_TEMPLATE_INSTANCE(remote_file template_var ${revision_arg} - GIT_PATH "${git_path}" - ARCHIVE_NAME "${package_string}" - PACKAGE_GROUP_NAME "${package_name}" + GIT_PATH "${git_path_norm}" + ARCHIVE_NAME "${package_string_norm}" + PACKAGE_GROUP_NAME "${package_name_norm}" ) + SET(git_archive_path_arg) + SET(git_revision_arg) + BA_PACKAGE_VARS_GET(GIT_PATH_TEMPLATE git_path_template_var) + IF(git_path_template_var) + CMLIB_STORAGE_TEMPLATE_INSTANCE(git_archive_path git_path_template_var + ${revision_arg} + GIT_PATH "${git_path_norm}" + ARCHIVE_NAME "${package_string_norm}" + PACKAGE_GROUP_NAME "${package_name_norm}" + ) + SET(git_revision_arg GIT_REVISION "${revision_var}") + SET(git_archive_path_arg GIT_PATH "${git_archive_path}") + ENDIF() + STRING(TOUPPER "${package_name}" package_name_upper_orig) - STRING(REGEX REPLACE "[^A-Z0-9]" "" package_name_upper "${package_name_upper_orig}") - STRING(REGEX REPLACE "[\\-]" "" package_name_upper_wodash "${package_name_upper_orig}") + STRING(REGEX REPLACE "[^A-Z0-9]" "" package_name_upper "${package_name_upper_orig}") IF(NOT package_name_upper) MESSAGE(FATAL_ERROR "Invalid package name: ${package_name}") ENDIF() - IF(NOT (package_name_upper STREQUAL package_name_upper_wodash)) - MESSAGE(WARNING "Package name ${package_name} contains invalid characters. It was normalized to form a proper CMLIB cache keyword: ${package_name} --> ${package_name_upper}") - ENDIF() + + # Not sure if this is useful? In production it feels weird. + # The only reason is to not have accidental collisions.... + #IF(NOT (package_name_upper STREQUAL package_name_upper_orig)) + # MESSAGE(WARNING "Package name ${package_name} contains invalid characters. It was normalized to form a proper CMLIB cache keyword: ${package_name} --> ${package_name_upper}") + #ENDIF() SET(keywords BACPACK ${package_name_upper}) @@ -186,7 +227,10 @@ FUNCTION(_BRINGAUTO_PACKAGE package_name version_tag prefix suffix output_var) CMLIB_DEPENDENCY( KEYWORDS ${keywords} TYPE ARCHIVE + ARCHIVE_TYPE ZIP URI "${remote_file}" + ${git_revision_arg} + ${git_archive_path_arg} OUTPUT_PATH_VAR cache_path ) ENDIF() @@ -198,7 +242,46 @@ ENDFUNCTION() ## Helper # -# Print preformatted message +# Percent-encode characters that are not allowed in URI components. +# Encoding is only performed when ESCAPE_TEMPLATE_ARGS is ON/True. +# +# ( +# +# ) +# +FUNCTION(_BA_PACKAGE_URL_ENCODE_IF_ENABLED input output) + BA_PACKAGE_VARS_GET(ESCAPE_TEMPLATE_ARGS _escape_enabled) + IF(NOT _escape_enabled) + SET(${output} "${input}" PARENT_SCOPE) + RETURN() + ENDIF() + SET(result "${input}") + STRING(REPLACE "%" "%25" result "${result}") + STRING(REPLACE " " "%20" result "${result}") + STRING(REPLACE "!" "%21" result "${result}") + STRING(REPLACE "#" "%23" result "${result}") + STRING(REPLACE "$" "%24" result "${result}") + STRING(REPLACE "&" "%26" result "${result}") + STRING(REPLACE "'" "%27" result "${result}") + STRING(REPLACE "(" "%28" result "${result}") + STRING(REPLACE ")" "%29" result "${result}") + STRING(REPLACE "*" "%2A" result "${result}") + STRING(REPLACE "+" "%2B" result "${result}") + STRING(REPLACE "," "%2C" result "${result}") + STRING(REPLACE "/" "%2F" result "${result}") + STRING(REPLACE ":" "%3A" result "${result}") + STRING(REPLACE ";" "%3B" result "${result}") + STRING(REPLACE "=" "%3D" result "${result}") + STRING(REPLACE "?" "%3F" result "${result}") + STRING(REPLACE "@" "%40" result "${result}") + SET(${output} "${result}" PARENT_SCOPE) +ENDFUNCTION() + + + +## Helper +# +# Print reformatted message # # ( # @@ -211,4 +294,4 @@ FUNCTION(_BA_PACKAGE_MESSAGE action message) MESSAGE(FATAL_ERROR "BA_PACKAGE: Cannot print unknown action ${action}") ENDIF() MESSAGE(STATUS "BA_PACKAGE [${action}]: ${message}") -ENDFUNCTION() \ No newline at end of file +ENDFUNCTION() diff --git a/BA_PACKAGE_VARS.cmake b/BA_PACKAGE_VARS.cmake index 8cd648b..04cd494 100644 --- a/BA_PACKAGE_VARS.cmake +++ b/BA_PACKAGE_VARS.cmake @@ -8,7 +8,7 @@ # be stored as INTERNAL cache variable. # - Every variable is stored as a CMake cache variable with name BA_PACKAGE_VARS__. # Double _ is chosen to avoid defining reserved variable names SET and GET. -# - Every variable shall be set/get by a SetterGetter function. +# - Every variable shall be set/get by a Setter-Getter function. # # Mechanism of Setter/Getter was chosen in order to simplify # future maintenance and "configuration" (in backward compatibility manner) @@ -27,6 +27,21 @@ SET(BA_PACKAGE_VARS__URI_TEMPLATE "NonExistentPath" "Storage URI template used to construct the package download URI" ) +SET(BA_PACKAGE_VARS__GIT_PATH_TEMPLATE "NonExistentPath" + CACHE INTERNAL + "Git path template to use. If non empty the URI_TEMPLATE represents remote Git repository. Takes same template params as URI_TEMPLATE." +) + +SET(BA_PACKAGE_VARS__HTTP_HEADER "NonExistentHTTPHEADER" + CACHE INTERNAL + "HTTP header to use when accessing Package Repository over HTTP." +) + +SET(BA_PACKAGE_VARS__ESCAPE_TEMPLATE_ARGS OFF + CACHE INTERNAL + "Escape template arguments when constructing the package download URI" +) + ## diff --git a/README.md b/README.md index 3a56c9f..65d8977 100644 --- a/README.md +++ b/README.md @@ -62,6 +62,7 @@ Setting variable values are highly affected by [CMCONF Global Config]. - `` - path to Packages in the repository for a given system. Set to `${CMDEF_DISTRO_ID}/${CMDEF_DISTRO_VERSION_ID}/${CMDEF_ARCHITECTURE}`, - `` - package group name as stated in [BringAuto Packager Context] - `` - full name of the Package. Set to ${package_group_name}_${version_tag}_${platform_string}.zip. The platform string is derived from CMDEF variables: `CMDEF_ARCHITECTURE`, `CMDEF_DISTRO_ID`, `CMDEF_DISTRO_VERSION_ID`. +- `GIT_PATH_TEMPLATE` - [CMake-lib] template to construct path to the package in the repository. If set `URI_TEMPLATE` shall represent a remote Git repository. It takes the same template params as `URI_TEMPLATE`. ```cmake # Set REVISION to deps_update @@ -70,29 +71,41 @@ BA_PACKAGE_VARS_SET(REVISION deps_update) BA_PACKAGE_LIBRARY(nlohmann-json v3.10.5) ``` +## Tests + +- [cmake_tests/] — unit tests for CMake module logic using mocks, no network or build required. +- [test/] — integration tests that build a real application, install dependencies, and verify installed file structure. + + ## FAQ +### Q: I want to migrate to newest version of Package tracker + +- see [doc/MigrationGuide_0_to_1.md] +- see [doc/MigrationGuide_1_to_2.md] + + ### Q: Package not found even if it exists in the repository - Ensure the package was built for your platform (CMDEF_DISTRO_ID, CMDEF_DISTRO_VERSION_ID, CMDEF_ARCHITECTURE). - Verify REVISION and URI_TEMPLATE (see CMCONF Global Config) point to the right Package Repository and branch. - If using a local Package Repository, confirm BA_PACKAGE_LOCAL_PATH points to the correct directory and that the expected package archive exists. -### Q: Package conflict if I want to build my project by second build type +### Q: Package conflict if I want to build my project by another build type -If you want to use the same cache path for Release and Debug build types -you must ensure that the package differs between Debug/Release build configs +If the same cache path is used for Release and Debug build types, +it must be ensured that the package differs between Debug/Release build configs and does not have files with the same paths. -If you have a package that has the same content for Debug and Release you need to -use `NO_DEBUG ON` in `BA_PACKAGE_LIBRARY`; otherwise the conflict will occur. +If the package has the same content for Debug and Release + `NO_DEBUG ON` flag shall be used in `BA_PACKAGE_LIBRARY`; otherwise the conflict will occur. (Look at [example/] for quick overview) - - [BringAuto Packager]: https://github.com/bacpack-system/packager [CMCONF Global Config]: ./doc/GlobalConfiguration.md [CMake-lib]: https://github.com/cmakelib/cmakelib [BringAuto Packager Context]: https://github.com/bacpack-system/packager/blob/master/doc/ContextStructure.md -[example/]: example/ \ No newline at end of file +[example/]: example/ +[cmake_tests/]: cmake_tests/ +[test/]: test/ \ No newline at end of file diff --git a/STORAGE.cmake b/STORAGE.cmake index 8d60c3e..0b140f9 100644 --- a/STORAGE.cmake +++ b/STORAGE.cmake @@ -7,26 +7,27 @@ SET(BA_PACKAGE_CMCONF_USE TRUE CACHE BOOL "Switch on for CMCONF use; off for testing purposes. Do not alter this setting unless you know what you are doing." ) +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE_VARS.cmake") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE.cmake") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE_DEPS.cmake") + IF(BA_PACKAGE_CMCONF_USE) - BA_PACKAGE_PREREQ_CMCONF_INIT(template revision) + BA_PACKAGE_PREREQ_CMCONF_INIT(template revision git_archive_path_template http_header template_args_uri_escape) + BA_PACKAGE_VARS_SET(REVISION "${revision}") + BA_PACKAGE_VARS_SET(URI_TEMPLATE "${template}") + BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "${git_archive_path_template}") + BA_PACKAGE_VARS_SET(ESCAPE_TEMPLATE_ARGS "${template_args_uri_escape}") + BA_PACKAGE_VARS_SET(HTTP_HEADER "${http_header}") ENDIF() -IF(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER) - IF(CMLIB_FILE_DOWNLOAD_AUTHORIZATION_HEADER) - MESSAGE(WARNING "HTTP Authorization header is defined but CMLIB_FILE_DOWNLOAD_AUTHORIZATION_HEADER is already set. Using BA_PACKAGE_HTTP_AUTHORIZATION_HEADER.") +BA_PACKAGE_VARS_GET(HTTP_HEADER http_header) +IF(http_header) + IF(CMLIB_FILE_DOWNLOAD_HTTP_HEADER AND (NOT CMLIB_FILE_DOWNLOAD_HTTP_HEADER STREQUAL http_header)) + MESSAGE(WARNING "BA_PACKAGE_HTTP_HEADER is defined but CMLIB_FILE_DOWNLOAD_HTTP_HEADER is already set. Using BA_PACKAGE_HTTP_HEADER.") ENDIF() - SET(CMLIB_FILE_DOWNLOAD_AUTHORIZATION_HEADER "Authorization: ${BA_PACKAGE_HTTP_AUTHORIZATION_HEADER}" + SET(CMLIB_FILE_DOWNLOAD_HTTP_HEADER "${http_header}" CACHE STRING - "HTTP Authorization header set by Package Tracker to access the private repository" + "HTTP header set by Package Tracker to access the private repository" FORCE ) -ENDIF() - - - -INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE_VARS.cmake") -INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE.cmake") -INCLUDE("${CMAKE_CURRENT_LIST_DIR}/BA_PACKAGE_DEPS.cmake") - -BA_PACKAGE_VARS_SET(REVISION "${revision}") -BA_PACKAGE_VARS_SET(URI_TEMPLATE "${template}") +ENDIF() \ No newline at end of file diff --git a/doc/GlobalConfiguration.md b/doc/GlobalConfiguration.md index d523dc6..06e5710 100644 --- a/doc/GlobalConfiguration.md +++ b/doc/GlobalConfiguration.md @@ -23,7 +23,9 @@ to [CMake User Package Registry]. [CMCONF Example] can be found in [CMCONF] repo | BA_PACKAGE_LOCAL_PATH | Absolute Path to the local Package Repository. Used if BA_PACKAGE_LOCAL_USE is set to ON. If ENV variable BA_PACKAGE_LOCAL_PATH is set it is used instead of this CMCONF setting. Resulting value is passed to URI_TEMPLATE setting variable as "file:///package///" | | BA_PACKAGE_URI_REVISION | Git revision to use when accessing Package Repository. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | | BA_PACKAGE_URI_TEMPLATE_REMOTE | [CMake-lib] template to construct URI to download package from remote Package Repository. Passed to URI_TEMPLATE setting variable. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | -| BA_PACKAGE_HTTP_AUTHORIZATION_HEADER | HTTP Authorization header to use when accessing Package Repository. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | +| BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE | When set the BA_PACKAGE_URI_TEMPLATE_REMOTE represents a Git repository URI which forces `git clone --archive` to be used to download depdencies instead of HTTP download. It is [CMake-lib] template to construct the git archive path. Passed to GIT_PATH_TEMPLATE setting variable. If set the BA_PACKAGE_URI_TEMPLATE_REMOTE shall point to the Git repository and BA_PACKAGE_URI_REVISION is used as Git revision. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | +| BA_PACKAGE_HTTP_HEADER | HTTP header to use when accessing Package Repository. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | +| BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE | If set to ON, template argument values (REVISION, GIT_PATH, PACKAGE_GROUP_NAME, ARCHIVE_NAME) are percent-encoded before URI template expansion. Used if BA_PACKAGE_LOCAL_USE is set to OFF. | ## Environment Variables diff --git a/doc/MigrationGuide.md b/doc/MigrationGuide_0_to_1.md similarity index 100% rename from doc/MigrationGuide.md rename to doc/MigrationGuide_0_to_1.md diff --git a/doc/MigrationGuide_1_to_2.md b/doc/MigrationGuide_1_to_2.md new file mode 100644 index 0000000..d6c2d65 --- /dev/null +++ b/doc/MigrationGuide_1_to_2.md @@ -0,0 +1,74 @@ + +# Package Tracker Migration Guide - v1 to v2 + +It describes how to migrate CMake projects for use with Package Tracker `v2.0.0`. + + + +## Changes + +- `BA_PACKAGE_HTTP_AUTHORIZATION_HEADER` CMCONF variable renamed to `BA_PACKAGE_HTTP_HEADER`. + The value must now contain the full HTTP header (e.g. `Authorization: token `) instead of just the token part. + Package Tracker no longer prepends `Authorization: ` automatically. +- New required CMCONF variables (must be defined even if empty/OFF): + - `BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE` — [CMake-lib] template to construct the git archive path. + - `BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE` — if ON, template argument values are percent-encoded before URI expansion. + - `BA_PACKAGE_HTTP_HEADER` — full HTTP header for accessing Package Repository. + +## Use Old Version + +To use old version of Package Tracker without the v2 changes, manually set Package Tracker revision to `v1.0.2` in [CMLibStorage.cmake]: + +```cmake +SET(STORAGE_LIST_DEP_REVISION "v1.0.2") +``` + +## Migration Steps + +Steps: + +- Update [cmakelib] to version v1.3.3 +- Rename `BA_PACKAGE_HTTP_AUTHORIZATION_HEADER` to `BA_PACKAGE_HTTP_HEADER` in the CMCONF Config file. + +- If HTTP Header is used, prepend `Authorization: ` to the value: + ```cmake + # v1 + CMCONF_SET(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER "token ") + # v2 + CMCONF_SET(BA_PACKAGE_HTTP_HEADER "Authorization: token ") + ``` + +- Add new required CMCONF variables to the CMCONF Config file: + + ```cmake + CMCONF_SET(BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") + CMCONF_SET(BA_PACKAGE_HTTP_HEADER "") + CMCONF_SET(BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + ``` + +- Clean all CMake caches and reconfigure the CMake project. + +Full CMCONF Config example for v2: + +```cmake +FIND_PACKAGE(CMLIB REQUIRED COMPONENTS CMCONF) +CMCONF_INIT_SYSTEM() + +CMCONF_SET(BA_PACKAGE_LOCAL_USE OFF) +CMCONF_SET(BA_PACKAGE_LOCAL_PATH "") + +CMCONF_SET(BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") +CMCONF_SET(BA_PACKAGE_HTTP_HEADER "") +CMCONF_SET(BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) +CMCONF_SET(BA_PACKAGE_URI_REVISION main) +CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitea.example.com/username/repository/media//package///") +``` + +Examples for different Package Repository hosting services and authentication methods can be found in [example/], [example-project] and [example-context] + + +[CMLibStorage.cmake]: ../example/CMLibStorage.cmake +[example/]: ../example/ +[cmakelib]: https://github.com/cmakelib/cmakelib +[example-project]: https://github.com/bacpack-system/example-project +[example-context]: https://github.com/bacpack-system/example-context \ No newline at end of file diff --git a/example/config/CMCONF_EXAMPLEConfig.cmake b/example/config/CMCONF_EXAMPLEConfig.cmake index c6ff21e..8957c34 100644 --- a/example/config/CMCONF_EXAMPLEConfig.cmake +++ b/example/config/CMCONF_EXAMPLEConfig.cmake @@ -13,12 +13,12 @@ CMCONF_INIT_SYSTEM(EXAMPLE) CMCONF_SET(BA_PACKAGE_LOCAL_USE OFF) CMCONF_SET(BA_PACKAGE_LOCAL_PATH "") -INCLUDE("${CMAKE_CURRENT_LIST_DIR}/credentials.cmake") -CMCONF_SET(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER "${credentials}") - # # It works for a publicly accessible repository. # +CMCONF_SET(BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") +CMCONF_SET(BA_PACKAGE_HTTP_HEADER "") +CMCONF_SET(BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) CMCONF_SET(BA_PACKAGE_URI_REVISION main) CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitea.example.com/username/repository/media//package///") @@ -31,11 +31,14 @@ CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitea.example.com/username/re # Gitea hosted private Package Repository. # Do not forget to specify Access Token # -#CMCONF_SET(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER "token ") +#CMCONF_SET(BA_PACKAGE_HTTP_HEADER "Authorization: token ") #CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitea.example.com/username/repository/raw//package///") # # Gitlab hosted private Package Repository. +# gitlab_project_id is the id of the project in Gitlab. It can be found in General setting page of the project # -#CMCONF_SET(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER "Bearer ") -#CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitlab.example.com/username/repository/-/raw//package///") \ No newline at end of file +#SET(gitlab_project_id 000) +#CMCONF_SET(BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE ON) +#CMCONF_SET(BA_PACKAGE_HTTP_HEADER "PRIVATE-TOKEN: $ENV{GITLAB_TOKEN}") +#CMCONF_SET(BA_PACKAGE_URI_TEMPLATE_REMOTE "https://gitlab.example.com/api/v4/projects/${gitlab_project_id}/repository/files/package%2F%2F%2F/raw?ref=&lfs=true") \ No newline at end of file diff --git a/helpers/BA_PACKAGE_PREREQ.cmake b/helpers/BA_PACKAGE_PREREQ.cmake index 973ba4e..8e9b094 100644 --- a/helpers/BA_PACKAGE_PREREQ.cmake +++ b/helpers/BA_PACKAGE_PREREQ.cmake @@ -37,7 +37,7 @@ ENDFUNCTION() # // variable name to receive the revision (parent scope) # ) # -FUNCTION(BA_PACKAGE_PREREQ_CMCONF_INIT template_output_var revision_output_var) +FUNCTION(BA_PACKAGE_PREREQ_CMCONF_INIT template_output_var revision_output_var git_archive_path_template_output_var http_header_output_var template_args_uri_escape_output_var) # # Let's get variables to ensure they are defined # By a Global Config for their appropriate use... @@ -46,20 +46,24 @@ FUNCTION(BA_PACKAGE_PREREQ_CMCONF_INIT template_output_var revision_output_var) IF(BA_PACKAGE_LOCAL_USE) CMCONF_GET(BA_PACKAGE_LOCAL_PATH) ELSE() - CMCONF_GET(BA_PACKAGE_HTTP_AUTHORIZATION_HEADER) + CMCONF_GET(BA_PACKAGE_HTTP_HEADER) CMCONF_GET(BA_PACKAGE_URI_REVISION) + CMCONF_GET(BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE) CMCONF_GET(BA_PACKAGE_URI_TEMPLATE_REMOTE) + CMCONF_GET(BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE) ENDIF() SET(template) SET(revision) + SET(git_archive_path) + SET(http_header) + SET(template_args_uri_escape) IF(DEFINED ENV{BA_PACKAGE_LOCAL_PATH}) IF(BA_PACKAGE_LOCAL_USE) MESSAGE(WARNING "BA_PACKAGE_LOCAL_PATH ENV variable is defined and BA_PACKAGE_LOCAL_USE is ON. Using BA_PACKAGE_LOCAL_PATH ENV variable to set as Repository path") ENDIF() BA_PACKAGE_PREREQ_LOCAL_PATH_CHECK("$ENV{BA_PACKAGE_LOCAL_PATH}") SET(template "file://$ENV{BA_PACKAGE_LOCAL_PATH}/package///") - SET(revision "") ELSE() IF(BA_PACKAGE_LOCAL_USE) BA_PACKAGE_PREREQ_LOCAL_PATH_CHECK("${BA_PACKAGE_LOCAL_PATH}") @@ -67,13 +71,24 @@ FUNCTION(BA_PACKAGE_PREREQ_CMCONF_INIT template_output_var revision_output_var) ELSE() SET(template "${BA_PACKAGE_URI_TEMPLATE_REMOTE}") SET(revision "${BA_PACKAGE_URI_REVISION}") + SET(git_archive_path "${BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE}") + SET(http_header "${BA_PACKAGE_HTTP_HEADER}") + SET(template_args_uri_escape "${BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE}") ENDIF() ENDIF() + # unreachable, but for clarity... IF(revision AND (BA_PACKAGE_LOCAL_USE OR DEFINED ENV{BA_PACKAGE_LOCAL_PATH})) MESSAGE(WARNING "Revision is defined but local repository is used.") ENDIF() + + IF(BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE AND BA_PACKAGE_HTTP_HEADER) + MESSAGE(WARNING "BA_PACKAGE_HTTP_HEADER is defined together with BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE. ARCHIVE_PATH_TEMPLATE implies the URI type is GIT but HTTP_HEADERS are used only for raw HTTP Downloads!") + ENDIF() SET(${template_output_var} "${template}" PARENT_SCOPE) SET(${revision_output_var} "${revision}" PARENT_SCOPE) + SET(${git_archive_path_template_output_var} "${git_archive_path}" PARENT_SCOPE) + SET(${http_header_output_var} "${http_header}" PARENT_SCOPE) + SET(${template_args_uri_escape_output_var} "${template_args_uri_escape}" PARENT_SCOPE) ENDFUNCTION() \ No newline at end of file diff --git a/integration_tests/BA_PACKAGE/CMakeLists.txt b/integration_tests/BA_PACKAGE/CMakeLists.txt new file mode 100644 index 0000000..6485bab --- /dev/null +++ b/integration_tests/BA_PACKAGE/CMakeLists.txt @@ -0,0 +1,35 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(BA_PACKAGE_TEST) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../TEST.cmake") + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/release_basic") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/debug_keyword") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/debug_suffix_applied") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/no_debug_skips_keyword") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/git_path_template_args") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/no_git_args_without_template") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/cache_only_skips_dependency") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/escape_template_args_applied") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/escape_template_args_not_applied") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/git_path_template_with_escape") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/output_var_set") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/archive_type_zip") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/empty_revision") + +#TEST_RUN_AND_CHECK_OUTPUT("package_name_dash_warning" +# WARNING_MESSAGE "Package name.*contains invalid characters.*normalized" +#) + +TEST_INVALID_CMAKE_RUN("${CMAKE_CURRENT_LIST_DIR}/invalid_package_name_error" + "Invalid package name" +) + +TEST_INVALID_CMAKE_RUN("${CMAKE_CURRENT_LIST_DIR}/cache_only_not_found_error" + "Package not found" +) + diff --git a/integration_tests/BA_PACKAGE/archive_type_zip/CMakeLists.txt b/integration_tests/BA_PACKAGE/archive_type_zip/CMakeLists.txt new file mode 100644 index 0000000..8dc0016 --- /dev/null +++ b/integration_tests/BA_PACKAGE/archive_type_zip/CMakeLists.txt @@ -0,0 +1,24 @@ +## +# Test: ARCHIVE_TYPE=ZIP is passed to CMLIB_DEPENDENCY +# +# Verifies that BA_PACKAGE passes ARCHIVE_TYPE ZIP to CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_ARCHIVE_TYPE_ZIP) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE "ZIP") + diff --git a/integration_tests/BA_PACKAGE/cache_only_not_found_error/CMakeLists.txt b/integration_tests/BA_PACKAGE/cache_only_not_found_error/CMakeLists.txt new file mode 100644 index 0000000..4d6c3bd --- /dev/null +++ b/integration_tests/BA_PACKAGE/cache_only_not_found_error/CMakeLists.txt @@ -0,0 +1,24 @@ +## +# Test: CACHE_ONLY=ON with missing package emits FATAL_ERROR +# +# Verifies that BA_PACKAGE with CACHE_ONLY=ON emits FATAL_ERROR +# when the package is not found in the cache (CMLIB_CACHE_GET returns empty). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_CACHE_ONLY_NOT_FOUND_ERROR) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_CACHE.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path CACHE_ONLY ON) + diff --git a/integration_tests/BA_PACKAGE/cache_only_skips_dependency/CMakeLists.txt b/integration_tests/BA_PACKAGE/cache_only_skips_dependency/CMakeLists.txt new file mode 100644 index 0000000..a100005 --- /dev/null +++ b/integration_tests/BA_PACKAGE/cache_only_skips_dependency/CMakeLists.txt @@ -0,0 +1,27 @@ +## +# Test: CACHE_ONLY=ON uses CMLIB_CACHE_GET instead of CMLIB_DEPENDENCY +# +# Verifies that BA_PACKAGE with CACHE_ONLY=ON calls CMLIB_CACHE_GET +# and does not call CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_CACHE_ONLY_SKIPS_DEPENDENCY) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "/mock/cached/path" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_CACHE.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path CACHE_ONLY ON) + +TEST_VAR_TRUE(MOCK_CMLIB_CACHE_GET_CALLED) +TEST_VAR_FALSE(MOCK_CMLIB_DEPENDENCY_CALLED) + diff --git a/integration_tests/BA_PACKAGE/debug_keyword/CMakeLists.txt b/integration_tests/BA_PACKAGE/debug_keyword/CMakeLists.txt new file mode 100644 index 0000000..c89de8c --- /dev/null +++ b/integration_tests/BA_PACKAGE/debug_keyword/CMakeLists.txt @@ -0,0 +1,29 @@ +## +# Test: Debug build adds DEBUG keyword +# +# Verifies that BA_PACKAGE in Debug mode adds the DEBUG keyword +# to CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_DEBUG_KEYWORD) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "DEBUG" idx_debug) +IF(idx_debug EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS missing DEBUG: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE/debug_suffix_applied/CMakeLists.txt b/integration_tests/BA_PACKAGE/debug_suffix_applied/CMakeLists.txt new file mode 100644 index 0000000..a4a7125 --- /dev/null +++ b/integration_tests/BA_PACKAGE/debug_suffix_applied/CMakeLists.txt @@ -0,0 +1,29 @@ +## +# Test: Prefix and suffix are applied to the package name +# +# Verifies that BA_PACKAGE constructs the expanded package name as +# prefix + package_name + suffix (e.g., "myprefixmypkgmysuffix"). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_DEBUG_SUFFIX_APPLIED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "myprefix" "mysuffix" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "myprefixmypkgmysuffix" found_expanded) +IF(found_expanded EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should contain 'myprefixmypkgmysuffix': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE/empty_revision/CMakeLists.txt b/integration_tests/BA_PACKAGE/empty_revision/CMakeLists.txt new file mode 100644 index 0000000..2f06202 --- /dev/null +++ b/integration_tests/BA_PACKAGE/empty_revision/CMakeLists.txt @@ -0,0 +1,25 @@ +## +# Test: Empty REVISION means no REVISION arg passed to template expansion +# +# Verifies that BA_PACKAGE does not pass REVISION to +# CMLIB_STORAGE_TEMPLATE_INSTANCE when REVISION is empty. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_EMPTY_REVISION) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com///") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION "") + diff --git a/integration_tests/BA_PACKAGE/escape_template_args_applied/CMakeLists.txt b/integration_tests/BA_PACKAGE/escape_template_args_applied/CMakeLists.txt new file mode 100644 index 0000000..99625fc --- /dev/null +++ b/integration_tests/BA_PACKAGE/escape_template_args_applied/CMakeLists.txt @@ -0,0 +1,27 @@ +## ESCAPE_TEMPLATE_ARGS=ON replaces "/" with "%2F" in template arguments +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_ESCAPE_TEMPLATE_ARGS_APPLIED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "refs/heads/main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") +BA_PACKAGE_VARS_SET(ESCAPE_TEMPLATE_ARGS ON) + +# "my+pkg" is used for test purposes only — package_name cannot normally contain "+" +BA_PACKAGE(my+pkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VALUE "https://example.com////") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION "refs%2Fheads%2Fmain") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_GIT_PATH "mock_distro%2F0.0.0%2Fmock_arch") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME "my%2Bpkg") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME "my%2Bpkg_v1.0.0_mock_arch_mock_distro_0.0.0.zip") + diff --git a/integration_tests/BA_PACKAGE/escape_template_args_not_applied/CMakeLists.txt b/integration_tests/BA_PACKAGE/escape_template_args_not_applied/CMakeLists.txt new file mode 100644 index 0000000..7318fca --- /dev/null +++ b/integration_tests/BA_PACKAGE/escape_template_args_not_applied/CMakeLists.txt @@ -0,0 +1,27 @@ +## ESCAPE_TEMPLATE_ARGS=OFF keeps "/" unchanged in template arguments +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_ESCAPE_TEMPLATE_ARGS_NOT_APPLIED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "refs/heads/main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") +BA_PACKAGE_VARS_SET(ESCAPE_TEMPLATE_ARGS OFF) + +# "my+pkg" is used for test purposes only — package_name cannot normally contain "+" +BA_PACKAGE(my+pkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VALUE "https://example.com////") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION "refs/heads/main") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_GIT_PATH "mock_distro/0.0.0/mock_arch") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME "my+pkg") +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME "my+pkg_v1.0.0_mock_arch_mock_distro_0.0.0.zip") + diff --git a/integration_tests/BA_PACKAGE/git_path_template_args/CMakeLists.txt b/integration_tests/BA_PACKAGE/git_path_template_args/CMakeLists.txt new file mode 100644 index 0000000..2fbe123 --- /dev/null +++ b/integration_tests/BA_PACKAGE/git_path_template_args/CMakeLists.txt @@ -0,0 +1,33 @@ +## +# Test: GIT_PATH_TEMPLATE defined passes GIT_REVISION and GIT_PATH to CMLIB_DEPENDENCY +# +# Verifies that when GIT_PATH_TEMPLATE is set, BA_PACKAGE passes +# GIT_REVISION and GIT_PATH arguments to CMLIB_DEPENDENCY for git-based downloads. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_GIT_PATH_TEMPLATE_ARGS) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT "package/mock_distro/0.0.0/mock_arch/mypkg/mypkg_v1.0.0.zip" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "git@github.com:org/repo.git") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "package///") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +IF(NOT MOCK_CMLIB_DEPENDENCY_GIT_REVISION) + MESSAGE(FATAL_ERROR "GIT_REVISION should be set when GIT_PATH_TEMPLATE is defined") +ENDIF() + +IF(NOT MOCK_CMLIB_DEPENDENCY_GIT_PATH) + MESSAGE(FATAL_ERROR "GIT_PATH should be set when GIT_PATH_TEMPLATE is defined") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE/git_path_template_with_escape/CMakeLists.txt b/integration_tests/BA_PACKAGE/git_path_template_with_escape/CMakeLists.txt new file mode 100644 index 0000000..038c90d --- /dev/null +++ b/integration_tests/BA_PACKAGE/git_path_template_with_escape/CMakeLists.txt @@ -0,0 +1,30 @@ +## +# Test: GIT_PATH_TEMPLATE + ESCAPE_TEMPLATE_ARGS=ON encodes template args but not GIT_REVISION +# +# Verifies that when both GIT_PATH_TEMPLATE and ESCAPE_TEMPLATE_ARGS are set, +# CMLIB_STORAGE_TEMPLATE_INSTANCE receives encoded args while +# CMLIB_DEPENDENCY GIT_REVISION stays unencoded (raw git ref). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_GIT_PATH_TEMPLATE_WITH_ESCAPE) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT "package/mock_distro/0.0.0/mock_arch/mypkg/mypkg_v1.0.0.zip" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "refs/heads/main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "git@github.com:org/repo.git") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "package///") +BA_PACKAGE_VARS_SET(ESCAPE_TEMPLATE_ARGS ON) + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +# Template args must be encoded +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION "refs%2Fheads%2Fmain") + +# GIT_REVISION for CMLIB_DEPENDENCY must stay unencoded (raw git ref) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_DEPENDENCY_GIT_REVISION "refs/heads/main") diff --git a/integration_tests/BA_PACKAGE/invalid_package_name_error/CMakeLists.txt b/integration_tests/BA_PACKAGE/invalid_package_name_error/CMakeLists.txt new file mode 100644 index 0000000..bdf5b55 --- /dev/null +++ b/integration_tests/BA_PACKAGE/invalid_package_name_error/CMakeLists.txt @@ -0,0 +1,22 @@ +## +# Test: Invalid package name (all special characters) emits FATAL_ERROR +# +# Verifies that BA_PACKAGE emits FATAL_ERROR when the package name +# normalizes to an empty string (e.g., "---" becomes ""). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_INVALID_PACKAGE_NAME_ERROR) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE("---" v1.0.0 "" "" output_path) + diff --git a/integration_tests/BA_PACKAGE/no_debug_skips_keyword/CMakeLists.txt b/integration_tests/BA_PACKAGE/no_debug_skips_keyword/CMakeLists.txt new file mode 100644 index 0000000..447e81c --- /dev/null +++ b/integration_tests/BA_PACKAGE/no_debug_skips_keyword/CMakeLists.txt @@ -0,0 +1,34 @@ +## +# Test: NO_DEBUG=ON suppresses DEBUG and RELEASE keywords +# +# Verifies that BA_PACKAGE with NO_DEBUG=ON does not add DEBUG or RELEASE +# keywords to CMLIB_DEPENDENCY even in Debug build mode. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_NO_DEBUG_SKIPS_KEYWORD) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path NO_DEBUG ON) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "DEBUG" idx_debug) +IF(NOT idx_debug EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain DEBUG when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "RELEASE" idx_release) +IF(NOT idx_release EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain RELEASE when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE/no_git_args_without_template/CMakeLists.txt b/integration_tests/BA_PACKAGE/no_git_args_without_template/CMakeLists.txt new file mode 100644 index 0000000..9b72e94 --- /dev/null +++ b/integration_tests/BA_PACKAGE/no_git_args_without_template/CMakeLists.txt @@ -0,0 +1,32 @@ +## +# Test: Empty GIT_PATH_TEMPLATE does not pass GIT_REVISION or GIT_PATH +# +# Verifies that when GIT_PATH_TEMPLATE is empty, BA_PACKAGE does not pass +# GIT_REVISION or GIT_PATH arguments to CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_NO_GIT_ARGS_WITHOUT_TEMPLATE) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +IF(MOCK_CMLIB_DEPENDENCY_GIT_REVISION) + MESSAGE(FATAL_ERROR "GIT_REVISION should NOT be set when GIT_PATH_TEMPLATE is empty: ${MOCK_CMLIB_DEPENDENCY_GIT_REVISION}") +ENDIF() + +IF(MOCK_CMLIB_DEPENDENCY_GIT_PATH) + MESSAGE(FATAL_ERROR "GIT_PATH should NOT be set when GIT_PATH_TEMPLATE is empty: ${MOCK_CMLIB_DEPENDENCY_GIT_PATH}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE/output_var_set/CMakeLists.txt b/integration_tests/BA_PACKAGE/output_var_set/CMakeLists.txt new file mode 100644 index 0000000..1953a87 --- /dev/null +++ b/integration_tests/BA_PACKAGE/output_var_set/CMakeLists.txt @@ -0,0 +1,25 @@ +## +# Test: output_var is set to the cache path returned by CMLIB_DEPENDENCY +# +# Verifies that BA_PACKAGE sets the output_var to the path returned +# by CMLIB_DEPENDENCY's OUTPUT_PATH_VAR. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_OUTPUT_VAR_SET) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_DEFINED(output_path) +TEST_VAR_EQUALS_LITERAL(output_path "/mock/cache/path") + diff --git a/integration_tests/BA_PACKAGE/package_name_dash_warning/CMakeLists.txt b/integration_tests/BA_PACKAGE/package_name_dash_warning/CMakeLists.txt new file mode 100644 index 0000000..f8716d4 --- /dev/null +++ b/integration_tests/BA_PACKAGE/package_name_dash_warning/CMakeLists.txt @@ -0,0 +1,24 @@ +## +# Test: Package name with dashes emits normalization warning +# +# Verifies that BA_PACKAGE emits a WARNING when the package name +# contains invalid characters (like dashes) that are normalized for CMLIB keywords. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_PACKAGE_NAME_DASH_WARNING) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(my-pkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + diff --git a/integration_tests/BA_PACKAGE/release_basic/CMakeLists.txt b/integration_tests/BA_PACKAGE/release_basic/CMakeLists.txt new file mode 100644 index 0000000..78786f9 --- /dev/null +++ b/integration_tests/BA_PACKAGE/release_basic/CMakeLists.txt @@ -0,0 +1,38 @@ +## +# Test: Release build sets BACPACK, package name, and RELEASE keywords +# +# Verifies that BA_PACKAGE in Release mode adds BACPACK, normalized package +# name, and RELEASE keywords to CMLIB_DEPENDENCY with TYPE=ARCHIVE. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_RELEASE_BASIC) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE(mypkg v1.0.0 "" "" output_path) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) +TEST_VAR_EQUALS_LITERAL(MOCK_CMLIB_DEPENDENCY_TYPE "ARCHIVE") + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "BACPACK" idx_bacpack) +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "MYPKG" idx_pkg) +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "RELEASE" idx_release) +IF(idx_bacpack EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS missing BACPACK: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() +IF(idx_pkg EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS missing MYPKG: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() +IF(idx_release EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS missing RELEASE: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/CMakeLists.txt new file mode 100644 index 0000000..a39aa0b --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/CMakeLists.txt @@ -0,0 +1,16 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(BA_PACKAGE_EXECUTABLE_TEST) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../TEST.cmake") + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/release_basic") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/debug_suffix") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/no_debug_skips_suffix") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/output_path_var_propagates") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/cmake_prefix_path_updated") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/cache_only_forwarding") + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/cache_only_forwarding/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/cache_only_forwarding/CMakeLists.txt new file mode 100644 index 0000000..8e0d7eb --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/cache_only_forwarding/CMakeLists.txt @@ -0,0 +1,27 @@ +## +# Test: CACHE_ONLY=ON is forwarded to BA_PACKAGE +# +# Verifies that BA_PACKAGE_EXECUTABLE with CACHE_ONLY=ON calls CMLIB_CACHE_GET +# and does not call CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_EXEC_CACHE_ONLY_FORWARDING) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "/mock/cached/path" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_CACHE.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0 CACHE_ONLY ON) + +TEST_VAR_TRUE(MOCK_CMLIB_CACHE_GET_CALLED) +TEST_VAR_FALSE(MOCK_CMLIB_DEPENDENCY_CALLED) + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/cmake_prefix_path_updated/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/cmake_prefix_path_updated/CMakeLists.txt new file mode 100644 index 0000000..6695318 --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/cmake_prefix_path_updated/CMakeLists.txt @@ -0,0 +1,29 @@ +## +# Test: CMAKE_PREFIX_PATH is updated with the cached package path +# +# Verifies that BA_PACKAGE_EXECUTABLE appends the package path to CMAKE_PREFIX_PATH +# so that find_package() can locate the installed package. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_EXECUTABLE_CMAKE_PREFIX_PATH_UPDATED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +SET(CMAKE_PREFIX_PATH "") + +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0) + +LIST(FIND CMAKE_PREFIX_PATH "/mock/cache/path" idx_found) +IF(idx_found EQUAL -1) + MESSAGE(FATAL_ERROR "CMAKE_PREFIX_PATH should contain /mock/cache/path: ${CMAKE_PREFIX_PATH}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/debug_suffix/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/debug_suffix/CMakeLists.txt new file mode 100644 index 0000000..86e78a1 --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/debug_suffix/CMakeLists.txt @@ -0,0 +1,40 @@ +## +# Test: Debug build adds only 'd' suffix for executable package (no '-dev') +# +# Verifies that BA_PACKAGE_EXECUTABLE in Debug mode produces a URI with 'd' suffix +# but without "lib" prefix and without "-dev" (e.g., mypkgd_v1.0.0 not libmypkgd-dev_v1.0.0). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_EXEC_DEBUG_SUFFIX) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +# Make sure the mypkg does not contain any keywords tested below +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "mypkgd_v1.0.0" found_debug_suffix) +IF(found_debug_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'mypkgd_v1.0.0': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "lib" found_lib) +IF(NOT found_lib EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should not contain 'lib': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "-dev" found_dev) +IF(NOT found_dev EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should not contain '-dev': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/no_debug_skips_suffix/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/no_debug_skips_suffix/CMakeLists.txt new file mode 100644 index 0000000..b622a91 --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/no_debug_skips_suffix/CMakeLists.txt @@ -0,0 +1,44 @@ +## +# Test: NO_DEBUG=ON skips debug suffix and build type keywords for executable +# +# Verifies that BA_PACKAGE_EXECUTABLE with NO_DEBUG=ON does not add DEBUG/RELEASE +# keywords and does not append 'd' suffix even in Debug build mode. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_EXEC_NO_DEBUG_SKIPS_SUFFIX) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0 NO_DEBUG ON) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "mypkgd" found_debug_suffix) +IF(NOT found_debug_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should NOT contain 'mypkgd' when NO_DEBUG=ON: ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "mypkg_v1.0.0" found_plain) +IF(found_plain EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'mypkg_v1.0.0': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "DEBUG" idx_debug) +IF(NOT idx_debug EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain DEBUG when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "RELEASE" idx_release) +IF(NOT idx_release EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain RELEASE when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/output_path_var_propagates/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/output_path_var_propagates/CMakeLists.txt new file mode 100644 index 0000000..892d021 --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/output_path_var_propagates/CMakeLists.txt @@ -0,0 +1,25 @@ +## +# Test: OUTPUT_PATH_VAR returns the cached package path +# +# Verifies that BA_PACKAGE_EXECUTABLE with OUTPUT_PATH_VAR parameter sets the +# specified variable to the path returned by CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_BA_PACKAGE_EXECUTABLE_OUTPUT_PATH_VAR_PROPAGATES) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0 OUTPUT_PATH_VAR my_output_path) + +TEST_VAR_DEFINED(my_output_path) +TEST_VAR_EQUALS_LITERAL(my_output_path "/mock/cache/path") + diff --git a/integration_tests/BA_PACKAGE_EXECUTABLE/release_basic/CMakeLists.txt b/integration_tests/BA_PACKAGE_EXECUTABLE/release_basic/CMakeLists.txt new file mode 100644 index 0000000..b70e0ea --- /dev/null +++ b/integration_tests/BA_PACKAGE_EXECUTABLE/release_basic/CMakeLists.txt @@ -0,0 +1,40 @@ +## +# Test: Release build uses empty prefix and empty suffix for executable package +# +# Verifies that BA_PACKAGE_EXECUTABLE in Release mode produces a URI without +# "lib" prefix and without "-dev" suffix (e.g., mypkg_v1.0.0 not libmypkg-dev_v1.0.0). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_EXEC_RELEASE_BASIC) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +# Make sure the mypkg does not contain any keywords tested below +BA_PACKAGE_EXECUTABLE(mypkg v1.0.0) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "mypkg_v1.0.0" found_pkg) +IF(found_pkg EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'mypkg_v1.0.0': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "lib" found_lib) +IF(NOT found_lib EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should not contain 'lib': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "-dev" found_dev) +IF(NOT found_dev EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should not contain '-dev': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/CMakeLists.txt new file mode 100644 index 0000000..5f0a620 --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/CMakeLists.txt @@ -0,0 +1,16 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(BA_PACKAGE_LIBRARY_TEST) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../TEST.cmake") + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/release_basic") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/debug_suffix") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/no_debug_skips_suffix") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/output_path_var_propagates") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/cmake_prefix_path_updated") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/cache_only_forwarding") + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/cache_only_forwarding/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/cache_only_forwarding/CMakeLists.txt new file mode 100644 index 0000000..61eb296 --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/cache_only_forwarding/CMakeLists.txt @@ -0,0 +1,27 @@ +## +# Test: CACHE_ONLY=ON is forwarded to BA_PACKAGE +# +# Verifies that BA_PACKAGE_LIBRARY with CACHE_ONLY=ON calls CMLIB_CACHE_GET +# and does not call CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_LIB_CACHE_ONLY_FORWARDING) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "/mock/cached/path" CACHE INTERNAL "") +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_CACHE.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0 CACHE_ONLY ON) + +TEST_VAR_TRUE(MOCK_CMLIB_CACHE_GET_CALLED) +TEST_VAR_FALSE(MOCK_CMLIB_DEPENDENCY_CALLED) + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/cmake_prefix_path_updated/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/cmake_prefix_path_updated/CMakeLists.txt new file mode 100644 index 0000000..6b10635 --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/cmake_prefix_path_updated/CMakeLists.txt @@ -0,0 +1,29 @@ +## +# Test: CMAKE_PREFIX_PATH is updated with the cached package path +# +# Verifies that BA_PACKAGE_LIBRARY appends the package path to CMAKE_PREFIX_PATH +# so that find_package() can locate the installed package. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_CMAKE_PREFIX_PATH_UPDATED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +SET(CMAKE_PREFIX_PATH "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0) + +LIST(FIND CMAKE_PREFIX_PATH "/mock/cache/path" idx_found) +IF(idx_found EQUAL -1) + MESSAGE(FATAL_ERROR "CMAKE_PREFIX_PATH should contain /mock/cache/path: ${CMAKE_PREFIX_PATH}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/debug_suffix/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/debug_suffix/CMakeLists.txt new file mode 100644 index 0000000..87d9903 --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/debug_suffix/CMakeLists.txt @@ -0,0 +1,29 @@ +## +# Test: Debug build adds 'd' suffix to package name and DEBUG keyword +# +# Verifies that BA_PACKAGE_LIBRARY in Debug mode adds DEBUG keyword and +# appends 'd' suffix to the package name in the URI (e.g., libmypkgd-dev). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_DEBUG_SUFFIX) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "libmypkgd-dev" found_debug_suffix) +IF(found_debug_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'libmypkgd-dev': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/no_debug_skips_suffix/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/no_debug_skips_suffix/CMakeLists.txt new file mode 100644 index 0000000..e43833e --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/no_debug_skips_suffix/CMakeLists.txt @@ -0,0 +1,44 @@ +## +# Test: NO_DEBUG=ON skips debug suffix and build type keywords +# +# Verifies that BA_PACKAGE_LIBRARY with NO_DEBUG=ON does not add DEBUG/RELEASE +# keywords and does not append 'd' suffix even in Debug build mode. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_NO_DEBUG_SKIPS_SUFFIX) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Debug") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0 NO_DEBUG ON) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "libmypkgd-dev" found_debug_suffix) +IF(NOT found_debug_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should NOT contain 'libmypkgd-dev' when NO_DEBUG=ON: ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "libmypkg-dev" found_release_suffix) +IF(found_release_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'libmypkg-dev': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "RELEASE" idx_release) +IF(NOT idx_release EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain RELEASE when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + +LIST(FIND MOCK_CMLIB_DEPENDENCY_KEYWORDS "DEBUG" idx_debug) +IF(NOT idx_debug EQUAL -1) + MESSAGE(FATAL_ERROR "KEYWORDS should NOT contain DEBUG when NO_DEBUG=ON: ${MOCK_CMLIB_DEPENDENCY_KEYWORDS}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/output_path_var_propagates/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/output_path_var_propagates/CMakeLists.txt new file mode 100644 index 0000000..966ce3e --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/output_path_var_propagates/CMakeLists.txt @@ -0,0 +1,25 @@ +## +# Test: OUTPUT_PATH_VAR returns the cached package path +# +# Verifies that BA_PACKAGE_LIBRARY with OUTPUT_PATH_VAR parameter sets the +# specified variable to the path returned by CMLIB_DEPENDENCY. +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_OUTPUT_PATH_VAR_PROPAGATES) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0 OUTPUT_PATH_VAR my_output_path) + +TEST_VAR_DEFINED(my_output_path) +TEST_VAR_EQUALS_LITERAL(my_output_path "/mock/cache/path") + diff --git a/integration_tests/BA_PACKAGE_LIBRARY/release_basic/CMakeLists.txt b/integration_tests/BA_PACKAGE_LIBRARY/release_basic/CMakeLists.txt new file mode 100644 index 0000000..6e84f94 --- /dev/null +++ b/integration_tests/BA_PACKAGE_LIBRARY/release_basic/CMakeLists.txt @@ -0,0 +1,34 @@ +## +# Test: Release build uses "lib" prefix and "-dev" suffix for library package +# +# Verifies that BA_PACKAGE_LIBRARY in Release mode produces a URI with +# "lib" prefix and "-dev" suffix (e.g., libmypkg-dev_v1.0.0). +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_LIB_RELEASE_BASIC) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../include_general.cmake") + +SET(CMAKE_BUILD_TYPE "Release") +BA_PACKAGE_VARS_SET(REVISION "main") +BA_PACKAGE_VARS_SET(URI_TEMPLATE "https://example.com////") +BA_PACKAGE_VARS_SET(GIT_PATH_TEMPLATE "") + +BA_PACKAGE_LIBRARY(mypkg v1.0.0) + +TEST_VAR_TRUE(MOCK_CMLIB_DEPENDENCY_CALLED) + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "libmypkg-dev" found_lib_dev) +IF(found_lib_dev EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME does not contain 'libmypkg-dev': ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + +STRING(FIND "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}" "libmypkgd-dev" found_debug_suffix) +IF(NOT found_debug_suffix EQUAL -1) + MESSAGE(FATAL_ERROR "ARCHIVE_NAME should NOT contain 'libmypkgd-dev' in Release: ${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME}") +ENDIF() + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/CMakeLists.txt new file mode 100644 index 0000000..dc829ab --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/CMakeLists.txt @@ -0,0 +1,32 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(BA_PACKAGE_PREREQ_CMCONF_INIT_TEST) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../TEST.cmake") + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/local_use_on") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/local_use_off") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/env_var_precedence") + +TEST_RUN_AND_CHECK_OUTPUT("env_var_with_local_use_warning" + WARNING_MESSAGE "BA_PACKAGE_LOCAL_PATH ENV variable is defined and BA_PACKAGE_LOCAL_USE is.*ON.*Using BA_PACKAGE_LOCAL_PATH ENV variable to set as Repository path" + ALWAYS_SCRIPT_MODE ON +) + +TEST_RUN_AND_CHECK_OUTPUT("git_archive_with_http_header_warning" + WARNING_MESSAGE "BA_PACKAGE_HTTP_HEADER is defined together with.*BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE.*ARCHIVE_PATH_TEMPLATE implies the.*URI type is GIT but HTTP_HEADERS are used only for raw HTTP Downloads" + ALWAYS_SCRIPT_MODE ON +) + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/git_archive_path_returned") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/http_header_returned") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/escape_template_args_on_returned") +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/escape_template_args_off_returned") + +TEST_INVALID_CMAKE_RUN("${CMAKE_CURRENT_LIST_DIR}/invalid_local_path" + "Local repository path variable is not a directory" +) + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_precedence/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_precedence/CMakeLists.txt new file mode 100644 index 0000000..c0a7c9d --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_precedence/CMakeLists.txt @@ -0,0 +1,34 @@ +## ENV{BA_PACKAGE_LOCAL_PATH} takes precedence over BA_PACKAGE_LOCAL_USE=OFF +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_ENV_VAR_PRECEDENCE) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "v1.0.0") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com/packages/") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +SET(ENV{BA_PACKAGE_LOCAL_PATH} "/tmp") + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +TEST_VAR_EQUALS_LITERAL(result_template "file:///tmp/package///") +TEST_VAR_EQUALS_LITERAL(result_revision "") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "") +TEST_VAR_EQUALS_LITERAL(result_http_header "") +TEST_VAR_EQUALS_LITERAL(result_escape "") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_with_local_use_warning/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_with_local_use_warning/CMakeLists.txt new file mode 100644 index 0000000..859acb9 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/env_var_with_local_use_warning/CMakeLists.txt @@ -0,0 +1,30 @@ +## Warning emitted when both BA_PACKAGE_LOCAL_USE=ON and ENV{BA_PACKAGE_LOCAL_PATH} are set +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_ENV_VAR_WITH_LOCAL_USE_WARNING) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE ON) +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_PATH "/tmp") + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +SET(ENV{BA_PACKAGE_LOCAL_PATH} "/tmp") + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +TEST_VAR_EQUALS_LITERAL(result_template "file:///tmp/package///") +TEST_VAR_EQUALS_LITERAL(result_revision "") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "") +TEST_VAR_EQUALS_LITERAL(result_http_header "") +TEST_VAR_EQUALS_LITERAL(result_escape "") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_off_returned/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_off_returned/CMakeLists.txt new file mode 100644 index 0000000..7b0bc01 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_off_returned/CMakeLists.txt @@ -0,0 +1,32 @@ +## BA_PACKAGE_LOCAL_USE=OFF with TEMPLATE_ARGS_URI_ESCAPE=OFF returns OFF +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_ESCAPE_TEMPLATE_ARGS_OFF_RETURNED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "Authorization: Bearer token/with/slashes") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "refs/heads/main") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com////") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "packages///") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com////") +TEST_VAR_EQUALS_LITERAL(result_revision "refs/heads/main") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "packages///") +TEST_VAR_EQUALS_LITERAL(result_http_header "Authorization: Bearer token/with/slashes") +TEST_VAR_EQUALS_LITERAL(result_escape "OFF") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_on_returned/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_on_returned/CMakeLists.txt new file mode 100644 index 0000000..f3b80b4 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/escape_template_args_on_returned/CMakeLists.txt @@ -0,0 +1,32 @@ +## BA_PACKAGE_LOCAL_USE=OFF with TEMPLATE_ARGS_URI_ESCAPE=ON returns ON +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_ESCAPE_TEMPLATE_ARGS_ON_RETURNED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "Authorization: Bearer token/with/slashes") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "refs/heads/main") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com////") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "packages///") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE ON) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com////") +TEST_VAR_EQUALS_LITERAL(result_revision "refs/heads/main") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "packages///") +TEST_VAR_EQUALS_LITERAL(result_http_header "Authorization: Bearer token/with/slashes") +TEST_VAR_EQUALS_LITERAL(result_escape "ON") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_path_returned/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_path_returned/CMakeLists.txt new file mode 100644 index 0000000..4831c46 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_path_returned/CMakeLists.txt @@ -0,0 +1,32 @@ +## BA_PACKAGE_LOCAL_USE=OFF returns configured BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_GIT_ARCHIVE_PATH_RETURNED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "v1.0.0") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com/packages/") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "packages///") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com/packages/") +TEST_VAR_EQUALS_LITERAL(result_revision "v1.0.0") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "packages///") +TEST_VAR_EQUALS_LITERAL(result_http_header "") +TEST_VAR_EQUALS_LITERAL(result_escape "OFF") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_with_http_header_warning/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_with_http_header_warning/CMakeLists.txt new file mode 100644 index 0000000..cd7eca6 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/git_archive_with_http_header_warning/CMakeLists.txt @@ -0,0 +1,32 @@ +## Warning when both BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE and BA_PACKAGE_HTTP_HEADER are set +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_GIT_ARCHIVE_WITH_HTTP_HEADER_WARNING) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "Authorization: Bearer token") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "v1.0.0") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com/packages/") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "packages///") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com/packages/") +TEST_VAR_EQUALS_LITERAL(result_revision "v1.0.0") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "packages///") +TEST_VAR_EQUALS_LITERAL(result_http_header "Authorization: Bearer token") +TEST_VAR_EQUALS_LITERAL(result_escape "OFF") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/http_header_returned/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/http_header_returned/CMakeLists.txt new file mode 100644 index 0000000..3da86e9 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/http_header_returned/CMakeLists.txt @@ -0,0 +1,32 @@ +## BA_PACKAGE_LOCAL_USE=OFF returns configured HTTP_HEADER +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_HTTP_HEADER_RETURNED) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "Authorization: Bearer mytoken") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "v1.0.0") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com/packages/") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com/packages/") +TEST_VAR_EQUALS_LITERAL(result_revision "v1.0.0") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "") +TEST_VAR_EQUALS_LITERAL(result_http_header "Authorization: Bearer mytoken") +TEST_VAR_EQUALS_LITERAL(result_escape "OFF") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/invalid_local_path/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/invalid_local_path/CMakeLists.txt new file mode 100644 index 0000000..48e805d --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/invalid_local_path/CMakeLists.txt @@ -0,0 +1,22 @@ +## FATAL_ERROR when BA_PACKAGE_LOCAL_PATH points to non-existent directory +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_INVALID_LOCAL_PATH) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE ON) +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_PATH "/nonexistent/invalid/path/that/does/not/exist") + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_off/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_off/CMakeLists.txt new file mode 100644 index 0000000..25939f5 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_off/CMakeLists.txt @@ -0,0 +1,32 @@ +## BA_PACKAGE_LOCAL_USE=OFF returns remote template and configured revision +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_LOCAL_USE_OFF) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE OFF) +SET(TEST_CMCONF_BA_PACKAGE_HTTP_HEADER "") +SET(TEST_CMCONF_BA_PACKAGE_URI_REVISION "v1.0.0") +SET(TEST_CMCONF_BA_PACKAGE_URI_TEMPLATE_REMOTE "https://example.com/packages/") +SET(TEST_CMCONF_BA_PACKAGE_GIT_ARCHIVE_PATH_TEMPLATE "") +SET(TEST_CMCONF_BA_PACKAGE_TEMPLATE_ARGS_URI_ESCAPE OFF) + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "https://example.com/packages/") +TEST_VAR_EQUALS_LITERAL(result_revision "v1.0.0") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "") +TEST_VAR_EQUALS_LITERAL(result_http_header "") +TEST_VAR_EQUALS_LITERAL(result_escape "OFF") + diff --git a/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_on/CMakeLists.txt b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_on/CMakeLists.txt new file mode 100644 index 0000000..2601828 --- /dev/null +++ b/integration_tests/BA_PACKAGE_PREREQ_CMCONF_INIT/local_use_on/CMakeLists.txt @@ -0,0 +1,28 @@ +## BA_PACKAGE_LOCAL_USE=ON returns local file:// template and empty revision +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_LOCAL_USE_ON) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_USE ON) +SET(TEST_CMCONF_BA_PACKAGE_LOCAL_PATH "/tmp") + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/helpers/BA_PACKAGE_PREREQ.cmake") + +UNSET(ENV{BA_PACKAGE_LOCAL_PATH}) + +BA_PACKAGE_PREREQ_CMCONF_INIT(result_template result_revision result_git_archive_path result_http_header result_escape) + +TEST_VAR_EQUALS_LITERAL(result_template "file:///tmp/package///") +TEST_VAR_EQUALS_LITERAL(result_revision "") +TEST_VAR_EQUALS_LITERAL(result_git_archive_path "") +TEST_VAR_EQUALS_LITERAL(result_http_header "") +TEST_VAR_EQUALS_LITERAL(result_escape "") + diff --git a/integration_tests/CMakeLists.txt b/integration_tests/CMakeLists.txt new file mode 100644 index 0000000..e407aec --- /dev/null +++ b/integration_tests/CMakeLists.txt @@ -0,0 +1,15 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(BA_PACKAGE_TESTS) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/TEST.cmake") + +TEST_RUN("BA_PACKAGE_PREREQ_CMCONF_INIT") +TEST_RUN("BA_PACKAGE") +TEST_RUN("BA_PACKAGE_LIBRARY") +TEST_RUN("BA_PACKAGE_EXECUTABLE") +TEST_RUN("mock/test") + diff --git a/integration_tests/README.md b/integration_tests/README.md new file mode 100644 index 0000000..cfa7459 --- /dev/null +++ b/integration_tests/README.md @@ -0,0 +1,27 @@ +# CMake Unit Tests + +Unit tests for individual CMake modules (BA_PACKAGE_VARS, BA_PACKAGE, BA_PACKAGE_LIBRARY, etc.). + +Tests use mocks to isolate modules from external dependencies (CMLIB, CMDEF, etc.). +Each test is a standalone CMakeLists.txt in its own subdirectory. + +## Run + +From repository root: + +``` +cmake -P integration_tests/CMakeLists.txt +``` + +## Mocks + +See [mock/MOCK_VARIABLES.md] for a detailed description of the mocks and the variables they set. + +## Difference from [test/] + +`cmake_tests/` — unit tests for CMake module logic using mocks, no network or build required. + +[test/] — integration tests that build a real application, install dependencies, and verify installed file structure. + +[test/]: ../test/ +[mock/MOCK_VARIABLES.md]: mock/MOCK_VARIABLES.md diff --git a/integration_tests/TEST.cmake b/integration_tests/TEST.cmake new file mode 100644 index 0000000..b4990d2 --- /dev/null +++ b/integration_tests/TEST.cmake @@ -0,0 +1,8 @@ +FIND_PACKAGE(CMLIB REQUIRED) + +IF(NOT EXISTS "${CMLIB_DIR}") + MESSAGE(FATAL_ERROR "Cannot find CMLIB_DIR '${CMLIB_DIR}'") +ENDIF() + +INCLUDE("${CMLIB_DIR}/test/TEST.cmake") + diff --git a/integration_tests/VARS.cmake b/integration_tests/VARS.cmake new file mode 100644 index 0000000..9aca1d3 --- /dev/null +++ b/integration_tests/VARS.cmake @@ -0,0 +1,9 @@ +# +# Root of the CMake tests directory +# +SET(CMAKE_TESTS_ROOT "${CMAKE_CURRENT_LIST_DIR}") + +# +# Root of the Package Tracker project +# +GET_FILENAME_COMPONENT(PACKAGER_PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/.." ABSOLUTE) \ No newline at end of file diff --git a/integration_tests/include_general.cmake b/integration_tests/include_general.cmake new file mode 100644 index 0000000..9754f87 --- /dev/null +++ b/integration_tests/include_general.cmake @@ -0,0 +1,23 @@ +## +# Common includes for BA_PACKAGE* tests +# +# Provides standard test setup including VARS, TEST framework, BA_PACKAGE modules, +# and all standard mocks (CMDEF_VARS, CMUTIL, CMLIB_STORAGE, CMLIB_DEPENDENCY). +# +# Does NOT include CMLIB_CACHE mock - tests requiring CACHE_ONLY must include it separately. +# +# Note: If test needs custom MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT, +# set it BEFORE including this file. +# + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +INCLUDE("${PACKAGER_PROJECT_ROOT}/BA_PACKAGE_VARS.cmake") +INCLUDE("${PACKAGER_PROJECT_ROOT}/BA_PACKAGE.cmake") + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMDEF_VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMUTIL.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_STORAGE.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMLIB_DEPENDENCY.cmake") + diff --git a/integration_tests/mock/CMCONF.cmake b/integration_tests/mock/CMCONF.cmake new file mode 100644 index 0000000..2ad9aa3 --- /dev/null +++ b/integration_tests/mock/CMCONF.cmake @@ -0,0 +1,15 @@ +## +# +# Mock CMCONF module for testing BA_PACKAGE_PREREQ_CMCONF_INIT +# +# This mock provides CMCONF_GET function that returns pre-configured test values. +# Test values are set via TEST_CMCONF_ before using CMCONF_GET +# + +FUNCTION(CMCONF_GET var_name) + IF(NOT DEFINED TEST_CMCONF_${var_name}) + MESSAGE(FATAL_ERROR "Mock CMCONF_GET: TEST_CMCONF_${var_name} is not defined") + ENDIF() + SET(${var_name} "${TEST_CMCONF_${var_name}}" PARENT_SCOPE) +ENDFUNCTION() + diff --git a/integration_tests/mock/CMDEF_VARS.cmake b/integration_tests/mock/CMDEF_VARS.cmake new file mode 100644 index 0000000..26bf09d --- /dev/null +++ b/integration_tests/mock/CMDEF_VARS.cmake @@ -0,0 +1,30 @@ +## +# +# Mock CMDEF variables for testing BA_PACKAGE_LIBRARY +# +# This file provides deterministic CMDEF_* variables that would normally be +# detected from the system by CMDEF. Using fictional values ensures tests +# produce consistent results and do not accidentally match real system values. +# +# Variables provided: +# CMDEF_ARCHITECTURE - CPU architecture +# CMDEF_DISTRO_ID - Linux distribution ID +# CMDEF_DISTRO_VERSION_ID - Distribution version +# +# Usage: +# Include this file AFTER BA_PACKAGE.cmake to override the real CMDEF values. +# + +SET(CMDEF_ARCHITECTURE "mock_arch" + CACHE INTERNAL + "Mock CPU architecture for testing" +) +SET(CMDEF_DISTRO_ID "mock_distro" + CACHE INTERNAL + "Mock Linux distribution ID for testing" +) +SET(CMDEF_DISTRO_VERSION_ID "0.0.0" + CACHE INTERNAL + "Mock distribution version for testing" +) + diff --git a/integration_tests/mock/CMLIB_CACHE.cmake b/integration_tests/mock/CMLIB_CACHE.cmake new file mode 100644 index 0000000..f47f106 --- /dev/null +++ b/integration_tests/mock/CMLIB_CACHE.cmake @@ -0,0 +1,62 @@ +## +# +# Mock CMLIB_CACHE module for testing BA_PACKAGE_LIBRARY CACHE_ONLY mode +# +# This mock captures arguments passed to CMLIB_CACHE_GET and returns a +# configurable path. Used to test BA_PACKAGE_LIBRARY's CACHE_ONLY behavior +# without accessing the real CMLIB cache. +# +# Captured variables (CACHE INTERNAL): +# MOCK_CMLIB_CACHE_GET_CALLED - TRUE if function was called +# MOCK_CMLIB_CACHE_GET_KEYWORDS - List of KEYWORDS passed +# +# Configuration: +# MOCK_CMLIB_CACHE_GET_RETURN_PATH - Set before including this file to control +# the return value. Empty string simulates +# cache miss (package not found). +# +# Usage: +# SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "/mock/cached/path" CACHE INTERNAL "") +# INCLUDE("mock/CMLIB_CACHE.cmake") +# BA_PACKAGE_LIBRARY(pkg v1.0.0 CACHE_ONLY ON) +# # Verify MOCK_CMLIB_CACHE_GET_CALLED is TRUE +# + +SET(MOCK_CMLIB_CACHE_GET_CALLED FALSE + CACHE INTERNAL + "TRUE if CMLIB_CACHE_GET was called" +) +SET(MOCK_CMLIB_CACHE_GET_KEYWORDS "" + CACHE INTERNAL + "Captured KEYWORDS argument list" +) +IF(NOT DEFINED MOCK_CMLIB_CACHE_GET_RETURN_PATH) + SET(MOCK_CMLIB_CACHE_GET_RETURN_PATH "" + CACHE INTERNAL + "Path to return from mock; empty simulates cache miss" + ) +ENDIF() + +## +# Mock implementation of CMLIB_CACHE_GET +# +# Captures KEYWORDS and returns MOCK_CMLIB_CACHE_GET_RETURN_PATH via CACHE_PATH_VAR. +# +FUNCTION(CMLIB_CACHE_GET) + SET_PROPERTY(CACHE MOCK_CMLIB_CACHE_GET_CALLED PROPERTY VALUE TRUE) + CMLIB_PARSE_ARGUMENTS( + MULTI_VALUE + KEYWORDS + ONE_VALUE + CACHE_PATH_VAR + OPTIONS + TRY_REGENERATE + P_ARGN + ${ARGN} + ) + SET_PROPERTY(CACHE MOCK_CMLIB_CACHE_GET_KEYWORDS PROPERTY VALUE "${__KEYWORDS}") + IF(__CACHE_PATH_VAR) + SET(${__CACHE_PATH_VAR} "${MOCK_CMLIB_CACHE_GET_RETURN_PATH}" PARENT_SCOPE) + ENDIF() +ENDFUNCTION() + diff --git a/integration_tests/mock/CMLIB_DEPENDENCY.cmake b/integration_tests/mock/CMLIB_DEPENDENCY.cmake new file mode 100644 index 0000000..704d502 --- /dev/null +++ b/integration_tests/mock/CMLIB_DEPENDENCY.cmake @@ -0,0 +1,84 @@ +## +# +# Mock CMLIB_DEPENDENCY module for testing BA_PACKAGE_LIBRARY +# +# This mock captures all arguments passed to CMLIB_DEPENDENCY without performing +# actual dependency resolution. It allows tests to verify that BA_PACKAGE_LIBRARY +# calls CMLIB_DEPENDENCY with correct arguments. +# +# Captured variables (CACHE INTERNAL): +# MOCK_CMLIB_DEPENDENCY_CALLED - TRUE if function was called +# MOCK_CMLIB_DEPENDENCY_KEYWORDS - List of KEYWORDS passed +# MOCK_CMLIB_DEPENDENCY_TYPE - TYPE argument value +# MOCK_CMLIB_DEPENDENCY_URI - URI argument value +# MOCK_CMLIB_DEPENDENCY_GIT_REVISION - GIT_REVISION argument value +# MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE - ARCHIVE_TYPE argument value +# MOCK_CMLIB_DEPENDENCY_GIT_PATH - GIT_PATH argument value +# +# The mock returns "/mock/cache/path" via OUTPUT_PATH_VAR if specified. +# +# Usage: +# Include this file AFTER BA_PACKAGE.cmake to override the real CMLIB_DEPENDENCY. +# Call BA_PACKAGE_LIBRARY, then verify MOCK_CMLIB_DEPENDENCY_* variables. +# + +SET(MOCK_CMLIB_DEPENDENCY_CALLED FALSE + CACHE INTERNAL + "TRUE if CMLIB_DEPENDENCY was called" +) +SET(MOCK_CMLIB_DEPENDENCY_KEYWORDS "" + CACHE INTERNAL + "Captured KEYWORDS argument list" +) +SET(MOCK_CMLIB_DEPENDENCY_TYPE "" + CACHE INTERNAL + "Captured TYPE argument value" +) +SET(MOCK_CMLIB_DEPENDENCY_URI "" + CACHE INTERNAL + "Captured URI argument value" +) +SET(MOCK_CMLIB_DEPENDENCY_GIT_REVISION "" + CACHE INTERNAL + "Captured GIT_REVISION argument value" +) +SET(MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE "" + CACHE INTERNAL + "Captured ARCHIVE_TYPE argument value" +) +SET(MOCK_CMLIB_DEPENDENCY_GIT_PATH "" + CACHE INTERNAL + "Captured GIT_PATH argument value" +) + +## +# Mock implementation of CMLIB_DEPENDENCY +# +# Captures all arguments and returns a mock path via OUTPUT_PATH_VAR. +# +FUNCTION(CMLIB_DEPENDENCY) + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_CALLED PROPERTY VALUE TRUE) + CMLIB_PARSE_ARGUMENTS( + MULTI_VALUE + KEYWORDS + ONE_VALUE + TYPE + ARCHIVE_TYPE + URI + GIT_REVISION + GIT_PATH + OUTPUT_PATH_VAR + P_ARGN + ${ARGN} + ) + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_KEYWORDS PROPERTY VALUE "${__KEYWORDS}") + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_TYPE PROPERTY VALUE "${__TYPE}") + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE PROPERTY VALUE "${__ARCHIVE_TYPE}") + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_URI PROPERTY VALUE "${__URI}") + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_GIT_REVISION PROPERTY VALUE "${__GIT_REVISION}") + SET_PROPERTY(CACHE MOCK_CMLIB_DEPENDENCY_GIT_PATH PROPERTY VALUE "${__GIT_PATH}") + IF(__OUTPUT_PATH_VAR) + SET(${__OUTPUT_PATH_VAR} "/mock/cache/path" PARENT_SCOPE) + ENDIF() +ENDFUNCTION() + diff --git a/integration_tests/mock/CMLIB_STORAGE.cmake b/integration_tests/mock/CMLIB_STORAGE.cmake new file mode 100644 index 0000000..7fa9f4e --- /dev/null +++ b/integration_tests/mock/CMLIB_STORAGE.cmake @@ -0,0 +1,94 @@ +## +# +# Mock CMLIB_STORAGE module for testing BA_PACKAGE_LIBRARY URI template expansion +# +# This mock replaces CMLIB_STORAGE_TEMPLATE_INSTANCE to return configurable URIs +# without performing actual template expansion. Allows tests to verify URI +# construction and control the expanded URI value. +# +# Captured variables (CACHE INTERNAL): +# MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED - TRUE if function was called +# MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VAR - Name of template variable passed +# +# Configuration: +# MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT - Set before including this file +# to control the returned URI. +# Defaults to mock URL if not set. +# +# Usage: +# SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT "https://example.com/pkg.zip" CACHE INTERNAL "") +# INCLUDE("mock/CMLIB_STORAGE.cmake") +# + +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED FALSE + CACHE INTERNAL + "TRUE if CMLIB_STORAGE_TEMPLATE_INSTANCE was called" +) +IF(NOT DEFINED MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT) + SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT "" + CACHE INTERNAL + "URI to return from mock; uses default if empty" + ) +ENDIF() +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VAR "" + CACHE INTERNAL + "Captured template variable name argument" +) +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME "" + CACHE INTERNAL + "Captured ARCHIVE_NAME argument" +) +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_GIT_PATH "" + CACHE INTERNAL + "Captured GIT_PATH argument" +) +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION "" + CACHE INTERNAL + "Captured REVISION argument" +) +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME "" + CACHE INTERNAL + "Captured PACKAGE_GROUP_NAME argument" +) +SET(MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VALUE "" + CACHE INTERNAL + "Captured template string value (dereferenced from template variable name)" +) + +## +# Mock implementation of CMLIB_STORAGE_TEMPLATE_INSTANCE +# +# Returns MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT or a default mock URL. +# +FUNCTION(CMLIB_STORAGE_TEMPLATE_INSTANCE output_var template_var_name) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED PROPERTY VALUE TRUE) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VAR PROPERTY VALUE "${template_var_name}") + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VALUE PROPERTY VALUE "${${template_var_name}}") + CMLIB_PARSE_ARGUMENTS( + ONE_VALUE + REVISION + GIT_PATH + ARCHIVE_NAME + PACKAGE_GROUP_NAME + P_ARGN + ${ARGN} + ) + IF(__ARCHIVE_NAME) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME PROPERTY VALUE "${__ARCHIVE_NAME}") + ENDIF() + IF(__GIT_PATH) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_GIT_PATH PROPERTY VALUE "${__GIT_PATH}") + ENDIF() + IF(__REVISION) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION PROPERTY VALUE "${__REVISION}") + ENDIF() + IF(__PACKAGE_GROUP_NAME) + SET_PROPERTY(CACHE MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME PROPERTY VALUE "${__PACKAGE_GROUP_NAME}") + ENDIF() + SET(result "https://mock.example.com/mock_expanded_uri") + IF(NOT "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT}" STREQUAL "") + SET(result "${MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT}") + ENDIF() + SET(${output_var} "${result}" PARENT_SCOPE) +ENDFUNCTION() + diff --git a/integration_tests/mock/CMUTIL.cmake b/integration_tests/mock/CMUTIL.cmake new file mode 100644 index 0000000..8cd096f --- /dev/null +++ b/integration_tests/mock/CMUTIL.cmake @@ -0,0 +1,53 @@ +## +# +# Mock CMUTIL module for testing BA_PACKAGE_LIBRARY platform string construction +# +# This mock replaces CMUTIL_PLATFORM_STRING_CONSTRUCT to return a deterministic +# platform string without querying the actual system. Allows tests to run +# consistently across different platforms. +# +# Captured variables (CACHE INTERNAL): +# MOCK_CMUTIL_PLATFORM_STRING_CONSTRUCT_CALLED - TRUE if function was called +# +# Configuration: +# MOCK_CMUTIL_PLATFORM_STRING - Set before including this file to override +# the default platform string construction. +# If not set, constructs from input arguments. +# +# Usage: +# SET(MOCK_CMUTIL_PLATFORM_STRING "x86_64_ubuntu_22.04" CACHE INTERNAL "") +# INCLUDE("mock/CMUTIL.cmake") +# + +SET(MOCK_CMUTIL_PLATFORM_STRING_CONSTRUCT_CALLED FALSE + CACHE INTERNAL + "TRUE if CMUTIL_PLATFORM_STRING_CONSTRUCT was called" +) +SET(MOCK_CMUTIL_PLATFORM_STRING "" + CACHE INTERNAL + "Platform string to return; uses constructed value if empty" +) + +## +# Mock implementation of CMUTIL_PLATFORM_STRING_CONSTRUCT +# +# Returns MOCK_CMUTIL_PLATFORM_STRING or constructs from MACHINE_DISTRO_NAME_ID_DISTRO_VERSION_ID. +# +FUNCTION(CMUTIL_PLATFORM_STRING_CONSTRUCT) + SET_PROPERTY(CACHE MOCK_CMUTIL_PLATFORM_STRING_CONSTRUCT_CALLED PROPERTY VALUE TRUE) + CMLIB_PARSE_ARGUMENTS( + ONE_VALUE + MACHINE + DISTRO_NAME_ID + DISTRO_VERSION_ID + OUTPUT_VAR + P_ARGN + ${ARGN} + ) + SET(result "${__MACHINE}_${__DISTRO_NAME_ID}_${__DISTRO_VERSION_ID}") + IF(MOCK_CMUTIL_PLATFORM_STRING) + SET(result "${MOCK_CMUTIL_PLATFORM_STRING}") + ENDIF() + SET(${__OUTPUT_VAR} "${result}" PARENT_SCOPE) +ENDFUNCTION() + diff --git a/integration_tests/mock/MOCK_VARIABLES.md b/integration_tests/mock/MOCK_VARIABLES.md new file mode 100644 index 0000000..98a37c5 --- /dev/null +++ b/integration_tests/mock/MOCK_VARIABLES.md @@ -0,0 +1,148 @@ +# Mock Variable Dependencies + +## Data Flow Through BA_PACKAGE + +```mermaid +flowchart TD + subgraph CMDEF_VARS["CMDEF_VARS.cmake (constants)"] + ARCH["CMDEF_ARCHITECTURE\n= mock_arch"] + DISTRO["CMDEF_DISTRO_ID\n= mock_distro"] + VER["CMDEF_DISTRO_VERSION_ID\n= 0.0.0"] + end + + subgraph CMUTIL["CMUTIL.cmake"] + direction LR + CMUTIL_CFG["config: MOCK_CMUTIL_PLATFORM_STRING\n(optional override)"] + CMUTIL_CAP["captured: MOCK_CMUTIL_PLATFORM_STRING\n_CONSTRUCT_CALLED"] + end + + subgraph BA["BA_PACKAGE (production code)"] + PLAT["platform_string"] + PKG["package_string"] + GIT["git_path"] + KW["keywords"] + RF["remote_file"] + end + + subgraph STORAGE["CMLIB_STORAGE.cmake"] + ST_CFG["config: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_OUTPUT\n(default: mock URL)"] + ST_CALLED["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_CALLED"] + ST_TVAR["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_TEMPLATE_VAR"] + ST_TVAL["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_TEMPLATE_VALUE"] + ST_AN["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_ARCHIVE_NAME"] + ST_GP["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_GIT_PATH"] + ST_REV["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_REVISION"] + ST_PGN["captured: MOCK_CMLIB_STORAGE\n_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME"] + end + + subgraph DEP["CMLIB_DEPENDENCY.cmake"] + DEP_CALLED["captured: MOCK_CMLIB_DEPENDENCY_CALLED"] + DEP_URI["captured: MOCK_CMLIB_DEPENDENCY_URI"] + DEP_KW["captured: MOCK_CMLIB_DEPENDENCY_KEYWORDS"] + DEP_TYPE["captured: MOCK_CMLIB_DEPENDENCY_TYPE"] + DEP_ATYPE["captured: MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE"] + DEP_GREV["captured: MOCK_CMLIB_DEPENDENCY_GIT_REVISION"] + DEP_GPATH["captured: MOCK_CMLIB_DEPENDENCY_GIT_PATH"] + end + + subgraph CACHE["CMLIB_CACHE.cmake (CACHE_ONLY)"] + CA_CFG["config: MOCK_CMLIB_CACHE\n_GET_RETURN_PATH\n(empty = cache miss)"] + CA_CALLED["captured: MOCK_CMLIB_CACHE_GET_CALLED"] + CA_KW["captured: MOCK_CMLIB_CACHE_GET_KEYWORDS"] + end + + ARCH --> PLAT + DISTRO --> PLAT + VER --> PLAT + CMUTIL_CFG -.->|overrides| PLAT + + ARCH --> GIT + DISTRO --> GIT + VER --> GIT + + PLAT --> PKG + + PKG --> ST_AN + GIT --> ST_GP + ST_CFG -->|returned as| RF + RF --> DEP_URI + + KW --> DEP_KW + KW --> CA_KW +``` + +> **Legend:** "config:" = variable set by test before calling production code, "captured:" = variable set by mock during execution. + +## Variable Categories + +### Configuration (set by test before calling production code) + +| Variable | Mock | Default | Effect | +|---|---|---|---| +| `MOCK_CMUTIL_PLATFORM_STRING` | CMUTIL | constructed from args | Overrides platform_string | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT` | CMLIB_STORAGE | `https://mock.example.com/mock_expanded_uri` | Returned as `remote_file` → captured in `MOCK_CMLIB_DEPENDENCY_URI` | +| `MOCK_CMLIB_CACHE_GET_RETURN_PATH` | CMLIB_CACHE | empty string, simulates cache miss | Returned as `cache_path` | +| `TEST_CMCONF_` | CMCONF | no default, must be defined by test | Returned by `CMCONF_GET(var_name)` | + +### Captured (set by mock during production code execution) + +| Variable | Captured From | Source in BA_PACKAGE | +|---|---|---| +| `MOCK_CMUTIL_PLATFORM_STRING_CONSTRUCT_CALLED` | function call | `CMUTIL_PLATFORM_STRING_CONSTRUCT(...)` | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_CALLED` | function call | `CMLIB_STORAGE_TEMPLATE_INSTANCE(...)` | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VAR` | 2nd positional arg | `template_var` (name of variable holding URI template) | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_TEMPLATE_VALUE` | dereferenced 2nd arg | `${template_var}` (the actual template string) | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME` | `ARCHIVE_NAME` kwarg | `package_string` = `{prefix}{name}{suffix}_{version}_{platform}.zip` | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_GIT_PATH` | `GIT_PATH` kwarg | `{DISTRO_ID}/{VERSION_ID}/{ARCH}` | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_REVISION` | `REVISION` kwarg | `BA_PACKAGE_VARS__REVISION` | +| `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_PACKAGE_GROUP_NAME` | `PACKAGE_GROUP_NAME` kwarg | `package_name` (original, not expanded) | +| `MOCK_CMLIB_DEPENDENCY_CALLED` | function call | `CMLIB_DEPENDENCY(...)` | +| `MOCK_CMLIB_DEPENDENCY_URI` | `URI` kwarg | `remote_file` (= return value of `CMLIB_STORAGE_TEMPLATE_INSTANCE`) | +| `MOCK_CMLIB_DEPENDENCY_KEYWORDS` | `KEYWORDS` kwarg | `BACPACK;{NAME_UPPER}[;{BUILD_TYPE}]` | +| `MOCK_CMLIB_DEPENDENCY_TYPE` | `TYPE` kwarg | `ARCHIVE` | +| `MOCK_CMLIB_DEPENDENCY_ARCHIVE_TYPE` | `ARCHIVE_TYPE` kwarg | `ZIP` | +| `MOCK_CMLIB_DEPENDENCY_GIT_REVISION` | `GIT_REVISION` kwarg | `revision` (only if `GIT_PATH_TEMPLATE` is set) | +| `MOCK_CMLIB_DEPENDENCY_GIT_PATH` | `GIT_PATH` kwarg | 2nd `CMLIB_STORAGE_TEMPLATE_INSTANCE` result (only if `GIT_PATH_TEMPLATE` is set) | +| `MOCK_CMLIB_CACHE_GET_CALLED` | function call | `CMLIB_CACHE_GET(...)` (only if `CACHE_ONLY`) | +| `MOCK_CMLIB_CACHE_GET_KEYWORDS` | `KEYWORDS` kwarg | same keywords as `CMLIB_DEPENDENCY` | + +### Constants (CMDEF_VARS.cmake) + +| Variable | Value | +|---|---| +| `CMDEF_ARCHITECTURE` | `mock_arch` | +| `CMDEF_DISTRO_ID` | `mock_distro` | +| `CMDEF_DISTRO_VERSION_ID` | `0.0.0` | + +## Key Mock-to-Mock Dependency + +``` +MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT ──→ MOCK_CMLIB_DEPENDENCY_URI +``` + +The mock does **not** perform template expansion. It returns `OUTPUT` (or a default URL) as `remote_file`, +which BA_PACKAGE then passes as `URI` to `CMLIB_DEPENDENCY`. Therefore `MOCK_CMLIB_DEPENDENCY_URI` +always equals `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_OUTPUT` (or the default) — it does **not** reflect +the computed `package_string`. + +To verify the actual archive name computed by BA_PACKAGE, check `MOCK_CMLIB_STORAGE_TEMPLATE_INSTANCE_ARCHIVE_NAME`. + +## Execution Paths + +| Condition | Path | Mocks Involved | +|---|---|---| +| `CACHE_ONLY=OFF` (default) | CMUTIL → CMLIB_STORAGE → CMLIB_DEPENDENCY | CMDEF_VARS, CMUTIL, CMLIB_STORAGE, CMLIB_DEPENDENCY | +| `CACHE_ONLY=ON` | CMUTIL → CMLIB_STORAGE → CMLIB_CACHE | CMDEF_VARS, CMUTIL, CMLIB_STORAGE, CMLIB_CACHE | +| `BA_PACKAGE_PREREQ_CMCONF_INIT` | CMCONF only | CMCONF | + +## Include Order (include_general.cmake) + +1. CMDEF_VARS +2. CMUTIL +3. CMLIB_STORAGE +4. CMLIB_DEPENDENCY + +CMLIB_CACHE is **not** included by default — tests requiring `CACHE_ONLY` include it separately. + +CMCONF is **not** included by default — `BA_PACKAGE_PREREQ_CMCONF_INIT` tests include it separately. + diff --git a/integration_tests/mock/test/CMakeLists.txt b/integration_tests/mock/test/CMakeLists.txt new file mode 100644 index 0000000..1011229 --- /dev/null +++ b/integration_tests/mock/test/CMakeLists.txt @@ -0,0 +1,15 @@ +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(MOCK_CMCONF_TEST) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../TEST.cmake") + +TEST_RUN("${CMAKE_CURRENT_LIST_DIR}/get_returns_value") + +TEST_INVALID_CMAKE_RUN("${CMAKE_CURRENT_LIST_DIR}/get_fails_on_undefined" + "Mock CMCONF_GET: TEST_CMCONF_UNDEFINED_VAR is not defined" +) + diff --git a/integration_tests/mock/test/get_fails_on_undefined/CMakeLists.txt b/integration_tests/mock/test/get_fails_on_undefined/CMakeLists.txt new file mode 100644 index 0000000..0d502d6 --- /dev/null +++ b/integration_tests/mock/test/get_fails_on_undefined/CMakeLists.txt @@ -0,0 +1,12 @@ +## Mock CMCONF_GET fails with FATAL_ERROR when TEST_CMCONF_* variable is not defined +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_CMCONF_GET_FAILS_ON_UNDEFINED) +ENDIF() + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") + +CMCONF_GET(UNDEFINED_VAR) + diff --git a/integration_tests/mock/test/get_returns_value/CMakeLists.txt b/integration_tests/mock/test/get_returns_value/CMakeLists.txt new file mode 100644 index 0000000..f3df062 --- /dev/null +++ b/integration_tests/mock/test/get_returns_value/CMakeLists.txt @@ -0,0 +1,32 @@ +## Mock CMCONF_GET returns values configured via TEST_CMCONF_* variables +# +IF(NOT DEFINED CMAKE_SCRIPT_MODE_FILE) + CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + PROJECT(TEST_CMCONF_GET_RETURNS_VALUE) +ENDIF() + +FIND_PACKAGE(CMLIB REQUIRED) + +INCLUDE("${CMAKE_CURRENT_LIST_DIR}/../../../VARS.cmake") +INCLUDE("${CMAKE_TESTS_ROOT}/TEST.cmake") + +SET(TEST_CMCONF_MY_STRING_VAR "expected_string_value") +SET(TEST_CMCONF_MY_BOOL_VAR ON) +SET(TEST_CMCONF_MY_PATH_VAR "/some/test/path") +SET(TEST_CMCONF_MY_EMPTY_VAR "") + +INCLUDE("${CMAKE_TESTS_ROOT}/mock/CMCONF.cmake") + +CMCONF_GET(MY_STRING_VAR) +TEST_VAR_EQUALS_LITERAL(MY_STRING_VAR "expected_string_value") + +CMCONF_GET(MY_BOOL_VAR) +TEST_VAR_TRUE(MY_BOOL_VAR) + +CMCONF_GET(MY_PATH_VAR) +TEST_VAR_EQUALS_LITERAL(MY_PATH_VAR "/some/test/path") + +CMCONF_GET(MY_EMPTY_VAR) +TEST_VAR_DEFINED(MY_EMPTY_VAR) +TEST_VAR_EQUALS_LITERAL(MY_EMPTY_VAR "") + diff --git a/test/app/main.c b/test/app/main.c deleted file mode 100644 index 2cbd637..0000000 --- a/test/app/main.c +++ /dev/null @@ -1,9 +0,0 @@ - -extern int shared_out_of_dir_symlink(); -extern int shared_with_soname(); - -int main() { - - return shared_out_of_dir_symlink() + shared_with_soname(); - -} \ No newline at end of file diff --git a/test/README.md b/unit_tests/README.md similarity index 71% rename from test/README.md rename to unit_tests/README.md index 1a1a677..9c01656 100644 --- a/test/README.md +++ b/unit_tests/README.md @@ -17,8 +17,20 @@ The test consists of Test Application located in 'app/' directory. In the \test/ directory run -```cmake -cmake -P ./run_tests.cmake +```bash +cmake -DTEST_WITH_DESTDIR=OFF -P ./run_app_tests.cmake +cmake -DTEST_WITH_DESTDIR=ON -P ./run_app_tests.cmake + +cmake -DINVALID_VAR_TEST=OFF -P ./run_vars_test.cmake + +# It shall fail - return code shall not be 0! +cmake -DINVALID_VAR_TEST=ON -P ./run_vars_test.cmake +``` + +or run all tests in one batch by running + +```bash +./run_tests.sh ``` ## Test application architecture @@ -29,6 +41,7 @@ Application components: - Application libraries (dependencies) - shared_library - shared_library_for_prerun + - shared_library_gst - tests_list `Application executable` links against `Application libraries`. As a build argument the name of the test from the `tests_list/` @@ -38,12 +51,14 @@ Files inside `tests_list/` directory serve as use cases for altering files insta ### Application Libraries (dependencies) -There are two shared libraries, `shared_library` and `shared_library_for_prerun` +There are three shared libraries, `shared_library`, `shared_library_for_prerun` and `shared_library_gst` `shared_library` represents standard CMake Package (with all needed exported targets etc.) `shared_library_for_prerun` represents standard system library (not a complete CMake Package - no exported targets and configs) +`shared_library_gst` represents a library with gstreamer-style naming where version is part of the name before `.so` (e.g. `libfoo-1.0.so`, `libfoo-1.0.so.0`, `libfoo-1.0.so.0.1.0`) + All libraries are built as a part of the `Application executable` CMake configure. ### Application Libraries - use case altering @@ -113,12 +128,41 @@ TEST_PRERUN_GET_EXPECTED_DEPENDENCY_FILE_LIST(...) TEST_GET_EXPECTED_INSTALLED_FILES_LIST(...) ``` +```cmake +# +# Function is called after the application target is created +# (after CMDEF_ADD_EXECUTABLE and base TARGET_LINK_LIBRARIES). +# +# Function allows the test to perform additional target setup such as +# creating IMPORTED GLOBAL library targets, linking additional libraries, +# or adding compile definitions. +# +# Tests that do not need additional target setup shall provide an empty stub. +# +# TARGET - name of the application target +# +# ( +# TARGET +# ) +# +TEST_POST_TARGET_SETUP(...) +``` + ## Test Run Workflow ![BringAuto Packager Test Activity](img/BAPackageTestActivity.svg) +## Difference from [cmake_tests/] + +`test/` — integration tests that build a real application, install dependencies, and verify installed file structure. + +[cmake_tests/] — unit tests for CMake module logic using mocks, no network or build required. + ## TODO - Rename `shared_library` and `shared_library_for_prerun` to `library` and `library_for_prerun` to avoid duplicities. (system automatically adds the -shared suffix to the resulting library names...) + + +[cmake_tests/]: ../cmake_tests/ \ No newline at end of file diff --git a/test/app/CMakeLists.txt b/unit_tests/app/CMakeLists.txt similarity index 95% rename from test/app/CMakeLists.txt rename to unit_tests/app/CMakeLists.txt index db60011..c6f17b7 100644 --- a/test/app/CMakeLists.txt +++ b/unit_tests/app/CMakeLists.txt @@ -76,6 +76,10 @@ ENDIF() IF(NOT COMMAND TEST_PRERUN_GET_EXPECTED_DEPENDENCY_FILE_LIST) MESSAGE(FATAL_ERROR "Test is not valid. TEST_PRERUN_GET_EXPECTED_DEPENDENCY_FILE_LIST function not found.") ENDIF() +IF(NOT COMMAND TEST_POST_TARGET_SETUP) + MESSAGE(FATAL_ERROR "Test is not valid. TEST_POST_TARGET_SETUP function not found.") +ENDIF() + TEST_PRERUN( VERSION "1.2.3" INSTALL_DIR "${DEPENDENCY_INSTALL_DIR}/lib/shared-library-for-prerun" @@ -108,6 +112,8 @@ TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC shared-library-shared::shared-library-shared shared-library-for-prerun-shared) +TEST_POST_TARGET_SETUP(TARGET ${PROJECT_NAME}) + CMDEF_INSTALL(TARGET ${PROJECT_NAME} NAMESPACE ${PROJECT_NAME}::) # Create a package diff --git a/test/app/lib/shared_library/CMakeLists.txt b/unit_tests/app/lib/shared_library/CMakeLists.txt similarity index 100% rename from test/app/lib/shared_library/CMakeLists.txt rename to unit_tests/app/lib/shared_library/CMakeLists.txt diff --git a/test/app/lib/shared_library/library.c b/unit_tests/app/lib/shared_library/library.c similarity index 100% rename from test/app/lib/shared_library/library.c rename to unit_tests/app/lib/shared_library/library.c diff --git a/test/app/lib/shared_library_for_prerun/CMakeLists.txt b/unit_tests/app/lib/shared_library_for_prerun/CMakeLists.txt similarity index 100% rename from test/app/lib/shared_library_for_prerun/CMakeLists.txt rename to unit_tests/app/lib/shared_library_for_prerun/CMakeLists.txt diff --git a/test/app/lib/shared_library_for_prerun/include/shared_out_of_dir_symlink.h b/unit_tests/app/lib/shared_library_for_prerun/include/shared_out_of_dir_symlink.h similarity index 100% rename from test/app/lib/shared_library_for_prerun/include/shared_out_of_dir_symlink.h rename to unit_tests/app/lib/shared_library_for_prerun/include/shared_out_of_dir_symlink.h diff --git a/test/app/lib/shared_library_for_prerun/library.c b/unit_tests/app/lib/shared_library_for_prerun/library.c similarity index 100% rename from test/app/lib/shared_library_for_prerun/library.c rename to unit_tests/app/lib/shared_library_for_prerun/library.c diff --git a/unit_tests/app/lib/shared_library_gst/CMakeLists.txt b/unit_tests/app/lib/shared_library_gst/CMakeLists.txt new file mode 100644 index 0000000..fe28efa --- /dev/null +++ b/unit_tests/app/lib/shared_library_gst/CMakeLists.txt @@ -0,0 +1,45 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 3.21) + +SET(PROJECT_NAME shared-library-gst) +PROJECT(${PROJECT_NAME} LANGUAGES C) + +IF(NOT DEFINED LIBRARY_VERSION) + MESSAGE(FATAL_ERROR "Please specify LIBRARY_VERSION in format major.minor.patch") +ENDIF() +IF(NOT CMAKE_BUILD_TYPE STREQUAL "Release") + MESSAGE(FATAL_ERROR "Only supported build type is Release! (specify by CMAKE_BUILD_TYPE)") +ENDIF() + +FIND_PACKAGE(CMLIB COMPONENTS CMDEF REQUIRED) + +SET(install_dir "lib/${PROJECT_NAME}") +SET(old_install_dir ${CMDEF_LIBRARY_INSTALL_DIR}) + +CMDEF_ADD_LIBRARY( + LIBRARY_GROUP ${PROJECT_NAME} + TYPE SHARED + SOURCES library.c + VERSION ${LIBRARY_VERSION} +) + +SET_TARGET_PROPERTIES(${PROJECT_NAME}-shared + PROPERTIES + OUTPUT_NAME ${PROJECT_NAME}-1.0 + SOVERSION 0 + VERSION ${LIBRARY_VERSION} +) + +SET(CMDEF_LIBRARY_INSTALL_DIR "${install_dir}" + CACHE STRING "Overridden" + FORCE +) +CMDEF_INSTALL( + TARGET ${PROJECT_NAME}-shared + NAMESPACE ${PROJECT_NAME}-shared:: + NO_INSTALL_CONFIG ON +) +SET(CMDEF_LIBRARY_INSTALL_DIR "${old_install_dir}" + CACHE STRING "Overridden" + FORCE +) + diff --git a/unit_tests/app/lib/shared_library_gst/library.c b/unit_tests/app/lib/shared_library_gst/library.c new file mode 100644 index 0000000..0b55384 --- /dev/null +++ b/unit_tests/app/lib/shared_library_gst/library.c @@ -0,0 +1,3 @@ + +int shared_gst_func() { return 42; } + diff --git a/unit_tests/app/main.c b/unit_tests/app/main.c new file mode 100644 index 0000000..e75e70d --- /dev/null +++ b/unit_tests/app/main.c @@ -0,0 +1,19 @@ + +extern int shared_out_of_dir_symlink(); +extern int shared_with_soname(); + +#ifdef USE_GST_LIBRARY +extern int shared_gst_func(); +#endif + +int main() { + + int r = shared_out_of_dir_symlink() + shared_with_soname(); + +#ifdef USE_GST_LIBRARY + r += shared_gst_func(); +#endif + + return r; + +} \ No newline at end of file diff --git a/unit_tests/app/tests_list/gstreamer_style_naming.txt b/unit_tests/app/tests_list/gstreamer_style_naming.txt new file mode 100644 index 0000000..08c84f4 --- /dev/null +++ b/unit_tests/app/tests_list/gstreamer_style_naming.txt @@ -0,0 +1,109 @@ +# +# Test for gstreamer-style library naming where version is part of the +# library name before .so (e.g. libfoo-1.0.so, libfoo-1.0.so.0, libfoo-1.0.so.0.1.0) +# + +FUNCTION(TEST_PRERUN) + BUILD_INSTALL_DEPENDENCY("${DEPENDENCY_INSTALL_PREFIX}" 0.1.0 ${TESTLIST_BASE_PATH}/../lib/shared_library_gst) +ENDFUNCTION() + +FUNCTION(TEST_POST_TARGET_SETUP) + CMLIB_PARSE_ARGUMENTS( + ONE_VALUE + TARGET + REQUIRED + TARGET + P_ARGN ${ARGN} + ) + + ADD_LIBRARY(shared-library-gst-shared SHARED IMPORTED GLOBAL) + SET_TARGET_PROPERTIES(shared-library-gst-shared + PROPERTIES + IMPORTED_LOCATION ${DEPENDENCY_INSTALL_DIR}/${CMDEF_LIBRARY_INSTALL_DIR}/shared-library-gst/shared-library-gst-1.0.so.0.1.0 + IMPORTED_SONAME shared-library-gst-1.0.so.0 + ) + + TARGET_LINK_LIBRARIES(${__TARGET} PUBLIC shared-library-gst-shared) + TARGET_COMPILE_DEFINITIONS(${__TARGET} PRIVATE USE_GST_LIBRARY) +ENDFUNCTION() + + + +# +# ${DEPENDENCY_INSTALL_DIR} +# ├── include +# │ └── shared_out_of_dir_symlink.h +# └── lib +# ├── cmake +# │ └── shared-library-shared +# │ ├── shared-library-shared.cmake +# │ ├── shared-library-sharedConfig.cmake +# │ ├── shared-library-sharedConfigVersion.cmake +# │ └── shared-library-shared-release.cmake +# ├── libshared-library-shared.so +# ├── libshared-library-shared.so.5.67.1 +# ├── shared-library-for-prerun +# │ ├── libshared-library-for-prerun-shared.so +# │ └── libshared-library-for-prerun-shared.so.1.2.3 +# └── shared-library-gst +# ├── shared-library-gst-1.0.so +# ├── shared-library-gst-1.0.so.0 +# └── shared-library-gst-1.0.so.0.1.0 +# +MACRO(TEST_PRERUN_GET_EXPECTED_DEPENDENCY_FILE_LIST list_var) + LIST(APPEND ${list_var} + "lib/cmake/shared-library-shared/shared-library-sharedConfig.cmake" + "lib/cmake/shared-library-shared/shared-library-sharedConfigVersion.cmake" + "lib/cmake/shared-library-shared/shared-library-shared.cmake" + "lib/cmake/shared-library-shared/shared-library-shared-release.cmake" + "include/shared_out_of_dir_symlink.h" + "lib/libshared-library-shared.so" + "lib/libshared-library-shared.so.5.67.1" + "lib/shared-library-for-prerun/libshared-library-for-prerun-shared.so" + "lib/shared-library-for-prerun/libshared-library-for-prerun-shared.so.1.2.3" + "lib/shared-library-gst/shared-library-gst-1.0.so" + "lib/shared-library-gst/shared-library-gst-1.0.so.0" + "lib/shared-library-gst/shared-library-gst-1.0.so.0.1.0" + ) +ENDMACRO() + + + +# +# Expected installed app structure +# +# ${INSTALL_DIR} +# ├── bin +# │ └── MyTestApp +# └── lib +# ├── cmake +# │ └── MyTestApp +# │ ├── MyTestApp.cmake +# │ ├── MyTestAppConfig.cmake +# │ ├── MyTestAppConfigVersion.cmake +# │ └── MyTestApp-release.cmake +# ├── libshared-library-for-prerun-shared.so +# ├── libshared-library-for-prerun-shared.so.1.2.3 +# ├── shared-library-gst-1.0.so +# ├── shared-library-gst-1.0.so.0 +# ├── shared-library-gst-1.0.so.0.1.0 +# ├── libshared-library-shared.so +# └── libshared-library-shared.so.5.67.1 +# +MACRO(TEST_GET_EXPECTED_INSTALLED_FILES_LIST list_var) + LIST(APPEND ${list_var} + "bin/MyTestApp" + "lib/cmake/MyTestApp/MyTestApp.cmake" + "lib/cmake/MyTestApp/MyTestAppConfig.cmake" + "lib/cmake/MyTestApp/MyTestAppConfigVersion.cmake" + "lib/cmake/MyTestApp/MyTestApp-release.cmake" + "lib/libshared-library-for-prerun-shared.so" + "lib/libshared-library-for-prerun-shared.so.1.2.3" + "lib/shared-library-gst-1.0.so" + "lib/shared-library-gst-1.0.so.0" + "lib/shared-library-gst-1.0.so.0.1.0" + "lib/libshared-library-shared.so" + "lib/libshared-library-shared.so.5.67.1" + ) +ENDMACRO() + diff --git a/test/app/tests_list/standard_install.txt b/unit_tests/app/tests_list/standard_install.txt similarity index 98% rename from test/app/tests_list/standard_install.txt rename to unit_tests/app/tests_list/standard_install.txt index 75e88d8..a63b7d7 100644 --- a/test/app/tests_list/standard_install.txt +++ b/unit_tests/app/tests_list/standard_install.txt @@ -2,6 +2,9 @@ # Test for standard library installation without modifications # +FUNCTION(TEST_POST_TARGET_SETUP target) +ENDFUNCTION() + # FUNCTION(TEST_PRERUN) MESSAGE(STATUS "Test STANDARD_INSTALL start") diff --git a/test/app/tests_list/symlink_named_differently.txt b/unit_tests/app/tests_list/symlink_named_differently.txt similarity index 98% rename from test/app/tests_list/symlink_named_differently.txt rename to unit_tests/app/tests_list/symlink_named_differently.txt index 7fc5906..cf7eb2e 100644 --- a/test/app/tests_list/symlink_named_differently.txt +++ b/unit_tests/app/tests_list/symlink_named_differently.txt @@ -1,6 +1,9 @@ # # +FUNCTION(TEST_POST_TARGET_SETUP target) +ENDFUNCTION() + # # More documentation can be found inside the README # diff --git a/test/app/tests_list/symlink_named_same_as_file.txt b/unit_tests/app/tests_list/symlink_named_same_as_file.txt similarity index 98% rename from test/app/tests_list/symlink_named_same_as_file.txt rename to unit_tests/app/tests_list/symlink_named_same_as_file.txt index 84b537f..882d01b 100644 --- a/test/app/tests_list/symlink_named_same_as_file.txt +++ b/unit_tests/app/tests_list/symlink_named_same_as_file.txt @@ -3,6 +3,9 @@ # and make soname symlink to pre_run library in the lib/ directory # +FUNCTION(TEST_POST_TARGET_SETUP target) +ENDFUNCTION() + # # More documentation can be found inside the README # diff --git a/test/img/BAPackageTestActivity.svg b/unit_tests/img/BAPackageTestActivity.svg similarity index 100% rename from test/img/BAPackageTestActivity.svg rename to unit_tests/img/BAPackageTestActivity.svg diff --git a/test/run_app_tests.cmake b/unit_tests/run_app_tests.cmake similarity index 100% rename from test/run_app_tests.cmake rename to unit_tests/run_app_tests.cmake diff --git a/test/run_tests.sh b/unit_tests/run_tests.sh similarity index 100% rename from test/run_tests.sh rename to unit_tests/run_tests.sh diff --git a/test/run_vars_test.cmake b/unit_tests/run_vars_test.cmake similarity index 100% rename from test/run_vars_test.cmake rename to unit_tests/run_vars_test.cmake diff --git a/version.txt b/version.txt index beb72cc..e997a9a 100644 --- a/version.txt +++ b/version.txt @@ -1 +1 @@ -version=1.0.0 \ No newline at end of file +version=2.0.0 \ No newline at end of file