Nothing
withr::local_options(lifecycle_verbosity = "quiet")
# ---- constructor ----
testthat::test_that("new_tdata accepts reactive and not reactive MAE and data.frames", {
testthat::skip_if_not_installed("MultiAssayExperiment")
utils::data(miniACC, package = "MultiAssayExperiment")
testthat::expect_no_error(
new_tdata(
list(
a = reactive(data.frame(x = 1:10)),
b = data.frame(y = 1:10),
c = reactive(miniACC),
d = miniACC
)
)
)
})
testthat::test_that("new_tdata throws error if data is not a list with unique names", {
testthat::expect_error(
new_tdata(data.frame(1:10)), "Must be of type 'list'"
)
testthat::expect_error(
new_tdata(list(data.frame(1:10))), "Must have names"
)
testthat::expect_error(
new_tdata(list(x = data.frame(1:10), x = data.frame(1:5))), "Must have unique names"
)
})
testthat::test_that("new_tdata throws error if contents of data list are not of correct type", {
testthat::expect_error(
new_tdata(list(x = 1)), "May only contain the following types: \\{data.frame,reactive,MultiAssayExperiment\\}"
)
})
testthat::test_that("new_tdata throws error if code is not character or reactive character", {
testthat::expect_error(
new_tdata(list(x = iris), code = 5),
"Assertion on 'code' failed: Must inherit from class 'character'/'reactive'"
)
testthat::expect_error(
new_tdata(list(x = iris), code = reactive(5)),
"Assertion on 'code' failed: Must inherit from class 'character'"
)
})
testthat::test_that("new_tdata accepts character and reactive characters for code argument", {
testthat::expect_no_error(
new_tdata(list(x = iris, y = mtcars), code = c("x <- iris", "y <- mtcars"))
)
testthat::expect_no_error(
new_tdata(list(x = iris, y = mtcars), code = reactive(c("x <- iris", "y <- mtcars")))
)
})
testthat::test_that("new_tdata throws error if join_keys is not of class join_keys", {
testthat::expect_error(
new_tdata(list(x = iris), join_keys = "x"),
"Assertion on 'join_keys' failed: Must inherit from class 'join_keys'"
)
})
testthat::test_that("new_tdata throws no error if join_keys is of class join_keys", {
testthat::expect_no_error(
new_tdata(list(x = iris), join_keys = teal.data::join_keys())
)
})
# note not testing the contents of metadata elements are good as we are relying on
# the (tested) function in teal.data to do this
testthat::test_that(
"new_tdata throws error if metadata is not a list with unique names a subset of the names of data",
{
testthat::expect_error(
new_tdata(list(x = iris, y = mtcars), metadata = 1:3),
"Assertion on 'metadata' failed: Must be of type 'list' \\(or 'NULL'\\)"
)
testthat::expect_error(
new_tdata(list(x = iris, y = mtcars), metadata = list(1, 2, 3)),
"Assertion on 'metadata' failed: Must have names."
)
testthat::expect_error(
new_tdata(list(x = iris, y = mtcars), metadata = list(x = list(A = 1), z = list(B = 1))),
"Must be a subset of \\{'x','y'\\}, but has additional elements \\{'z'\\}."
)
}
)
testthat::test_that("new_tdata does not throw error with valid metadata", {
testthat::expect_no_error(
new_tdata(list(x = iris, y = mtcars), metadata = list(x = list(A = 1), y = list(B = 1)))
)
})
# ---- get_metadata ----
testthat::test_that("get_metadata returns NULL if no metadata", {
my_tdata <- new_tdata(data = list(iris = iris, mtcars = mtcars))
testthat::expect_null(get_metadata(my_tdata, "iris"))
})
testthat::test_that("get_metadata returns NULL if no metadata for given dataset", {
my_tdata <- new_tdata(
data = list(iris = iris, mtcars = mtcars),
metadata = list(mtcars = list(A = 1))
)
testthat::expect_null(get_metadata(my_tdata, "iris"))
})
testthat::test_that("get_metadata returns metadata for given dataset", {
my_tdata <- new_tdata(
data = list(iris = iris, mtcars = mtcars),
metadata = list(mtcars = list(A = 1, B = 2))
)
testthat::expect_equal(get_metadata(my_tdata, "mtcars"), list(A = 1, B = 2))
})
testthat::test_that("get_metadata returns NULL if dataset doesn't exist", {
my_tdata <- new_tdata(
data = list(iris = iris, mtcars = mtcars),
metadata = list(mtcars = list(A = 1, B = 2))
)
testthat::expect_null(get_metadata(my_tdata, "not_existing_df"))
})
# ---- get_code ----
testthat::test_that("get_code returns empty character if tdata object has no code", {
my_tdata <- new_tdata(data = list(iris = iris, mtcars = mtcars))
testthat::expect_equal("", isolate(get_code_tdata(my_tdata)))
})
testthat::test_that("get_code returns character of code if tdata object has code", {
code_string <- c("iris <- head(iris)", "mtcars <- head(mtcars)")
# reactive case (for constructor)
my_tdata <- new_tdata(
data = list(x = iris, mtcars = head(mtcars)),
code = reactive(code_string)
)
testthat::expect_equal(isolate(get_code_tdata(my_tdata)), code_string)
# not reactive case (for constructor)
my_tdata <- new_tdata(
data = list(x = iris, mtcars = head(mtcars)),
code = code_string
)
testthat::expect_equal(isolate(get_code_tdata(my_tdata)), code_string)
})
# ---- get_code wrapper ----
testthat::test_that("get_code_tdata accepts tdata", {
data <- new_tdata(data = list(iris = iris), code = "iris <- iris")
testthat::expect_no_error(isolate(get_code_tdata(data)))
})
testthat::test_that("get_code_tdata throws error when input is not tdata", {
testthat::expect_error(
isolate(get_code_tdata(iris)),
"Assertion on 'data' failed: Must inherit from class 'tdata', but has class 'data.frame'."
)
testthat::expect_error(
isolate(get_code_tdata("iris")),
"Assertion on 'data' failed: Must inherit from class 'tdata', but has class 'character'."
)
})
testthat::test_that("get_code_tdata returns character code", {
data <- new_tdata(data = list(iris = iris), code = "iris <- iris")
testthat::expect_identical(isolate(get_code_tdata(data)), "iris <- iris")
})
# ---- tdata2env ----
testthat::test_that("tdata2env returns environment containing tdata contents ", {
testthat::skip_if_not_installed("MultiAssayExperiment")
utils::data(miniACC, package = "MultiAssayExperiment")
my_tdata <- new_tdata(data = list(iris = iris, mae = reactive(miniACC)))
my_env <- isolate(tdata2env(my_tdata))
my_env_as_list <- as.list(my_env)
testthat::expect_setequal(names(my_env_as_list), c("iris", "mae"))
testthat::expect_equal(iris, my_env_as_list$iris)
testthat::expect_equal(miniACC, my_env_as_list$mae)
})
testthat::test_that("tdata2env throws error if argument is not tdata", {
testthat::expect_error(tdata2env(iris), "Must inherit from class 'tdata'")
})
# ---- join_keys ----
testthat::test_that("join_keys returns NULL if no join_keys object exists inside tdata", {
my_tdata <- new_tdata(data = list(iris = iris, mae = reactive(miniACC)))
testthat::expect_null(join_keys(my_tdata))
})
testthat::test_that("join_keys returns join_keys object if it exists inside tdata", {
jk <- teal.data::join_keys(teal.data::join_key("A", "B", c("id" = "fk")))
my_tdata <- new_tdata(
data = list(
A = data.frame(id = 1:10, val = 1:10),
B = data.frame(id = 1:10, val = 1:10, fk = 10:1)
),
join_keys = jk
)
testthat::expect_equal(join_keys(my_tdata), jk)
})
# as_tdata ----
code <- c("iris <- iris", "mtcars <- mtcars")
data_tdata <- teal::new_tdata(list(iris = iris, mtcars = mtcars), code)
data_teal_data <- teal.data::teal_data(iris = iris, mtcars = mtcars, code = code)
data_reactive <- shiny::reactive(teal.data::teal_data(iris = iris, mtcars = mtcars, code = code))
testthat::test_that("as_tdata accepts all possible inputs", {
testthat::expect_no_error(as_tdata(data_tdata))
testthat::expect_no_error(as_tdata(data_teal_data))
testthat::expect_no_error(as_tdata(data_reactive))
})
testthat::test_that("as_tdata always returns tdata object", {
data_tdata_downgraded <- as_tdata(data_tdata)
data_teal_data_downgraded <- as_tdata(data_teal_data)
data_reactive_downgraded <- as_tdata(data_teal_data)
testthat::expect_s3_class(data_tdata_downgraded, "tdata")
testthat::expect_s3_class(data_teal_data_downgraded, "tdata")
testthat::expect_s3_class(data_reactive_downgraded, "tdata")
})
testthat::test_that("datasets are maintained during conversion", {
data_tdata_downgraded <- as_tdata(data_teal_data)
datanames_teal_data <- sort(teal.data::datanames(data_teal_data))
datanames_tdata <- sort(names(data_tdata_downgraded))
testthat::expect_identical(datanames_teal_data, datanames_tdata)
datasets_teal_data <- sapply(datanames_teal_data, function(x) teal.code::get_var(data_teal_data, x))
datasets_tdata <- sapply(datanames_tdata, function(x) shiny::isolate(data_tdata_downgraded[[x]]()))
testthat::expect_identical(datasets_teal_data, datasets_tdata)
})
testthat::test_that("as_tdata maintains code during conversion", {
data_teal_data_downgraded <- as_tdata(data_teal_data)
testthat::expect_identical(
teal.code::get_code(data_teal_data),
shiny::isolate(attr(data_teal_data_downgraded, "code")())
)
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.