tests/testthat/test-compare_df_cols.R

In janitor: Simple Tools for Examining and Cleaning Dirty Data

test_that("data.frame comparison works", {
  # Names are intentionally not pretty to make it easier to see the source.
  # These data.frames are not typically used, and if the input name is needed,
  # it can be a named argument.
  expect_equal(
    compare_df_cols(data.frame(A=1), data.frame(B=2)),
    setNames(
      data.frame(
        column_name=c("A", "B"),
        A=c("numeric", NA),
        B=c(NA, "numeric"),
        stringsAsFactors=FALSE
      ),
      c("column_name",
        "data.frame(A = 1)",
        "data.frame(B = 2)")
    ),
    info="Names are detected from unnamed input"
  )
  expect_equal(
    compare_df_cols(foo=data.frame(A=1), bar=data.frame(B=2)),
    data.frame(
      column_name=c("A", "B"),
      foo=c("numeric", NA),
      bar=c(NA, "numeric"),
      stringsAsFactors=FALSE
    ),
    info="Names can be used from the input"
  )
  expect_equal(
    compare_df_cols(foo=data.frame(A=1), data.frame(B=2)),
    setNames(
      data.frame(
        column_name=c("A", "B"),
        A=c("numeric", NA),
        B=c(NA, "numeric"),
        stringsAsFactors=FALSE
      ),
      c("column_name",
        "foo",
        "data.frame(B = 2)")
    ),
    info="Names are detected from unnamed input and can be mixed with named arguments"
  )
  expect_equal(
    compare_df_cols(foo=data.frame(A=1, B=1), bar=data.frame(B=2)),
    data.frame(
      column_name=c("A", "B"),
      foo="numeric",
      bar=c(NA, "numeric"),
      stringsAsFactors=FALSE
    ),
    info="all output comes through when requested"
  )
  expect_equal(
    compare_df_cols(foo=data.frame(A=1, B=1), bar=data.frame(B=2), return="match", bind_method = "rbind"),
    data.frame(
      column_name="B",
      foo="numeric",
      bar="numeric",
      stringsAsFactors=FALSE
    ),
    info="only matching output comes through when requested"
  )
  expect_equal(
    compare_df_cols(foo=data.frame(A=1, B=1), bar=data.frame(B=2), return="mismatch", bind_method = "rbind"),
    data.frame(
      column_name="A",
      foo="numeric",
      bar=NA_character_,
      stringsAsFactors=FALSE
    ),
    info="only mismatching output comes through when requested"
  )
  expect_warning(
    expect_equal(
      compare_df_cols(foo=data.frame(A=1, B=1), return="mismatch"),
      data.frame(
        column_name=c("A", "B"),
        foo="numeric",
        stringsAsFactors=FALSE
      ),
      info="A single data.frame gives all results"
    ),
    info="A single data.frame isn't very meaningful, so the user is warned that they probably didn't do what they meant to do."
  )
  expect_equal(
    compare_df_cols(
      foo=data.frame(A=1, B=1, C=factor("A"), D=factor("B")),
      bar=data.frame(B=2, C=factor("A"), D=factor(c("A", "B"))),
      return="mismatch",
      bind_method = "rbind"
    ),
    data.frame(
      column_name="A",
      foo="numeric",
      bar=NA_character_,
      stringsAsFactors=FALSE
    ),
    info="only mismatching output comes through when requested (and it works with something a bit more complex than numeric)"
  )
  expect_equal(
    compare_df_cols(
      foo=data.frame(A=1, B=1, C=factor("A"), D=factor("B")),
      bar=data.frame(B=2, C=factor("A"), D=factor(c("A", "B"))),
      return="mismatch",
      bind_method = "rbind",
      strict_description=TRUE
    ),
    data.frame(
      column_name=c("A", "D"),
      foo=c("numeric", 'factor(levels=c("B"))'),
      bar=c(NA_character_, 'factor(levels=c("A", "B"))'),
      stringsAsFactors=FALSE
    ),
    info="only mismatching output comes through when requested (and it works with something a bit more complex than numeric)"
  )
  expect_equal(
    compare_df_cols(
      foo=data.frame(A=1, B=1, C=factor("A"), D=factor("B")),
      bar=data.frame(B=2, C=factor("A"), D=factor(c("A", "B"))),
      return="mismatch",
      strict_description=FALSE
    ),
    data.frame(
      column_name="D",
      foo='factor',
      bar='factor',
      stringsAsFactors=FALSE
    )[-1,],
    info="bind_rows output skips NA"
  )
  expect_equal(
    compare_df_cols(
      foo=data.frame(A=1, B=1, C=factor("A"), D=factor("B")),
      bar=data.frame(B=2, C=factor("A"), D=factor(c("A", "B"))),
      return="mismatch",
      bind_method="bind_rows",
      strict_description=TRUE
    ),
    data.frame(
      column_name="D",
      foo='factor(levels=c("B"))',
      bar='factor(levels=c("A", "B"))',
      stringsAsFactors=FALSE
    ),
    info="bind_rows output skips NA"
  )

  expect_warning(
    expect_equal(
      compare_df_cols(data.frame()),
      data.frame(
        column_name=character(0),
        stringsAsFactors=FALSE
      )
    ),
    regexp="data.frame() has zero columns and will not appear in output.",
    fixed=TRUE,
    info="empty data.frames by themselves work"
  )
  expect_warning(
    expect_equal(
      compare_df_cols(foo=data.frame(), bar=data.frame(A=1)),
      data.frame(
        column_name="A",
        bar="numeric",
        stringsAsFactors=FALSE
      )
    ),
    regexp="foo has zero columns and will not appear in output.",
    fixed=TRUE,
    info="empty data.frames with other inputs work"
  )
})

