tests: add CMake-integrated poller unit coverage

Author: aarond10

.github/workflows/cmake.yml

@@ -33,7 +33,7 @@ jobs:
     - name: Configure CMake
       env:
         CC: ${{ matrix.compiler }}
-      run: cmake -D CMAKE_BUILD_TYPE=Debug -D PYTHON3_EXE=${{github.workspace}}/venv/bin/python3 -B ${{github.workspace}}/
+      run: cmake -D CMAKE_BUILD_TYPE=Debug -D BUILD_TESTING=ON -D PYTHON3_EXE=${{github.workspace}}/venv/bin/python3 -B ${{github.workspace}}/
 
     - name: Build
       env:

CMakeLists.txt

@@ -192,24 +192,34 @@ install(FILES ${CMAKE_BINARY_DIR}/${TARGET_NAME}.service
 
 # TESTING
 
-enable_testing()
-add_test(NAME dns_poller_watchers
-  COMMAND ${CMAKE_COMMAND} -E env "CC=${CMAKE_C_COMPILER}"
-          sh ${CMAKE_SOURCE_DIR}/tests/unit/run_dns_poller_test.sh)
-
-find_program(
-  PYTHON3_EXE
-  NAMES "python3"
-  DOC "Path to python3 executable"
-  )
-if(NOT PYTHON3_EXE)
-  message(STATUS "python3 not found, robot testing not possible")
-else()
-  message(STATUS "python3 found: ${PYTHON3_EXE}")
+option(BUILD_TESTING "Build tests" OFF)
+include(CTest)
+if(BUILD_TESTING)
+  add_executable(dns_poller_watchers_test
+    tests/unit/test_dns_poller.c
+    src/logging.c
+    src/ring_buffer.c)
+  set_property(SOURCE tests/unit/test_dns_poller.c APPEND
+    PROPERTY COMPILE_DEFINITIONS __FILENAME__="dns_poller_test")
+  target_link_libraries(dns_poller_watchers_test cares ev)
+  set_property(TARGET dns_poller_watchers_test PROPERTY C_STANDARD 11)
+  add_test(NAME dns_poller_watchers COMMAND dns_poller_watchers_test)
+  set_tests_properties(dns_poller_watchers PROPERTIES LABELS unit)
 
-  # Robot framework tests
-  add_test(NAME robot COMMAND ${PYTHON3_EXE} -m robot.run functional_tests.robot
-           WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests/robot)
+  find_program(
+    PYTHON3_EXE
+    NAMES "python3"
+    DOC "Path to python3 executable"
+    )
+  if(NOT PYTHON3_EXE)
+    message(STATUS "python3 not found, robot testing not possible")
+  else()
+    message(STATUS "python3 found: ${PYTHON3_EXE}")
+
+    # Robot framework tests
+    add_test(NAME robot COMMAND ${PYTHON3_EXE} -m robot.run functional_tests.robot
+             WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests/robot)
+  endif()
 endif()
 
 # Clean target (removes entire build directory)

tests/docker/Dockerfile

@@ -24,4 +24,4 @@ WORKDIR /src
 
 # Default command: build and run tests
 # Symlink needed because Robot test expects binary at project root
-CMD ["bash", "-c", "cmake -S . -B build && cmake --build build && ln -sf build/https_dns_proxy https_dns_proxy && ctest --test-dir build --output-on-failure"]
+CMD ["bash", "-c", "cmake -S . -B build -DBUILD_TESTING=ON && cmake --build build && ln -sf build/https_dns_proxy https_dns_proxy && ctest --test-dir build --output-on-failure"]

tests/unit/run_dns_poller_test.sh

@@ -1,41 +1,135 @@
-#include <assert.h>
 #include <sys/socket.h>
 #include <unistd.h>
+
+#include "test_harness.h"
 #include "../../src/dns_poller.c"
-int main(void) {
-  dns_poller_t d = {0};
-  struct ev_loop *loop = ev_loop_new(0);
-  assert(loop);
-  dns_poller_init(&d, loop, "127.0.0.1,127.0.0.2", 60, NULL,
+
+enum {
+  TEST_SOCKET_COUNT = 40,
+  TEST_FD_CAPACITY = 48
+};
+
+static dns_poller_t poller;
+static struct ev_loop *loop;
+static int poller_initialized;
+static int tracked_fds[TEST_FD_CAPACITY];
+static unsigned tracked_fd_count;
+
+static void setUp(void) {
+  poller_initialized = 0;
+  tracked_fd_count = 0;
+  loop = NULL;
+  memset(&poller, 0, sizeof(poller));
+  loop = ev_loop_new(0);
+  if (!loop) {
+    test_fail(__FILE__, __LINE__, "ev_loop_new(0)");
+    return;
+  }
+  dns_poller_init(&poller, loop, "127.0.0.1,127.0.0.2", 60, NULL,
                   "example.com", AF_INET, NULL, NULL);
-  ev_timer_stop(loop, &d.timer);
-  int fds[40];
-  ev_io *first = NULL;
-  for (int i = 0; i < 40; i++) {
-    fds[i] = socket(AF_INET, SOCK_DGRAM, 0);
-    assert(fds[i] >= 0);
-    sock_state_cb(&d, fds[i], 1, 0);
-    assert(get_io_event(&d, fds[i]));
-    if (!i) first = get_io_event(&d, fds[i]);
-    assert(get_io_event(&d, fds[0]) == first);
+  poller_initialized = 1;
+  ev_timer_stop(loop, &poller.timer);
+}
+
+static void tearDown(void) {
+  if (poller_initialized) {
+    dns_poller_cleanup(&poller);
+    poller_initialized = 0;
+  }
+  for (unsigned i = 0; i < tracked_fd_count; i++) {
+    close(tracked_fds[i]);
   }
-  ev_io *reused = get_io_event(&d, fds[10]);
-  sock_state_cb(&d, fds[10], 0, 0);
-  assert(!get_io_event(&d, fds[10]));
-  sock_state_cb(&d, fds[10], 1, 1);
-  assert(get_io_event(&d, fds[10]) == reused);
-  for (int i = 0; i < 40; i++) {
-    sock_state_cb(&d, fds[i], 0, 0);
-    close(fds[i]);
+  if (loop) {
+    ev_loop_destroy(loop);
+    loop = NULL;
   }
-  // Also exercise cleanup with a registered watcher still active.
-  int remaining = socket(AF_INET, SOCK_DGRAM, 0);
-  assert(remaining >= 0);
-  sock_state_cb(&d, remaining, 1, 0);
-  dns_poller_cleanup(&d);
-  close(remaining);
-  ev_run(loop, EVRUN_NOWAIT);
-  ev_loop_destroy(loop);
-  puts("PASS: 40 sockets / 2 servers; stable addresses; update/reuse/cleanup");
-  return 0;
+}
+
+static int open_test_socket(void) {
+  int fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (fd < 0) {
+    return fd;
+  }
+  if (tracked_fd_count >= TEST_FD_CAPACITY) {
+    close(fd);
+    return -1;
+  }
+  tracked_fds[tracked_fd_count++] = fd;
+  return fd;
+}
+
+static int watcher_matches(ev_io *watcher, int fd, int events) {
+  return watcher && ev_is_active(watcher) && !ev_is_pending(watcher) &&
+         watcher->fd == fd && watcher->events == events &&
+         watcher->data == &poller;
+}
+
+static void test_allocates_watchers_beyond_nameserver_count(void) {
+  ev_io *first = NULL;
+  int first_fd = ARES_SOCKET_BAD;
+
+  for (int i = 0; i < TEST_SOCKET_COUNT; i++) {
+    int fd = open_test_socket();
+    TEST_ASSERT(fd >= 0);
+    sock_state_cb(&poller, fd, 1, 0);
+    TEST_ASSERT(watcher_matches(get_io_event(&poller, fd), fd, EV_READ));
+    if (i == 0) {
+      first = get_io_event(&poller, fd);
+      first_fd = fd;
+    }
+    TEST_ASSERT_EQUAL_PTR(first, get_io_event(&poller, first_fd));
+  }
+}
+
+static void test_reuses_released_watcher(void) {
+  int fd = open_test_socket();
+  TEST_ASSERT(fd >= 0);
+  sock_state_cb(&poller, fd, 1, 0);
+  ev_io *watcher = get_io_event(&poller, fd);
+  TEST_ASSERT(watcher_matches(watcher, fd, EV_READ));
+
+  sock_state_cb(&poller, fd, 0, 0);
+  TEST_ASSERT(!get_io_event(&poller, fd));
+  TEST_ASSERT(!ev_is_active(watcher));
+  TEST_ASSERT(!ev_is_pending(watcher));
+  TEST_ASSERT(watcher->fd == ARES_SOCKET_BAD);
+  sock_state_cb(&poller, fd, 1, 1);
+  TEST_ASSERT_EQUAL_PTR(watcher, get_io_event(&poller, fd));
+  TEST_ASSERT(watcher_matches(watcher, fd, EV_READ | EV_WRITE));
+}
+
+static void test_fd_zero_does_not_alias_free_watcher(void) {
+  sock_state_cb(&poller, 0, 1, 0);
+  ev_io *fd_zero_watcher = get_io_event(&poller, 0);
+  TEST_ASSERT(watcher_matches(fd_zero_watcher, 0, EV_READ));
+
+  int fd = open_test_socket();
+  TEST_ASSERT(fd > 0);
+  sock_state_cb(&poller, fd, 1, 0);
+  TEST_ASSERT(watcher_matches(get_io_event(&poller, fd), fd, EV_READ));
+  TEST_ASSERT_EQUAL_PTR(fd_zero_watcher, get_io_event(&poller, 0));
+  TEST_ASSERT(get_io_event(&poller, fd) != fd_zero_watcher);
+}
+
+static void test_cleanup_stops_active_watchers(void) {
+  int fd = open_test_socket();
+  TEST_ASSERT(fd >= 0);
+  sock_state_cb(&poller, fd, 1, 0);
+  ev_io *watcher = get_io_event(&poller, fd);
+  TEST_ASSERT(watcher_matches(watcher, fd, EV_READ));
+  ev_feed_event(loop, watcher, EV_READ);
+  TEST_ASSERT(ev_is_pending(watcher));
+
+  dns_poller_cleanup(&poller);
+  poller_initialized = 0;
+  TEST_ASSERT(!poller.io_events);
+  TEST_ASSERT(ev_run(loop, EVRUN_NOWAIT) == 0);
+}
+
+int main(void) {
+  TEST_RUN(test_allocates_watchers_beyond_nameserver_count);
+  TEST_RUN(test_reuses_released_watcher);
+  TEST_RUN(test_fd_zero_does_not_alias_free_watcher);
+  TEST_RUN(test_cleanup_stops_active_watchers);
+  return test_summary();
 }

tests/unit/test_dns_poller.c

@@ -0,0 +1,52 @@
+#ifndef TEST_HARNESS_H
+#define TEST_HARNESS_H
+
+#include <stdio.h>
+
+static unsigned test_count;
+static unsigned test_failures;
+static int test_failed;
+
+static void test_fail(const char *file, int line, const char *expression) {
+  (void)fprintf(stderr, "%s:%d: assertion failed: %s\n", file, line, expression);
+  test_failed = 1;
+}
+
+#define TEST_ASSERT(condition) do { \
+  if (!(condition)) { \
+    test_fail(__FILE__, __LINE__, #condition); \
+    return; \
+  } \
+} while (0)
+
+#define TEST_ASSERT_EQUAL_PTR(expected, actual) do { \
+  const void *expected_ptr = (expected); \
+  const void *actual_ptr = (actual); \
+  if (expected_ptr != actual_ptr) { \
+    test_fail(__FILE__, __LINE__, #expected " == " #actual); \
+    return; \
+  } \
+} while (0)
+
+#define TEST_RUN(test) do { \
+  test_failed = 0; \
+  setUp(); \
+  if (!test_failed) { \
+    test(); \
+  } \
+  tearDown(); \
+  test_count++; \
+  if (test_failed) { \
+    test_failures++; \
+    (void)printf("FAIL: %s\n", #test); \
+  } else { \
+    (void)printf("PASS: %s\n", #test); \
+  } \
+} while (0)
+
+static int test_summary(void) {
+  (void)printf("%u tests, %u failures\n", test_count, test_failures);
+  return test_failures == 0 ? 0 : 1;
+}
+
+#endif