context("utility")
# Setup ------------------------------------------------------------------------
source("setup.R")
# Test to_html -----------------------------------------------------------------
test_that("to_html converts file extension Rmd", {
expected <- "file.html"
actual <- workflowr:::to_html("file.Rmd")
expect_identical(actual, expected)
})
test_that("to_html converts file extension rmd", {
expected <- "file.html"
actual <- workflowr:::to_html("file.rmd")
expect_identical(actual, expected)
})
test_that("to_html converts file extension even if it also appears in filename", {
expected <- "Rmd.html"
actual <- workflowr:::to_html("Rmd.Rmd")
expect_identical(actual, expected)
})
test_that("to_html converts simple absolute path", {
docs <- "/home/user/project/docs"
expected <- file.path(docs, "file.html")
actual <- workflowr:::to_html("/home/user/project/analysis/file.Rmd",
outdir = docs)
expect_identical(actual, expected)
})
test_that("to_html converts simple relative path", {
docs <- "docs"
expected <- file.path(docs, "file.html")
actual <- workflowr:::to_html("analysis/file.Rmd", outdir = docs)
expect_identical(actual, expected)
})
test_that("to_html does not prepend ./", {
docs <- "."
expected <- "file.html"
actual <- workflowr:::to_html("analysis/file.Rmd", outdir = docs)
expect_identical(actual, expected)
})
test_that("to_html is vectorized", {
docs <- "/home/user/project/docs"
expected <- file.path(docs, c("1.html", "2.html", "3.html"))
actual <- workflowr:::to_html(c("1.Rmd", "2.Rmd", "3.Rmd"),
outdir = docs)
expect_identical(actual, expected)
})
test_that("to_html handles trailing slashes", {
docs <- "/home/user/project/docs/"
expected <- "/home/user/project/docs/file.html"
actual <- workflowr:::to_html("/home/user/project/analysis/file.Rmd",
outdir = docs)
expect_identical(actual, expected)
})
test_that("to_html throws errors for invalid extensions", {
expect_error(workflowr:::to_html("file.md"), "Invalid file extension")
expect_error(workflowr:::to_html("file.z"), "Invalid file extension")
expect_error(workflowr:::to_html("file"), "Invalid file extension")
})
# Test absolute ----------------------------------------------------------------
test_that("absolute expands existing file", {
path_rel <- "test-utility.R"
path_abs <- workflowr:::absolute(path_rel)
expect_true(fs::is_absolute_path(path_abs))
})
test_that("absolute expands existing directory", {
path_rel <- "."
path_abs <- workflowr:::absolute(path_rel)
expect_true(fs::is_absolute_path(path_abs))
})
test_that("absolute expands non-existent file", {
path_rel <- "non-existent-file"
path_abs <- workflowr:::absolute(path_rel)
expect_true(fs::is_absolute_path(path_abs))
})
test_that("absolute expands non-existent directory", {
path_rel <- "a/b/c"
path_abs <- workflowr:::absolute(path_rel)
expect_true(fs::is_absolute_path(path_abs))
})
test_that("absolute removes duplicated forward slashes", {
path_rel <- "a//b/c"
path_abs <- workflowr:::absolute(path_rel)
expect_false(stringr::str_detect(path_abs, "//"))
})
test_that("absolute removes duplicated back slashes", {
path_rel <- "a\\\\b/c"
path_abs <- workflowr:::absolute(path_rel)
expect_false(stringr::str_detect(path_abs, "\\\\"))
})
test_that("absolute removes trailing forward slash(es)", {
path_rel <- c("a/b/c/", "a/b/c//")
path_abs <- workflowr:::absolute(path_rel)
expect_false(all(stringr::str_detect(path_abs, "/$")))
})
test_that("absolute removes trailing back slash(es)", {
path_rel <- c("a\\b\\c\\", "a\\b\\c\\\\")
path_abs <- workflowr:::absolute(path_rel)
expect_false(all(stringr::str_detect(path_abs, "\\$")))
})
test_that("absolute converts back slashes to forward slashes", {
path_rel <- c("a\\b\\c\\", "a\\\\b\\\\c\\\\")
path_abs <- workflowr:::absolute(path_rel)
expect_false(all(stringr::str_detect(path_abs, "\\\\")))
})
test_that("absolute does not add any attributes to the character vector", {
path_rel <- c("a/b/c", "x/y/z")
path_abs <- workflowr:::absolute(path_rel)
expect_true(is.character(path_abs))
expect_true(is.null(attributes(path_abs)))
})
test_that("absolute returns NULL for NULL", {
expect_identical(workflowr:::absolute(NULL), NULL)
})
test_that("absolute returns NA for NA", {
expect_identical(workflowr:::absolute(NA), NA)
})
# Test relative ----------------------------------------------------------------
test_that("relative returns subdirectory", {
path <- "/test/location/project"
start <- "/test/location"
expected <- "project"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns nested subdirectories", {
path <- "/test/location/project/sub1/sub2"
start <- "/test/location"
expected <- "project/sub1/sub2"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns upstream directory", {
path <- "/test"
start <- "/test/location"
expected <- ".."
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns multiple upstream directories", {
path <- "/test"
start <- "/test/location/project"
expected <- "../.."
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns . when directories are the same", {
path <- "/test/location/project"
start <- "/test/location/project"
expected <- "."
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns files in upstream directories", {
path <- "/test/location/project/sub1/file"
start <- "/test/location/project/sub2"
expected <- "../sub1/file"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative can handle tilde for home directory", {
path <- "~/test/location/project/sub1/file"
start <- "~/test/location/project/sub2"
expected <- "../sub1/file"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative can handle a tilde in an absolute path", {
path <- "/test/location/project/sub1/file~"
start <- "/test/location/project/sub2"
expected <- "../sub1/file~"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns NULL for NULL", {
expect_identical(workflowr:::relative(NULL), NULL)
})
test_that("relative returns NA for NA", {
expect_identical(workflowr:::relative(NA), NA)
})
test_that("relative works on vector input", {
path <- c("/test", "/test/location/subdir")
start <- "/test/location"
expected <- c("..", "subdir")
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative works on relative paths to existing files", {
fs::dir_create("x/y/z")
on.exit(unlink("x", recursive = TRUE, force = TRUE))
path <- c("x", "x/y/z")
start <- "./x/y"
expected <- c("..", "z")
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative handles NA and NULL", {
expect_null(workflowr:::relative(NULL))
expect_identical(NA, workflowr:::relative(NA))
path <- c("/test", NA, NULL, "/test/location/subdir")
start <- "/test/location"
expected <- c("..", NA, NULL, "subdir")
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns absolute path when path and start on different Windows drive", {
if (.Platform$OS.type != "windows") skip("Only relevant on Windows")
path <- "D:/a/file"
start <- "C:/Users/CRAN"
expected <- path
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative returns relative path when path and start on same Windows drive", {
if (.Platform$OS.type != "windows") skip("Only relevant on Windows")
path <- "C:/a/file"
start <- "C:/Users/CRAN"
expected <- "../../a/file"
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative throws error when paths have different Windows drive", {
if (.Platform$OS.type != "windows") skip("Only relevant on Windows")
path <- c("C:/a/file", "D:/a/file")
start <- "C:/Users/CRAN"
expect_error(workflowr:::relative(path, start),
"All paths must be on the same Windows drive")
})
test_that("relative can handle Windows drives on winbuilder", {
if (.Platform$OS.type != "windows") skip("Only relevant on Windows")
path <- c("D:/a/file1", "D:/a/file2")
start <- "c:/Users/CRAN"
expected <- path
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
test_that("relative handles NA and NULL with Windows drives", {
if (.Platform$OS.type != "windows") skip("Only relevant on Windows")
path <- c("C:/a/file1", NA, NULL, "C:/a/file2")
start <- "C:/Users/CRAN"
expected <- c("../../a/file1", NA, "../../a/file2")
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
path <- c("D:/a/file1", NA, NULL, "D:/a/file2")
start <- "C:/Users/CRAN"
expected <- path
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
path <- c("C:/a/file", NA, NULL, "D:/a/file")
start <- "C:/Users/CRAN"
expect_error(workflowr:::relative(path, start),
"All paths must be on the same Windows drive")
path <- c("D:/a/file1", NA, NULL, "D:/a/file2")
start <- "c:/Users/CRAN"
expected <- path
actual <- workflowr:::relative(path, start)
expect_identical(actual, expected)
})
# Test ability to resolve symlinks ---------------------------------------------
test_that("absolute can resolve symlinks", {
link <- workflowr:::absolute(tempfile())
target <- workflowr:::absolute(".")
on.exit(fs::link_delete(link))
fs::link_create(target, link)
expect_equal(workflowr:::absolute(link), target)
# Non-existent path
nonexist <- file.path(link, "x/y/z")
expect_equal(workflowr:::absolute(nonexist), file.path(target, "x/y/z"))
})
test_that("relative can resolve symlinks", {
link <- workflowr:::absolute(tempfile())
target <- workflowr:::absolute(".")
on.exit(fs::link_delete(link))
fs::link_create(target, link)
expect_equal(workflowr:::relative(link), ".")
# Non-existent path
nonexist <- file.path(link, "x/y/z")
expect_equal(workflowr:::relative(nonexist), "x/y/z")
})
# Explicitly test resolve_symlink on all platforms (currently only used on
# Windows)
test_that("resolve_symlink can resolve symlinks", {
link <- workflowr:::absolute(tempfile())
target <- workflowr:::absolute(".")
on.exit(fs::link_delete(link))
fs::link_create(target, link)
expect_equal(workflowr:::resolve_symlink(link), target)
# Non-existent path
nonexist <- file.path(link, "x/y/z")
expect_equal(workflowr:::resolve_symlink(nonexist), file.path(target, "x/y/z"))
})
# Test toupper_win_drive -------------------------------------------------------
test_that("toupper_win_drive capitalizes lowercase Windows drives", {
expect_equal(workflowr:::toupper_win_drive("a:/a/b/c"), "A:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("b:/a/b/c"), "B:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("c:/a/b/c"), "C:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("d:/a/b/c"), "D:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("x:/a/b/c"), "X:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("y:/a/b/c"), "Y:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("z:/a/b/c"), "Z:/a/b/c")
})
test_that("toupper_win_drive is vectorized", {
expect_equal(workflowr:::toupper_win_drive(c("c:/a/b/c", "d:/a/b/c")),
c("C:/a/b/c", "D:/a/b/c"))
})
test_that("toupper_win_drive ignores Unix-like paths", {
expect_equal(workflowr:::toupper_win_drive("/a/b/c"), "/a/b/c")
expect_equal(workflowr:::toupper_win_drive("/tmp"), "/tmp")
expect_equal(workflowr:::toupper_win_drive("/"), "/")
})
test_that("toupper_win_drive ignores relative paths", {
expect_equal(workflowr:::toupper_win_drive(".."), "..")
expect_equal(workflowr:::toupper_win_drive("./tmp"), "./tmp")
expect_equal(workflowr:::toupper_win_drive("../../a/b/c"), "../../a/b/c")
})
test_that("toupper_win_drive has no effect if drive is already capitalized", {
expect_equal(workflowr:::toupper_win_drive("A:/a/b/c"), "A:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("B:/a/b/c"), "B:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("C:/a/b/c"), "C:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("D:/a/b/c"), "D:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("X:/a/b/c"), "X:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("Y:/a/b/c"), "Y:/a/b/c")
expect_equal(workflowr:::toupper_win_drive("Z:/a/b/c"), "Z:/a/b/c")
})
test_that("toupper_win_drive ignores any potential drive that is not a single letter", {
expect_equal(workflowr:::toupper_win_drive("1:/"), "1:/")
expect_equal(workflowr:::toupper_win_drive("abc:/"), "abc:/")
expect_equal(workflowr:::toupper_win_drive("/a:/b/c"), "/a:/b/c")
})
# Test get_win_drive -----------------------------------------------------------
test_that("get_win_drive returns the Windows drive", {
expect_equal(get_win_drive("C:/a/b/c"), "C:")
expect_equal(get_win_drive("D:/a/b/c"), "D:")
expect_equal(get_win_drive(c("C:/a/b/c", "D:/a/b/c")), c("C:", "D:"))
})
# Test get_host_from_remote ----------------------------------------------------
tmp_dir <- tempfile("test-get_host_from_remote")
fs::dir_create(tmp_dir)
tmp_dir <- workflowr:::absolute(tmp_dir)
test_that("get_host_from_remote returns NA when no Git repo", {
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, NA_character_)
})
git2r::init(tmp_dir)
r <- git2r::repository(tmp_dir)
test_that("get_host_from_remote returns NA when no remotes", {
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, NA_character_)
})
wflow_git_remote(remote = "nonstandard", user = "testuser", repo = "testrepo",
verbose = FALSE, project = tmp_dir)
test_that("get_host_from_remote returns NA when no origin", {
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, NA_character_)
})
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
verbose = FALSE, project = tmp_dir)
test_that("get_host_from_remote works with HTTPS protocol", {
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://github.com/testuser2/testrepo")
})
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
protocol = "ssh", action = "set_url", verbose = FALSE,
project = tmp_dir)
test_that("get_host_from_remote works with SSH protocol", {
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://github.com/testuser2/testrepo")
})
wflow_git_remote(remote = "origin", action = "remove", verbose = FALSE,
project = tmp_dir)
test_that("get_host_from_remote works with GitLab.com HTTPS protocol", {
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
domain = "gitlab.com", project = tmp_dir)
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://gitlab.com/testuser2/testrepo")
wflow_git_remote(remote = "origin", action = "remove", project = tmp_dir)
})
test_that("get_host_from_remote works with GitLab.com SSH protocol", {
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
protocol = "ssh", domain = "gitlab.com", project = tmp_dir)
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://gitlab.com/testuser2/testrepo")
wflow_git_remote(remote = "origin", action = "remove", project = tmp_dir)
})
test_that("get_host_from_remote works with custom HTTPS protocol", {
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
domain = "git.rcc.uchicago.edu", project = tmp_dir)
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://git.rcc.uchicago.edu/testuser2/testrepo")
wflow_git_remote(remote = "origin", action = "remove", project = tmp_dir)
})
test_that("get_host_from_remote works with custom SSH protocol", {
wflow_git_remote(remote = "origin", user = "testuser2", repo = "testrepo",
protocol = "ssh", domain = "git.rcc.uchicago.edu", project = tmp_dir)
observed <- workflowr:::get_host_from_remote(tmp_dir)
expect_identical(observed, "https://git.rcc.uchicago.edu/testuser2/testrepo")
wflow_git_remote(remote = "origin", action = "remove", project = tmp_dir)
})
unlink(tmp_dir, recursive = TRUE)
rm(r, tmp_dir)
# Test status_to_df and df_to_status -------------------------------------------
test_that("status_to_df converts to data frame and df_to_status reverts", {
files_staged <- structure(list(modified = "staged-1.txt"),
.Names = "modified")
files_unstaged <- structure(list(modified = "unstaged-1.txt"),
.Names = "modified")
files_untracked <- structure(list(untracked = "untracked-1.txt",
untracked = "untracked-2.txt"),
.Names = c("untracked", "untracked"))
input <- structure(list(staged = files_staged,
unstaged = files_unstaged,
untracked = files_untracked),
.Names = c("staged", "unstaged", "untracked"),
class = "git_status")
expected <- data.frame(
status = c("staged", "unstaged", "untracked", "untracked"),
substatus = c("modified", "modified", "untracked", "untracked"),
file = c("staged-1.txt", "unstaged-1.txt", "untracked-1.txt", "untracked-2.txt"),
stringsAsFactors = FALSE)
observed <- workflowr:::status_to_df(input)
expect_identical(observed, expected)
# Revert to git_status
expect_identical(workflowr:::df_to_status(observed), input)
})
test_that("status_to_df and df_to_status can handle empty status", {
input <- structure(list(staged = structure(list(), .Names = character(0)),
unstaged = structure(list(), .Names = character(0)),
untracked = structure(list(), .Names = character(0))),
.Names = c("staged", "unstaged", "untracked"),
class = "git_status")
expected <- data.frame(status = character(), substatus = character(),
file = character(), stringsAsFactors = FALSE)
observed <- workflowr:::status_to_df(input)
expect_identical(observed, expected)
# Revert to git_status
expect_identical(workflowr:::df_to_status(observed), input)
})
# Test file_is_executable ------------------------------------------------------
test_that("file_executable returns FALSE for non-executable file", {
if (.Platform$OS.type == "windows")
skip("File permissions are different on Windows")
f <- fs::file_temp()
fs::file_create(f)
on.exit(fs::file_delete(f))
expect_false(workflowr:::file_is_executable(f))
})
test_that("file_executable returns TRUE for executable file", {
if (.Platform$OS.type == "windows")
skip("File permissions are different on Windows")
f <- fs::file_temp()
fs::file_create(f)
on.exit(fs::file_delete(f))
fs::file_chmod(f, "a+x")
expect_true(workflowr:::file_is_executable(f))
})
# Test wflow_dependson ---------------------------------------------------------
test_that("wflow_dependson returns labels of cached chunks", {
skip_on_cran()
tmp_dir <- tempfile()
fs::dir_create(tmp_dir)
tmp_dir <- workflowr:::absolute(tmp_dir)
on.exit(unlink(tmp_dir, recursive = TRUE))
# If no caching is used, dependson=NULL.
rmd <- file.path(tmp_dir, "file.Rmd")
fs::file_copy("files/test-wflow_html/dependson-cache-none.Rmd", rmd)
html <- render(rmd, quiet = TRUE)
expect_true(fs::file_exists(html))
rds <- file.path(tmp_dir, "labels.rds")
labels <- readRDS(rds)
expect_null(labels)
# If global cache=FALSE, but specific chunks have cache=TRUE, only depend on
# these chunks.
rmd <- file.path(tmp_dir, "file.Rmd")
fs::file_copy("files/test-wflow_html/dependson-cache-local.Rmd", rmd,
overwrite = TRUE)
html <- render(rmd, quiet = TRUE)
expect_true(fs::file_exists(html))
rds <- file.path(tmp_dir, "labels.rds")
labels <- readRDS(rds)
expect_identical(labels, c("plot-one", "plot-two"))
# If global cache=TRUE, depend on all chunks except those with cache=FALSE.
rmd <- file.path(tmp_dir, "file.Rmd")
fs::file_copy("files/test-wflow_html/dependson-cache-global.Rmd", rmd,
overwrite = TRUE)
html <- render(rmd, quiet = TRUE)
expect_true(fs::file_exists(html))
rds <- file.path(tmp_dir, "labels.rds")
labels <- readRDS(rds)
expect_identical(labels, c("setup", "plot-one", "plot-three",
"session-info-chunk-inserted-by-workflowr"))
})
# Test check_browser -----------------------------------------------------------
test_that("check_browser returns TRUE for valid browser options", {
withr::with_options(list(browser = "xdg-open"),
expect_true(workflowr:::check_browser()))
withr::with_options(list(browser = "firefox"),
expect_true(workflowr:::check_browser()))
# This function is the default option inside RStudio
withr::with_options(list(browser = function(url) .Call("rs_browseURL", url)),
expect_true(workflowr:::check_browser()))
})
test_that("check_browser returns FALSE for invalid browser options", {
withr::with_options(list(browser = NULL),
expect_false(workflowr:::check_browser()))
withr::with_options(list(browser = ""),
expect_false(workflowr:::check_browser()))
})
# Test get_first_line ----------------------------------------------------------
test_that("get_first_line returns the first line", {
messages <- c(
"Only has 1 line",
"Short title
line 2
line 3",
"This is a much longer title as you can observe by its length...
some more notes"
)
observed <- workflowr:::get_first_line(messages)
expect_identical(observed, c("Only has 1 line", "Short title",
"This is a much longer title as you can observe by its length..."))
})
# Test check_site_generator ----------------------------------------------------
test_that("check_site_generator checks for wflow_site", {
index <- fs::file_temp(ext = ".Rmd")
expect_error(
workflowr:::check_site_generator(index),
"Unable to find index.Rmd"
)
fs::file_create(index)
on.exit(fs::file_delete(index))
expect_false(workflowr:::check_site_generator(index))
writeLines(c("---", "site: workflowr::wflow_site", "---"), con = index)
expect_true(workflowr:::check_site_generator(index))
writeLines(c("---", "site: rmarkdown::default_site_generator", "---"), con = index)
expect_false(workflowr:::check_site_generator(index))
})
test_that("check_site_generator generates warning from wflow_build", {
skip_on_cran()
# Setup functions from setup.R
path <- test_setup()
on.exit(test_teardown(path))
index <- file.path(path, "analysis", "index.Rmd")
writeLines(c("---", "output: workflowr::wflow_html", "---"), con = index)
expect_warning(
wflow_build(index, view = FALSE, project = path),
"Missing workflowr-specific site generator."
)
})
# Test is_rmd ------------------------------------------------------------------
test_that("is_rmd distinguishes between Rmd and non-Rmd files", {
expect_identical(workflowr:::is_rmd("file.Rmd"), TRUE)
expect_identical(workflowr:::is_rmd("file.rmd"), TRUE)
expect_identical(workflowr:::is_rmd(c("file.Rmd", "file.rmd")), TRUE)
expect_identical(workflowr:::is_rmd("file.md"), FALSE)
expect_identical(workflowr:::is_rmd("file.RRmd"), FALSE)
expect_identical(workflowr:::is_rmd("file.Rrmd"), FALSE)
expect_identical(workflowr:::is_rmd("file.rrmd"), FALSE)
expect_identical(workflowr:::is_rmd("file.MRmd"), FALSE)
expect_identical(
workflowr:::is_rmd(c("path/to/file.md", "path/to/file.Rmd",
"path/to/file.Rrmd", "path/to/file.rmd")),
FALSE)
})
# Test check_wd_exists() -------------------------------------------------------
test_that("check_wd_exists throws error if working directory has been deleted", {
# The current working directory cannot be deleted on Solaris or Windows
skip_on_os(c("solaris", "windows"))
cwd <- fs::path_wd()
on.exit(setwd(cwd))
path <- fs::file_temp()
fs::dir_create(path)
setwd(path)
expect_silent(check_wd_exists())
fs::dir_delete(path)
expect_error(check_wd_exists(), "The current working directory doesn't exist.")
})
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.