CA: check the parameters a cacheAs file was created with
Until now, a cacheAs file was used whenever it existed. Changing a
parameter and forgetting to delete the file therefore silently returned
an analysis computed with the old parameters. Inferring the parameters
from the cached data frame would not help much: of the 23 parameters
that affect the result, only node, vc, leftContextSize and
rightContextSize are recoverable from it, which leaves out exactly the
ones that are typically tuned between runs, such as minOccur,
topCollocatesLimit, searchHitsSampleLimit, exactFrequencies, stopwords
and threshold.
The parameters are therefore recorded when the file is written, and
compared on the next call. They are collected from the call frame rather
than listed explicitly, so that parameters added later are covered
without having to remember to register them. Also recorded is the API
URL, since reusing one cache file for two KorAP instances is a mistake
worth catching, and, for reference only, the index revision: corpus
updates should not invalidate an analysis that was deliberately kept.
If parameters differ, the analysis is recomputed and the file
overwritten, with a warning naming the differing parameters. That is
preferred over an error: it never returns results that disagree with the
requested parameters, and never breaks a long pipeline. Users who want
to keep an old analysis can pass a different cacheAs file name.
The parameters are stored in an attribute, so the file stays a plain
data frame for anyone reading it with readRDS(), and the attribute is
stripped when loading, so the returned value is the same whether it came
from the cache or not. Cache files written by 1.3.0 carry no attribute
and are used as they are.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Change-Id: Ib21aa93fa3c2bf1cd42dd07dbfcbd2970841a412
diff --git a/tests/testthat/test-collocation-cache-parameters.R b/tests/testthat/test-collocation-cache-parameters.R
new file mode 100644
index 0000000..06e8ca1
--- /dev/null
+++ b/tests/testthat/test-collocation-cache-parameters.R
@@ -0,0 +1,174 @@
+offlineConnection <- function() {
+ methods::new(
+ "KorAPConnection",
+ apiUrl = "https://example.invalid/",
+ KorAPUrl = "https://example.invalid/",
+ # keeps the unrelated "authorize your application" warning out of the way
+ authorizationSupported = FALSE,
+ verbose = FALSE
+ )
+}
+
+# Returning no candidates lets collocationAnalysis() finish without contacting
+# the server, so that the caching around it can be tested offline.
+mockEmptyAnalysis <- function() {
+ testthat::local_mocked_bindings(
+ collocatesQuery = function(...) tibble::tibble(),
+ .package = "RKorAPClient",
+ .env = parent.frame()
+ )
+}
+
+test_that("cache files record the parameters of the analysis", {
+ mockEmptyAnalysis()
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+
+ collocationAnalysis(offlineConnection(), "Test", minOccur = 3, cacheAs = cacheFile)
+
+ stored <- attr(readRDS(cacheFile), RKorAPClient:::collocationCacheAttribute)
+ expect_false(is.null(stored))
+ expect_equal(stored$parameters$node, "Test")
+ expect_equal(stored$parameters$minOccur, 3)
+ expect_equal(stored$apiUrl, "https://example.invalid/")
+ # every parameter of the analysis is recorded, not just those visible in the
+ # result, so that added parameters are covered automatically
+ expect_true(all(c(
+ "topCollocatesLimit", "searchHitsSampleLimit", "exactFrequencies",
+ "stopwords", "threshold", "collocateFilterRegex", "seed"
+ ) %in% names(stored$parameters)))
+ # kco and cacheAs are not parameters of the analysis
+ expect_false(any(c("kco", "cacheAs") %in% names(stored$parameters)))
+})
+
+test_that("the returned result is the same whether it was cached or not", {
+ mockEmptyAnalysis()
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+ kco <- offlineConnection()
+
+ fresh <- collocationAnalysis(kco, "Test", cacheAs = cacheFile)
+ fromCache <- collocationAnalysis(kco, "Test", cacheAs = cacheFile)
+
+ expect_equal(fromCache, fresh)
+ # the parameters live in the file only, not in the returned value
+ expect_null(attr(fromCache, RKorAPClient:::collocationCacheAttribute))
+})
+
+test_that("an unchanged call is served from the cache without contacting the server", {
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+ kco <- offlineConnection()
+
+ local({
+ mockEmptyAnalysis()
+ collocationAnalysis(kco, "Test", minOccur = 3, cacheAs = cacheFile)
+ })
+
+ testthat::local_mocked_bindings(
+ collocatesQuery = function(...) stop("server must not be contacted"),
+ .package = "RKorAPClient"
+ )
+ expect_no_warning(collocationAnalysis(kco, "Test", minOccur = 3, cacheAs = cacheFile))
+})
+
+test_that("changed parameters make the analysis be recomputed, with a warning", {
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+ kco <- offlineConnection()
+
+ local({
+ mockEmptyAnalysis()
+ collocationAnalysis(kco, "Test", minOccur = 3, cacheAs = cacheFile)
+ })
+
+ testthat::local_mocked_bindings(
+ collocatesQuery = function(...) stop("recomputed"),
+ .package = "RKorAPClient"
+ )
+
+ # the warning names the parameter that differs, and the analysis is rerun
+ expect_warning(
+ expect_error(
+ collocationAnalysis(kco, "Test", minOccur = 5, cacheAs = cacheFile),
+ "recomputed"
+ ),
+ "minOccur"
+ )
+
+ # a changed node is caught as well
+ expect_warning(
+ expect_error(
+ collocationAnalysis(kco, "Other", minOccur = 3, cacheAs = cacheFile),
+ "recomputed"
+ ),
+ "node"
+ )
+})
+
+test_that("a recomputed analysis overwrites the stale cache file", {
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+ kco <- offlineConnection()
+
+ local({
+ mockEmptyAnalysis()
+ collocationAnalysis(kco, "Test", minOccur = 3, cacheAs = cacheFile)
+ })
+
+ local({
+ mockEmptyAnalysis()
+ expect_warning(
+ collocationAnalysis(kco, "Test", minOccur = 5, cacheAs = cacheFile),
+ "minOccur"
+ )
+ })
+
+ stored <- attr(readRDS(cacheFile), RKorAPClient:::collocationCacheAttribute)
+ expect_equal(stored$parameters$minOccur, 5)
+})
+
+test_that("cache files written without parameters are still used", {
+ cacheFile <- tempfile(fileext = ".rds")
+ on.exit(unlink(cacheFile), add = TRUE)
+ kco <- offlineConnection()
+
+ # as written by RKorAPClient 1.3.0
+ legacy <- tibble::tibble(node = "Test", collocate = "c", logDice = 7)
+ saveRDS(legacy, cacheFile)
+
+ testthat::local_mocked_bindings(
+ collocatesQuery = function(...) stop("server must not be contacted"),
+ .package = "RKorAPClient"
+ )
+ expect_equal(collocationAnalysis(kco, "Test", cacheAs = cacheFile), legacy)
+})
+
+test_that("differingCollocationCacheParameters reports what changed", {
+ differing <- RKorAPClient:::differingCollocationCacheParameters
+
+ stored <- list(
+ parameters = list(node = "Test", minOccur = 3, vc = ""),
+ dots = list(),
+ apiUrl = "https://korap.ids-mannheim.de/api/v1.0/"
+ )
+
+ expect_equal(differing(stored, stored), character(0))
+
+ changed <- stored
+ changed$parameters$minOccur <- 5
+ expect_equal(differing(stored, changed), "minOccur")
+
+ changed <- stored
+ changed$parameters$minOccur <- 5
+ changed$parameters$vc <- "textType=/Zeit.*/"
+ expect_setequal(differing(stored, changed), c("minOccur", "vc"))
+
+ changed <- stored
+ changed$dots <- list(smoothingConstant = 1)
+ expect_equal(differing(stored, changed), "...")
+
+ changed <- stored
+ changed$apiUrl <- "https://korap.dnb.de/api/v1.0/"
+ expect_equal(differing(stored, changed), "KorAP instance")
+})