Nothing
# Fixtures
fixtures <- list()
fixtures$retrieve_lint <- function() {
file_name <- "R/test.R"
lines <- c("foobar1", "foobar2", "foobar3")
lints <- list(
Lint(file_name, 1L, line = "foobar1"),
Lint(file_name, 2L, line = "foobar2"),
Lint(file_name, 3L, line = "foobar3")
)
expr <- list(content = paste(collapse = "\n", lines))
list(
lines = lines,
linters = list(),
lints = lints,
expr = expr
)
}
# Run tests with a temporary cache directory, so we don't leave files behind
# after running
withr::local_options(lintr.cache_directory = withr::local_tempdir())
# Helper functions
fhash <- function(filename) {
digest::digest(filename, algo = "sha1")
}
# Tests
# `clear_cache`
test_that("clear_cache deletes the file if a file is given", {
skip_if_not_installed("mockery")
mockery::stub(clear_cache, "read_settings", function(...) invisible(...))
mockery::stub(clear_cache, "unlink", function(...) list(...))
e1 <- new.env(parent = emptyenv())
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
lintr:::save_cache(cache = e1, file = f1, path = d1)
want <- list(file.path(d1, fhash("R/test.R")), recursive = TRUE)
expect_identical(clear_cache(f1, d1), want)
expect_identical(clear_cache(file = f1, path = d1), want)
})
test_that("clear_cache deletes the directory if no file is given", {
skip_if_not_installed("mockery")
mockery::stub(clear_cache, "read_settings", function(...) invisible(...))
mockery::stub(clear_cache, "unlink", function(...) list(...))
expect_identical(clear_cache(file = NULL, path = "."), list(".", recursive = TRUE))
})
# `load_cache`
test_that("load_cache loads the saved file in a new empty environment", {
e1 <- new.env(parent = emptyenv())
e1[["x"]] <- "foobar"
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
lintr:::save_cache(cache = e1, file = f1, path = d1)
e2 <- lintr:::load_cache(file = f1, path = d1)
expect_identical(e2, e1)
})
test_that("load_cache returns an empty environment if no cache file exists", {
e1 <- new.env(parent = emptyenv())
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
f2 <- "test.R"
lintr:::save_cache(cache = e1, file = f1, path = d1)
e2 <- lintr:::load_cache(file = f2, path = d1)
expect_identical(e2, e1)
})
test_that("load_cache returns an empty environment if reading cache file fails", {
e1 <- new.env(parent = emptyenv())
e1[["x"]] <- "foobar"
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
lintr:::save_cache(cache = e1, file = f1, path = d1)
cache_f1 <- file.path(d1, fhash(f1))
writeLines(character(), cache_f1)
expect_warning(
{
e2 <- lintr:::load_cache(file = f1, path = d1)
},
"Could not load cache file"
)
saveRDS(e1, cache_f1)
expect_warning(
{
e3 <- lintr:::load_cache(file = f1, path = d1)
},
"Could not load cache file"
)
expect_identical(ls(e2), character())
expect_identical(ls(e3), character())
})
# `save_cache`
test_that("save_cache creates a directory if needed", {
e1 <- new.env(parent = emptyenv())
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
expect_false(file.exists(d1))
expect_false(file.exists(file.path(d1, fhash(f1))))
lintr:::save_cache(cache = e1, file = f1, path = d1)
expect_true(file.exists(d1))
expect_true(file.info(d1)$isdir)
expect_true(file.exists(file.path(d1, fhash(f1))))
})
test_that("save_cache uses unambiguous cache file names", {
e1 <- new.env(parent = emptyenv())
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
f2 <- "test.R"
expect_false(file.exists(file.path(d1, fhash(f1))))
expect_false(file.exists(file.path(d1, fhash(f2))))
lintr:::save_cache(cache = e1, file = f1, path = d1)
lintr:::save_cache(cache = e1, file = f2, path = d1)
expect_true(fhash(f1) != fhash(f2))
expect_true(file.exists(file.path(d1, fhash(f1))))
expect_true(file.exists(file.path(d1, fhash(f2))))
})
test_that("save_cache saves all non-hidden objects from the environment", {
e1 <- new.env(parent = emptyenv())
e1$t1 <- 1L
e1$t2 <- 2L
d1 <- withr::local_tempfile(pattern = "lintr_cache_")
f1 <- "R/test.R"
lintr:::save_cache(cache = e1, file = f1, path = d1)
e2 <- new.env(parent = emptyenv())
load(file = file.path(d1, fhash(f1)), envir = e2)
expect_identical(e2, e1)
})
# `cache_file`
test_that("cache_file generates the same cache with different lints", {
e1 <- new.env(parent = emptyenv())
f1 <- withr::local_tempfile(lines = "foobar")
lintr:::cache_file(e1, f1, list(), list())
lintr:::cache_file(e1, f1, list(), list(1L))
expect_length(ls(e1), 1L)
})
test_that("cache_file generates different caches for different linters", {
e1 <- new.env(parent = emptyenv())
f1 <- withr::local_tempfile(lines = "foobar")
lintr:::cache_file(e1, f1, list(), list())
lintr:::cache_file(e1, f1, list(1L), list())
expect_length(ls(e1), 2L)
})
# `retrieve_file`
test_that("retrieve_file returns NULL if there is no cached result", {
e1 <- new.env(parent = emptyenv())
f1 <- withr::local_tempfile(lines = "foobar")
expect_null(lintr:::retrieve_file(e1, f1, list()))
})
test_that("retrieve_file returns the cached result if found", {
e1 <- new.env(parent = emptyenv())
f1 <- withr::local_tempfile(lines = "foobar")
lintr:::cache_file(e1, f1, list(), list("foobar"))
expect_identical(lintr:::retrieve_file(e1, f1, list()), list("foobar"))
})
# `cache_lint`
test_that("cache_lint generates the same cache with different lints", {
e1 <- new.env(parent = emptyenv())
t1 <- list(content = "test")
lintr:::cache_lint(e1, t1, list(), list())
lintr:::cache_lint(e1, t1, list(), list(1L))
expect_length(ls(e1), 1L)
})
test_that("cache_lint generates different caches for different linters", {
e1 <- new.env(parent = emptyenv())
t1 <- list(content = "test")
lintr:::cache_lint(e1, t1, list(), list())
lintr:::cache_lint(e1, t1, list(1L), list())
expect_length(ls(e1), 2L)
})
# `retrieve_lint`
test_that("retrieve_lint returns the same lints if nothing has changed", {
test_data <- fixtures$retrieve_lint()
e1 <- new.env(parent = emptyenv())
lintr:::cache_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lints = test_data[["lints"]]
)
t1 <- lintr:::retrieve_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lines = test_data[["lines"]]
)
expect_identical(t1, test_data[["lints"]])
})
test_that(
"retrieve_lint returns the same lints with fixed line numbers if lines added above",
{
test_data <- fixtures$retrieve_lint()
e1 <- new.env(parent = emptyenv())
lines1 <- test_data[["lines"]]
lines2 <- c("", lines1)
lints <- test_data[["lints"]]
lintr:::cache_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lints = lints
)
t1 <- lintr:::retrieve_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lines = lines2
)
expect_identical(t1[[1L]]$line_number, lints[[1L]]$line_number + 1L)
expect_identical(t1[[2L]]$line_number, lints[[2L]]$line_number + 1L)
expect_identical(t1[[3L]]$line_number, lints[[3L]]$line_number + 1L)
}
)
test_that("retrieve_lint returns the same lints with lines added below", {
test_data <- fixtures$retrieve_lint()
e1 <- new.env(parent = emptyenv())
lines1 <- test_data[["lines"]]
lines2 <- c(lines1, "")
lintr:::cache_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lints = test_data[["lints"]]
)
t1 <- lintr:::retrieve_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lines = lines2
)
expect_identical(t1, test_data[["lints"]])
})
test_that(
"retrieve_lint returns the same lints with fixed line numbers if lines added between",
{
test_data <- fixtures$retrieve_lint()
e1 <- new.env(parent = emptyenv())
lines1 <- test_data[["lines"]]
lines2 <- c(lines1[1L], "", lines1[2L:3L], "")
lints1 <- test_data[["lints"]]
lintr:::cache_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lints = lints1
)
t1 <- lintr:::retrieve_lint(
cache = e1,
expr = test_data[["expr"]],
linter = test_data[["linters"]],
lines = lines2
)
expect_identical(t1[[1L]]$line_number, lints1[[1L]]$line_number)
expect_identical(t1[[2L]]$line_number, lints1[[2L]]$line_number + 1L)
expect_identical(t1[[3L]]$line_number, lints1[[3L]]$line_number + 1L)
}
)
# `has_lint`
test_that("has_lint returns FALSE if there is no cached result", {
e1 <- new.env(parent = emptyenv())
t1 <- list(content = "foobar")
expect_false(lintr:::has_lint(e1, t1, list()))
})
test_that("has_lint returns TRUE if there is a cached result", {
e1 <- new.env(parent = emptyenv())
t1 <- list(content = "foobar")
lintr:::cache_lint(e1, t1, list(), list())
expect_true(lintr:::has_lint(e1, t1, list()))
})
test_that("has_lint distinguishes global expressions from line expression with same content", {
e1 <- new.env(parent = emptyenv())
same_content <- "foobar"
line_expr <- list(content = same_content, parsed_content = data.frame())
lintr:::cache_lint(e1, line_expr, list(), list())
global_expr <- list(content = same_content, file_lines = character())
expect_false(lintr:::has_lint(e1, global_expr, list()))
})
# `find_new_line`
test_that("find_new_line returns the same if the line is the same", {
t1 <- c(
"foobar1",
"foobar2",
"foobar3"
)
expect_identical(lintr:::find_new_line(1L, "foobar1", t1), 1L)
expect_identical(lintr:::find_new_line(2L, "foobar2", t1), 2L)
expect_identical(lintr:::find_new_line(3L, "foobar3", t1), 3L)
})
test_that("find_new_line returns the correct line if it is before the current line", {
t1 <- c(
"foobar1",
"foobar2",
"foobar3"
)
expect_identical(lintr:::find_new_line(1L, "foobar1", t1), 1L)
expect_identical(lintr:::find_new_line(2L, "foobar1", t1), 1L)
expect_identical(lintr:::find_new_line(3L, "foobar1", t1), 1L)
})
test_that("find_new_line returns the correct line if it is after the current line", {
t1 <- c(
"foobar1",
"foobar2",
"foobar3"
)
expect_identical(lintr:::find_new_line(1L, "foobar3", t1), 3L)
expect_identical(lintr:::find_new_line(2L, "foobar3", t1), 3L)
expect_identical(lintr:::find_new_line(3L, "foobar3", t1), 3L)
})
#
test_that("lint with cache uses the provided relative cache directory", {
path <- withr::local_tempdir("my_cache_dir")
linter <- assignment_linter()
# create the cache
expect_lint("a <- 1", NULL, linter, cache = path)
expect_true(dir.exists(path))
expect_length(list.files(file.path(path)), 1L)
# read the cache
expect_lint("a <- 1", NULL, linter, cache = path)
expect_true(dir.exists(path))
})
test_that("it works outside of a package", {
skip_if_not_installed("mockery")
linter <- assignment_linter()
mockery::stub(lintr:::find_default_encoding, "find_package", function(...) NULL)
path <- withr::local_tempfile(pattern = "my_cache_dir_")
expect_false(dir.exists(path))
expect_lint("a <- 1", NULL, linter, cache = path)
expect_true(dir.exists(path))
expect_length(list.files(path), 1L)
expect_lint("a <- 1", NULL, linter, cache = path)
expect_true(dir.exists(path))
})
test_that("cache = TRUE workflow works", {
# Need a test structure with a safe to load .lintr
pkg <- "dummy_packages/package"
files <- normalizePath(list.files(pkg, recursive = TRUE, full.names = TRUE))
# Manually clear cache (that function is exported)
for (f in files) {
clear_cache(file = f)
}
l1 <- lint_package(pkg, cache = TRUE)
l2 <- lint_package(pkg, cache = TRUE)
expect_identical(l1, l2)
})
test_that("cache = TRUE works with nolint", {
linters <- list(infix_spaces_linter())
file <- withr::local_tempfile()
writeLines("1+1\n", file)
expect_length(lint(file, linters, cache = TRUE), 1L)
writeLines("1+1 # nolint\n", file)
expect_length(lint(file, linters, cache = TRUE), 0L)
writeLines("1+1\n", file)
expect_length(lint(file, linters, cache = TRUE), 1L)
writeLines("1+1 # nolint\n", file)
expect_length(lint(file, linters, cache = TRUE), 0L)
})
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.