test_that("class detection works", {
  expect_equal(describe_class(5), "numeric")
  expect_equal(describe_class("A"), "character")
  expect_equal(
    describe_class(as.POSIXct("2019-01-02")), "POSIXct, POSIXt",
    info="multiple classes work"
  )
  expect_equal(
    describe_class(factor("A")),
    'factor(levels=c("A"))'
  )
  expect_equal(
    describe_class(factor("A", ordered=TRUE)),
    'ordered, factor(levels=c("A"))'
  )
  expect_equal(
    describe_class(factor(c("A", "B"), ordered=TRUE)),
    'ordered, factor(levels=c("A", "B"))'
  )
})

test_that("class description without strict description", {
  # No change with numeric
  expect_equal(describe_class(5, strict_description=FALSE), "numeric")
  # ordered factors don't show "ordered" or the levels
  expect_equal(describe_class(ordered(c("A", "B")), strict_description=FALSE), "factor")
})

test_that("boolean df comparison works", {
  expect_true(compare_df_cols_same(data.frame(A=1), data.frame(A=2)))
  expect_output(expect_false(compare_df_cols_same(data.frame(A=1), data.frame(A="string"))))
  expect_silent(expect_false(compare_df_cols_same(data.frame(A=1), data.frame(A="string"), verbose=FALSE)))
  expect_false(compare_df_cols_same(data.frame(A=1L), data.frame(A=1.5), bind_method="bind_rows", verbose = FALSE))
  expect_false(compare_df_cols_same(data.frame(A=1L), data.frame(A=1.5), bind_method="rbind", verbose = FALSE))
})

test_that("error messages are correct", {
  expect_error(
    compare_df_cols("A"),
    regexp="Input given with.*Argument number 1 is not."
  )
  expect_error(
    compare_df_cols("A", data.frame(A=1), 3),
    regexp="Input given with.*Argument numbers 1, 3 are not."
  )
})

