Nothing
test_that("Persistent package models survive reads and recover from corrupt cache files", {
# Starts subprocesses; too slow and timing-sensitive for CRAN machines.
skip_on_cran()
directory <- withr::local_tempdir()
withr::local_options(languageserver.package_cache_dir = directory)
package_metadata_cache_server()
prepared <- 0L
prepare_input <- member_namespace_input
testthat::local_mocked_bindings(member_namespace_input = function(...) {
prepared <<- prepared + 1L
prepare_input(...)
}, .package = "languageserver")
first <- member_prepare_package("collections")
expect_identical(prepared, 1L)
second <- member_prepare_package("collections")
expect_identical(prepared, 1L)
expect_identical(second, first)
path <- package_metadata_cache_path("members", first$identity)
expect_true(file.exists(path))
cross_session <- file.path(directory, "cross-session.rds")
callr::r(function(path, identity, value) {
languageserver:::package_metadata_cache_write(path, identity, value)
}, args = list(cross_session, first$identity, first), libpath = .libPaths(),
system_profile = FALSE, user_profile = FALSE)
restored <- callr::r(function(path, identity) {
languageserver:::package_metadata_cache_read(path, identity)
}, args = list(cross_session, first$identity), libpath = .libPaths(), system_profile = FALSE, user_profile = FALSE)
expect_identical(restored, first)
writeLines("corrupt cache", path)
expect_null(package_metadata_cache_read(path, first$identity))
third <- member_prepare_package("collections")
expect_identical(prepared, 2L)
expect_identical(package_metadata_cache_read(package_metadata_cache_path("members", third$identity), third$identity), third)
changed <- member_prepare_package("collections", context = "changed_namespace_context")
expect_identical(prepared, 3L)
expect_false(identical(changed$identity, first$identity))
expect_null(package_metadata_cache_read(path, changed$identity))
})
test_that("Persistent caching can be disabled without affecting package preparation", {
withr::local_options(languageserver.package_cache_dir = FALSE)
expect_null(package_metadata_cache_directory())
expect_null(package_metadata_cache_path("members", list(package = "fixture")))
expect_null(package_metadata_cache_read(NULL, list()))
expect_silent(package_metadata_cache_write(NULL, list(), list()))
})
test_that("Disabling disk caching also rejects previously computed paths", {
withr::local_options(languageserver.package_cache_dir = withr::local_tempdir())
identity <- list(package = "disablefixture")
path <- package_metadata_cache_path("fixture", identity)
package_metadata_cache_write(path, identity, list(value = 1))
unsafe <- identity
unsafe$context <- list(cacheable = FALSE)
expect_null(package_metadata_cache_read(path, unsafe))
package_metadata_cache_write(path, unsafe, list(value = 2))
expect_identical(unserialize(readRDS(path)$payload), list(value = 1))
withr::local_options(languageserver.package_cache_dir = FALSE)
expect_null(package_metadata_cache_read(path, identity))
package_metadata_cache_write(path, identity, list(value = 2))
expect_identical(unserialize(readRDS(path)$payload), list(value = 1))
})
test_that("Server fingerprints refresh after live implementation and nested constant changes", {
original <- package_metadata_cache_server()
ns <- asNamespace("languageserver")
update <- function(name, value) {
unlockBinding(name, ns)
assign(name, value, ns)
lockBinding(name, ns)
}
constants <- member_base_intrinsics
withr::defer(update("member_base_intrinsics", constants))
update("member_base_intrinsics", c(constants, "cache_review_fixture"))
expect_false(identical(package_metadata_cache_server(), original))
update("member_base_intrinsics", constants)
expect_identical(package_metadata_cache_server(), original)
expect_true(package_metadata_server_constant(list(nested = list(value = TRUE))))
expect_false(identical(package_metadata_server_syntax(list(nested = list(value = TRUE))),
package_metadata_server_syntax(list(nested = list(value = FALSE)))))
expect_false(package_metadata_server_constant(list(runtime = new.env())))
})
test_that("Server file compatibility describes the loaded implementation", {
root <- withr::local_tempdir()
dir.create(file.path(root, "R"))
native <- file.path(root, "server-native")
writeBin(charToRaw("first"), native)
previous <- as.list(package_metadata_server_load_state)
withr::defer({
package_metadata_server_load_state$files <- previous$files
package_metadata_server_load_state$namespace <- previous$namespace
})
load <- package_metadata_server_loaded
environment(load) <- list2env(list(getLoadedDLLs = function() list(languageserver = list(path = native)),
getNamespaceInfo = function(ns, which) root), parent = environment(load))
load()
loaded <- package_metadata_cache_server()
writeBin(charToRaw("other"), native)
expect_identical(package_metadata_cache_server(), loaded)
load()
expect_false(identical(package_metadata_cache_server(), loaded))
})
test_that("Oversized and malformed persistent entries are cache misses", {
withr::local_options(languageserver.package_cache_dir = withr::local_tempdir())
testthat::local_mocked_bindings(package_metadata_cache_max_bytes = 512, .package = "languageserver")
identity <- list(package = "boundedfixture")
path <- package_metadata_cache_path("fixture", identity)
package_metadata_cache_write(path, identity, raw(1000L))
expect_false(file.exists(path))
dir.create(dirname(path), recursive = TRUE)
writeBin(raw(1000L), path)
expect_null(package_metadata_cache_read(path, identity))
saveRDS("invalid record", path)
expect_null(package_metadata_cache_read(path, identity))
})
test_that("Cache types, format revisions and server versions remain isolated", {
withr::local_options(languageserver.package_cache_dir = withr::local_tempdir())
identity <- list(package = "fixture", revision = 1L)
paths <- vapply(c("members", "s3", "documentation"), package_metadata_cache_path, character(1L), identity = identity)
expect_length(unique(paths), 3L)
path <- paths[[1L]]
package_metadata_cache_write(path, identity, list(value = "valid"))
expect_identical(package_metadata_cache_read(path, identity), list(value = "valid"))
expect_null(package_metadata_cache_read(path, identity, is.character))
record <- readRDS(path)
record$payload <- serialize(list(value = "silently modified"), NULL)
saveRDS(record, path)
expect_null(package_metadata_cache_read(path, identity))
expect_null(package_metadata_cache_path("s3", list(package = "fixture", context = list(cacheable = FALSE))))
record$payload <- serialize(list(value = "valid"), NULL)
record$format <- 999L
saveRDS(record, path)
expect_null(package_metadata_cache_read(path, identity))
record$format <- package_metadata_cache_format
record$server$version <- "999.0.0"
saveRDS(record, path)
expect_null(package_metadata_cache_read(path, identity))
})
test_that("Content fingerprints are reused and detect replacements preserving size and mtime", {
root <- withr::local_tempdir()
path <- file.path(root, "fixture.rds")
writeBin(charToRaw("first"), path)
first <- package_metadata_file_fingerprint(path)
checksum <- package_metadata_file_checksum
computed <- 0L
testthat::local_mocked_bindings(package_metadata_file_checksum = function(files) {
computed <<- computed + 1L
checksum(files)
}, .package = "languageserver")
expect_identical(package_metadata_file_fingerprint(path), first)
expect_identical(computed, 0L)
stamp <- file.info(path)
writeBin(charToRaw("other"), path)
Sys.setFileTime(path, stamp$mtime)
expect_identical(file.info(path)$size, stamp$size)
expect_equal(file.info(path)$mtime, stamp$mtime)
expect_false(identical(package_metadata_file_fingerprint(path), first))
expect_identical(computed, 1L)
expect_silent(package_metadata_file_fingerprint(path))
expect_identical(computed, 1L)
})
test_that("Namespace validation reuses unchanged canonical facts and inspects mutable bindings", {
ns <- new.env(parent = baseenv())
ns$target <- function(x) x
environment(ns$target) <- ns
ns$registry <- new.env(parent = emptyenv())
ns$registry$value <- 1
captured <- new.env(parent = baseenv())
captured$kind <- "first"
ns$captured <- function(x) list(kind = kind)
environment(ns$captured) <- captured
getter <- function() {
writeLines("getter", marker)
stop("must not invoke getter")
}
marker <- withr::local_tempfile()
environment(getter) <- list2env(list(marker = marker), parent = baseenv())
makeActiveBinding("active", getter, ns)
delayedAssign("deferred", stop("must not force promise"), assign.env = ns)
calls <- 0L
normalize <- package_metadata_signature
testthat::local_mocked_bindings(package_metadata_signature = function(value) {
calls <<- calls + 1L
normalize(value)
}, .package = "languageserver")
resolve <- function() package_metadata_namespace_state(ns, "validationfixture")
first <- resolve()
initial <- calls
calls <- 0L
expect_identical(resolve(), first)
expect_identical(calls, 0L)
captured$kind <- "other"
expect_false(identical(resolve(), first))
expect_gt(calls, 0L)
expect_lt(calls, initial)
previous <- resolve()
ns$registry$value <- 2
expect_false(identical(resolve(), previous))
previous <- resolve()
ns$target <- function(revised) revised
environment(ns$target) <- ns
expect_false(identical(resolve(), previous))
replacement <- new.env(parent = baseenv())
replacement$target <- ns$target
expect_false(identical(package_metadata_namespace_state(replacement, "validationfixture"), resolve()))
expect_false(file.exists(marker))
})
test_that("Function syntax validation reuses closures and refreshes replacements and formatting", {
calls <- 0L
syntax <- member_function_syntax
testthat::local_mocked_bindings(member_function_syntax = function(fn) {
calls <<- calls + 1L
syntax(fn)
}, .package = "languageserver")
fn <- function(value = 1e5) value
withr::local_options(scipen = 0)
first <- package_metadata_function_signature(fn)
expect_identical(calls, 1L)
expect_identical(package_metadata_function_signature(fn), first)
expect_identical(calls, 1L)
key <- .Call("member_function_key_c", fn, PACKAGE = "languageserver")
replacement <- fn
body(replacement) <- quote(value + 1)
expect_false(identical(.Call("member_function_key_c", replacement, PACKAGE = "languageserver"), key))
expect_false(identical(package_metadata_function_signature(replacement), first))
expect_identical(calls, 2L)
withr::local_options(scipen = 999)
expect_false(identical(package_metadata_function_signature(fn), first))
expect_identical(calls, 3L)
expect_error(.Call("member_function_key_c", quote(value), PACKAGE = "languageserver"), "Expected a closure")
})
test_that("Loaded namespace changes cannot poison models for another library", {
# Starts subprocesses; too slow and timing-sensitive for CRAN machines.
skip_on_cran()
root <- withr::local_tempdir()
withr::local_options(languageserver.package_cache_dir = file.path(root, "cache"))
original <- .libPaths()
withr::defer(.libPaths(original))
package <- "lscachefixture"
withr::defer(if (package %in% loadedNamespaces()) unloadNamespace(package))
install <- function(field, lib) {
dir.create(lib)
source <- file.path(root, paste0("source-", field))
dir.create(source)
dir.create(file.path(source, "R"))
dir.create(file.path(source, "man"))
writeLines(c("Package: lscachefixture", "Version: 0.0.1", "Title: Cache Test Fixture",
"Description: Test package metadata cache invalidation.", "License: MIT",
"Author: Test", "Maintainer: Test <test@example.com>"), file.path(source, "DESCRIPTION"))
writeLines(c("export(api, target, adapt)", "S3method(adapt, default)"), file.path(source, "NAMESPACE"))
writeLines(c(paste0("api <- list(", field, " = TRUE)"), "target <- function(value = 1e5) value",
"adapt <- function(x) UseMethod('adapt')", "adapt.default <- function(x) list(done = TRUE)"),
file.path(source, "R", "api.R"))
writeLines(c("\\name{api}", "\\alias{api}", if (field == "new") "\\alias{late_topic}",
paste0("\\title{The ", field, " documentation}"),
paste0("\\description{The ", field, " description.}")), file.path(source, "man", "api.Rd"))
result <- callr::rcmd("INSTALL", cmdargs = c(paste0("--library=", lib), source),
stdout = "|", stderr = "|", system_profile = FALSE, user_profile = FALSE)
expect_identical(result$status, 0L)
}
first_lib <- file.path(root, "first")
second_lib <- file.path(root, "second")
install("old", first_lib)
install("new", second_lib)
.libPaths(c(first_lib, original))
first <- member_prepare_package(package)
expect_identical(names(first$roots$api$fields), "old")
namespace <- PackageNamespace$new(package)
expect_match(namespace$get_documentation("api")$title, "old documentation", fixed = TRUE)
expect_identical(namespace$get_documentation("late_topic"), list())
expect_false(is.null(package_metadata_help_identity(character(), package)))
first_help <- utils::help("api", (package), lib.loc = first_lib)
second_help <- utils::help("api", (package), lib.loc = second_lib)
expect_false(identical(package_metadata_help_identity(first_help), package_metadata_help_identity(second_help)))
expect_match(get_help(second_help, "text"), "new description", fixed = TRUE)
workspace <- Workspace$new(NULL)
expect_match(workspace$get_help("api", package), "old description", fixed = TRUE)
# Replace the installed help database without changing the version or
# loaded namespace. R's own lazy-load database cache must refresh too.
files <- list.files(file.path(second_lib, package, "help"), full.names = TRUE)
for (source in files) {
destination <- file.path(first_lib, package, "help", basename(source))
stamp <- file.info(destination)$mtime
expect_true(file.copy(source, destination, overwrite = TRUE))
# e.g. R builds with --enable-prebuilt-html.
if (is.na(stamp)) next
Sys.setFileTime(destination, stamp)
}
expect_true(file.copy(file.path(second_lib, package, "Meta/Rd.rds"),
file.path(first_lib, package, "Meta/Rd.rds"), overwrite = TRUE))
expect_match(namespace$get_documentation("api")$title, "new documentation", fixed = TRUE)
expect_match(namespace$get_documentation("late_topic")$title, "new documentation", fixed = TRUE)
expect_match(workspace$get_help("api", package), "new description", fixed = TRUE)
expect_match(get_help(first_help, "text"), "new description", fixed = TRUE)
# A same-version, same-size DESCRIPTION replacement changes the general
# package identity even when its modification time is preserved.
before <- package_metadata_identity(package)
description <- file.path(first_lib, package, "DESCRIPTION")
stamp <- file.info(description)
text <- readLines(description)
writeLines(sub("Cache Test Fixture", "Cache Best Fixture", text, fixed = TRUE), description)
Sys.setFileTime(description, stamp$mtime)
expect_identical(file.info(description)$size, stamp$size)
expect_false(identical(package_metadata_identity(package), before))
second <- member_prepare_package(package, c(second_lib, original))
expect_identical(names(second$roots$api$fields), "old")
unloadNamespace(package)
third <- member_prepare_package(package, c(second_lib, original))
expect_identical(names(third$roots$api$fields), "new")
expect_false(identical(second$identity$namespace, third$identity$namespace))
ns <- asNamespace(package)
withr::local_options(scipen = 0)
signature <- namespace$get_signature("target")
withr::local_options(scipen = 999)
expect_false(identical(namespace$get_signature("target"), signature))
expect_identical(names(formals(namespace$get_diagnostic_stub("target"))), "value")
replacement <- function(revised = TRUE) revised
environment(replacement) <- ns
unlockBinding("target", ns)
assign("target", replacement, ns)
lockBinding("target", ns)
expect_identical(names(namespace$get_formals("target")), "revised")
expect_identical(names(formals(namespace$get_diagnostic_stub("target"))), "revised")
unlockBinding("api", ns)
assign("api", list(runtime = TRUE), ns)
lockBinding("api", ns)
changed <- member_prepare_package(package, c(second_lib, original))
expect_identical(names(changed$roots$api$fields), "runtime")
expect_false(identical(changed$identity$namespace, third$identity$namespace))
registered <- ns$adapt.default
bindings <- s3_metadata_context(package)
expect_false(is.null(bindings))
foreign <- registered
environment(foreign) <- new.env(parent = ns)
expect_identical(member_function_syntax(registered), member_function_syntax(foreign))
registerS3method("adapt", "default", foreign, envir = ns)
expect_false(identical(s3_metadata_context(package), bindings))
changed <- member_prepare_package(package, c(second_lib, original))
expect_identical(changed$generic_external, "adapt")
other <- registered
environment(other) <- new.env(parent = ns)
registerS3method("adapt", "default", other, envir = ns)
expect_identical(member_prepare_package(package, c(second_lib, original))$generic_external, "adapt")
})
test_that("S3 catalogs reuse cached metadata and detect registry changes", {
withr::local_options(languageserver.package_cache_dir = withr::local_tempdir())
prepared <- character()
prepare <- s3_prepare_namespace
testthat::local_mocked_bindings(s3_prepare_namespace = function(package, identity = NULL) {
prepared <<- c(prepared, package)
prepare(package, identity = identity)
}, .package = "languageserver")
first <- s3_prepare_packages("datasets")
# s3_prepare_packages() turns any error raised while preparing a namespace
# into an `error` record, so check that nothing was swallowed.
expect_true("datasets" %in% names(first))
for (record in first) expect_null(record$error)
initial_preparations <- length(prepared)
prepared <- character()
second <- s3_prepare_packages("datasets")
expect_true(initial_preparations > 0L)
expect_length(prepared, 0L)
expect_identical(second, first)
table <- get(".__S3MethodsTable__.", asNamespace("base"))
method <- "print.persistent_cache_fixture"
withr::defer(rm(list = method, envir = table))
assign(method, function(x, ...) NULL, table)
changed <- s3_prepare_packages("datasets")
for (record in changed) expect_null(record$error)
expect_true(length(prepared) > 0L)
expect_false(identical(changed$base$generation, first$base$generation))
expect_true(paste0("base::", method) %in% names(changed$base$methods))
})
test_that("Documentation and rendered help reuse the shared package cache", {
withr::local_options(languageserver.package_cache_dir = withr::local_tempdir())
parsed <- 0L
parse_help <- get_help_rd
testthat::local_mocked_bindings(get_help_rd = function(...) {
parsed <<- parsed + 1L
parse_help(...)
}, .package = "languageserver")
first <- PackageNamespace$new("base")$get_documentation("sum")
expect_identical(parsed, 1L)
second <- PackageNamespace$new("base")$get_documentation("sum")
expect_identical(second, first)
expect_identical(parsed, 1L)
help <- utils::help("sum", "base")
text <- get_help(help, "text")
expect_identical(parsed, 2L)
expect_identical(get_help(help, "text"), text)
expect_identical(parsed, 2L)
})
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.