replace expect_not_in() and expect_not_contains() by expect_disjoint()

Author: stibu81

NAMESPACE

@@ -82,6 +82,7 @@ export(expect)
 export(expect_condition)
 export(expect_contains)
 export(expect_cpp_tests_pass)
+export(expect_disjoint)
 export(expect_equal)
 export(expect_equal_to_reference)
 export(expect_equivalent)
@@ -113,8 +114,6 @@ export(expect_no_match)
 export(expect_no_message)
 export(expect_no_success)
 export(expect_no_warning)
-export(expect_not_contains)
-export(expect_not_in)
 export(expect_null)
 export(expect_output)
 export(expect_output_file)

NEWS.md

@@ -1,6 +1,6 @@
 # testthat (development version)
 
-* New `expect_not_contains()` and `expect_not_in()` to check for the absence of values (#1851).
+* New `expect_disjoint()` to check for the absence of values (#1851).
 * New `vignette("mocking")` explains mocking in detail (#1265).
 * New `vignette("challenging-functions")` provides an index to other documentation organised by testing challenges (#1265).
 * When running a test interactively, testthat now reports the number of succeses. The results should also be more useful if you are using nested tests.

R/expect-setequal.R

@@ -4,11 +4,9 @@
 #'    and that every element of `y` occurs in `x`.
 #' * `expect_contains(x, y)` tests that `x` contains every element of `y`
 #'   (i.e. `y` is a subset of `x`).
-#' * `expect_not_contains(x, y)` tests that `x` contains none of the elements
-#'   of `y` (i.e. `y` is disjoint from `x`).
 #' * `expect_in(x, y)` tests that every element of `x` is in `y`
 #'   (i.e. `x` is a subset of `y`).
-#' * `expect_not_in(x, y)` tests that no element of `x` is in `y`
+#' * `expect_disjoint(x, y)` tests that no element of `x` is in `y`
 #'   (i.e. `x` is disjoint from `y`).
 #' * `expect_mapequal(x, y)` treats lists as if they are mappings between names
 #'   and values. Concretely, this drops `NULL`s in both objects and sorts
@@ -121,32 +119,6 @@ expect_contains <- function(object, expected) {
   pass(act$val)
 }
 
-#' @export
-#' @rdname expect_setequal
-expect_not_contains <- function(object, expected) {
-  act <- quasi_label(enquo(object))
-  exp <- quasi_label(enquo(expected))
-
-  check_vector(object)
-  check_vector(expected)
-
-  exp_found <- exp$val %in% act$val
-  if (any(exp_found)) {
-    msg_exp <- sprintf(
-      "Expected %s to contain none of the values in %s.",
-      act$lab,
-      exp$lab
-    )
-    msg_act <- c(
-      sprintf("Actual: %s", values(act$val)),
-      sprintf("Expected: none of %s", values(exp$val)),
-      sprintf("Found: %s", values(exp$val[exp_found]))
-    )
-    fail(c(msg_exp, msg_act))
-  }
-
-  pass(act$val)
-}
 
 #' @export
 #' @rdname expect_setequal
@@ -177,24 +149,24 @@ expect_in <- function(object, expected) {
 
 #' @export
 #' @rdname expect_setequal
-expect_not_in <- function(object, expected) {
+expect_disjoint <- function(object, expected) {
   act <- quasi_label(enquo(object))
   exp <- quasi_label(enquo(expected))
 
   check_vector(object)
   check_vector(expected)
 
-  act_found <- act$val %in% exp$val
-  if (any(act_found)) {
+  act_common <- act$val %in% exp$val
+  if (any(act_common)) {
     msg_exp <- sprintf(
-      "Expected %s to contain no values from %s.",
+      "Expected %s to be disjoint from %s.",
       act$lab,
       exp$lab
     )
     msg_act <- c(
       sprintf("Actual: %s", values(act$val)),
       sprintf("Expected: none of %s", values(exp$val)),
-      sprintf("Invalid: %s", values(act$val[act_found]))
+      sprintf("Invalid: %s", values(act$val[act_common]))
     )
     fail(c(msg_exp, msg_act))
   }

man/expect_setequal.Rd

@@ -121,28 +121,6 @@
       Expected: "d", "e"
       Missing: "d", "e"
 
-# expect_not_contains() gives useful message on failure
-
-    Code
-      expect_not_contains(x1, x2)
-    Condition
-      Error:
-      ! Expected `x1` to contain none of the values in `x2`.
-      Actual: "a", "b", "c"
-      Expected: none of "c", "d"
-      Found: "c"
-
----
-
-    Code
-      expect_not_contains(x1, x3)
-    Condition
-      Error:
-      ! Expected `x1` to contain none of the values in `x3`.
-      Actual: "a", "b", "c"
-      Expected: none of "b", "c", "d"
-      Found: "b", "c"
-
 # expect_in() gives useful message on failure
 
     Code
@@ -165,24 +143,24 @@
       Expected: "d", "e"
       Invalid: "a", "b"
 
-# expect_not_in() gives useful message on failure
+# expect_disjoint() gives useful message on failure
 
     Code
-      expect_not_in(x1, x2)
+      expect_disjoint(x1, x2)
     Condition
       Error:
-      ! Expected `x1` to contain no values from `x2`.
+      ! Expected `x1` to be disjoint from `x2`.
       Actual: "a", "b", "c"
       Expected: none of "c", "d"
       Invalid: "c"
 
 ---
 
     Code
-      expect_not_in(x1, x3)
+      expect_disjoint(x1, x3)
     Condition
       Error:
-      ! Expected `x1` to contain no values from `x3`.
+      ! Expected `x1` to be disjoint from `x3`.
       Actual: "a", "b", "c"
       Expected: none of "b", "c", "d"
       Invalid: "b", "c"

tests/testthat/_snaps/expect-setequal.md

@@ -131,23 +131,6 @@ test_that("expect_contains() gives useful message on failure", {
   expect_snapshot_failure(expect_contains(x1, x3))
 })
 
-# not_contains ----------------------------------------------------------------
-
-test_that("expect_not_contains() succeeds when appropriate", {
-  expect_success(expect_not_contains(letters, 1))
-  expect_success(expect_not_contains(letters, LETTERS))
-  expect_success(expect_not_contains(letters, character()))
-})
-
-test_that("expect_not_contains() gives useful message on failure", {
-  x1 <- c("a", "b", "c")
-  x2 <- c("c", "d")
-  x3 <- c("b", "c", "d")
-
-  expect_snapshot_failure(expect_not_contains(x1, x2))
-  expect_snapshot_failure(expect_not_contains(x1, x3))
-})
-
 
 # in ----------------------------------------------------------------
 
@@ -166,19 +149,19 @@ test_that("expect_in() gives useful message on failure", {
   expect_snapshot_failure(expect_in(x1, x3))
 })
 
-# not_in ----------------------------------------------------------------
+# disjoint ----------------------------------------------------------------
 
-test_that("expect_not_in() succeeds when appropriate", {
-  expect_success(expect_not_in(1, letters))
-  expect_success(expect_not_in(LETTERS, letters))
-  expect_success(expect_not_in(character(), letters))
+test_that("expect_disjoint() succeeds when appropriate", {
+  expect_success(expect_disjoint(1, letters))
+  expect_success(expect_disjoint(LETTERS, letters))
+  expect_success(expect_disjoint(character(), letters))
 })
 
-test_that("expect_not_in() gives useful message on failure", {
+test_that("expect_disjoint() gives useful message on failure", {
   x1 <- c("a", "b", "c")
   x2 <- c("c", "d")
   x3 <- c("b", "c", "d")
 
-  expect_snapshot_failure(expect_not_in(x1, x2))
-  expect_snapshot_failure(expect_not_in(x1, x3))
+  expect_snapshot_failure(expect_disjoint(x1, x2))
+  expect_snapshot_failure(expect_disjoint(x1, x3))
 })