VladPolskiy/mod_tile
1
0
Fork 0
mirror of https://github.com/openstreetmap/mod_tile.git synced 2025-07-23 02:58:17 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
743cf651b1dfebb3f2feea36e25c9db1844c89fc
mod_tile/tests/CMakeLists.txt
Hummeltech 743cf651b1 Follow up to #190 for render_list (#417) 
* Fixed `render_list` build needs `libm`
* Added tests
* Updated man page
* Created function to set double
* Cleaned up / optimized a bit
* Removed `--dont-render` option
2024-03-21 13:22:02 -07:00

1224 lines
46 KiB
CMake
Raw Blame History

#-----------------------------------------------------------------------------
#
# CMake Config
#
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
#
# Find external dependencies
#
#-----------------------------------------------------------------------------
include(CTest)
include(ProcessorCount)
processorcount(PROCESSOR_COUNT)
execute_process(COMMAND ${APXS_EXECUTABLE} -q progname
OUTPUT_VARIABLE HTTPD_PROGNAME
OUTPUT_STRIP_TRAILING_WHITESPACE
)
find_package(UnixCommands REQUIRED)
find_program(CAT_EXECUTABLE NAMES cat REQUIRED)
find_program(CURL_EXECUTABLE NAMES curl REQUIRED)
find_program(GREP_EXECUTABLE NAMES grep REQUIRED)
find_program(HTTPD_EXECUTABLE NAMES ${HTTPD_PROGNAME} REQUIRED)
find_program(ID_EXECUTABLE NAMES id REQUIRED)
find_program(JQ_EXECUTABLE NAMES jq)
find_program(KILL_EXECUTABLE NAMES kill REQUIRED)
find_program(MEMCACHED_EXECUTABLE NAMES memcached)
find_program(MKDIR_EXECUTABLE NAMES mkdir REQUIRED)
find_program(PS_EXECUTABLE NAMES ps REQUIRED)
find_program(SHA256SUM_EXECUTABLE NAMES gsha256sum sha256sum REQUIRED)
find_program(SLEEP_EXECUTABLE NAMES sleep REQUIRED)
find_program(TOUCH_EXECUTABLE NAMES gtouch touch REQUIRED)
# Sets the host to be used for CTest test services
if(DEFINED ENV{CTEST_SERVER_HOST})
# To the value of environment variable "CTEST_SERVER_HOST"
set(CTEST_SERVER_HOST "$ENV{CTEST_SERVER_HOST}")
else()
# Or to 0.0.0.0 by default
set(CTEST_SERVER_HOST "0.0.0.0")
endif()
# Sets the host to be used for CTest client
if(DEFINED ENV{CTEST_CLIENT_HOST})
# To the value of environment variable "CTEST_CLIENT_HOST"
set(CTEST_CLIENT_HOST "$ENV{CTEST_CLIENT_HOST}")
else()
# Or to 127.0.0.1 by default
set(CTEST_CLIENT_HOST "127.0.0.1")
endif()
#-----------------------------------------------------------------------------
#
# Test configurations
#
#-----------------------------------------------------------------------------
set(DEFAULT_MAP_NAME "default")
set(HTTPD0_HOST "${CTEST_SERVER_HOST}")
set(HTTPD0_PORT_BASE "59000")
set(HTTPD1_HOST "${CTEST_SERVER_HOST}")
set(HTTPD1_PORT_BASE "59100")
set(HTTPD2_HOST "${CTEST_SERVER_HOST}")
set(HTTPD2_PORT_BASE "59200")
set(MEMCACHED_HOST "${CTEST_SERVER_HOST}")
set(MEMCACHED_PORT_BASE "60000")
set(RENDERD1_HOST "${CTEST_SERVER_HOST}")
set(RENDERD1_PORT_BASE "59500")
set(CURL_CMD "${CURL_EXECUTABLE} --fail --silent")
set(MAP_NAMES jpg png256 png32 webp)
set(TESTS_CONF_DIR "${PROJECT_BINARY_DIR}/tests/conf")
set(TESTS_LOGS_DIR "${PROJECT_BINARY_DIR}/tests/logs")
set(TESTS_RUN_DIR "${PROJECT_BINARY_DIR}/tests/run")
set(TESTS_TILES_DIR "${PROJECT_BINARY_DIR}/tests/tiles")
file(COPY tiles.sha256sum DESTINATION ${PROJECT_BINARY_DIR}/tests)
set(TILE_ZXY "9/297/191")
set(WWW_USER_NAME "nobody")
execute_process(COMMAND ${ID_EXECUTABLE} -gn ${WWW_USER_NAME}
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE WWW_GROUP_NAME
)
execute_process(COMMAND ${ID_EXECUTABLE} -un
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE USER_NAME
)
# Storage backend name (for test display and configuration only)
set(STORAGE_BACKENDS file)
if(MEMCACHED_EXECUTABLE AND LIBMEMCACHED_FOUND)
# Add MemcacheD storage backend
list(APPEND STORAGE_BACKENDS memcached_custom memcached_default)
endif()
list(LENGTH STORAGE_BACKENDS STORAGE_BACKENDS_LENGTH)
math(EXPR STORAGE_BACKENDS_LENGTH "${STORAGE_BACKENDS_LENGTH} - 1")
#-----------------------------------------------------------------------------
#
# Test functions
#
#-----------------------------------------------------------------------------
function(add_bad_tile_download_test TEST_NAME TEST_URL REQUIRED_FIXTURE_NAME)
add_test(NAME bad_download_tile_${TEST_NAME}
COMMAND ${BASH} -c "
echo 'Downloading ${TEST_URL}'
while true; do
HTTP_CODE=$(${CURL_CMD} --write-out '%{http_code}' ${TEST_URL})
echo \"HTTP Code: '\${HTTP_CODE}'\"
if [ \"\${HTTP_CODE}\" == \"404\" ] || [ \"\${HTTP_CODE}\" == \"500\" ]; then
exit 0;
fi
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(bad_download_tile_${TEST_NAME} PROPERTIES
FIXTURES_REQUIRED ${REQUIRED_FIXTURE_NAME}
TIMEOUT 10 # Needs to be more than ModTileMissingRequestTimeout in httpd.conf
)
endfunction()
function(add_good_tile_download_test TEST_NAME TEST_URL FILE_NAME FIXTURE_NAME REQUIRED_FIXTURE_NAME)
add_test(NAME download_tile_${TEST_NAME}
COMMAND ${BASH} -c "
echo 'Downloading ${TEST_URL}'
until $(${CURL_CMD} ${TEST_URL} --output ${FILE_NAME}); do
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(download_tile_${TEST_NAME} PROPERTIES
FIXTURES_REQUIRED ${REQUIRED_FIXTURE_NAME}
FIXTURES_SETUP ${FIXTURE_NAME}
TIMEOUT 10
)
add_test(NAME check_tile_${TEST_NAME}
COMMAND ${BASH} -c "
${SHA256SUM_EXECUTABLE} -c tiles.sha256sum | ${GREP_EXECUTABLE} ${FILE_NAME} | ${GREP_EXECUTABLE} -q OK
"
WORKING_DIRECTORY tests
)
set_tests_properties(check_tile_${TEST_NAME} PROPERTIES
DEPENDS_ON download_tile_${TEST_NAME}
FIXTURES_REQUIRED ${FIXTURE_NAME}
REQUIRED_FILES ${FILE_NAME}
)
add_test(NAME remove_tile_${TEST_NAME}
COMMAND ${RM} -v ${FILE_NAME}
WORKING_DIRECTORY tests
)
set_tests_properties(remove_tile_${TEST_NAME} PROPERTIES
DEPENDS_ON download_tile_${TEST_NAME}
FIXTURES_CLEANUP ${FIXTURE_NAME}
REQUIRED_FILES ${FILE_NAME}
)
endfunction()
#-----------------------------------------------------------------------------
#
# Tests
#
#-----------------------------------------------------------------------------
add_test(NAME gen_tile_test
COMMAND gen_tile_test
)
add_test(
NAME render_expired_test
COMMAND render_expired_test
)
add_test(
NAME render_list_test
COMMAND render_list_test
)
add_test(
NAME render_old_test
COMMAND render_old_test
)
add_test(
NAME render_speedtest_test
COMMAND render_speedtest_test
)
add_test(
NAME renderd_test
COMMAND renderd_test
)
foreach(STORAGE_BACKEND_INDEX RANGE ${STORAGE_BACKENDS_LENGTH})
# Get STORAGE_BACKEND from STORAGE_BACKENDS list
list(GET STORAGE_BACKENDS ${STORAGE_BACKEND_INDEX} STORAGE_BACKEND)
# Increment Ports
math(EXPR HTTPD0_PORT "${HTTPD0_PORT_BASE} + ${STORAGE_BACKEND_INDEX}")
math(EXPR HTTPD1_PORT "${HTTPD1_PORT_BASE} + ${STORAGE_BACKEND_INDEX}")
math(EXPR HTTPD2_PORT "${HTTPD2_PORT_BASE} + ${STORAGE_BACKEND_INDEX}")
math(EXPR RENDERD1_PORT "${RENDERD1_PORT_BASE} + ${STORAGE_BACKEND_INDEX}")
if(STORAGE_BACKEND STREQUAL memcached_custom)
math(EXPR MEMCACHED_PORT "${MEMCACHED_PORT_BASE} + ${STORAGE_BACKEND_INDEX}")
elseif(STORAGE_BACKEND STREQUAL memcached_default)
set(MEMCACHED_PORT "11211")
endif()
# Set STORAGE_BACKEND-level directory names
set(TEST_CONF_DIR "${TESTS_CONF_DIR}/${STORAGE_BACKEND}")
set(TEST_LOGS_DIR "${TESTS_LOGS_DIR}/${STORAGE_BACKEND}")
set(TEST_RUN_DIR "${TESTS_RUN_DIR}/${STORAGE_BACKEND}")
set(TEST_TILES_DIR "${TESTS_TILES_DIR}/${STORAGE_BACKEND}")
# Set STORAGE_BACKEND-level URLs
set(METRICS_OFF_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}/metrics")
set(METRICS_ON_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}/metrics")
set(MOD_TILE_OFF_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}/mod_tile")
set(MOD_TILE_ON_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}/mod_tile")
set(TILE_DEFAULT_TILEJSON_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}/tiles/${DEFAULT_MAP_NAME}/tile-layer.json")
# Set STORAGE_BACKEND-level config file/log/pid/socket file names
set(HTTPD_CONF "${TEST_CONF_DIR}/httpd.conf")
set(HTTPD_LOG "${TEST_LOGS_DIR}/httpd.log")
set(HTTPD_LOG_ACCESS "${TEST_LOGS_DIR}/httpd_access.log")
set(HTTPD_LOG_ERROR "${TEST_LOGS_DIR}/httpd_error.log")
set(HTTPD_PID "${TEST_RUN_DIR}/httpd.pid")
set(MEMCACHED_LOG "${TEST_LOGS_DIR}/memcached.log")
set(MEMCACHED_PID "${TEST_RUN_DIR}/memcached.pid")
set(RENDERD0_LOG "${TEST_LOGS_DIR}/renderd0.log")
set(RENDERD0_PID "${TEST_RUN_DIR}/renderd0.pid")
set(RENDERD0_SOCKET "${TEST_RUN_DIR}/renderd0.sock")
set(RENDERD1_LOG "${TEST_LOGS_DIR}/renderd1.log")
set(RENDERD1_PID "${TEST_RUN_DIR}/renderd1.pid")
set(RENDERD2_LOG "${TEST_LOGS_DIR}/renderd2.log")
set(RENDERD2_PID "${TEST_RUN_DIR}/renderd2.pid")
set(RENDERD2_SOCKET "${TEST_RUN_DIR}/renderd2.sock")
set(RENDERD_CONF "${TEST_CONF_DIR}/renderd.conf")
# Set TILE_DIR value
if(STORAGE_BACKEND STREQUAL file)
# Use TEST_TILES_DIR for file backend
set(TILE_DIR "${TEST_TILES_DIR}")
elseif(STORAGE_BACKEND STREQUAL memcached_custom)
# MemcacheD backend "custom" host:port
set(TILE_DIR "memcached://${MEMCACHED_HOST}:${MEMCACHED_PORT}")
elseif(STORAGE_BACKEND STREQUAL memcached_default)
# MemcacheD backend "default"
set(TILE_DIR "memcached://")
endif()
# Generate renderd.conf file
configure_file(renderd.conf.in ${RENDERD_CONF})
# Generate httpd.conf filelogs
configure_file(httpd.conf.in ${HTTPD_CONF})
# Set list of service start commands
set(SERVICES_START_CMDS
"$<TARGET_FILE:renderd> --config ${RENDERD_CONF} --slave 0 --foreground > ${RENDERD0_LOG} 2>&1 &
PID=\${!}\;
${SLEEP_EXECUTABLE} 1\;
${PS_EXECUTABLE} -p \${PID} || exit 1\;
echo \${PID} > ${RENDERD0_PID}"
"$<TARGET_FILE:renderd> --config ${RENDERD_CONF} --slave 1 --foreground > ${RENDERD1_LOG} 2>&1 &
PID=\${!}\;
${SLEEP_EXECUTABLE} 1\;
${PS_EXECUTABLE} -p \${PID} || exit 1\;
echo \${PID} > ${RENDERD1_PID}"
"$<TARGET_FILE:renderd> --config ${RENDERD_CONF} --slave 2"
"${HTTPD_EXECUTABLE} -e debug -E ${HTTPD_LOG} -f ${HTTPD_CONF} -k start"
)
# Conditionally append memcached start commands to SERVICES_START_CMDS based on STORAGE_BACKEND value
if(STORAGE_BACKEND MATCHES "memcached_.+")
list(APPEND SERVICES_START_CMDS
"${MEMCACHED_EXECUTABLE} -l ${MEMCACHED_HOST} -p ${MEMCACHED_PORT} -u ${USER_NAME} -vvv > ${MEMCACHED_LOG} 2>&1 &
PID=\${!}\;
${SLEEP_EXECUTABLE} 1\;
${PS_EXECUTABLE} -p \${PID} || exit 1\;
echo \${PID} > ${MEMCACHED_PID}"
)
endif()
add_test(NAME create_dirs_${STORAGE_BACKEND}
COMMAND ${MKDIR_EXECUTABLE} -p -v
${TEST_LOGS_DIR}
${TEST_RUN_DIR}
${TEST_TILES_DIR}
WORKING_DIRECTORY tests
)
set_tests_properties(create_dirs_${STORAGE_BACKEND} PROPERTIES
FIXTURES_SETUP services_started_${STORAGE_BACKEND}
)
list(LENGTH SERVICES_START_CMDS SERVICES_START_CMDS_LENGTH)
math(EXPR SERVICES_START_CMDS_LENGTH "${SERVICES_START_CMDS_LENGTH} - 1")
foreach(SERVICES_START_CMDS_INDEX RANGE ${SERVICES_START_CMDS_LENGTH})
# Get SERVICES_START_CMD from SERVICES_START_CMDS list
list(GET SERVICES_START_CMDS ${SERVICES_START_CMDS_INDEX} SERVICES_START_CMD)
add_test(NAME start_services_${STORAGE_BACKEND}_${SERVICES_START_CMDS_INDEX}
COMMAND ${BASH} -c "${SERVICES_START_CMD}"
WORKING_DIRECTORY tests
)
set_tests_properties(start_services_${STORAGE_BACKEND}_${SERVICES_START_CMDS_INDEX} PROPERTIES
DEPENDS create_dirs_${STORAGE_BACKEND}
FIXTURES_SETUP services_started_${STORAGE_BACKEND}
)
endforeach()
foreach(SOCKET_TYPE sock tcp)
# Use socket file as --socket value for communicating with renderd process
if(SOCKET_TYPE STREQUAL sock)
set(SOCKET ${RENDERD0_SOCKET})
endif()
# Use TCP host:port as --socket value for communicating with renderd process
if(SOCKET_TYPE STREQUAL tcp)
set(SOCKET ${RENDERD1_HOST}:${RENDERD1_PORT})
endif()
add_test(NAME render_expired_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
printf '0/0/0\n%.0s' {0..100} | $<TARGET_FILE:render_expired> \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_expired_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_expired_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
echo '100/100/100' | $<TARGET_FILE:render_expired> \
--config ${RENDERD_CONF} \
--no-progress
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_expired_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 60
)
add_test(NAME render_expired_delete_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
echo '0/0/0' | $<TARGET_FILE:render_expired> \
--delete-from 0 \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_expired_delete_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_expired_touch_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_expired_touch_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
echo '0/0/0' | $<TARGET_FILE:render_expired> \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--touch-from 0 \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_expired_touch_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_list_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
$<TARGET_FILE:render_list> \
--all \
--force \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_list_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_list_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
$<TARGET_FILE:render_list> \
--all \
--config ${RENDERD_CONF} \
--max-lat 85.0511 \
--max-lon 180 \
--max-zoom 5 \
--min-lat -85.0511 \
--min-lon -180 \
--min-zoom 5
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_list_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 60
)
add_test(NAME render_list_stdin_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
printf '0 0 0\n%.0s' {0..10} | $<TARGET_FILE:render_list> \
--force \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_list_stdin_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_list_stdin_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
echo '0 0 0' | $<TARGET_FILE:render_list> \
--config ${RENDERD_CONF} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_list_stdin_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 60
)
add_test(NAME render_old_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
${TOUCH_EXECUTABLE} -d '+1 month' ${TEST_TILES_DIR}/planet-import-complete
$<TARGET_FILE:render_old> \
--config ${RENDERD_CONF} \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 5 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET} \
--tile-dir ${TILE_DIR} \
--verbose
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_old_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 90
)
add_test(NAME render_old_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
${TOUCH_EXECUTABLE} -d '+1 month' ${TEST_TILES_DIR}/planet-import-complete
$<TARGET_FILE:render_old> \
--config ${RENDERD_CONF}
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_old_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 60
)
add_test(NAME render_old_config_timestamp_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
$<TARGET_FILE:render_old> \
--config ${RENDERD_CONF} \
--timestamp 01/01/2024
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_old_config_timestamp_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
DEPENDS render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
TIMEOUT 60
)
add_test(NAME render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
$<TARGET_FILE:render_speedtest> \
--map ${DEFAULT_MAP_NAME} \
--max-zoom 10 \
--min-zoom 0 \
--num-threads 1 \
--socket ${SOCKET}
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_speedtest_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED "services_started_${STORAGE_BACKEND};tiles_downloaded_${STORAGE_BACKEND}"
TIMEOUT 90
)
add_test(NAME render_speedtest_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
$<TARGET_FILE:render_speedtest> \
--config ${RENDERD_CONF}
"
WORKING_DIRECTORY tests
)
set_tests_properties(render_speedtest_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED "services_started_${STORAGE_BACKEND};tiles_downloaded_${STORAGE_BACKEND}"
TIMEOUT 60
)
add_test(NAME add_tile_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
CONFIG_NAME=\"bad_tile_config_${SOCKET_TYPE}\"
SEARCH_LINE=\$(${GREP_EXECUTABLE} -m1 \"Loading tile config \${CONFIG_NAME}\" ${HTTPD_LOG})
SEARCH_STRS=(
\" at /\${CONFIG_NAME}/ \"
\" extension .jpg \"
\" mime type image/jpeg$\"
\" tile directory ${TILE_DIR} \"
\" zooms 10 - 15 \"
)
echo \"Searching log line '\${SEARCH_LINE}'\"
for SEARCH_STR in \"\${SEARCH_STRS[@]}\"; do
echo \"\tFor '\${SEARCH_STR}'\"
echo \"\${SEARCH_LINE}\" | ${GREP_EXECUTABLE} -q -e \"\${SEARCH_STR}\" || exit 1
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(add_tile_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
add_test(NAME add_tile_mime_config_${SOCKET_TYPE}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
for SEARCH_CONFIG in js png; do
CONFIG_NAME=\"bad_tile_mime_config_\${SEARCH_CONFIG}_${SOCKET_TYPE}\"
MIME_TYPE=image/png
if [ \"\${SEARCH_CONFIG}\" = \"js\" ]; then
MIME_TYPE=text/javascript
fi
SEARCH_LINE=\$(${GREP_EXECUTABLE} -m1 \"Loading tile config \${CONFIG_NAME}\" ${HTTPD_LOG})
SEARCH_STRS=(
\" at /\${CONFIG_NAME}/ \"
\" extension .\${SEARCH_CONFIG} \"
\" mime type \${MIME_TYPE}$\"
\" tile directory ${RENDERD_TILE_DIR} \"
\" zooms 0 - 20 \"
)
echo \"Searching log line '\${SEARCH_LINE}'\"
for SEARCH_STR in \"\${SEARCH_STRS[@]}\"; do
echo \"\tFor '\${SEARCH_STR}'\"
echo \"\${SEARCH_LINE}\" | ${GREP_EXECUTABLE} -q -e \"\${SEARCH_STR}\" || exit 1
done
SEARCH_LINE=\$(${GREP_EXECUTABLE} \"AddTileMimeConfig will be deprecated\" ${HTTPD_LOG} | \
${GREP_EXECUTABLE} -m1 \"\${CONFIG_NAME}\")
echo \"Searching log line '\${SEARCH_LINE}'\"
SEARCH_STR=\"AddTileConfig /\${CONFIG_NAME}/ \${CONFIG_NAME} mimetype=\${MIME_TYPE} extension=\${SEARCH_CONFIG}\"
echo \"\tFor '\${SEARCH_STR}'\"
echo \"\${SEARCH_LINE}\" | ${GREP_EXECUTABLE} -q -e \"\${SEARCH_STR}\" || exit 1
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(add_tile_mime_config_${SOCKET_TYPE}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
foreach(BAD_ADD_CONFIG bad_tile_config bad_tile_mime_config_js bad_tile_mime_config_png)
if(BAD_ADD_CONFIG STREQUAL bad_tile_config)
set(EXTENSION jpg)
elseif(BAD_ADD_CONFIG STREQUAL bad_tile_mime_config_js)
set(EXTENSION js)
elseif(BAD_ADD_CONFIG STREQUAL bad_tile_mime_config_png)
set(EXTENSION png)
endif()
# Generate URL path for tiles
set(TILE_URL_PATH "/${BAD_ADD_CONFIG}_${SOCKET_TYPE}/${TILE_ZXY}.${EXTENSION}")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_bad_tile_download_test(
${BAD_ADD_CONFIG}_${SOCKET_TYPE}_${STORAGE_BACKEND}_0
${HTTPD0_URL}
services_started_${STORAGE_BACKEND}
)
add_bad_tile_download_test(
${BAD_ADD_CONFIG}_${SOCKET_TYPE}_${STORAGE_BACKEND}_1
${HTTPD1_URL}
services_started_${STORAGE_BACKEND}
)
endforeach()
endforeach()
foreach(MAP_NAME IN LISTS MAP_NAMES)
# Set EXTENSION from MAP_NAME (only works for map names containing an actual extension)
string(REGEX REPLACE "[0-9]+" "" EXTENSION ${MAP_NAME})
# Set count for stats to 0
set(STATS_COUNTER 0)
# Generate file and URL paths for tiles
set(TILE_FILE_NAME "tile.${MAP_NAME}.${STORAGE_BACKEND}")
set(TILE_URL_PATH "/tiles/${MAP_NAME}/${TILE_ZXY}.${EXTENSION}")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
set(HTTPD2_URL "http://${HTTPD2_HOST}:${HTTPD2_PORT}${TILE_URL_PATH}")
# Generate tile dirty and status URLs
set(DIRTY_OFF_URL "${HTTPD1_URL}/dirty")
set(DIRTY_ON_URL "${HTTPD0_URL}/dirty")
set(STATUS_OFF_URL "${HTTPD1_URL}/status")
set(STATUS_ON_URL "${HTTPD0_URL}/status")
# Increment count for stats (only counted by requests to HTTPD0_URL, HTTPD1_URL has stats disabled)
math(EXPR STATS_COUNTER "${STATS_COUNTER} + 1")
add_good_tile_download_test(
${MAP_NAME}_${STORAGE_BACKEND}_0
${HTTPD0_URL}
${TILE_FILE_NAME}.0
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
add_good_tile_download_test(
${MAP_NAME}_${STORAGE_BACKEND}_1
${HTTPD1_URL}
${TILE_FILE_NAME}.1
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
add_test(NAME dirty_and_status_${MAP_NAME}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
TILE_DIRTY_ON_CMD=\"${CURL_CMD} ${DIRTY_ON_URL}\"
TILE_STATUS_ON_CMD=\"${CURL_CMD} ${STATUS_ON_URL}\"
TILE_LAST_RENDERED_AT_OLD=$(\${TILE_STATUS_ON_CMD} | ${GREP_EXECUTABLE} -o 'Last rendered at [^\\.]*.')
echo \"Tile Last Rendered At (Old): \${TILE_LAST_RENDERED_AT_OLD}\"
${SLEEP_EXECUTABLE} 1
TILE_DIRTY_ON_OUTPUT=$(\${TILE_DIRTY_ON_CMD})
echo \"Dirty On Output: \${TILE_DIRTY_ON_OUTPUT}\"
until [ \"\${TILE_DIRTY_ON_OUTPUT}\" == \"Tile submitted for rendering\" ]; do
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
TILE_DIRTY_ON_OUTPUT=$(\${TILE_DIRTY_ON_CMD})
echo \"Dirty On Output: \${TILE_DIRTY_ON_OUTPUT}\"
done
TILE_LAST_RENDERED_AT_NEW=$(\${TILE_STATUS_ON_CMD} | ${GREP_EXECUTABLE} -o 'Last rendered at [^\\.]*.')
echo \"Tile Last Rendered At (New): \${TILE_LAST_RENDERED_AT_NEW}\"
until [ \"\${TILE_LAST_RENDERED_AT_OLD}\" != \"\${TILE_LAST_RENDERED_AT_NEW}\" ]; do
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
TILE_LAST_RENDERED_AT_NEW=$(\${TILE_STATUS_ON_CMD} | ${GREP_EXECUTABLE} -o 'Last rendered at [^\\.]*.');
echo \"Tile Last Rendered At (New): \${TILE_LAST_RENDERED_AT_NEW}\";
done
TILE_DIRTY_OFF_CODE=$(${CURL_CMD} --write-out '%{http_code}' ${DIRTY_OFF_URL})
echo \"Dirty Off code: '\${TILE_DIRTY_OFF_CODE}'\"
until [ \"\${TILE_DIRTY_OFF_CODE}\" == \"404\" ]; do
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
TILE_DIRTY_OFF_CODE=$(${CURL_CMD} --write-out '%{http_code}' ${DIRTY_OFF_URL})
echo \"Dirty Off code: '\${TILE_DIRTY_OFF_CODE}'\"
done
TILE_STATUS_OFF_CODE=$(${CURL_CMD} --write-out '%{http_code}' ${STATUS_OFF_URL})
echo \"Status Off code: '\${TILE_STATUS_OFF_CODE}'\"
until [ \"\${TILE_STATUS_OFF_CODE}\" == \"404\" ]; do
echo 'Sleeping 1s';
${SLEEP_EXECUTABLE} 1;
TILE_STATUS_OFF_CODE=$(${CURL_CMD} --write-out '%{http_code}' ${STATUS_OFF_URL})
echo \"Status Off code: '\${TILE_STATUS_OFF_CODE}'\"
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(dirty_and_status_${MAP_NAME}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED "services_started_${STORAGE_BACKEND};tiles_downloaded_${STORAGE_BACKEND}"
TIMEOUT 20
)
add_test(NAME stats_urls_${MAP_NAME}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
METRICS_ON_CMD=\"${CURL_CMD} ${METRICS_ON_URL}\"
METRICS_ON_OUTPUT=$(\${METRICS_ON_CMD})
echo \"Metrics On output: \${METRICS_ON_OUTPUT}\"
METRICS_200=\"modtile_layer_responses_total{layer=\\\"/tiles/${MAP_NAME}/\\\",status=\\\"200\\\"} ${STATS_COUNTER}\"
echo \"\${METRICS_200}\";
if [[ \"\${METRICS_ON_OUTPUT}\" != *\"\${METRICS_200}\"* ]]; then
exit 1;
fi
METRICS_OFF_OUTPUT=$(${CURL_CMD} ${METRICS_OFF_URL})
echo \"Metrics Off output: '\${METRICS_OFF_OUTPUT}'\";
if [ \"\${METRICS_OFF_OUTPUT}\" != \"Stats are not enabled for this server\" ]; then
exit 1;
fi
MOD_TILE_ON_CMD=\"${CURL_CMD} ${MOD_TILE_ON_URL}\"
MOD_TILE_ON_OUTPUT=$(\${MOD_TILE_ON_CMD})
echo \"Mod_tile On output: \${MOD_TILE_ON_OUTPUT}\"
MOD_TILE_200=\"NoRes200Layer/tiles/${MAP_NAME}/: ${STATS_COUNTER}\"
echo \"\${MOD_TILE_200}\";
if [[ \"\${MOD_TILE_ON_OUTPUT}\" != *\"\${MOD_TILE_200}\"* ]]; then
exit 1;
fi
MOD_TILE_OFF_OUTPUT=$(${CURL_CMD} ${MOD_TILE_OFF_URL})
echo \"Mod_tile Off output: '\${MOD_TILE_OFF_OUTPUT}'\";
if [ \"\${MOD_TILE_OFF_OUTPUT}\" != \"Stats are not enabled for this server\" ]; then
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(stats_urls_${MAP_NAME}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED "services_started_${STORAGE_BACKEND};tiles_downloaded_${STORAGE_BACKEND}"
)
add_test(NAME tile_expired_${MAP_NAME}_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
${TOUCH_EXECUTABLE} -d '-1 month' ${TEST_TILES_DIR}/planet-import-complete
if ! ${CURL_CMD} --output /dev/null ${HTTPD1_URL}; then
echo \"Past import: ${HTTPD1_URL}\";
fi
if ! ${CURL_CMD} --output /dev/null ${HTTPD2_URL}; then
echo \"Past import: ${HTTPD2_URL}\";
fi
${TOUCH_EXECUTABLE} -d '+1 month' ${TEST_TILES_DIR}/planet-import-complete
if ! ${CURL_CMD} --output /dev/null ${HTTPD1_URL}; then
echo \"Future import: ${HTTPD1_URL}\";
fi
if ! ${CURL_CMD} --output /dev/null ${HTTPD2_URL}; then
echo \"Future import: ${HTTPD2_URL}\";
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(tile_expired_${MAP_NAME}_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
endforeach()
# Generate file and URL paths for tiles
set(TILE_FILE_NAME "tile.add_tile_config.${STORAGE_BACKEND}")
set(TILE_URL_PATH "/good_add_tile_config/${TILE_ZXY}.png")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_good_tile_download_test(
add_tile_config_${STORAGE_BACKEND}_0
${HTTPD0_URL}
${TILE_FILE_NAME}.0
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
add_good_tile_download_test(
add_tile_config_${STORAGE_BACKEND}_1
${HTTPD1_URL}
${TILE_FILE_NAME}.1
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
if(NOT PROCESSOR_COUNT EQUAL 0)
# Set CTEST_NUM_SLAVE_THREADS to 5 (renderd1 = 1, renderd2 = 4 [NUM_THREADS])
set(CTEST_NUM_SLAVE_THREADS 5)
add_test(NAME renderd_num_threads_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
if ! ${GREP_EXECUTABLE} -q \"renderd: num_threads = '${PROCESSOR_COUNT}'\" \"${RENDERD0_LOG}\"; then
${GREP_EXECUTABLE} \"renderd: num_threads = \" \"${RENDERD0_LOG}\"
exit 1;
fi
if ! ${GREP_EXECUTABLE} -q \"renderd: num_slave_threads = '${CTEST_NUM_SLAVE_THREADS}'\" \"${RENDERD0_LOG}\"; then
${GREP_EXECUTABLE} \"renderd: num_slave_threads = \" \"${RENDERD0_LOG}\"
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(renderd_num_threads_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
REQUIRED_FILES ${RENDERD0_LOG}
)
endif()
add_test(NAME stop_services_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
for SERVICE_PID_FILE in ${TEST_RUN_DIR}/*.pid; do
${KILL_EXECUTABLE} $(${CAT_EXECUTABLE} \${SERVICE_PID_FILE});
${RM} \${SERVICE_PID_FILE};
${SLEEP_EXECUTABLE} 1;
done
"
WORKING_DIRECTORY tests
)
set_tests_properties(stop_services_${STORAGE_BACKEND} PROPERTIES
FIXTURES_CLEANUP services_started_${STORAGE_BACKEND}
)
add_test(NAME clear_dirs_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
${RM} -f -r -v \
${TEST_LOGS_DIR}/* \
${TEST_RUN_DIR}/* \
${TEST_TILES_DIR}/*
"
WORKING_DIRECTORY tests
)
set_tests_properties(clear_dirs_${STORAGE_BACKEND} PROPERTIES
DEPENDS stop_services_${STORAGE_BACKEND}
FIXTURES_CLEANUP services_started_${STORAGE_BACKEND}
REQUIRED_FILES "${TEST_LOGS_DIR};${TEST_RUN_DIR};${TEST_TILES_DIR}"
)
if(STORAGE_BACKEND STREQUAL file)
# Generate file and URL paths for tiles
set(TILE_FILE_NAME "tile.parameterization.${STORAGE_BACKEND}")
set(TILE_URL_PATH "/tiles/parameterization/en,de,_/${TILE_ZXY}.png")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_good_tile_download_test(
parameterization_${STORAGE_BACKEND}_0
${HTTPD0_URL}
${TILE_FILE_NAME}.0
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
add_good_tile_download_test(
parameterization_${STORAGE_BACKEND}_1
${HTTPD1_URL}
${TILE_FILE_NAME}.1
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
# Generate file and URL paths for tiles
set(TILE_FILE_NAME "tile.htcp.${STORAGE_BACKEND}")
set(TILE_URL_PATH "/tiles/htcp/${TILE_ZXY}.png")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_good_tile_download_test(
htcp_${STORAGE_BACKEND}_0
${HTTPD0_URL}
${TILE_FILE_NAME}.0
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
add_good_tile_download_test(
htcp_${STORAGE_BACKEND}_1
${HTTPD1_URL}
${TILE_FILE_NAME}.1
tiles_downloaded_${STORAGE_BACKEND}
services_started_${STORAGE_BACKEND}
)
# Generate URL path for tiles
set(TILE_URL_PATH "/tiles/cors_all/${TILE_ZXY}.png")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_test(NAME cors_all_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
RESPONSE_CODE_CMD=\"${CURL_CMD} --write-out %{http_code} --output /dev/null\"
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} ${HTTPD0_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"200\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} ${HTTPD1_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"200\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: example.com\" ${HTTPD0_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"200\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: example.com\" ${HTTPD1_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"200\" ]; then
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(cors_all_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
# Generate URL path for tiles
set(TILE_URL_PATH "/tiles/cors_localhost/${TILE_ZXY}.png")
# Generate tile URLs
set(HTTPD0_URL "http://${HTTPD0_HOST}:${HTTPD0_PORT}${TILE_URL_PATH}")
set(HTTPD1_URL "http://${HTTPD1_HOST}:${HTTPD1_PORT}${TILE_URL_PATH}")
add_test(NAME cors_localhost_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
RESPONSE_CODE_CMD=\"${CURL_CMD} --write-out %{http_code}\"
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: notlocalhost\" ${HTTPD0_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"403\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: notlocalhost\" ${HTTPD1_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"403\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: localhost\" ${HTTPD0_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" = \"403\" ]; then
exit 1;
fi
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"Origin: localhost\" ${HTTPD1_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" = \"403\" ]; then
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(cors_localhost_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
# Generate URL path for tiles
set(TILE_URL_PATH "/tiles/png256/18/16125/115188.png")
# Generate tile URL
set(HTTPD2_URL "http://${HTTPD2_HOST}:${HTTPD2_PORT}${TILE_URL_PATH}")
add_test(NAME max_load_missing_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
RESPONSE_CODE_CMD=\"${CURL_CMD} --write-out %{http_code}\"
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} ${HTTPD2_URL})
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" != \"404\" ]; then
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(max_load_missing_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
add_test(NAME throttling_xforward_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
RESPONSE_CODE_CMD=\"${CURL_CMD} --write-out %{http_code}\"
for i in {0..20}; do
RESPONSE_CODE=$(\${RESPONSE_CODE_CMD} --header \"X-Forwarded-For: ${CTEST_SERVER_HOST}, ${CTEST_CLIENT_HOST}\" \
http://${HTTPD2_HOST}:${HTTPD2_PORT}/tiles/webp/\$i/0/0.webp)
echo \"Response code: '\${RESPONSE_CODE}'\"
if [ \"\${RESPONSE_CODE}\" = \"503\" ]; then
echo 'Request being rejected';
exit 0;
fi
done
echo 'Request was never rejected';
exit 1;
"
WORKING_DIRECTORY tests
)
set_tests_properties(throttling_xforward_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
RUN_SERIAL TRUE
)
endif()
if(JQ_EXECUTABLE)
add_test(NAME tilejson_url_${STORAGE_BACKEND}
COMMAND ${BASH} -c "
TILE_DEFAULT_TILEJSON_CMD=\"${CURL_CMD} ${TILE_DEFAULT_TILEJSON_URL}\"
TILE_DEFAULT_TILEJSON_OUTPUT=$(\${TILE_DEFAULT_TILEJSON_CMD})
TILE_DEFAULT_TILEJSON_ATTRIBUTION=$(echo \"\${TILE_DEFAULT_TILEJSON_OUTPUT}\" | ${JQ_EXECUTABLE} -r .attribution)
if [ \"\${TILE_DEFAULT_TILEJSON_ATTRIBUTION}\" != \"Attribution for ${DEFAULT_MAP_NAME}\" ]; then
exit 1;
fi
TILE_DEFAULT_TILEJSON_DESCRIPTION=$(echo \"\${TILE_DEFAULT_TILEJSON_OUTPUT}\" | ${JQ_EXECUTABLE} -r .description)
if [ \"\${TILE_DEFAULT_TILEJSON_DESCRIPTION}\" != \"Description for ${DEFAULT_MAP_NAME}\" ]; then
exit 1;
fi
TILE_DEFAULT_TILEJSON_NAME=$(echo \"\${TILE_DEFAULT_TILEJSON_OUTPUT}\" | ${JQ_EXECUTABLE} -r .name)
if [ \"\${TILE_DEFAULT_TILEJSON_NAME}\" != \"${DEFAULT_MAP_NAME}\" ]; then
exit 1;
fi
TILE_DEFAULT_TILEJSON_VERSION=$(echo \"\${TILE_DEFAULT_TILEJSON_OUTPUT}\" | ${JQ_EXECUTABLE} -r .tilejson)
if [ \"\${TILE_DEFAULT_TILEJSON_VERSION}\" != \"2.0.0\" ]; then
exit 1;
fi
"
WORKING_DIRECTORY tests
)
set_tests_properties(tilejson_url_${STORAGE_BACKEND} PROPERTIES
FIXTURES_REQUIRED services_started_${STORAGE_BACKEND}
)
endif()
endforeach()
# Test mal-formed HTTPD configuration directives
set(DIRECTIVES
"AddTileConfig"
"AddTileConfig string"
"AddTileConfig string string maxzoom=100"
"LoadTileConfigFile"
"LoadTileConfigFile /tmp/bad/file/name"
"ModTileCacheDurationDirty string"
"ModTileCacheDurationLowZoom 1 string"
"ModTileCacheDurationLowZoom string 1"
"ModTileCacheDurationMax string"
"ModTileCacheDurationMediumZoom 1 string"
"ModTileCacheDurationMediumZoom string 1"
"ModTileCacheDurationMinimum string"
"ModTileCacheExtendedDuration string"
"ModTileCacheLastModifiedFactor string"
"ModTileEnableTileThrottlingXForward -1"
"ModTileEnableTileThrottlingXForward 3"
"ModTileEnableTileThrottlingXForward string"
"ModTileMaxLoadMissing string"
"ModTileMaxLoadOld string"
"ModTileMissingRequestTimeout string"
"ModTileRenderdSocketAddr string string"
"ModTileRequestTimeout string"
"ModTileThrottlingRenders 1 string"
"ModTileThrottlingRenders string 1"
"ModTileThrottlingTiles 1 string"
"ModTileThrottlingTiles string 1"
"ModTileVeryOldThreshold string"
)
set(DIRECTIVE_ERRORS
"AddTileConfig error, URL path not defined"
"AddTileConfig error, name of renderd config not defined"
"The configured zoom level lies outside of the range supported by this server"
"LoadTileConfigFile takes one argument, load an entire renderd config file"
"LoadTileConfigFile error, unable to open config file"
"ModTileCacheDurationDirty needs integer argument"
"ModTileCacheDurationLowZoom needs integer argument"
"ModTileCacheDurationLowZoom needs integer argument"
"ModTileCacheDurationMax needs integer argument"
"ModTileCacheDurationMediumZoom needs integer argument"
"ModTileCacheDurationMediumZoom needs integer argument"
"ModTileCacheDurationMinimum needs integer argument"
"ModTileCacheExtendedDuration needs integer argument"
"ModTileCacheLastModifiedFactor needs float argument"
"ModTileEnableTileThrottlingXForward needs integer argument between 0 and 2 (0 => off\;
1 => use client\; 2 => use last entry in chain"
"ModTileEnableTileThrottlingXForward needs integer argument between 0 and 2 (0 => off\;
1 => use client\; 2 => use last entry in chain"
"ModTileEnableTileThrottlingXForward needs integer argument between 0 and 2"
"ModTileMaxLoadMissing needs integer argument"
"ModTileMaxLoadOld needs integer argument"
"ModTileMissingRequestTimeout needs integer argument"
"ModTileRenderdSocketAddr TCP port needs to be an integer argument"
"ModTileRequestTimeout needs integer argument"
"ModTileThrottlingRenders needs two numerical arguments, the first one must be integer"
"ModTileThrottlingRenders needs two numerical arguments, the first one must be integer"
"ModTileThrottlingTiles needs two numerical arguments, the first one must be integer"
"ModTileThrottlingTiles needs two numerical arguments, the first one must be integer"
"ModTileVeryOldThreshold needs integer argument"
)
list(LENGTH DIRECTIVES DIRECTIVES_LENGTH)
math(EXPR DIRECTIVES_LENGTH "${DIRECTIVES_LENGTH} - 1")
foreach(DIRECTIVE_INDEX RANGE ${DIRECTIVES_LENGTH})
set(HTTPD_CONF "${TESTS_CONF_DIR}/httpd_bad_${DIRECTIVE_INDEX}.conf")
# Get DIRECTIVE from DIRECTIVES list
list(GET DIRECTIVES ${DIRECTIVE_INDEX} DIRECTIVE)
# Get DIRECTIVE_ERROR from DIRECTIVE_ERRORS list
list(GET DIRECTIVE_ERRORS ${DIRECTIVE_INDEX} DIRECTIVE_ERROR)
# Generate httpd.conf file
configure_file(httpd.conf.in ${HTTPD_CONF})
add_test(NAME bad_httpd_config_${DIRECTIVE_INDEX}
COMMAND ${BASH} -c "
HTTPD_OUTPUT=$(${HTTPD_EXECUTABLE} -e debug -f ${HTTPD_CONF} -t 2>&1)
if [ \"\${?}\" -eq \"0\" ]; then
echo \"Unexpected success.\"
echo \"\${HTTPD_OUTPUT}\"
exit 1;
fi
if echo \"\${HTTPD_OUTPUT}\" | ${GREP_EXECUTABLE} -q \"${DIRECTIVE_ERROR}\"; then
exit 0;
else
echo \"\${HTTPD_OUTPUT}\"
exit 1;
fi
"
WORKING_DIRECTORY tests
)
endforeach()
#-----------------------------------------------------------------------------
#
# Test targets
#
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
#
# catch_main_o
#
#-----------------------------------------------------------------------------
add_library(catch_main_o OBJECT
catch/catch_main.cpp
${PROJECT_SOURCE_DIR}/tests/catch/catch_test_common.cpp
)
target_include_directories(catch_main_o PRIVATE ${GLIB_INCLUDE_DIRS})
#-----------------------------------------------------------------------------
#
# catch_test_common_o
#
#-----------------------------------------------------------------------------
add_library(catch_test_common_o OBJECT ${PROJECT_SOURCE_DIR}/tests/catch/catch_test_common.cpp)
target_include_directories(catch_test_common_o PRIVATE ${GLIB_INCLUDE_DIRS})
#-----------------------------------------------------------------------------
#
# gen_tile_test
#
#-----------------------------------------------------------------------------
# Added by ${PROJECT_SOURCE_DIR}/src/CMakeLists.txt
# (in order to reduce redundant source and library definitions)
#-----------------------------------------------------------------------------
#
# Additional options for targets added hereafter
#
#-----------------------------------------------------------------------------
add_compile_definitions(
PROJECT_BINARY_DIR="${PROJECT_BINARY_DIR}/src"
RENDERD_CONF="${PROJECT_SOURCE_DIR}/etc/renderd/renderd.conf"
)
include_directories(${PROJECT_SOURCE_DIR}/includes)
link_libraries(${GLIB_LIBRARIES})
#-----------------------------------------------------------------------------
#
# render_expired_test
#
#-----------------------------------------------------------------------------
add_executable(render_expired_test
$<TARGET_OBJECTS:catch_main_o>
render_expired_test.cpp
)
#-----------------------------------------------------------------------------
#
# render_list_test
#
#-----------------------------------------------------------------------------
add_executable(render_list_test
$<TARGET_OBJECTS:catch_main_o>
render_list_test.cpp
)
#-----------------------------------------------------------------------------
#
# render_old_test
#
#-----------------------------------------------------------------------------
add_executable(render_old_test
$<TARGET_OBJECTS:catch_main_o>
render_old_test.cpp
)
#-----------------------------------------------------------------------------
#
# render_speedtest_test
#
#-----------------------------------------------------------------------------
add_executable(render_speedtest_test
$<TARGET_OBJECTS:catch_main_o>
render_speedtest_test.cpp
)
#-----------------------------------------------------------------------------
#
# renderd_test
#
#-----------------------------------------------------------------------------
add_executable(renderd_test
$<TARGET_OBJECTS:catch_main_o>
renderd_test.cpp
)
Reference in New Issue View Git Blame Copy Permalink