test_that("list inputs to compare_df_cols give appropriate errors", {
  expect_error(
    compare_df_cols(list("A")),
    regexp="List inputs must be lists of data.frames.  List input number 1 is not a list of data.frames.",
    fixed=TRUE
  )
  expect_error(
    compare_df_cols(data.frame(), list("A")),
    regexp="List inputs must be lists of data.frames.  List input number 2 is not a list of data.frames.",
    fixed=TRUE
  )
  expect_error(
    compare_df_cols(list("A"), list("A")),
    regexp="List inputs must be lists of data.frames.  List input numbers 1, 2 are not lists of data.frames.",
    fixed=TRUE
  )
  expect_error(
    compare_df_cols(list("A"), list("A"), list("A"), list("A"), list("A"), list("A")),
    regexp="List inputs must be lists of data.frames.  List input numbers 1, 2, 3, 4, 5, ... are not lists of data.frames.",
    fixed=TRUE
  )
  expect_error(
    compare_df_cols(list(column_name=data.frame())),
    regexp="None of the input ... argument names or list names may be `column_name`.",
    fixed=TRUE
  )
})

test_that("list inputs to compare_df_cols work as expected", {
  expect_warning(
    expect_equal(
      compare_df_cols(
        list(foo=data.frame(), bar=data.frame(A=1, B=2)),
        baz=data.frame(A=2, C=3)
      ),
      data.frame(
        column_name=c("A", "B", "C"),
        bar=c("numeric", "numeric", NA_character_),
        baz=c("numeric", NA_character_, "numeric"),
        stringsAsFactors=FALSE
      )
    ),
    regexp="foo has zero columns and will not appear in output.",
    info="empty data.frame with other data.frames"
  )
  expect_equal(
    compare_df_cols(
      list(foo=data.frame(A=1), bar=data.frame(A=1, B=2)),
      baz=data.frame(A=2, C=3)
    ),
    data.frame(
      column_name=c("A", "B", "C"),
      foo=c("numeric", NA_character_, NA_character_),
      bar=c("numeric", "numeric", NA_character_),
      baz=c("numeric", NA_character_, "numeric"),
      stringsAsFactors=FALSE
    )
  )
  # Naming complexity
  expect_equal(
    compare_df_cols(
      list(data.frame(A=1), bar=data.frame(A=1, B=2)),
      baz=data.frame(A=2, C=3)
    ),
    setNames(
      data.frame(
        column_name=c("A", "B", "C"),
        foo=c("numeric", NA_character_, NA_character_),
        bar=c("numeric", "numeric", NA_character_),
        baz=c("numeric", NA_character_, "numeric"),
        stringsAsFactors=FALSE
      ),
      c("column_name", "list(data.frame(A = 1), bar = data.frame(A = 1, B = 2))_1", "bar", "baz")
    )
  )
  expect_equal(
    compare_df_cols(
      foo=list(data.frame(A=1), bar=data.frame(A=1, B=2)),
      baz=data.frame(A=2, C=3)
    ),
    setNames(
      data.frame(
        column_name=c("A", "B", "C"),
        foo=c("numeric", NA_character_, NA_character_),
        bar=c("numeric", "numeric", NA_character_),
        baz=c("numeric", NA_character_, "numeric"),
        stringsAsFactors=FALSE
      ),
      c("column_name", "foo_1", "bar", "baz")
    )
  )
  expect_equal(
    compare_df_cols(
      foo=list(data.frame(A=1), data.frame(A=1, B=2)),
      baz=data.frame(A=2, C=3)
    ),
    setNames(
      data.frame(
        column_name=c("A", "B", "C"),
        foo=c("numeric", NA_character_, NA_character_),
        bar=c("numeric", "numeric", NA_character_),
        baz=c("numeric", NA_character_, "numeric"),
        stringsAsFactors=FALSE
      ),
      c("column_name", "foo_1", "foo_2", "baz")
    )
  )
})

test_that("compare_df_cols_df_maker catches bad inputs", {
  expect_error(
    compare_df_cols_df_maker(x = mtcars, class_colname = "column_name"),
    regexp = '`class_colname` cannot be "column_name"',
    fixed = TRUE
  )
  expect_error(
    compare_df_cols_df_maker(list(x = mtcars, y = iris), class_colname = "class"),
    regexp = '`x` and `class_colname` must be the same length.',
    fixed = TRUE
  )
  expect_error(
    compare_df_cols_df_maker(list(x = mtcars), class_colname = c("column_name")),
    regexp = '`class_colname` cannot be "column_name"',
    fixed = TRUE
  )
})