Ensure expect_no_*() runs complete block

Instead of terminating early. Fixes #1991.

Author: hadley

NEWS.md

@@ -1,5 +1,6 @@
 # testthat (development version)
 
+* `expect_no_*()` now executes the entire code block, rather than stopping at the first message or warning (#1991).
 * `expect_no_failures()` and `expect_no_successes()` are now deprecated as `expect_success()` now test for no failures and `expect_failure()` tests for no successes (#)
 * New `pass()` function to use in place of `succeed()` (#2113).
 * `expectation()` is now a combination of `new_expectation()` and `exp_signal()` (#2125).

R/expect-no-condition.R

@@ -82,45 +82,53 @@ expect_no_ <- function(
       is.null(class)
   )
 
+  first_match <- NULL
   capture <- function(code) {
-    try_fetch(
-      {
-        code
-        # We can't call succeed() here because that generates a condition
-        # that causes `expect_no_condition()` to always fail
-        NULL
-      },
-      !!base_class := function(cnd) {
-        if (!matcher(cnd)) {
-          return(zap())
-        }
+    withRestarts(
+      withCallingHandlers(
+        code,
+        condition = function(cnd) {
+          if (!is.null(first_match) || !matcher(cnd)) {
+            return()
+          }
+
+          first_match <<- cnd
+          cnd_muffle(cnd)
 
-        expected <- paste0(
-          "Expected ",
-          quo_label(enquo(object)),
-          " to run without any ",
-          base_class,
-          "s",
-          if (!is.null(class)) paste0(" of class '", class, "'"),
-          if (!is.null(regexp)) paste0(" matching pattern '", regexp, "'"),
-          "."
-        )
-        actual <- paste0(
-          "Actually got a <",
-          class(cnd)[[1]],
-          "> with text:\n",
-          indent_lines(rlang::cnd_message(cnd))
-        )
-        message <- format_error_bullets(c(expected, i = actual))
-        fail(message, trace_env = trace_env)
-      }
+          # Matching errors should terminate execution
+          if (inherits(cnd, "error")) {
+            invokeRestart("done")
+          }
+        }
+      ),
+      done = function() {}
     )
   }
 
   act <- quasi_capture(enquo(object), NULL, capture)
-  if (is.null(act$cap)) {
-    succeed()
+
+  if (!is.null(first_match)) {
+    expected <- paste0(
+      "Expected ",
+      quo_label(enquo(object)),
+      " to run without any ",
+      base_class,
+      "s",
+      if (!is.null(class)) paste0(" of class '", class, "'"),
+      if (!is.null(regexp)) paste0(" matching pattern '", regexp, "'"),
+      "."
+    )
+    actual <- paste0(
+      "Actually got a <",
+      class(first_match)[[1]],
+      "> with text:\n",
+      indent_lines(rlang::cnd_message(first_match))
+    )
+    message <- format_error_bullets(c(expected, i = actual))
+    return(fail(message, trace_env = trace_env))
   }
+
+  succeed()
   invisible(act$val)
 }
 

tests/testthat/test-expect-no-condition.R

@@ -19,26 +19,26 @@ test_that("expect_no_* pass with pure code", {
   expect_success(expect_no_condition(1))
 })
 
+test_that("expect_no_ continues execution", {
+  b <- 1
+  expect_failure(expect_no_warning({
+    warning("x")
+    b <- 2
+  }))
+  expect_equal(b, 2)
+})
+
 test_that("expect_no_* don't emit success when they fail", {
   expect_failure(expect_no_error(stop("!")))
 })
 
 test_that("capture correct trace_env (#1994)", {
   # This should fail, not error
-  expect_failure(
-    expect_message({
-      message("a")
-      warn("b")
-    }) |>
-      expect_no_warning()
-  )
-  expect_failure(
-    expect_no_message({
-      message("a")
-      warn("b")
-    }) |>
-      expect_warning()
+  status <- capture_success_failure(
+    expect_warning(expect_error(stop("oops")))
   )
+  expect_equal(status$n_success, 1) # from expect_error()
+  expect_equal(status$n_failure, 1) # from expect_warning()
 })
 
 test_that("unmatched conditions bubble up", {