Restore existing test comments and keep variadic assertion tests

NAMESPACE

@@ -33,6 +33,7 @@ export(assert_flag)
 export(assert_function)
 export(assert_function_expects)
 export(assert_function_expects_n_arguments)
+export(assert_function_variadic)
 export(assert_greater_than)
 export(assert_greater_than_or_equal_to)
 export(assert_identical)

NEWS.md

@@ -2,6 +2,8 @@
 
 * Added `assert_function_expects()` for checking required argument names in functions
 
+* Added `assert_function_variadic()` for checking whether functions declare `...`
+
 * Added `assert_all_strings_contain()` and `assert_string_contains()` for checking character inputs against regular expressions
 
 * Added `assert_packages_installed()`

R/assert_functions.R

@@ -24,6 +24,16 @@ function_expects_n_arguments_advanced <- function(x, n, dots = c("throw_error","
   return(TRUE)
 }
 
+function_variadic_advanced <- function(x){
+  if(!is.function(x))
+    return("{.strong '{arg_name}'} must be a function, not a {class(arg_value)}")
+
+  if(!func_supports_variable_arguments(x))
+    return("{.strong '{arg_name}'} must accept variable arguments via {.strong ...}")
+
+  return(TRUE)
+}
+
 
 # Expect function has arguments
 # @param
@@ -70,6 +80,32 @@ function_expects_advanced <- function(x, required){
 #' @export
 assert_function_expects_n_arguments <- assert_create(func = function_expects_n_arguments_advanced)
 
+#' Assert function is variadic
+#'
+#' Assert that a function signature declares the `...` argument (variadic
+#' arguments).
+#'
+#' @param x a function to check includes `...` in its signature
+#' @inheritParams common_roxygen_params
+#'
+#' @return invisible(TRUE) if function `x` declares `...`, otherwise aborts with
+#'   the error message specified by `msg`
+#'
+#' @examples
+#' my_fun <- function(x, ...) x
+#' assert_function_variadic(my_fun)
+#'
+#' try({
+#'   my_fun_no_dots <- function(x) x
+#'   assert_function_variadic(my_fun_no_dots)
+#' })
+#'
+#' @export
+assert_function_variadic <- assert_create_chain(
+  assert_function,
+  assert_create(func = function_variadic_advanced)
+)
+
 #' Assert function expects specific parameter names
 #'
 #' Assert that a function signature includes required set of parameter names in its

tests/testthat/test-assert_functions.R

@@ -9,6 +9,7 @@ fn_2_args_with_dots <- function(a, b, ...) {}
 fn_with_required_args <- function(x, y, z = 1, ...) {}
 fn_with_defaults <- function(x = 1, y = 2) {}
 fn_with_no_required <- function(...) {}
+fn_no_dots <- function(x, y) x + y
 
 # Unit tests for `function_expects_n_arguments_advanced`
 test_that("function_expects_n_arguments_advanced behaves correctly for exact argument count", {
@@ -25,7 +26,7 @@ test_that("function_expects_n_arguments_advanced behaves correctly for exact arg
 test_that("function_expects_n_arguments_advanced handles dots behavior correctly", {
   # Test with `...` and dots="throw_error"
   expect_match(function_expects_n_arguments_advanced(fn_1_arg_with_dots, 1, dots = "throw_error"),
-               "must not contain ... arguments", fixed = TRUE)
+               "must not contain ... arguments", fixed = TRUE) # dots throw error by default
 
   # Test with `...` and dots="count_as_0"
   expect_true(function_expects_n_arguments_advanced(fn_1_arg_with_dots, 1, dots = "count_as_0"))
@@ -44,6 +45,8 @@ test_that("function_expects_n_arguments_advanced returns correct error for non-f
   # Input is not a function
   expect_match(function_expects_n_arguments_advanced(42, 1), "must be a function, not a", fixed = TRUE)
   expect_match(function_expects_n_arguments_advanced("not_a_function", 1), "must be a function, not a", fixed = TRUE)
+  expect_match(function_expects_n_arguments_advanced(list(), 1), "must be a function, not a", fixed = TRUE)
+  expect_match(function_expects_n_arguments_advanced(NULL, 1), "must be a function, not a", fixed = TRUE)
 })
 
 test_that("function_expects_n_arguments_advanced correctly counts arguments for functions with no arguments", {
@@ -87,6 +90,18 @@ test_that("function_expects_advanced validates required argument names", {
                "must be a function, not a", fixed = TRUE)
 })
 
+test_that("function_variadic_advanced validates variable arguments", {
+  expect_true(function_variadic_advanced(fn_1_arg_with_dots))
+  expect_true(function_variadic_advanced(fn_2_args_with_dots))
+
+  expect_match(function_variadic_advanced(fn_no_dots),
+               "must accept variable arguments", fixed = TRUE)
+  expect_match(function_variadic_advanced(1),
+               "must be a function, not a", fixed = TRUE)
+  expect_match(function_variadic_advanced(list()),
+               "must be a function, not a", fixed = TRUE)
+})
+
 
 
 
@@ -171,5 +186,42 @@ cli::test_that_cli("assert_function_expects() works", config = "plain", {
     "Custom error message"
   )
 
+  # Works with a single required argument
+  expect_true(assert_function_expects(fn_with_required_args, "x"))
+
+  # Reports missing parameters when multiple are absent
+  expect_error(
+    assert_function_expects(fn_with_defaults, c("x", "z")),
+    "missing the following parameter",
+    fixed = TRUE
+  )
 })
 
+cli::test_that_cli("assert_function_variadic() works", config = "plain", {
+  my_fun <- function(a, ...) { a }
+  my_fun_no_dots <- function(a) { a }
+  my_fun_with_defaults <- function(a = 1, ...) { a }
+  my_fun_only_dots <- function(...) { }
+  my_fun_many <- function(a, b = 1, ...) { a + b }
+
+  # Accepts a basic variadic signature
+  expect_true(assert_function_variadic(my_fun))
+
+  # Accepts variadic signatures with defaults
+  expect_true(assert_function_variadic(my_fun_with_defaults))
+
+  # Accepts dots-only signatures
+  expect_true(assert_function_variadic(my_fun_only_dots))
+
+  # Accepts multiple arguments with dots
+  expect_true(assert_function_variadic(my_fun_many))
+
+  # Rejects non-variadic signatures
+  expect_error(assert_function_variadic(my_fun_no_dots), "must accept variable arguments", fixed = TRUE)
+
+  # Rejects non-function numeric input
+  expect_error(assert_function_variadic(123), "'123' must be a function, not a numeric")
+
+  # Rejects non-function list input
+  expect_error(assert_function_variadic(list()), "must be a .*function", fixed = FALSE)
+})