diff --git a/tests/testthat/setup-test_params.R b/tests/testthat/setup-test_params.R
index 30926de..0069617 100644
--- a/tests/testthat/setup-test_params.R
+++ b/tests/testthat/setup-test_params.R
@@ -1,18 +1,26 @@
-test_param_package <- function(tested_function, ...) {
+test_param_package <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`package` must be a character vector", {
     expect_error(
-      tested_function(package = 1, ...),
+      expression |>
+        rlang::call_modify(package = 1) |>
+        rlang::eval_tidy(),
       "`package` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(package = list(), ...),
+      expression |>
+        rlang::call_modify(package = list()) |>
+        rlang::eval_tidy(),
       "`package` must be a character vector, not .*"
     )
   })
 
   test_that("`package` must have length 1", {
     expect_error(
-      tested_function(package = letters, ...),
+      expression |>
+        rlang::call_modify(package = letters) |>
+        rlang::eval_tidy(),
       sprintf("`package` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -20,28 +28,38 @@ test_param_package <- function(tested_function, ...) {
 
   test_that("`package` must not be NA", {
     expect_error(
-      tested_function(package = NA_character_, ...),
+      expression |>
+        rlang::call_modify(package = NA_character_) |>
+        rlang::eval_tidy(),
       "`package` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_version <- function(tested_function, ...) {
+test_param_version <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`version` must be a character vector", {
     expect_error(
-      tested_function(version = 1, ...),
+      expression |>
+        rlang::call_modify(version = 1) |>
+        rlang::eval_tidy(),
       "`version` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(version = list(), ...),
+      expression |>
+        rlang::call_modify(version = list()) |>
+        rlang::eval_tidy(),
       "`version` must be a character vector, not .*"
     )
   })
 
   test_that("`version` must have length 1", {
     expect_error(
-      tested_function(version = letters, ...),
+      expression |>
+        rlang::call_modify(version = letters) |>
+        rlang::eval_tidy(),
       sprintf("`version` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -49,28 +67,38 @@ test_param_version <- function(tested_function, ...) {
 
   test_that("`version` must not be NA", {
     expect_error(
-      tested_function(version = NA_character_, ...),
+      expression |>
+        rlang::call_modify(version = NA_character_) |>
+        rlang::eval_tidy(),
       "`version` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_repos <- function(tested_function, ...) {
+test_param_repos <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`repos` must be a character vector", {
     expect_error(
-      tested_function(repos = 1, ...),
+      expression |>
+        rlang::call_modify(repos = 1) |>
+        rlang::eval_tidy(),
       "`repos` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(repos = list(), ...),
+      expression |>
+        rlang::call_modify(repos = list()) |>
+        rlang::eval_tidy(),
       "`repos` must be a character vector, not .*"
     )
   })
 
   test_that("`repos` must not be empty", {
     expect_error(
-      tested_function(repos = character(), ...),
+      expression |>
+        rlang::call_modify(repos = character()) |>
+        rlang::eval_tidy(),
       "`repos` must not be empty.",
       fixed = TRUE
     )
@@ -78,7 +106,9 @@ test_param_repos <- function(tested_function, ...) {
 
   test_that("`repos` must not be NA", {
     expect_error(
-      tested_function(repos = c(letters, NA_character_), ...),
+      expression |>
+        rlang::call_modify(repos = c(letters, NA_character_)) |>
+        rlang::eval_tidy(),
       "`repos` must not contain NAs.",
       fixed = TRUE
     )
@@ -86,28 +116,38 @@ test_param_repos <- function(tested_function, ...) {
 
   test_that("`repos` must be unique", {
     expect_error(
-      tested_function(repos = c("h", letters), ...),
+      expression |>
+        rlang::call_modify(repos = c("h", letters)) |>
+        rlang::eval_tidy(),
       "`repos` must not contain duplicate values.",
       fixed = TRUE
     )
   })
 }
 
-test_param_packages <- function(tested_function, ...) {
+test_param_packages <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`packages` must be a character vector", {
     expect_error(
-      tested_function(packages = 1, ...),
+      expression |>
+        rlang::call_modify(packages = 1) |>
+        rlang::eval_tidy(),
       "`packages` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(packages = list(), ...),
+      expression |>
+        rlang::call_modify(packages = list()) |>
+        rlang::eval_tidy(),
       "`packages` must be a character vector, not .*"
     )
   })
 
   test_that("`packages` must not be NA", {
     expect_error(
-      tested_function(packages = c(letters, NA_character_), ...),
+      expression |>
+        rlang::call_modify(packages = c(letters, NA_character_)) |>
+        rlang::eval_tidy(),
       "`packages` must not contain NAs.",
       fixed = TRUE
     )
@@ -115,28 +155,38 @@ test_param_packages <- function(tested_function, ...) {
 
   test_that("`packages` must be unique", {
     expect_error(
-      tested_function(packages = c("h", letters), ...),
+      expression |>
+        rlang::call_modify(packages = c("h", letters)) |>
+        rlang::eval_tidy(),
       "`packages` must not contain duplicate values.",
       fixed = TRUE
     )
   })
 }
 
-test_param_runiverse <- function(tested_function, ...) {
+test_param_runiverse <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`universe` must be a character vector", {
     expect_error(
-      tested_function(universe = 1, ...),
+      expression |>
+        rlang::call_modify(universe = 1) |>
+        rlang::eval_tidy(),
       "`universe` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(universe = list(), ...),
+      expression |>
+        rlang::call_modify(universe = list()) |>
+        rlang::eval_tidy(),
       "`universe` must be a character vector, not .*"
     )
   })
 
   test_that("`universe` must have length 1", {
     expect_error(
-      tested_function(universe = letters, ...),
+      expression |>
+        rlang::call_modify(universe = letters) |>
+        rlang::eval_tidy(),
       sprintf("`universe` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -144,28 +194,38 @@ test_param_runiverse <- function(tested_function, ...) {
 
   test_that("`universe` must not be NA", {
     expect_error(
-      tested_function(universe = NA_character_, ...),
+      expression |>
+        rlang::call_modify(universe = NA_character_) |>
+        rlang::eval_tidy(),
       "`universe` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_url_repo <- function(tested_function, ...) {
+test_param_url_repo <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`repository` must be a character vector", {
     expect_error(
-      tested_function(repository = 1, ...),
+      expression |>
+        rlang::call_modify(repository = 1) |>
+        rlang::eval_tidy(),
       "`repository` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(repository = list(), ...),
+      expression |>
+        rlang::call_modify(repository = list()) |>
+        rlang::eval_tidy(),
       "`repository` must be a character vector, not .*"
     )
   })
 
   test_that("`repository` must have length 1", {
     expect_error(
-      tested_function(repository = letters, ...),
+      expression |>
+        rlang::call_modify(repository = letters) |>
+        rlang::eval_tidy(),
       sprintf("`repository` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -173,28 +233,38 @@ test_param_url_repo <- function(tested_function, ...) {
 
   test_that("`repository` must not be NA", {
     expect_error(
-      tested_function(repository = NA_character_, ...),
+      expression |>
+        rlang::call_modify(repository = NA_character_) |>
+        rlang::eval_tidy(),
       "`repository` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_paths <- function(tested_function, ...) {
+test_param_paths <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`paths` must be a character vector", {
     expect_error(
-      tested_function(paths = 1, ...),
+      expression |>
+        rlang::call_modify(paths = 1) |>
+        rlang::eval_tidy(),
       "`paths` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(paths = list(), ...),
+      expression |>
+        rlang::call_modify(paths = list()) |>
+        rlang::eval_tidy(),
       "`paths` must be a character vector, not .*"
     )
   })
 
   test_that("`paths` must not be empty", {
     expect_error(
-      tested_function(paths = character(), ...),
+      expression |>
+        rlang::call_modify(paths = character()) |>
+        rlang::eval_tidy(),
       "`paths` must not be empty.",
       fixed = TRUE
     )
@@ -202,7 +272,9 @@ test_param_paths <- function(tested_function, ...) {
 
   test_that("`paths` must not be NA", {
     expect_error(
-      tested_function(paths = c(letters, NA_character_), ...),
+      expression |>
+        rlang::call_modify(paths = c(letters, NA_character_)) |>
+        rlang::eval_tidy(),
       "`paths` must not contain NAs.",
       fixed = TRUE
     )
@@ -210,7 +282,9 @@ test_param_paths <- function(tested_function, ...) {
 
   test_that("`paths` must be unique", {
     expect_error(
-      tested_function(paths = c("h", letters), ...),
+      expression |>
+        rlang::call_modify(paths = c("h", letters)) |>
+        rlang::eval_tidy(),
       "`paths` must not contain duplicate values.",
       fixed = TRUE
     )
@@ -218,7 +292,9 @@ test_param_paths <- function(tested_function, ...) {
 
   test_that("`paths` cannot contain \"all\" mixed with paths", {
     expect_error(
-      tested_function(paths = c("all", letters), ...),
+      expression |>
+        rlang::call_modify(paths = c("all", letters)) |>
+        rlang::eval_tidy(),
       "`paths` must not contain both \"all\" and paths.",
       fixed = TRUE
     )
@@ -226,28 +302,38 @@ test_param_paths <- function(tested_function, ...) {
 
   test_that("`paths` cannot contain non-existent directories", {
     expect_error(
-      tested_function(paths = c("inst", "nonexistent"), ...),
+      expression |>
+        rlang::call_modify(paths = c("inst", "nonexistent")) |>
+        rlang::eval_tidy(),
       "`paths` must contain only valid paths.",
       fixed = TRUE
     )
   })
 }
 
-test_param_bioc_release <- function(tested_function, ...) {
+test_param_bioc_release <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`release` must be a character vector", {
     expect_error(
-      tested_function(release = 1, ...),
+      expression |>
+        rlang::call_modify(release = 1) |>
+        rlang::eval_tidy(),
       "`release` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(release = list(), ...),
+      expression |>
+        rlang::call_modify(release = list()) |>
+        rlang::eval_tidy(),
       "`release` must be a character vector, not .*"
     )
   })
 
   test_that("`release` must have length 1", {
     expect_error(
-      tested_function(release = letters, ...),
+      expression |>
+        rlang::call_modify(release = letters) |>
+        rlang::eval_tidy(),
       sprintf("`release` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -255,7 +341,9 @@ test_param_bioc_release <- function(tested_function, ...) {
 
   test_that("`release` must not be NA", {
     expect_error(
-      tested_function(release = NA_character_, ...),
+      expression |>
+        rlang::call_modify(release = NA_character_) |>
+        rlang::eval_tidy(),
       "`release` must not contain NAs.",
       fixed = TRUE
     )
@@ -263,33 +351,45 @@ test_param_bioc_release <- function(tested_function, ...) {
 
   test_that("`release` must be a release code or a keyword", {
     expect_error(
-      tested_function(release = "1.10.0", ...),
+      expression |>
+        rlang::call_modify(release = "1.10.0") |>
+        rlang::eval_tidy(),
       "`release` must be a valid Bioconductor release code.",
       fixed = TRUE
     )
     expect_error(
-      tested_function(release = "future", ...),
+      expression |>
+        rlang::call_modify(release = "future") |>
+        rlang::eval_tidy(),
       "`release` must be a valid Bioconductor release code.",
       fixed = TRUE
     )
   })
 }
 
-test_param_gh_user <- function(tested_function, ...) {
+test_param_gh_user <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`user` must be a character vector", {
     expect_error(
-      tested_function(user = 1, ...),
+      expression |>
+        rlang::call_modify(user = 1) |>
+        rlang::eval_tidy(),
       "`user` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(user = list(), ...),
+      expression |>
+        rlang::call_modify(user = list()) |>
+        rlang::eval_tidy(),
       "`user` must be a character vector, not .*"
     )
   })
 
   test_that("`user` must have length 1", {
     expect_error(
-      tested_function(user = letters, ...),
+      expression |>
+        rlang::call_modify(user = letters) |>
+        rlang::eval_tidy(),
       sprintf("`user` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -297,28 +397,38 @@ test_param_gh_user <- function(tested_function, ...) {
 
   test_that("`user` must not be NA", {
     expect_error(
-      tested_function(user = NA_character_, ...),
+      expression |>
+        rlang::call_modify(user = NA_character_) |>
+        rlang::eval_tidy(),
       "`user` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_include_forks <- function(tested_function, ...) {
+test_param_include_forks <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`include_forks` must be a logical vector", {
     expect_error(
-      tested_function(include_forks = "TRUE", ...),
+      expression |>
+        rlang::call_modify(include_forks = "TRUE") |>
+        rlang::eval_tidy(),
       "`include_forks` must be a logical vector, not .*"
     )
     expect_error(
-      tested_function(include_forks = list(), ...),
+      expression |>
+        rlang::call_modify(include_forks = list()) |>
+        rlang::eval_tidy(),
       "`include_forks` must be a logical vector, not .*"
     )
   })
 
   test_that("`include_forks` must have length 1", {
     expect_error(
-      tested_function(include_forks = c(TRUE, FALSE, FALSE), ...),
+      expression |>
+        rlang::call_modify(include_forks = c(TRUE, FALSE, FALSE)) |>
+        rlang::eval_tidy(),
       "`include_forks` must have length 1, not 3.",
       fixed = TRUE
     )
@@ -326,28 +436,38 @@ test_param_include_forks <- function(tested_function, ...) {
 
   test_that("`include_forks` must not be NA", {
     expect_error(
-      tested_function(include_forks = NA, ...),
+      expression |>
+        rlang::call_modify(include_forks = NA) |>
+        rlang::eval_tidy(),
       "`include_forks` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_tag <- function(tested_function, ...) {
+test_param_tag <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`tag` must be a character vector", {
     expect_error(
-      tested_function(tag = 1, ...),
+      expression |>
+        rlang::call_modify(tag = 1) |>
+        rlang::eval_tidy(),
       "`tag` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(tag = list(), ...),
+      expression |>
+        rlang::call_modify(tag = list()) |>
+        rlang::eval_tidy(),
       "`tag` must be a character vector, not .*"
     )
   })
 
   test_that("`tag` must have length 1", {
     expect_error(
-      tested_function(tag = letters, ...),
+      expression |>
+        rlang::call_modify(tag = letters) |>
+        rlang::eval_tidy(),
       sprintf("`tag` must have length 1, not %i.", length(letters)),
       fixed = TRUE
     )
@@ -355,28 +475,38 @@ test_param_tag <- function(tested_function, ...) {
 
   test_that("`tag` must not be NA", {
     expect_error(
-      tested_function(tag = NA_character_, ...),
+      expression |>
+        rlang::call_modify(tag = NA_character_) |>
+        rlang::eval_tidy(),
       "`tag` must not contain NAs.",
       fixed = TRUE
     )
   })
 }
 
-test_param_which_deps <- function(tested_function, ...) {
+test_param_which_deps <- function(expression) {
+  expression <- rlang::enquo(expression)
+
   test_that("`which` must be a character vector", {
     expect_error(
-      tested_function(which = 1, ...),
+      expression |>
+        rlang::call_modify(which = 1) |>
+        rlang::eval_tidy(),
       "`which` must be a character vector, not .*"
     )
     expect_error(
-      tested_function(which = list(), ...),
+      expression |>
+        rlang::call_modify(which = list()) |>
+        rlang::eval_tidy(),
       "`which` must be a character vector, not .*"
     )
   })
 
   test_that("`which` must not be NA", {
     expect_error(
-      tested_function(which = c(letters, NA_character_), ...),
+      expression |>
+        rlang::call_modify(which = c(letters, NA_character_)) |>
+        rlang::eval_tidy(),
       "`which` must not contain NAs.",
       fixed = TRUE
     )
@@ -384,7 +514,9 @@ test_param_which_deps <- function(tested_function, ...) {
 
   test_that("`which` must be unique", {
     expect_error(
-      tested_function(which = c("h", letters), ...),
+      expression |>
+        rlang::call_modify(which = c("h", letters)) |>
+        rlang::eval_tidy(),
       "`which` must not contain duplicate values.",
       fixed = TRUE
     )
@@ -392,7 +524,9 @@ test_param_which_deps <- function(tested_function, ...) {
 
   test_that("`which` must not contain multiple keywords", {
     expect_error(
-      tested_function(which = c("most", "strong"), ...),
+      expression |>
+        rlang::call_modify(which = c("most", "strong")) |>
+        rlang::eval_tidy(),
       "`which` must not contain multiple keywords.",
       fixed = TRUE
     )
@@ -400,7 +534,9 @@ test_param_which_deps <- function(tested_function, ...) {
 
   test_that("`which` must be a subset of legal values", {
     expect_error(
-      tested_function(which = c("Depends", "Imports", "Cracks"), ...),
+      expression |>
+        rlang::call_modify(which = c("Depends", "Imports", "Cracks")) |>
+        rlang::eval_tidy(),
       "`which` must contain valid dependency types.",
       fixed = TRUE
     )
@@ -408,7 +544,9 @@ test_param_which_deps <- function(tested_function, ...) {
 
   test_that("`which` must not mix dep types and keywords", {
     expect_error(
-      tested_function(which = c("Depends", "strong"), ...),
+      expression |>
+        rlang::call_modify(which = c("Depends", "strong")) |>
+        rlang::eval_tidy(),
       "`which` must not mix dependency types and keywords.",
       fixed = TRUE
     )
diff --git a/tests/testthat/test-bioc-dependencies.R b/tests/testthat/test-bioc-dependencies.R
index e94f766..601916c 100644
--- a/tests/testthat/test-bioc-dependencies.R
+++ b/tests/testthat/test-bioc-dependencies.R
@@ -9,8 +9,8 @@ with_mock_dir("a", {
 # TESTS ----
 test_dependencies(Biostrings_deps)
 test_cache({ wood_bioc_dependencies("Biostrings") }, Biostrings_deps)
-test_param_package(wood_bioc_dependencies)
-test_param_bioc_release(wood_bioc_dependencies, package = "Biostrings")
+test_param_package(wood_bioc_dependencies(package = "Biostrings"))
+test_param_bioc_release(wood_bioc_dependencies(package = "Biostrings"))
 
 test_that("raises an exception if package not available", {
   expect_error(
diff --git a/tests/testthat/test-bioc-packages.R b/tests/testthat/test-bioc-packages.R
index 3fa0c7b..564c9ce 100644
--- a/tests/testthat/test-bioc-packages.R
+++ b/tests/testthat/test-bioc-packages.R
@@ -9,7 +9,7 @@ with_mock_dir("c", {
 # TESTS ----
 test_packages(bioc_packages)
 test_cache({ wood_bioc_packages() }, bioc_packages)
-test_param_bioc_release(wood_bioc_packages)
+test_param_bioc_release(wood_bioc_packages())
 
 test_that("there's a Biostrings package in the list", {
   expect_subset("Biostrings", bioc_packages)
diff --git a/tests/testthat/test-bioc-version.R b/tests/testthat/test-bioc-version.R
index 3f22ec3..3ca4c00 100644
--- a/tests/testthat/test-bioc-version.R
+++ b/tests/testthat/test-bioc-version.R
@@ -9,8 +9,8 @@ with_mock_dir("f", {
 # TESTS ----
 test_version(affy_version)
 test_cache({ wood_bioc_version("affy") }, affy_version)
-test_param_package(wood_bioc_version)
-test_param_bioc_release(wood_bioc_version, package = "affy")
+test_param_package(wood_bioc_version(package = "affy"))
+test_param_bioc_release(wood_bioc_version(package = "affy"))
 
 with_mock_dir("g", {
   test_that("correctly retrieves data from older releases", {
diff --git a/tests/testthat/test-core-dependencies.R b/tests/testthat/test-core-dependencies.R
index 6734922..4108bd9 100644
--- a/tests/testthat/test-core-dependencies.R
+++ b/tests/testthat/test-core-dependencies.R
@@ -3,7 +3,7 @@ stats_deps <- wood_core_dependencies("stats")
 
 # TESTS ----
 test_dependencies(stats_deps)
-test_param_package(wood_core_dependencies)
+test_param_package(wood_core_dependencies(package = "stats"))
 
 test_that("raises an exception if package not available", {
   expect_error(
diff --git a/tests/testthat/test-core-version.R b/tests/testthat/test-core-version.R
index 9aa74ec..96eabcd 100644
--- a/tests/testthat/test-core-version.R
+++ b/tests/testthat/test-core-version.R
@@ -3,7 +3,7 @@ utils_version <- wood_core_version("utils")
 
 # TESTS ----
 test_version(utils_version)
-test_param_package(wood_core_version)
+test_param_package(wood_core_version(package = "utils"))
 
 test_that("raises an exception if package not available", {
   expect_error(
diff --git a/tests/testthat/test-cran-dependencies.R b/tests/testthat/test-cran-dependencies.R
index ed83d7c..2466fd3 100644
--- a/tests/testthat/test-cran-dependencies.R
+++ b/tests/testthat/test-cran-dependencies.R
@@ -9,8 +9,8 @@ with_mock_dir("h", {
 # TESTS ----
 test_dependencies(deepdep_deps)
 test_cache({ wood_cran_dependencies("deepdep", version = "0.2.0") }, deepdep_deps)
-test_param_package(wood_cran_dependencies, version = "0.2.0")
-test_param_version(wood_cran_dependencies, package = "deepdep")
+test_param_package(wood_cran_dependencies(package = "deepdep", version = "0.2.0"))
+test_param_version(wood_cran_dependencies(package = "deepdep", version = "0.2.0"))
 
 test_that("uses cache from wood_cran_versions() if available", {
   wood_clear_cache()
diff --git a/tests/testthat/test-cran-latest.R b/tests/testthat/test-cran-latest.R
index 8743237..3dd9370 100644
--- a/tests/testthat/test-cran-latest.R
+++ b/tests/testthat/test-cran-latest.R
@@ -9,7 +9,7 @@ with_mock_dir("j", {
 # TESTS ----
 test_version(versionsort_latest)
 test_cache({ wood_cran_latest("versionsort") }, versionsort_latest)
-test_param_package(wood_cran_latest)
+test_param_package(wood_cran_latest(package = "versionsort"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-cran-versions.R b/tests/testthat/test-cran-versions.R
index 53fc13c..449af86 100644
--- a/tests/testthat/test-cran-versions.R
+++ b/tests/testthat/test-cran-versions.R
@@ -9,7 +9,7 @@ with_mock_dir("l", {
 # TESTS ----
 test_versions(versionsort_versions)
 test_cache({ wood_cran_versions("versionsort") }, versionsort_versions)
-test_param_package(wood_cran_versions)
+test_param_package(wood_cran_versions(package = "versionsort"))
 
 test_that("versionsort versions contain some of the published version codes", {
   expect_subset(c("1.0.0", "1.1.0"), versionsort_versions)
diff --git a/tests/testthat/test-deps-filter.R b/tests/testthat/test-deps-filter.R
index 1cef9ad..c6965b4 100644
--- a/tests/testthat/test-deps-filter.R
+++ b/tests/testthat/test-deps-filter.R
@@ -13,7 +13,7 @@ empty_deps <- as_wood_deps(data.frame(
 
 # TESTS ----
 test_dependencies(filter_dependencies(woodendesc_deps, "strong"))
-test_param_which_deps(filter_dependencies, object = empty_deps)
+test_param_which_deps(filter_dependencies(object = empty_deps))
 lapply(filter_dependencies(mixed_deps, "strong"), function(deps) {
   test_dependencies(deps)
 })
diff --git a/tests/testthat/test-github-dependencies.R b/tests/testthat/test-github-dependencies.R
index 2432a0f..5d75a42 100644
--- a/tests/testthat/test-github-dependencies.R
+++ b/tests/testthat/test-github-dependencies.R
@@ -10,9 +10,9 @@ with_mock_dir("n", {
 # TESTS ----
 test_dependencies(gglgbtq_deps)
 test_cache({ wood_github_dependencies("gglgbtq", "turtletopia", tag = "v0.1.0") }, gglgbtq_deps)
-test_param_package(wood_github_dependencies, user = "turtletopia")
-test_param_gh_user(wood_github_dependencies, package = "gglgbtq")
-test_param_tag(wood_github_dependencies, package = "gglgbtq", user = "turtletopia")
+test_param_package(wood_github_dependencies(package = "gglgbtq", user = "turtletopia"))
+test_param_gh_user(wood_github_dependencies(package = "gglgbtq", user = "turtletopia"))
+test_param_tag(wood_github_dependencies(package = "gglgbtq", user = "turtletopia"))
 
 with_mock_dir("o", {
   test_that("uses cache from wood_github_versions() if available if not latest commit", {
diff --git a/tests/testthat/test-github-latest.R b/tests/testthat/test-github-latest.R
index 37dd9a1..8cdb12e 100644
--- a/tests/testthat/test-github-latest.R
+++ b/tests/testthat/test-github-latest.R
@@ -10,8 +10,8 @@ with_mock_dir("q", {
 # TESTS ----
 test_version(gglgbtq_latest)
 test_cache({ wood_github_latest("gglgbtq", "turtletopia") }, gglgbtq_latest)
-test_param_package(wood_github_latest, user = "turtletopia")
-test_param_gh_user(wood_github_latest, package = "gglgbtq")
+test_param_package(wood_github_latest(package = "gglgbtq", user = "turtletopia"))
+test_param_gh_user(wood_github_latest(package = "gglgbtq", user = "turtletopia"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-github-packages.R b/tests/testthat/test-github-packages.R
index c848ca1..c839185 100644
--- a/tests/testthat/test-github-packages.R
+++ b/tests/testthat/test-github-packages.R
@@ -12,8 +12,8 @@ turtletopia_packages <- wood_github_packages("turtletopia")
 # TESTS ----
 test_packages(turtletopia_packages)
 test_cache({ wood_github_packages(user = "turtletopia") }, turtletopia_packages)
-test_param_gh_user(wood_github_packages)
-test_param_include_forks(wood_github_packages, user = "turtletopia")
+test_param_gh_user(wood_github_packages(user = "turtletopia"))
+test_param_include_forks(wood_github_packages(user = "turtletopia"))
 
 test_that("several packages make the list", {
   expect_subset(c("versionsort", "gglgbtq", "woodendesc"), turtletopia_packages)
diff --git a/tests/testthat/test-github-tags.R b/tests/testthat/test-github-tags.R
index 9106dfa..ef01bd2 100644
--- a/tests/testthat/test-github-tags.R
+++ b/tests/testthat/test-github-tags.R
@@ -10,8 +10,8 @@ with_mock_dir("s", {
 # TESTS ----
 test_tags(gglgbtq_tags)
 test_cache({ wood_github_tags("gglgbtq", "turtletopia") }, gglgbtq_tags)
-test_param_package(wood_github_tags, user = "turtletopia")
-test_param_gh_user(wood_github_tags, package = "gglgbtq")
+test_param_package(wood_github_tags(package = "gglgbtq", user = "turtletopia"))
+test_param_gh_user(wood_github_tags(package = "gglgbtq", user = "turtletopia"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-github-versions.R b/tests/testthat/test-github-versions.R
index 177270b..a2fd5db 100644
--- a/tests/testthat/test-github-versions.R
+++ b/tests/testthat/test-github-versions.R
@@ -10,8 +10,8 @@ with_mock_dir("t", {
 # TESTS ----
 test_versions(gglgbtq_versions)
 test_cache({ wood_github_versions("gglgbtq", "turtletopia") }, gglgbtq_versions)
-test_param_package(wood_github_versions, user = "turtletopia")
-test_param_gh_user(wood_github_versions, package = "gglgbtq")
+test_param_package(wood_github_versions(package = "gglgbtq", user = "turtletopia"))
+test_param_gh_user(wood_github_versions(package = "gglgbtq", user = "turtletopia"))
 
 test_that("gglgbtq versions contain some of the tagged version codes", {
   expect_subset(c("0.1.0", "0.1.1"), gglgbtq_versions)
diff --git a/tests/testthat/test-gitlab-dependencies.R b/tests/testthat/test-gitlab-dependencies.R
index d158b63..888534e 100644
--- a/tests/testthat/test-gitlab-dependencies.R
+++ b/tests/testthat/test-gitlab-dependencies.R
@@ -9,9 +9,9 @@ with_mock_dir("l0", {
 # TESTS ----
 test_dependencies(rock_deps)
 test_cache({ wood_gitlab_dependencies("rock", "r-packages", tag = "0.6.0") }, rock_deps)
-test_param_package(wood_gitlab_dependencies, user = "r-packages")
-test_param_gh_user(wood_gitlab_dependencies, package = "rock")
-test_param_tag(wood_gitlab_dependencies, package = "rock", user = "r-packages")
+test_param_package(wood_gitlab_dependencies(package = "rock", user = "r-packages"))
+test_param_gh_user(wood_gitlab_dependencies(package = "rock", user = "r-packages"))
+test_param_tag(wood_gitlab_dependencies(package = "rock", user = "r-packages"))
 
 # with_mock_dir("l1", {
 #   test_that("uses cache from wood_gitlab_versions() if available if not latest commit", {
diff --git a/tests/testthat/test-gitlab-latest.R b/tests/testthat/test-gitlab-latest.R
index c1f4f0a..ff3ffe8 100644
--- a/tests/testthat/test-gitlab-latest.R
+++ b/tests/testthat/test-gitlab-latest.R
@@ -9,8 +9,8 @@ with_mock_dir("l3", {
 # TESTS ----
 test_version(rock_latest)
 test_cache({ wood_gitlab_latest("rock", "r-packages") }, rock_latest)
-test_param_package(wood_gitlab_latest, user = "r-packages")
-test_param_gh_user(wood_gitlab_latest, package = "rock")
+test_param_package(wood_gitlab_latest(package = "rock", user = "r-packages"))
+test_param_gh_user(wood_gitlab_latest(package = "rock", user = "r-packages"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-gitlab-packages.R b/tests/testthat/test-gitlab-packages.R
index de3a869..a10fee3 100644
--- a/tests/testthat/test-gitlab-packages.R
+++ b/tests/testthat/test-gitlab-packages.R
@@ -9,8 +9,8 @@ with_mock_dir("l4", {
 # TESTS ----
 test_packages(r_packages_packages)
 test_cache({ wood_gitlab_packages(user = "r-packages") }, r_packages_packages)
-test_param_gh_user(wood_gitlab_packages)
-test_param_include_forks(wood_gitlab_packages, user = "r-packages")
+test_param_gh_user(wood_gitlab_packages(user = "r-packages"))
+test_param_include_forks(wood_gitlab_packages(user = "r-packages"))
 
 test_that("several packages make the list", {
   expect_subset(c("rock", "limonaid", "preregr"), r_packages_packages)
diff --git a/tests/testthat/test-local-dependencies.R b/tests/testthat/test-local-dependencies.R
index 2033d52..73f0548 100644
--- a/tests/testthat/test-local-dependencies.R
+++ b/tests/testthat/test-local-dependencies.R
@@ -3,8 +3,8 @@ woodendesc_deps <- wood_local_dependencies("woodendesc")
 
 # TESTS ----
 test_dependencies(woodendesc_deps)
-test_param_package(wood_local_dependencies)
-test_param_paths(wood_local_dependencies, package = "woodendesc")
+test_param_package(wood_local_dependencies(package = "woodendesc"))
+test_param_paths(wood_local_dependencies(package = "woodendesc"))
 
 test_that("raises an exception if package not available", {
   expect_error(wood_local_dependencies("fakepackage"))
diff --git a/tests/testthat/test-local-packages.R b/tests/testthat/test-local-packages.R
index 90778db..392d488 100644
--- a/tests/testthat/test-local-packages.R
+++ b/tests/testthat/test-local-packages.R
@@ -7,7 +7,7 @@ local_packages <- wood_local_packages()
 
 # TESTS ----
 test_packages(local_packages)
-test_param_paths(wood_local_packages)
+test_param_paths(wood_local_packages())
 
 test_that("local packages include woodendesc package", {
   expect_subset("woodendesc", local_packages)
diff --git a/tests/testthat/test-local-versions.R b/tests/testthat/test-local-versions.R
index 98d53b8..0d9b9f8 100644
--- a/tests/testthat/test-local-versions.R
+++ b/tests/testthat/test-local-versions.R
@@ -5,8 +5,8 @@ lib_dir <- local_fake_library("fakepackage", "woodendesc")
 lib_dir_2 <- local_fake_library("fakepackage", "woodendesc", path = "fake_dir")
 
 # TESTS ----
-test_param_package(wood_local_versions)
-test_param_paths(wood_local_versions, package = "woodendesc")
+test_param_package(wood_local_versions(package = "woodendesc"))
+test_param_paths(wood_local_versions(package = "woodendesc"))
 
 woodendesc_versions <- wood_local_versions("woodendesc")
 
diff --git a/tests/testthat/test-runiverse-dependencies.R b/tests/testthat/test-runiverse-dependencies.R
index efefe78..47a98bb 100644
--- a/tests/testthat/test-runiverse-dependencies.R
+++ b/tests/testthat/test-runiverse-dependencies.R
@@ -9,8 +9,8 @@ with_mock_dir("u", {
 # TESTS ----
 test_dependencies(ggplot2_deps)
 test_cache({ wood_runiverse_dependencies("ggplot2", "tidyverse") }, ggplot2_deps)
-test_param_package(wood_runiverse_dependencies, universe = "tidyverse")
-test_param_runiverse(wood_runiverse_dependencies, package = "ggplot2")
+test_param_package(wood_runiverse_dependencies(package = "ggplot2", universe = "tidyverse"))
+test_param_runiverse(wood_runiverse_dependencies(package = "ggplot2", universe = "tidyverse"))
 
 test_that("raises an exception if package not available", {
   expect_error(
diff --git a/tests/testthat/test-runiverse-packages.R b/tests/testthat/test-runiverse-packages.R
index 331dbe0..1ff4440 100644
--- a/tests/testthat/test-runiverse-packages.R
+++ b/tests/testthat/test-runiverse-packages.R
@@ -9,7 +9,7 @@ with_mock_dir("v", {
 # TESTS ----
 test_packages(tidyverse_packages)
 test_cache({ wood_runiverse_packages(universe = "tidyverse") }, tidyverse_packages)
-test_param_runiverse(wood_runiverse_packages)
+test_param_runiverse(wood_runiverse_packages(universe = "tidyverse"))
 
 test_that("tidyverse universe has ggplot2 package", {
   expect_subset("ggplot2", tidyverse_packages)
diff --git a/tests/testthat/test-runiverse-version.R b/tests/testthat/test-runiverse-version.R
index 2bac88c..5858c03 100644
--- a/tests/testthat/test-runiverse-version.R
+++ b/tests/testthat/test-runiverse-version.R
@@ -9,8 +9,8 @@ with_mock_dir("w", {
 # TESTS ----
 test_version(versionsort_version)
 test_cache({ wood_runiverse_version("versionsort", "turtletopia") }, versionsort_version)
-test_param_package(wood_runiverse_version, universe = "turtletopia")
-test_param_runiverse(wood_runiverse_version, package = "versionsort")
+test_param_package(wood_runiverse_version(package = "versionsort", universe = "turtletopia"))
+test_param_runiverse(wood_runiverse_version(package = "versionsort", universe = "turtletopia"))
 
 test_that("raises an exception if package not available", {
   expect_error(
diff --git a/tests/testthat/test-url-dependencies.R b/tests/testthat/test-url-dependencies.R
index acb6876..fa4045f 100644
--- a/tests/testthat/test-url-dependencies.R
+++ b/tests/testthat/test-url-dependencies.R
@@ -9,8 +9,8 @@ with_mock_dir("x", {
 # TESTS ----
 test_dependencies(dockerfiler_deps)
 test_cache({ wood_url_dependencies("dockerfiler", "https://colinfay.me") }, dockerfiler_deps)
-test_param_package(wood_url_dependencies, repository = "https://colinfay.me")
-test_param_url_repo(wood_url_dependencies, package = "dockerfiler")
+test_param_package(wood_url_dependencies(package = "dockerfiler", repository = "https://colinfay.me"))
+test_param_url_repo(wood_url_dependencies(package = "dockerfiler", repository = "https://colinfay.me"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-url-packages.R b/tests/testthat/test-url-packages.R
index 91f034a..7b25630 100644
--- a/tests/testthat/test-url-packages.R
+++ b/tests/testthat/test-url-packages.R
@@ -9,7 +9,7 @@ with_mock_dir("y", {
 # TESTS ----
 test_packages(cynkra_packages)
 test_cache({ wood_url_packages("https://cynkra.r-universe.dev") }, cynkra_packages)
-test_param_url_repo(wood_url_packages)
+test_param_url_repo(wood_url_packages(repository = "https://cynkra.r-universe.dev"))
 
 test_that("Cynkra repository has cynkrathis package", {
   expect_subset("cynkrathis", cynkra_packages)
diff --git a/tests/testthat/test-url-version.R b/tests/testthat/test-url-version.R
index 206c50f..498edba 100644
--- a/tests/testthat/test-url-version.R
+++ b/tests/testthat/test-url-version.R
@@ -9,8 +9,8 @@ with_mock_dir("x", {
 # TESTS ----
 test_version(dockerfiler_version)
 test_cache({ wood_url_version("dockerfiler", "https://colinfay.me") }, dockerfiler_version)
-test_param_package(wood_url_version, repository = "https://colinfay.me")
-test_param_url_repo(wood_url_version, package = "dockerfiler")
+test_param_package(wood_url_version(package = "dockerfiler", repository = "https://colinfay.me"))
+test_param_url_repo(wood_url_version(package = "dockerfiler", repository = "https://colinfay.me"))
 
 skip_if_offline()
 test_that("raises an exception if package not available", {
diff --git a/tests/testthat/test-wood-dependencies.R b/tests/testthat/test-wood-dependencies.R
index 10c1348..b8787da 100644
--- a/tests/testthat/test-wood-dependencies.R
+++ b/tests/testthat/test-wood-dependencies.R
@@ -9,8 +9,8 @@ with_mock_dir("z", {
 
 # TESTS ----
 test_list_of(mixed_deps, pkgs, test_dependencies)
-test_param_packages(wood_dependencies)
-test_param_repos(wood_dependencies, packages = c("versionsort", "gglgbtq"))
+test_param_packages(wood_dependencies(packages = c("versionsort", "gglgbtq")))
+test_param_repos(wood_dependencies(packages = c("versionsort", "gglgbtq")))
 
 test_that("returns a 'wood_dep_list' object", {
   expect_s3_class(mixed_deps, "wood_dep_list")
diff --git a/tests/testthat/test-wood-packages.R b/tests/testthat/test-wood-packages.R
index b00e27f..594ebc4 100644
--- a/tests/testthat/test-wood-packages.R
+++ b/tests/testthat/test-wood-packages.R
@@ -12,7 +12,7 @@ with_mock_dir("1", {
 
 # TESTS ----
 test_packages(packages)
-test_param_repos(wood_packages)
+test_param_repos(wood_packages())
 
 test_that("uppercase in URL is preserved", {
   expect_not_empty(colinfay_packages)
diff --git a/tests/testthat/test-wood-versions.R b/tests/testthat/test-wood-versions.R
index c7f6be6..eb2b7e6 100644
--- a/tests/testthat/test-wood-versions.R
+++ b/tests/testthat/test-wood-versions.R
@@ -9,7 +9,7 @@ with_mock_dir("2", {
 
 # TESTS ----
 test_list_of(mixed_versions, pkgs, test_versions)
-test_param_packages(wood_versions)
-test_param_repos(wood_versions, packages = c("versionsort", "gglgbtq"))
+test_param_packages(wood_versions(packages = c("versionsort", "gglgbtq")))
+test_param_repos(wood_versions(packages = c("versionsort", "gglgbtq")))
 
 # TODO: maybe add test whether version codes are sorted?