Add `expect_assertions(n)`

[schloerke]

When using callbacks (or async promises), it is nice to know that the callback was actually reached. With expect_assertions(n), you could declare the count of assertions at the top of a function and the remaining amount of expectations would be counted.

Implementation ideas:

• Could use the$test_expectations value to set and check the total.
• Might be useful to only set the method once.

Related: https://jestjs.io/docs/expect#assertion-count

Example implementation that does not have access to the$test_expectations: https://github.com/rstudio/promises/pull/192/files#diff-6481dd5af605948a35f35754a60e76df1c572fed58f647c29822fa5861eac1b9R148-R207
Example usage: https://github.com/rstudio/promises/pull/192/files#diff-f6895bf7784e973143ddcff9843efa2f831fba8ece0589789bd66bf6fd9e4ed1R14-R24

[hadley]

I suspect that's too special purpose for testthat itself. But I'm happy to help you figure out how to write it more simply. Is there a reason that you use defer()? i.e. why not do expect_assertions(expect_true(), 1)?

[schloerke]

I'd be up for the expression being passed in.

Ah! and if it's an evaluated expression, I can capture the conditions being thrown ("expectation") via withCallingHandlers() and rethrow withRestarts(). 👀

[schloerke]

@hadley This solution worked for me... Do you have a proper solution? I still get restarts usage mixed up.

expect_assertions <- function(expr, n) {
  assertion_count <- 0

  withCallingHandlers(
    {
      force(expr)
    },
    expectation = function(e) {
      if (
        inherits(e, "expectation_success") || inherits(e, "expectation_failure")
      ) {
        assertion_count <<- assertion_count + 1L
      }
      # Re-signal expectation
      testthat::exp_signal(e)
    }
  )

  expect_equal(assertion_count, n, label = "Expected assertion count")
}

expect_assertions(n = 2, {
  expect_true(TRUE)
})
#> Error: Expected assertion count (`actual`) not equal to `n` (`expected`).
#> 
#>   `actual`: 1.0
#> `expected`: 2.0

[hadley]

I think you can simplify that to this:

expect_assertions <- function(code, n_expected ) {
  n <- 0

  withCallingHandlers(code,
    expectation_success = \(e) n <<- n + 1L,
    expectation_failure = \(e) n <<- n + 1L
  )
  
  expect_equal(n, n_expected, label = "Expected assertion count")
}

expect_assertions(n = 2, {
  expect_true(TRUE)
})

R is different to all the other programming languages I know in that "handling" an exception doesn't stop it from continuing to percolate up the stack. That normally makes life more challenging, but in this case it makes it much simpler 😄

Would you also mind reading https://testthat.r-lib.org/dev/articles/custom-expectation.html and trying to make it a "real" expectation? Your feedback on that doc would be super useful to me.

[hadley]

Closing just to help me keep track of issues prior to release. I'm happy to keep discussing here.