`expect_not_contains()`

[aronatkins]

It would be helpful to have a collection of negated checkers, or utilities to help negate existing checks. For example, we have expect_contains, but not a straightforward way to check when values should no be in the haystack.

expect_not_contains(c("a","b"), c("a","c"))
Error: c("a", "b") (`actual`) contains some of the values in c("a", "c") (`unexpected`).
* Missing from `actual`: "c"
* Present in `actual`:   "a", "b"

I could write this as the following, but would not receive any assistance in reporting the unexpected values:

expect_false(any(c("a","c") %in% c("a","b")))

Getting feedback is cumbersome:

haystack <- c("a","b")
values <- c("a","c")
testthat::expect_false(any(values %in% haystack), paste("unexpected: ", paste0(values[values %in% haystack], collapse = ", ")))

[hadley]

Presumably expect_not_in() would be good too.

But I think expect_not_setequal() is probably too weak a test to be useful?

[aronatkins]

The "utilities to help negate checks" could be really powerful, but it's a departure from the current approach. I didn't really detail that idea earlier, so here's what I was trying to suggest:

Consider a generic expect_that helper that allowed composable checks.

expect_that(equals, A, B)
expect_that(not(equals), A, B)
expect_that(contains, A, B)
expect_that(not(contains), A, B)

I'm hand-waving the implementation details and how the "checks" are defined, but something like this would reduce the number of unique expect_not_some_specific_thing functions and build a grammar of composable test operators.

The operators don't all need to take two arguments.

expect_that(file_exists, A)
expect_that(not(file_exists), B)
expect_that(nearly_equal, A, B, 0.05)
expect_that(not(nearly_equal), A, B, 0.05)

[hadley]

Amusingly that is how testthat v1 worked and indeed there's already a testthat::not() function 😆 The reason I transitioned away from this is that it's really hard to generically write negated expressions (at least for me) and so it's easier to tackle on a case by case basis.