context("config")
test_that("defaults are sensible", {
res <- withr::with_options(
tmp_options_didehpc(),
didehpc_config_defaults())
non_null <- c("cluster", "use_workers", "use_rrq", "worker_timeout",
"use_java", "conan_bootstrap")
null <- c("home", "temp", "shares", "template", "cores",
"wholenode", "parallel", "workdir", "r_version", "java_home")
i <- vlapply(res, is.null)
expect_true("credentials" %in% names(res)) # might be here or not
expect_setequal(setdiff(names(res)[i], "credentials"), null)
expect_setequal(setdiff(names(res)[!i], "credentials"), non_null)
expect_equal(res$cluster, "fi--dideclusthn") # old cluster
expect_false(res$use_workers)
expect_false(res$use_rrq)
expect_equal(res$worker_timeout, 600)
expect_true(res$conan_bootstrap)
expect_false(res$use_java)
})
test_that("use didehpc.username if needed and available", {
blank <- withr::with_options(
tmp_options_didehpc(),
didehpc_config_defaults())
res1 <- withr::with_options(
tmp_options_didehpc(didehpc.credentials = "bob"),
didehpc_config_defaults())
res2 <- withr::with_options(
tmp_options_didehpc(didehpc.username = "bob"),
didehpc_config_defaults())
res3 <- withr::with_options(
tmp_options_didehpc(didehpc.username = "alice",
didehpc.credentials = "bob"),
didehpc_config_defaults())
expect_equal(res1$credentials, "bob")
expect_mapequal(res1[names(res1) != "credentials"],
res2[names(res2) != "credentials"])
expect_equal(res2, res1)
expect_equal(res3, res1)
})
test_that("Try and get the username out of windows", {
mock_is_windows <- mockery::mock(FALSE, TRUE)
mockery::stub(didehpc_config_defaults, "is_windows", mock_is_windows)
withr::with_envvar(c(USERNAME = "bob"), {
res_other <- withr::with_options(
tmp_options_didehpc(),
didehpc_config_defaults())
res_win <- withr::with_options(
tmp_options_didehpc(),
didehpc_config_defaults())
})
expect_null(res_other$credentials)
expect_equal(res_win$credentials, "bob")
})
test_that("valid clusters is correct", {
expect_equal(valid_clusters(), c("fi--dideclusthn", "fi--didemrchnb",
"wpia-hn"))
})
test_that("Can transform cluster names", {
expect_equal(cluster_name("fi--dideclusthn"), "fi--dideclusthn")
expect_equal(cluster_name("small"), "fi--dideclusthn")
expect_equal(cluster_name("little"), "fi--dideclusthn")
expect_equal(cluster_name("dide"), "fi--dideclusthn")
expect_equal(cluster_name("ide"), "fi--dideclusthn")
expect_equal(cluster_name("dideclusthn"), "fi--dideclusthn")
expect_equal(cluster_name("fi--didemrchnb"), "fi--didemrchnb")
expect_equal(cluster_name("big"), "fi--didemrchnb")
expect_equal(cluster_name("mrc"), "fi--didemrchnb")
})
test_that("Check that resources are acceptable", {
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", 1, FALSE, FALSE),
list(template = "GeneralNodes", parallel = FALSE, count = 1L,
type = "Cores"))
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", NULL, NULL, NULL),
list(template = "GeneralNodes", parallel = FALSE, count = 1L,
type = "Cores"))
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", NULL, TRUE, FALSE),
list(template = "GeneralNodes", parallel = FALSE, count = 1L,
type = "Nodes"))
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", NULL, TRUE, TRUE),
list(template = "GeneralNodes", parallel = TRUE, count = 1L,
type = "Nodes"))
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", 8, FALSE, FALSE),
list(template = "GeneralNodes", parallel = FALSE, count = 8L,
type = "Cores"))
expect_equal(
check_resources("fi--dideclusthn", "GeneralNodes", 8, FALSE, NULL),
list(template = "GeneralNodes", parallel = TRUE, count = 8L,
type = "Cores"))
expect_error(
check_resources("fi--dideclusthn", "GeneralNodes", 9001, FALSE, FALSE),
"Maximum number of cores for fi--dideclusthn is 24")
expect_error(
check_resources("fi--didemrchnb", "GeneralNodes", 9001, FALSE, FALSE),
"Maximum number of cores for fi--didemrchnb is 64")
expect_error(
check_resources("fi--dideclusthn", "GeneralNodes", 2, TRUE, FALSE),
"Cannot specify both wholenode and cores")
expect_error(
didehpc_check_max_cores("unknown_cluster", 99),
"Invalid cluster 'unknown_cluster'")
})
test_that("default core/node choice consistent across clusters", {
matching <- function(returned, expected) {
for (field in c("parallel", "count", "type")) {
if (!(identical(expected[[field]], returned[[field]]))) {
return(FALSE)
}
}
TRUE
}
# Args for check_resources: cluster, template, cores, wholenode, parallel
# If we don't specify cores/parallel/whole node, we should get 1 core.
expect_true(matching(check_resources("fi--didemrchnb", "GeneralNodes", NULL, NULL, NULL),
list(parallel = FALSE, count = 1L, type = "Cores")))
expect_true(matching(check_resources("fi--didemrchnb", "32Core", NULL, NULL, NULL),
list(parallel = FALSE, count = 1L, type = "Cores")))
expect_true(matching(check_resources("wpia-hn", "AllNodes", NULL, NULL, NULL),
list(parallel = FALSE, count = 1L, type = "Cores")))
})
test_that("Can find redis host, given cluster", {
expect_equal(redis_host("fi--didemrchnb"), "12.0.0.1")
expect_equal(redis_host("fi--dideclusthn"), "11.0.0.1")
expect_equal(redis_host("wpia-hn"), "10.0.2.254")
expect_error(redis_host("fi--didegpu"),
"No redis host for cluster 'fi--didegpu'")
})
test_that("fetch r versions", {
testthat::skip_if_offline()
dat <- r_versions()
expect_is(dat, "numeric_version")
expect_true(numeric_version("4.3.0") %in% dat)
expect_true(length(dat) > 3)
})
test_that("Select a sensible r version", {
testthat::skip_if_offline()
v <- r_versions()
vmax <- max(v)
vmid <- v[length(v) - 3]
expect_equal(select_r_version(vmax), vmax)
expect_error(select_r_version("3.6.0"),
"Unsupported R version: 3.6.0")
expect_equal(select_r_version(NULL, vmid), vmid)
expect_equal(select_r_version(NULL, "4.1.0"), numeric_version("4.1.3"))
})
test_that("Build config", {
root <- tempfile()
mounts <- example_mounts(root)
workdir <- file.path(root, "home", "sub")
mock_detect_mount <- mockery::mock(mounts)
mockery::stub(didehpc_config, "detect_mount", mock_detect_mount)
cfg <- withr::with_options(
tmp_options_didehpc(),
didehpc_config(credentials = list(username = "bob", password = "secret"),
workdir = workdir))
mockery::expect_called(mock_detect_mount, 1L)
expect_equal(
mockery::mock_args(mock_detect_mount), list(list()))
expect_s3_class(cfg, "didehpc_config")
str <- capture.output(print(cfg))
expect_match(str, "<didehpc_config>", all = FALSE)
expect_match(str, " - username: bob", all = FALSE)
expect_match(str, " - password: \\*+$", all = FALSE)
expect_match(str, " - parallel: FALSE", all = FALSE)
})
test_that("Build config", {
root <- tempfile()
mounts <- example_mounts(root)
workdir <- file.path(root, "home", "sub")
mock_detect_mount <- mockery::mock(mounts)
mockery::stub(didehpc_config, "detect_mount", mock_detect_mount)
cfg <- withr::with_options(
tmp_options_didehpc(),
didehpc_config(credentials = "bob", workdir = workdir))
mockery::expect_called(mock_detect_mount, 1L)
expect_equal(
mockery::mock_args(mock_detect_mount), list(list()))
expect_s3_class(cfg, "didehpc_config")
str <- capture.output(print(cfg))
expect_match(str, "<didehpc_config>", all = FALSE)
expect_match(str, " - username: bob", all = FALSE)
expect_match(str, " - parallel: FALSE", all = FALSE)
})
test_that("workdir must exist", {
root <- tempfile()
mounts <- example_mounts(root)
workdir <- file.path(root, "home", "sub")
mock_detect_mount <- mockery::mock(mounts)
mockery::stub(didehpc_config, "detect_mount", mock_detect_mount)
withr::with_options(
tmp_options_didehpc(),
expect_error(
didehpc_config(credentials = "bob", workdir = tempfile()),
"workdir must be an existing directory"))
})
test_that("config getter requires sensible args", {
expect_error(
as_didehpc_config("bob"),
"Expected a didehpc_config for 'config'")
})
test_that("config getter tries to construct options", {
root <- tempfile()
workdir <- file.path(root, "home", "sub")
config <- example_config()
mock_do_call <- mockery::mock(config)
mockery::stub(as_didehpc_config, "do.call", mock_do_call)
cmp <- withr::with_options(
tmp_options_didehpc(),
as_didehpc_config(list(credentials = "bob", workdir = workdir)))
expect_equal(cmp, config)
mockery::expect_called(mock_do_call, 1L)
expect_equal(
mockery::mock_args(mock_do_call)[[1]],
list("didehpc_config", list(credentials = "bob", workdir = workdir)))
})
test_that("java options", {
root <- tempfile()
cfg1 <- example_config(root = tempfile())
expect_false(cfg1$use_java)
expect_null(cfg1$java_home)
cfg2 <- example_config(use_java = TRUE, root = tempfile())
expect_true(cfg2$use_java)
expect_equal(cfg2$java_home, "")
cfg3 <- example_config(use_java = TRUE, java_home = "T:/java",
root = tempfile())
expect_true(cfg3$use_java)
expect_equal(cfg3$java_home, "T:/java")
})
test_that("Global options", {
opts <- options()
on.exit(options(opts))
expect_equal(didehpc_config_global(), list())
expect_error(didehpc_config_global("user"),
"All options must be named")
expect_error(didehpc_config_global(credentials = "user", unknown = 2),
"Unknown options: unknown")
expect_equal(options(), opts)
mock_config <- mockery::mock(stop("Some error"))
mockery::stub(didehpc_config_global, "didehpc_config", mock_config)
withr::with_options(list(didehpc.credentials = "alice"), {
res <- didehpc_config_global(credentials = "bob", check = FALSE)
expect_equal(res$didehpc.credentials, "alice")
expect_equal(getOption("didehpc.credentials"), "bob")
mockery::expect_called(mock_config, 0)
expect_error(
didehpc_config_global(credentials = "charlie", check = TRUE),
"Some error")
mockery::expect_called(mock_config, 1)
expect_equal(mockery::mock_args(mock_config)[[1]], list())
expect_equal(getOption("didehpc.credentials"), "bob")
})
})
test_that("different worker configuration", {
w <- worker_resource(wholenode = TRUE, template = "8Core",
parallel = FALSE)
expect_is(w, "worker_resource")
cfg <- example_config(worker_resource = w, use_rrq = TRUE)
expect_equal(cfg$worker_resource,
list(template = "8Core", parallel = FALSE, count = 1,
type = "Nodes"))
})
test_that("different worker configuration requires use_rrq", {
w <- worker_resource(wholenode = TRUE, template = "8Core",
parallel = FALSE)
expect_error(
example_config(worker_resource = w),
"'worker_resource' provided but 'use_rrq' is FALSE")
})
test_that("error in worker configuration raises informatively", {
expect_error(
example_config(worker_resource = worker_resource(cores = 9001),
use_rrq = TRUE),
"Invalid worker resource request: Maximum number of cores for")
})
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.