Nothing
drake_context("deprecate")
test_with_dir("defunct functions", {
skip_on_cran()
suppressWarnings({
expect_condition(
drake_defunct(),
regexp = "defunct"
)
expect_error(
drake_defunct(),
regexp = "drake_defunct"
)
expect_error(analyses(), regexp = "analyses")
expect_error(drake::analyses(), regexp = "drake::analyses")
expect_error(from_plan(), regexp = "defunct")
})
})
test_with_dir("deprecation: target()", {
skip_on_cran()
expect_error(target(123), regexp = "user-side")
})
test_with_dir("deprecation: fetch_cache", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
dp <- drake_plan(x = 1)
expect_warning(make(dp, fetch_cache = ""), regexp = "deprecated")
expect_warning(drake_config(dp, fetch_cache = ""), regexp = "deprecated")
})
test_with_dir("deprecation: deps_targets() and knitr_deps()", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
config <- drake_config(
drake_plan(x = 1),
cache = storr::storr_environment(),
session_info = FALSE
)
expect_warning(deps_targets("x", config), regexp = "deprecated")
make_impl(config = config)
expect_warning(
dependency_profile(x, config, character_only = FALSE),
regexp = "deprecated"
)
expect_warning(
dependency_profile("x", config, character_only = TRUE),
regexp = "deprecated"
)
skip_if_not_installed("knitr")
load_mtcars_example()
expect_warning(knitr_deps("report.Rmd"), regexp = "deprecated")
})
test_with_dir("deprecation: cache functions", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
plan <- drake_plan(x = 1)
expect_error(expect_warning(tmp <- read_drake_meta()))
expect_silent(make(plan, verbose = 0L, session_info = FALSE))
expect_true(is.numeric(readd(x)))
expect_equal(cached(), "x")
cache <- drake_cache()
expect_warning(short_hash(cache))
expect_warning(long_hash(cache))
expect_warning(default_short_hash_algo(cache))
expect_warning(default_long_hash_algo(cache))
expect_warning(available_hash_algos())
expect_warning(new_cache(short_hash_algo = "123", long_hash_algo = "456"))
})
test_with_dir("deprecation: built", {
skip_on_cran()
plan <- drake_plan(x = 1)
make(plan)
config <- drake_config(plan)
expect_warning(built(cache = NULL))
expect_equal(
sort(suppressWarnings(built())),
sort(redisplay_keys(plan$target))
)
twopiece <- sort(
c(
suppressWarnings(built()),
suppressWarnings(imported(files_only = FALSE))
)
)
expect_equal(
sort(cached()),
sort(redisplay_keys(twopiece))
)
expect_warning(imported(files_only = TRUE))
})
test_with_dir("deprecation: imported", {
skip_on_cran()
expect_identical(
suppressWarnings(imported(cache = NULL)),
character(0)
)
for (fo in c(FALSE, TRUE)) {
imp <- suppressWarnings(imported(files_only = fo))
expect_equal(
sort(imp),
sort(setdiff(cached(targets_only = FALSE), cached(targets_only = TRUE))),
info = paste("files_only =", fo)
)
}
})
test_with_dir("deprecation: find_project", {
skip_on_cran()
scratch <- "./scratch"
dir.create(scratch)
fp <- suppressWarnings(find_project(path = scratch))
expect_null(fp)
plan <- drake_plan(x = 1)
make(plan)
fp <- suppressWarnings(find_project(path = normalizePath(scratch)))
expect_is(fp, "character")
})
test_with_dir("drake version checks in previous caches", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
# We need to be able to set the drake version
# to check back compatibility.
plan <- drake_plan(x = 1)
expect_silent(make(plan, verbose = 0L, session_info = TRUE))
x <- drake_cache()
suppressWarnings(expect_error(drake_session(cache = NULL), regexp = "make"))
expect_warning(drake_session(cache = x), regexp = "deprecated")
skip_if_not_installed("lubridate")
expect_warning(build_times(targets_only = TRUE), regexp = "deprecated")
config <- drake_config(plan)
expect_warning(
predict_runtime_impl(config, targets_only = TRUE),
regexp = "deprecated"
)
})
test_with_dir("deprecated graphing functions", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
pl <- drake_plan(a = 1, b = 2)
expect_warning(build_drake_graph(pl))
con <- drake_config(plan = pl)
skip_if_not_installed("lubridate")
skip_if_not_installed("visNetwork")
skip_if_not_installed("ggraph")
expect_warning(out <- vis_drake_graph_impl(config = con, direction = "LR"))
expect_warning(out <- vis_drake_graph_impl(config = con, layout = "sugiyama"))
expect_warning(out <- static_drake_graph(config = con))
expect_true(inherits(out, "gg"))
df <- drake_graph_info_impl(config = con)
expect_warning(out <- render_static_drake_graph(df))
expect_true(inherits(out, "gg"))
expect_warning(find_cache(directory = "x"), regexp = "deprecated")
})
test_with_dir("deprecate misc utilities", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
skip_if_not_installed("lubridate")
skip_if_not_installed("visNetwork")
expect_warning(drake_unquote("x"))
expect_warning(drake_quotes(character(0)))
expect_warning(drake_quotes(""))
expect_warning(drake_quotes("x"))
expect_warning(drake_quotes("x", single = TRUE))
expect_warning(drake_quotes("x", single = FALSE))
expect_warning(drake_strings("x"))
cache <- storr::storr_environment()
expect_warning(configure_cache(
cache, log_progress = TRUE, init_common_values = TRUE
))
load_mtcars_example()
expect_warning(config <- drake_config(my_plan, graph = 1, spec = 2))
expect_warning(make_imports(config))
expect_warning(make_targets(config))
expect_warning(make_with_config(config))
expect_warning(default_verbose())
expect_warning(default_Makefile_args(2, 2))
expect_warning(default_Makefile_args(0, 0))
expect_warning(default_Makefile_command())
expect_warning(Makefile_recipe())
expect_warning(default_recipe_command())
expect_warning(r_recipe_wildcard())
expect_warning(parallelism_choices(TRUE))
expect_warning(parallelism_choices(FALSE))
expect_warning(shell_file())
expect_warning(default_parallelism())
expect_warning(read_drake_config())
expect_warning(read_drake_graph())
expect_warning(read_drake_plan())
expect_warning(prune_drake_graph(config$graph, "small"))
expect_warning(predict_load_balancing(config), regexp = "deprecated")
expect_warning(tmp <- this_cache(), regexp = "deprecated")
expect_warning(drake_cache_log_file(), regexp = "deprecated")
expect_warning(get_trace("a", "b"), regexp = "deprecated")
})
test_with_dir("deprecated arguments", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
expect_warning(
pl <- drake_plan(a = 1, b = a, tidy_evaluation = TRUE),
regexp = "deprecated"
)
con <- drake_config(plan = pl)
expect_warning(drake::drake_plan(x = y, file_targets = TRUE))
expect_warning(drake_plan(list = c(a = "1")), regexp = "deprecated")
expect_warning(make(drake_plan(x = 1), recipe_command = "123"))
expect_warning(make(drake_plan(x = 1), hasty_build = "123"))
expect_warning(loadd(x, graph = 123))
expect_warning(failed(upstream_only = TRUE))
expect_error(expect_warning(loadd(list = "a", deps = TRUE)))
expect_warning(loadd(imported_only = TRUE), regexp = "deprecated")
expect_warning(cached(list = "x"), regexp = "deprecated")
expect_warning(
drake_config(plan = pl, ensure_workers = TRUE),
regexp = "deprecated"
)
expect_warning(cached(verbose = 1L), regexp = "deprecated")
expect_warning(
drake_cache(console_log_file = "123"),
regexp = "deprecated"
)
})
test_with_dir("example template files (deprecated)", {
skip_on_cran()
expect_false(file.exists("slurm_batchtools.tmpl"))
expect_warning(
drake_batchtools_tmpl_file("slurm_batchtools.tmpl"),
regexp = "deprecated"
)
expect_true(file.exists("slurm_batchtools.tmpl"))
})
test_with_dir("force with a non-back-compatible cache", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
expect_equal(cache_vers_check(NULL), character(0))
expect_null(drake_cache())
expect_true(
inherits(
suppressWarnings(recover_cache()),
"refclass_decorated_storr"
)
)
zip <- system.file(
file.path("testing", "built_mtcars_example_v6.2.1.zip"),
package = "drake",
mustWork = TRUE
)
unzip(zip, exdir = ".", setTimes = TRUE)
expect_warning(drake_cache(), regexp = "compatible")
expect_warning(recover_cache(), regexp = "compatible")
suppressWarnings(
expect_error(drake_config(drake_plan(x = 1)), regexp = "compatible")
)
suppressWarnings(
expect_error(make(drake_plan(x = 1)), regexp = "compatible")
)
expect_warning(make(drake_plan(x = 1), force = TRUE), regexp = "compatible")
tmp <- drake_cache()
})
test_with_dir("deprecate the `force` argument", {
skip_on_cran()
expect_warning(tmp <- recover_cache(force = TRUE), regexp = "deprecated")
expect_warning(load_mtcars_example(force = TRUE), regexp = "deprecated")
})
test_with_dir("timeout argument", {
skip_on_cran()
expect_warning(
make(
drake_plan(x = 1),
timeout = 5,
session_info = FALSE,
cache = storr::storr_environment()
)
)
})
test_with_dir("old trigger interface", {
skip_on_cran()
for (old_trigger in suppressWarnings(triggers())) {
plan <- drake_plan(x = 1)
plan$trigger <- old_trigger
clean()
cache <- storr::storr_environment()
expect_warning(
make(
plan,
session_info = FALSE,
cache = cache
),
regexp = "old trigger interface in drake is deprecated"
)
suppressWarnings(
config <- drake_config(
plan,
session_info = FALSE,
cache = cache
)
)
trigger <- diagnose(x, cache = config$cache)$trigger
expect_true(is.list(trigger))
if (identical(trigger$condition, TRUE)) {
expect_equal(old_trigger, "always")
} else {
expect_false(old_trigger == "always")
}
expect_equal(
trigger$command,
old_trigger %in% c("always", "any", "command")
)
expect_equal(
trigger$file,
old_trigger %in% c("always", "any", "file")
)
expect_equal(
trigger$depend,
old_trigger %in% c("always", "any", "depends")
)
}
})
test_with_dir("mtcars example", {
skip_on_cran()
expect_warning(
load_mtcars_example(report_file = "other_name.Rmd"),
regexp = "report_file"
)
})
test_with_dir("deprecated hooks", {
skip_on_cran()
expect_warning(
make(
drake_plan(x = 1),
hook = 123,
session_info = FALSE,
cache = storr::storr_environment()
),
regexp = "deprecated"
)
})
test_with_dir("pruning_strategy", {
skip_on_cran()
expect_warning(
make(
drake_plan(x = 1),
pruning_strategy = 123,
session_info = FALSE,
cache = storr::storr_environment()
),
regexp = "deprecated"
)
})
test_with_dir("main example", {
skip_on_cran()
skip_if_not_installed("curl")
skip_if_not_installed("downloader")
skip_if_not_installed("tibble")
skip_if_not_installed("tidyr")
if (!curl::has_internet()) {
skip("no internet connection")
}
skip_if_offline()
skip_if_not_installed("curl")
url <- "https://wlandau.github.io/drake-examples/main.zip" # nolint
tryCatch(
mem <- curl::curl_fetch_memory(url),
error = function(e) {
skip("test URL unreachable")
}
)
skip_if_not_installed("ggplot2")
for (file in c("raw_data.xlsx", "report.Rmd")) {
expect_false(file.exists(file))
}
# load_main_example() is now deprecated so should get a warning
expect_warning(load_main_example())
for (file in c("raw_data.xlsx", "report.Rmd")) {
expect_true(file.exists(file))
}
expect_warning(load_main_example(overwrite = TRUE), regexp = "Overwriting")
expect_warning(clean_main_example())
for (file in c("raw_data.xlsx", "report.Rmd")) {
expect_false(file.exists(file))
}
})
test_with_dir("session arg to make()", {
skip_on_cran()
expect_warning(
make(drake_plan(x = 1), session = "callr::r_vanilla"),
regexp = "deprecated"
)
})
test_with_dir("deprecated check_plan()", {
skip_on_cran()
# Circular non-DAG plan
x <- drake_plan(a = b, b = c, c = a)
expect_error(tmp <- capture.output(suppressWarning(check_plan(x))))
})
test_with_dir("deprecated cache_ and target_namespaces() etc.", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
x <- suppressWarnings(cache_namespaces())
y <- suppressWarnings(target_namespaces())
expect_true(all(y %in% x))
expect_false(all(x %in% y))
expect_warning(cleaned_namespaces(), regexp = "deprecated")
})
test_with_dir("deprecated drake_tip()", {
skip_on_cran()
expect_true(is.character(suppressWarnings(drake_tip())))
})
test_with_dir("former external functions that will become internal", {
skip_on_cran()
plan <- drake_plan(x = 1)
make(plan)
config <- drake_config(plan)
expect_warning(analysis_wildcard(), regexp = "deprecated")
expect_warning(cache_namespaces(), regexp = "deprecated")
expect_warning(cache_path(), regexp = "deprecated")
expect_warning(check_plan(plan = plan), regexp = "deprecated")
expect_warning(dataset_wildcard(), regexp = "deprecated")
expect_warning(drake_meta("x", config), regexp = "deprecated")
expect_warning(drake_palette(), regexp = "deprecated")
expect_warning(in_progress(), regexp = "deprecated")
expect_warning(progress(no_imported_objects = TRUE), regexp = "deprecated")
expect_warning(recover_cache(), regexp = "deprecated")
expect_warning(target_namespaces(), regexp = "deprecated")
})
test_with_dir("analyses and summaries", {
skip_on_cran()
datasets <- drake_plan(small = simulate(5), large = simulate(50))
methods <- drake_plan(
regression1 = reg1(dataset__),
regression2 = reg2(dataset__)
)
analyses <- expect_warning(
plan_analyses(methods, datasets = datasets, sep = ".")
)
x <- weak_tibble(
target = c(
"regression1.small",
"regression1.large",
"regression2.small",
"regression2.large"
),
command = c(
"reg1(small)",
"reg1(large)",
"reg2(small)",
"reg2(large)")
)
equivalent_plans(x, analyses)
analyses <- expect_warning(
plan_analyses(methods, datasets = datasets)
)
x <- weak_tibble(
target = c(
"regression1_small",
"regression1_large",
"regression2_small",
"regression2_large"
),
command = c(
"reg1(small)",
"reg1(large)",
"reg2(small)",
"reg2(large)")
)
equivalent_plans(analyses, x)
m2 <- drake_plan(regression1 = reg1(n), regression2 = reg2(n))
out <- expect_warning(plan_analyses(m2, datasets = datasets))
equivalent_plans(out, m2)
no_analyses <- drake_plan(
summ = summary(dataset__),
coef = stats::coefficients(dataset__)
)
suppressWarnings(
expect_error(
plan_summaries(no_analyses, analyses, datasets)
)
)
summary_types <- drake_plan(
summ = summary(analysis__),
coef = stats::coefficients(analysis__)
)
results <- expect_warning(
plan_summaries(
summary_types,
analyses,
datasets,
gather = NULL,
sep = "."
)
)
x <- weak_tibble(
target = c(
"summ.regression1_small",
"summ.regression1_large",
"summ.regression2_small",
"summ.regression2_large",
"coef.regression1_small",
"coef.regression1_large",
"coef.regression2_small",
"coef.regression2_large"
),
command = c(
"summary(regression1_small)",
"summary(regression1_large)",
"summary(regression2_small)",
"summary(regression2_large)",
"stats::coefficients(regression1_small)",
"stats::coefficients(regression1_large)",
"stats::coefficients(regression2_small)",
"stats::coefficients(regression2_large)"
)
)
equivalent_plans(results, x)
results <- expect_warning(
plan_summaries(summary_types, analyses, datasets, gather = NULL)
)
x <- weak_tibble(
target = c(
"summ_regression1_small",
"summ_regression1_large",
"summ_regression2_small",
"summ_regression2_large",
"coef_regression1_small",
"coef_regression1_large",
"coef_regression2_small",
"coef_regression2_large"
),
command = c(
"summary(regression1_small)",
"summary(regression1_large)",
"summary(regression2_small)",
"summary(regression2_large)",
"stats::coefficients(regression1_small)",
"stats::coefficients(regression1_large)",
"stats::coefficients(regression2_small)",
"stats::coefficients(regression2_large)"
)
)
equivalent_plans(results, x)
summary_types <- drake_plan(
summ = summary(analysis__, dataset__),
coef = stats::coefficients(analysis__)
)
results <- expect_warning(
plan_summaries(
summary_types,
analyses,
datasets,
gather = c("list", "rbind")
)
)
x <- weak_tibble(
target = c(
"summ_regression1_small",
"summ_regression1_large",
"summ_regression2_small",
"summ_regression2_large",
"coef_regression1_small",
"coef_regression1_large",
"coef_regression2_small",
"coef_regression2_large"
),
command = c(
"summary(regression1_small, small)",
"summary(regression1_large, large)",
"summary(regression2_small, small)",
"summary(regression2_large, large)",
"stats::coefficients(regression1_small)",
"stats::coefficients(regression1_large)",
"stats::coefficients(regression2_small)",
"stats::coefficients(regression2_large)"
)
)
y <- results[-1:-2, ]
row.names(x) <- row.names(y) <- NULL
equivalent_plans(x, y)
expect_true(grepl("^rbind\\(coef", results$command[1]))
expect_true(grepl("^list\\(summ", results$command[2]))
results <- expect_warning(
plan_summaries(summary_types, analyses, datasets)
)
expect_true(all(grepl("^list\\(", results$command[1:2])))
results <- expect_warning(
plan_summaries(
summary_types, analyses, datasets, gather = "my_bind"
)
)
expect_true(all(grepl("^my_bind\\(", results$command[1:2])))
expect_error(
suppressWarnings(
nope <- plan_summaries(
summary_types,
analyses,
datasets,
gather = rep("list", 37)
)
)
)
newtypes <- rbind(
summary_types,
drake_plan(
other = myother(dataset__)
)
)
expect_warning(
s <- plan_summaries(
newtypes,
analyses,
datasets,
gather = NULL
)
)
expect_equal(nrow(s), 8)
})
test_with_dir("wildcards", {
skip_on_cran()
plan <- drake_plan(x = 1)
expect_warning(map_plan(data.frame(x = 1), f), regexp = "deprecated")
expect_warning(gather_plan(plan), regexp = "deprecated")
expect_warning(gather_by(plan), regexp = "deprecated")
expect_warning(reduce_plan(plan), regexp = "deprecated")
expect_warning(reduce_by(plan), regexp = "deprecated")
expect_warning(evaluate_plan(plan), regexp = "deprecated")
expect_warning(expand_plan(plan), regexp = "deprecated")
})
test_with_dir("empty generative args", suppressWarnings({
skip_on_cran()
x <- drake_plan(a = 1, b = FUNCTION())
equivalent_plans(evaluate_plan(x), x)
equivalent_plans(evaluate_wildcard_rules(x, rules = NULL), x)
equivalent_plans(expand_plan(x), x)
}))
test_with_dir("evaluate and expand", suppressWarnings({
skip_on_cran()
df <- drake_plan(data = simulate(center = MU, scale = SIGMA))
m0 <- evaluate_plan(df, wildcard = "NULL", values = 1:2)
equivalent_plans(m0, df)
m1 <- evaluate_plan(df, rules = list(nothing = 1:2), expand = FALSE)
equivalent_plans(m1, df)
x <- expand_plan(df, values = c("rep1", "rep2"), sep = ".")
y <- weak_tibble(
target = c("data.rep1", "data.rep2"),
command = rep("simulate(center = MU, scale = SIGMA)", 2)
)
equivalent_plans(x, y)
x <- expand_plan(df, values = c("rep1", "rep2"))
y <- weak_tibble(
target = c("data_rep1", "data_rep2"),
command = rep("simulate(center = MU, scale = SIGMA)", 2)
)
equivalent_plans(x, y)
x1 <- expand_plan(df, values = c("rep1", "rep2"), rename = TRUE)
x2 <- expand_plan(df, values = c("rep1", "rep2"), rename = FALSE)
y2 <- weak_tibble(
target = c("data", "data"),
command = rep("simulate(center = MU, scale = SIGMA)", 2)
)
equivalent_plans(x1, y)
equivalent_plans(x2, y2)
x2 <- evaluate_plan(x, wildcard = "MU", values = 1:2, sep = ".")
y <- weak_tibble(
target = c("data_rep1.1", "data_rep1.2", "data_rep2.1", "data_rep2.2"),
command = c(
"simulate(center = 1, scale = SIGMA)",
"simulate(center = 2, scale = SIGMA)",
"simulate(center = 1, scale = SIGMA)",
"simulate(center = 2, scale = SIGMA)"
)
)
equivalent_plans(x2, y)
x2 <- evaluate_plan(x, wildcard = "MU", values = 1:2)
y <- weak_tibble(
target = c("data_rep1_1", "data_rep1_2", "data_rep2_1", "data_rep2_2"),
command = c(
"simulate(center = 1, scale = SIGMA)",
"simulate(center = 2, scale = SIGMA)",
"simulate(center = 1, scale = SIGMA)",
"simulate(center = 2, scale = SIGMA)"
)
)
equivalent_plans(x2, y)
x3 <- evaluate_plan(x2, wildcard = "SIGMA", values = letters[1:2],
expand = FALSE)
y <- weak_tibble(
target = c("data_rep1_1", "data_rep1_2", "data_rep2_1", "data_rep2_2"),
command = c(
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)",
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)"
)
)
equivalent_plans(x3, y)
x3a <- evaluate_plan(x2, wildcard = "SIGMA", values = letters[1:2],
expand = FALSE, rename = TRUE)
y <- weak_tibble(
target = c(
"data_rep1_1_a", "data_rep1_2_b", "data_rep2_1_a", "data_rep2_2_b"),
command = c(
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)",
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)"
)
)
equivalent_plans(x3a, y)
x3b <- evaluate_plan(
x2,
wildcard = "SIGMA",
values = letters[1:2],
expand = FALSE,
rename = TRUE,
sep = "."
)
y <- weak_tibble(
target = c(
"data_rep1_1.a", "data_rep1_2.b", "data_rep2_1.a", "data_rep2_2.b"),
command = c(
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)",
"simulate(center = 1, scale = a)",
"simulate(center = 2, scale = b)"
)
)
equivalent_plans(x3b, y)
x4 <- evaluate_plan(x, rules = list(MU = 1:2, SIGMA = c(0.1, 1)),
expand = FALSE)
y <- weak_tibble(
target = c("data_rep1", "data_rep2"),
command = c(
"simulate(center = 1, scale = 0.1)",
"simulate(center = 2, scale = 1)"
)
)
equivalent_plans(x4, y)
x5 <- evaluate_plan(x, rules = list(MU = 1:2, SIGMA = c(0.1, 1, 10)))
expect_equal(12L, nrow(x5))
expect_equal(12L, length(unique(x5$target)))
expect_equal(6L, length(unique(x5$command)))
x6 <- evaluate_plan(df, rules = list(MU = 0:1, SIGMA = 1:2), sep = ".")
y <- weak_tibble(
target = c("data.0.1", "data.0.2", "data.1.1", "data.1.2"),
command = c(
"simulate(center = 0, scale = 1)",
"simulate(center = 0, scale = 2)",
"simulate(center = 1, scale = 1)",
"simulate(center = 1, scale = 2)"
)
)
equivalent_plans(x6, y)
}))
test_with_dir("evaluate_plan() and trace", suppressWarnings({
skip_on_cran()
plan <- drake_plan(
top = 3,
data = simulate(center = MU, scale = SIGMA),
mus = c(MU, x),
simple = 1,
sigmas = c(SIGMA, y),
cheap = 2
)
x <- evaluate_plan(
plan, trace = TRUE, wildcard = "MU", values = 1:2, expand = FALSE)
y <- weak_tibble(
target = c(
"top",
"data",
"mus",
"simple",
"sigmas",
"cheap"
),
command = c(
3,
"simulate(center = 1, scale = SIGMA)",
"c(2, x)",
1,
"c(SIGMA, y)",
2
),
MU = as.character(c(NA, 1, 2, NA, NA, NA)),
MU_from = as.character(c(NA, "data", "mus", NA, NA, NA))
)
equivalent_plans(x, y)
x <- evaluate_plan(
plan, trace = TRUE, wildcard = "SIGMA", values = 1:2, expand = FALSE)
y <- weak_tibble(
target = c(
"top",
"data",
"mus",
"simple",
"sigmas",
"cheap"
),
command = c(
3,
"simulate(center = MU, scale = 1)",
"c(MU, x)",
1,
"c(2, y)",
2
),
SIGMA = as.character(c(NA, 1, NA, NA, 2, NA)),
SIGMA_from = as.character(c(NA, "data", NA, NA, "sigmas", NA))
)
equivalent_plans(x, y)
x <- evaluate_plan(plan, trace = TRUE, wildcard = "MU", values = 1:2)
y <- weak_tibble(
target = c(
"top",
"data_1",
"data_2",
"mus_1",
"mus_2",
"simple",
"sigmas",
"cheap"
),
command = c(
3,
"simulate(center = 1, scale = SIGMA)",
"simulate(center = 2, scale = SIGMA)",
"c(1, x)",
"c(2, x)",
1,
"c(SIGMA, y)",
2
),
MU = as.character(c(NA, 1, 2, 1, 2, NA, NA, NA)),
MU_from = as.character(c(NA, "data", "data", "mus", "mus", NA, NA, NA))
)
equivalent_plans(x, y)
x <- evaluate_plan(
plan, trace = TRUE, rules = list(MU = 1:2, SIGMA = 3:4), expand = FALSE)
y <- weak_tibble(
target = c(
"top",
"data",
"mus",
"simple",
"sigmas",
"cheap"
),
command = c(
3,
"simulate(center = 1, scale = 3)",
"c(2, x)",
1,
"c(4, y)",
2
),
MU = as.character(c(NA, 1, 2, NA, NA, NA)),
MU_from = as.character(c(NA, "data", "mus", NA, NA, NA)),
SIGMA = as.character(c(NA, 3, NA, NA, 4, NA)),
SIGMA_from = as.character(c(NA, "data", NA, NA, "sigmas", NA))
)
equivalent_plans(x, y)
x <- evaluate_plan(plan, trace = TRUE, rules = list(MU = 1:2, SIGMA = 3:4))
y <- weak_tibble(
target = c(
"top",
"data_1_3",
"data_1_4",
"data_2_3",
"data_2_4",
"mus_1",
"mus_2",
"simple",
"sigmas_3",
"sigmas_4",
"cheap"
),
command = c(
3,
"simulate(center = 1, scale = 3)",
"simulate(center = 1, scale = 4)",
"simulate(center = 2, scale = 3)",
"simulate(center = 2, scale = 4)",
"c(1, x)",
"c(2, x)",
1,
"c(3, y)",
"c(4, y)",
2
),
MU = as.character(c(NA, 1, 1, 2, 2, 1, 2, NA, NA, NA, NA)),
MU_from = as.character(
c(NA, rep("data", 4), rep("mus", 2), NA, NA, NA, NA)
),
SIGMA = as.character(c(NA, 3, 4, 3, 4, NA, NA, NA, 3, 4, NA)),
SIGMA_from = as.character(
c(
NA, rep(c("data_1", "data_2"), each = 2),
NA, NA, NA, rep("sigmas", 2), NA
)
)
)
equivalent_plans(x, y)
}))
test_with_dir("make() with wildcard columns", suppressWarnings({
skip_on_cran()
plan <- evaluate_plan(
drake_plan(x = rnorm(n__)),
wildcard = "n__",
values = 1:2,
trace = TRUE
)
expect_equal(nrow(plan), 2)
for (col in c("n__", "n___from")) {
expect_true(col %in% colnames(plan))
}
cache <- storr::storr_environment()
make(plan, cache = cache, session_info = FALSE)
con <- drake_config(plan, cache = cache, session_info = FALSE)
expect_true(all(plan$target %in% cached(cache = con$cache)))
}))
test_with_dir("unconventional wildcards", suppressWarnings({
skip_on_cran()
df <- drake_plan(data = simulate(center = .MU., scale = `{SIGMA}`)) # nolint
x0 <- expand_plan(df, values = c("rep1", "rep2"))
x <- evaluate_plan(
x0, rules = list(.MU. = 1:2, "`{SIGMA}`" = c(0.1, 1)), expand = FALSE # nolint
)
y <- weak_tibble(
target = c("data_rep1", "data_rep2"),
command = c(
"simulate(center = 1, scale = 0.1)",
"simulate(center = 2, scale = 1)"
)
)
equivalent_plans(x, y)
}))
test_with_dir("'columns' argument to evaluate_plan()", suppressWarnings({
skip_on_cran()
plan <- drake_plan(
x = target(always, cpu = "any"),
y = target(any, cpu = "always"),
z = target(any, cpu = "any")
)
out <- weak_tibble(
target = c("x_1", "x_2", "y_1", "y_2", "z"),
command = c(1, 2, rep("any", 3)),
cpu = c("any", "any", 1, 2, "any")
)
equivalent_plans(
evaluate_plan(
plan, wildcard = "always", values = 1:2, columns = c("command", "cpu")
),
out
)
out <- weak_tibble(
target = c("x", "y_1", "y_2", "z"),
command = c("always", rep("any", 3)),
cpu = c("any", 1, 2, "any")
)
equivalent_plans(
evaluate_plan(
plan, wildcard = "always", values = 1:2, columns = "cpu"
),
out
)
out <- weak_tibble(
target = c("x", "y", "z"),
command = c(1, rep("any", 2)),
cpu = c("any", 2, "any")
)
equivalent_plans(
evaluate_plan(
plan, wildcard = "always", values = 1:2, columns = c("command", "cpu"),
expand = FALSE
),
out
)
rules <- list(always = 1:2, any = 3:4)
out <- weak_tibble(
target = c(
"x_1_3", "x_1_4", "x_2_3", "x_2_4", "y_1_3",
"y_1_4", "y_2_3", "y_2_4", "z_3", "z_4"
),
command = as.character(c(1, 1, 2, 2, 3, 4, 3, 4, 3, 4)),
cpu = as.character(c(3, 4, 3, 4, 1, 1, 2, 2, 3, 4))
)
equivalent_plans(
evaluate_plan(plan, rules = rules, columns = c("command", "cpu")),
out
)
}))
test_with_dir("issue 187 on Github (from Kendon Bell)", suppressWarnings({
skip_on_cran() # CRAN gets essential tests only (check time limits).
test <- drake_plan(test = run_it(wc__))
out <- evaluate_plan(test, rules = list(wc__ = list(1:4, 5:8, 9:12)))
out2 <- weak_tibble(
target = c("test_1.4", "test_5.8", "test_9.12"),
command = c("run_it(1:4)", "run_it(5:8)", "run_it(9:12)")
)
equivalent_plans(out, out2)
}))
test_with_dir("conflicts in wildcard names/values", suppressWarnings({
skip_on_cran() # CRAN gets essential tests only (check time limits).
plan <- drake_plan(a = 1, b = 2)
rules1 <- list(plant = 1:2, seed = 3:4, plantseed = 5:6)
rules2 <- list(
plant = c("grow", "tall"),
bean = c("legume", "stalk"),
example = c("bean", "stalk")
)
expect_error(
evaluate_plan(plan, rules = rules1), regexp = "wildcard name")
expect_error(
evaluate_plan(plan, rules = rules2), regexp = "replacement value")
}))
test_with_dir("bad 'columns' argument to evaluate_plan()", suppressWarnings({
skip_on_cran()
plan <- drake_plan(
x = target("always", cpu = "any"),
y = target("any", cpu = "always"),
z = target("any", cpu = "any")
)
expect_error(
evaluate_plan(plan, wildcard = "any", values = 1:2, columns = "target"),
regexp = "argument of evaluate_plan"
)
expect_error(
evaluate_plan(plan, wildcard = "any", values = 1:2, columns = "nobodyhere"),
regexp = "not in the plan"
)
equivalent_plans(
plan,
evaluate_plan(plan, wildcard = "any", values = 1:2, columns = NULL)
)
}))
test_with_dir("map_plan()", suppressWarnings({
skip_on_cran()
fn <- function(a, b) {
a + b
}
args <- expand.grid(a = 1:2, b = 3:5)
plan1 <- map_plan(args = args, fun = fn)
args$id <- LETTERS[seq_len(nrow(args))]
plan2 <- map_plan(args = args, fun = fn)
args$x <- args$id
args$id <- NULL
plan3 <- map_plan(args = args, fun = fn, id = x)
plan4 <- map_plan(args = args, fun = "fn", id = "x", character_only = TRUE)
plan5 <- map_plan(args = args, fun = fn, id = x, trace = TRUE)
expect_equal(deparse_lang_col(plan1$command), deparse_lang_col(plan2$command))
equivalent_plans(plan2, plan3)
equivalent_plans(plan3, plan4)
equivalent_plans(weak_as_tibble(cbind(plan3, args)), plan5)
cache <- storr::storr_environment()
make(plan2, session_info = FALSE, cache = cache)
expect_equal(
vapply(
args$x, readd, FUN.VALUE = integer(1), USE.NAMES = FALSE,
cache = cache, character_only = TRUE
),
as.integer(args$a + args$b)
)
}))
test_with_dir("map_plan() onto a matrix", suppressWarnings({
skip_on_cran()
skip_if_not_installed("datasets")
my_model_fit <- function(x1, x2) {
lm(as.formula(paste("mpg ~", x1, "+", x2)), data = datasets::mtcars)
}
covariates <- setdiff(colnames(datasets::mtcars), "mpg")
args <- t(combn(covariates, 2))
colnames(args) <- c("x1", "x2")
plan <- map_plan(args, "my_model_fit")
cache <- storr::storr_environment()
make(plan, cache = cache, session_info = FALSE)
x <- readd(plan$target[1], character_only = TRUE, cache = cache)
expect_true(is.numeric(stats::coefficients(x)))
}))
test_with_dir("map_plan() with symbols", suppressWarnings({
skip_on_cran()
skip_if_not_installed("datasets")
my_model_fit <- function(x1, x2, data) {
formula <- as.formula(paste("mpg ~", x1, "+", x1))
lm(formula, data = data)
}
covariates <- setdiff(colnames(datasets::mtcars), "mpg")
args <- t(combn(covariates, 2))
colnames(args) <- c("x1", "x2")
args <- weak_as_tibble(args)
args$data <- rlang::syms(rep("mtcars", nrow(args)))
plan <- map_plan(args, my_model_fit)
cache <- storr::storr_environment()
make(plan, verbose = 0L, cache = cache)
x <- readd(plan$target[1], character_only = TRUE, cache = cache)
expect_true(is.numeric(stats::coefficients(x)))
}))
test_with_dir("gather_plan()", suppressWarnings({
skip_on_cran()
df <- drake_plan(data = simulate(center = MU, scale = SIGMA))
m0 <- evaluate_plan(df, wildcard = "NULL", values = 1:2)
equivalent_plans(m0, df)
m1 <- evaluate_plan(df, rules = list(nothing = 1:2), expand = FALSE)
equivalent_plans(m1, df)
x <- expand_plan(df, values = c("rep1", "rep2"))
x6 <- gather_plan(x, append = FALSE)
y <- sanitize_plan(
weak_tibble(
target = "target",
command = "list(data_rep1 = data_rep1, data_rep2 = data_rep2)"
)
)
equivalent_plans(x6, y)
z <- gather_plan(x, append = TRUE)
equivalent_plans(z, bind_plans(x, y))
x7 <- gather_plan(
x, target = "my_summaries", gather = "rbind", append = FALSE
)
y <- weak_tibble(
target = "my_summaries",
command = "rbind(data_rep1 = data_rep1, data_rep2 = data_rep2)"
)
equivalent_plans(x7, y)
}))
test_with_dir("reduce_plan()", suppressWarnings({
skip_on_cran() # CRAN gets essential tests only (check time limits).
# Non-pairwise reduce
x_plan <- evaluate_plan(
drake_plan(x = VALUE),
wildcard = "VALUE",
values = 1:8
)
x <- reduce_plan(
x_plan, target = "x_sum", pairwise = FALSE,
begin = "", end = "", append = FALSE
)
x0 <- weak_tibble(
target = "x_sum",
command = paste0(x_plan$target, collapse = " + ")
)
equivalent_plans(x, x0)
z <- reduce_plan(
x_plan, target = "x_sum", pairwise = FALSE,
begin = "", end = "", append = TRUE
)
z0 <- bind_plans(x_plan, x)
equivalent_plans(z, z0)
make(rbind(x_plan, x), session_info = FALSE)
expect_equal(readd(x_sum), sum(1:8))
clean(destroy = TRUE)
# Pairwise reduce even number of targets
x <- reduce_plan(x_plan, target = "x_sum", pairwise = TRUE)
x0 <- weak_tibble(
target = c(paste0("x_sum_", 1:6), "x_sum"),
command = c(
"x_1 + x_2", "x_3 + x_4", "x_5 + x_6", "x_7 + x_8",
"x_sum_1 + x_sum_2", "x_sum_3 + x_sum_4",
"x_sum_5 + x_sum_6"
)
)
equivalent_plans(x, x0)
x <- reduce_plan(
x_plan, target = "x_sum", pairwise = FALSE,
begin = "", end = ""
)
x0 <- weak_tibble(
target = "x_sum",
command = paste0(x_plan$target, collapse = " + ")
)
equivalent_plans(x, x0)
x <- reduce_plan(x_plan, target = "x_sum", pairwise = TRUE)
x0 <- weak_tibble(
target = c(paste0("x_sum_", 1:6), "x_sum"),
command = c(
"x_1 + x_2", "x_3 + x_4", "x_5 + x_6", "x_7 + x_8",
"x_sum_1 + x_sum_2", "x_sum_3 + x_sum_4",
"x_sum_5 + x_sum_6"
)
)
equivalent_plans(x, x0)
make(rbind(x_plan, x), session_info = FALSE)
expect_equal(readd(x_sum), sum(1:8))
clean(destroy = TRUE)
# Odd number of targets
x_plan <- evaluate_plan(
drake_plan(x = VALUE),
wildcard = "VALUE",
values = 1:9
)
x <- reduce_plan(x_plan, target = "x_sum", pairwise = TRUE)
x0 <- weak_tibble(
target = c(paste0("x_sum_", 1:7), "x_sum"),
command = c(
"x_1 + x_2", "x_3 + x_4", "x_5 + x_6", "x_7 + x_8",
"x_9 + x_sum_1",
"x_sum_2 + x_sum_3", "x_sum_4 + x_sum_5",
"x_sum_6 + x_sum_7"
)
)
equivalent_plans(x, x0)
make(rbind(x_plan, x), session_info = FALSE)
expect_equal(readd(x_sum), sum(1:9))
clean(destroy = TRUE)
# Arbitrary function in reduction
x_plan <- evaluate_plan(
drake_plan(x = VALUE),
wildcard = "VALUE",
values = 1:8
)
fun <- function(x, y) {
x ^ 2 - 3 * y
}
x <- reduce_plan(x_plan, target = "x_sum", pairwise = TRUE,
begin = "fun(", op = ", ", end = ")")
x0 <- weak_tibble(
target = c(paste0("x_sum_", 1:6), "x_sum"),
command = c(
"fun(x_1, x_2)", "fun(x_3, x_4)", "fun(x_5, x_6)", "fun(x_7, x_8)",
"fun(x_sum_1, x_sum_2)", "fun(x_sum_3, x_sum_4)",
"fun(x_sum_5, x_sum_6)"
)
)
equivalent_plans(x, x0)
make(rbind(x_plan, x))
out <- fun(
fun(
fun(1, 2),
fun(3, 4)
),
fun(
fun(5, 6),
fun(7, 8)
)
)
expect_equal(readd(x_sum), out)
}))
test_with_dir("gather_by()", suppressWarnings({
skip_on_cran()
plan <- evaluate_plan(
drake_plan(x = rnorm(m__), y = rexp(n__), z = 10),
rules = list(
m__ = 1:2,
n__ = c("a", "b")
),
trace = TRUE
)
x <- gather_by(plan, append = TRUE)
new_row <- drake_plan(
target = list(x_1 = x_1, x_2 = x_2, y_a = y_a, y_b = y_b, z = z)
)
y <- bind_plans(plan, new_row)
equivalent_plans(x[, c("target", "command")], y)
x <- gather_by(plan, append = TRUE, sep = ".")
equivalent_plans(x[, c("target", "command")], y)
z <- gather_by(plan, append = FALSE)
equivalent_plans(z[, c("target", "command")], y[nrow(y), ])
x <- gather_by(
plan,
n___from,
prefix = "xyz",
gather = "c",
append = TRUE,
sep = "."
)
y <- weak_tibble(
target = c("xyz.y", "xyz.NA"),
command = c("c(y_a = y_a, y_b = y_b)", "c(x_1 = x_1, x_2 = x_2, z = z)"),
m__ = as.character(NA),
m___from = as.character(NA),
n__ = NA,
n___from = c("y", NA)
)
y <- sanitize_plan(y)
equivalent_plans(x, bind_plans(plan, y))
x <- gather_by(plan, n___from, prefix = "xyz", gather = "c", append = TRUE)
y <- weak_tibble(
target = c("xyz_y", "xyz_NA"),
command = c("c(y_a = y_a, y_b = y_b)", "c(x_1 = x_1, x_2 = x_2, z = z)"),
m__ = as.character(NA),
m___from = as.character(NA),
n__ = NA,
n___from = c("y", NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
x <- gather_by(plan, m__, n__, prefix = "xyz", gather = "c", append = TRUE)
y <- weak_tibble(
target = c("xyz_1_NA", "xyz_2_NA", "xyz_NA_a", "xyz_NA_b", "xyz_NA_NA"),
command = c(
"c(x_1 = x_1)",
"c(x_2 = x_2)",
"c(y_a = y_a)",
"c(y_b = y_b)",
"c(z = z)"
),
m__ = as.character(c(1, 2, NA, NA, NA)),
m___from = as.character(NA),
n__ = c(NA, NA, "a", "b", NA),
n___from = as.character(NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
plan$n___from <- c("x", "x", "y", "y", NA)
x <- gather_by(
plan,
n___from,
prefix = "xyz",
gather = "c",
append = TRUE,
filter = n___from == "x"
)
new_row <- drake_plan(xyz_x = c(x_1 = x_1, x_2 = x_2))
y <- bind_plans(plan, new_row)
equivalent_plans(x[, c("target", "command")], y)
}))
test_with_dir("reduce_by()", suppressWarnings({
skip_on_cran()
plan <- evaluate_plan(
drake_plan(x = rnorm(m__), y = rexp(n__), z = 10),
rules = list(
m__ = 1:4,
n__ = c("a", "b")
),
trace = TRUE
)
x <- reduce_by(plan, pairwise = FALSE, append = TRUE)
new_row <- drake_plan(target = x_1 + x_2 + x_3 + x_4 + y_a + y_b + z)
y <- bind_plans(plan, new_row)
equivalent_plans(x[, c("target", "command")], y)
z <- reduce_by(plan, pairwise = FALSE, append = FALSE)
equivalent_plans(z[, c("target", "command")], y[nrow(y), ])
x <- reduce_by(
plan, m___from,
prefix = "xyz",
op = ", ",
begin = "c(",
end = ")",
append = TRUE,
sep = "."
)
y <- weak_tibble(
target = c("xyz.1.x", "xyz.2.x", "xyz.x", "xyz.1.NA", "xyz.NA"),
command = c(
"c(x_1, x_2)",
"c(x_3, x_4)",
"c(xyz.1, xyz.2)",
"c(y_a, y_b)",
"c(z, xyz.1)"
),
m__ = as.character(NA),
m___from = c(rep("x", 3), rep(NA, 2)),
n__ = as.character(NA),
n___from = as.character(NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
x <- reduce_by(
plan, m___from,
prefix = "xyz",
op = ", ",
begin = "c(",
end = ")",
append = TRUE
)
y <- weak_tibble(
target = c("xyz_1_x", "xyz_2_x", "xyz_x", "xyz_1_NA", "xyz_NA"),
command = c(
"c(x_1, x_2)", "c(x_3, x_4)", "c(xyz_1, xyz_2)",
"c(y_a, y_b)", "c(z, xyz_1)"
),
m__ = as.character(NA),
m___from = c(rep("x", 3), rep(NA, 2)),
n__ = as.character(NA),
n___from = as.character(NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
x <- reduce_by(
plan, m___from, prefix = "xyz", op = ", ", begin = "c(", end = ")",
pairwise = FALSE, append = TRUE
)
y <- weak_tibble(
target = c("xyz_x", "xyz_NA"),
command = c("c(c(c(x_1, x_2), x_3), x_4)", "c(c(y_a, y_b), z)"),
m__ = as.character(NA),
m___from = c("x", NA),
n__ = as.character(NA),
n___from = as.character(NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
x <- reduce_by(plan, m___from, n___from, append = TRUE)
y <- weak_tibble(
target = c(
"target_1_x_NA",
"target_2_x_NA",
"target_x_NA",
"target_NA_y"
),
command = c(
"x_1 + x_2",
"x_3 + x_4",
"target_1 + target_2",
"y_a + y_b"
),
m__ = as.character(NA),
m___from = c(rep("x", 3), NA),
n__ = as.character(NA),
n___from = c(rep(NA, 3), "y")
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
x <- reduce_by(plan, m___from, n___from, pairwise = FALSE, append = TRUE)
y <- weak_tibble(
target = c(
"target_x_NA",
"target_NA_y",
"target_NA_NA"
),
command = c(
"x_1 + x_2 + x_3 + x_4",
"y_a + y_b",
"z"
),
m__ = as.character(NA),
m___from = c("x", NA, NA),
n__ = as.character(NA),
n___from = c(NA, "y", NA)
)
y <- sanitize_plan(y)
expected <- bind_plans(plan, y)
equivalent_plans(x[order(x$target), ], expected[order(expected$target), ])
plan$from <- c(rep("x", 4), rep("y", 2), NA)
x <- reduce_by(
plan,
from,
prefix = "xyz",
append = TRUE,
pairwise = FALSE,
filter = from == "y"
)
new_row <- drake_plan(xyz_y = y_a + y_b)
y <- bind_plans(plan, new_row)
equivalent_plans(x[, c("target", "command")], y)
}))
test_with_dir("get_cache", {
skip_on_cran()
make(drake_plan(x = 1), session_info = FALSE)
tmp1 <- expect_warning(get_cache(search = TRUE), regexp = "deprecated")
tmp2 <- expect_warning(get_cache(search = FALSE), regexp = "deprecated")
expect_true(inherits(tmp1, "refclass_decorated_storr"))
expect_true(inherits(tmp2, "refclass_decorated_storr"))
})
test_with_dir("deprecated memory strategies", {
skip_on_cran()
plan <- drake_plan(x = 1)
expect_warning(
make(
plan,
cache = storr::storr_environment(),
session_info = FALSE,
memory_strategy = "memory"
),
regexp = "preclean"
)
})
test_with_dir("deprecated decorated storr methods", {
skip_on_cran()
cache <- new_cache()
expect_silent(cache$reset_ht_hash())
expect_equal(1, 1)
})
test_with_dir("config arg of make() (#1118)", {
skip_on_cran()
plan <- drake_plan(x = 1)
config <- drake_config(
plan,
session_info = FALSE,
cache = storr::storr_environment()
)
expect_warning(
make(config = config),
regexp = "deprecated"
)
})
test_with_dir("progress(), running(), and failed()", {
skip_on_cran()
expect_warning(prg <- progress(x), regexp = "deprecated")
expect_equal(nrow(prg), 0L)
plan <- drake_plan(x = stop())
expect_error(make(plan))
expect_warning(prg <- progress(x), regexp = "deprecated")
expect_warning(prg <- progress(progress = "done"), regexp = "deprecated")
expect_warning(prg <- progress(), regexp = "deprecated")
expect_warning(run <- running(), regexp = "deprecated")
expect_warning(fld <- failed(), regexp = "deprecated")
})
test_with_dir("expose_imports() works", {
skip_on_cran() # CRAN gets essential tests only (check time limits).
scenario <- get_testing_scenario()
envir <- eval(parse(text = scenario$envir))
evalq(
f <- function(x) {
g(x)
},
envir = envir
)
evalq(
g <- function(x) {
digest(x)
},
envir = envir
)
plan <- drake_plan(
x = f(1),
y = digest::digest(x)
) # double-scoped functions stop the nesting.
config <- drake_config(plan, envir = envir)
n_nodes <- length(igraph::V(config$graph)$name)
expect_true(n_nodes < 10)
envir <- expect_warning(
expose_imports(digest, envir = envir),
message = "deprecated"
)
config <- drake_config(plan, envir = envir)
n_nodes_new <- length(igraph::V(config$graph)$name)
expect_true(n_nodes_new > n_nodes)
make_impl(config = config)
expect_is(readd(x), "character")
})
test_with_dir("move to caching = \"main\" at the top level", {
skip_if_not_installed("future")
plan <- drake_plan(x = 1)
expect_warning(make(plan, caching = "master"), message = "deprecated")
})
test_with_dir("move to caching = \"main\" at the target level", {
skip_if_not_installed("future")
plan <- drake_plan(x = target(1, caching = "master"))
expect_warning(
make(plan, caching = "worker", parallelism = "future"),
message = "deprecated"
)
})
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.