Running ‘testthat.R’ [15s/37s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(dockerfiler)
  > 
  > test_check("dockerfiler")
  i Please wait while we compute system requirements...
  renv version = 0.16.0
  i Please wait while we compute system requirements...
  Fetching system dependencies for 1 package(s) records.
  i No sysreqs required
  v Done
  [ FAIL 7 | WARN 3 | SKIP 2 | PASS 46 ]
  
  ══ Skipped tests (2) ═══════════════════════════════════════════════════════════
  • On CRAN (2): 'test-dockerbuild.R:24:7', 'test-get_sysreqs.R:2:3'
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error ('test-dock_from_desc.R:43:7'): dock_from_desc works ──────────────────
  Error in `readRDS(mapfile)`: Cannot load processx from the private library: error reading from connection
  Backtrace:
       ▆
    1. └─dockerfiler::dock_from_desc(file.path(".", "DESCRIPTION__")) at test-dock_from_desc.R:43:7
    2.   ├─base::unique(get_sysreqs(packages = packages))
    3.   └─dockerfiler::get_sysreqs(packages = packages)
    4.     └─pak::pkg_sysreqs(pkg = all_deps, sysreqs_platform = "debian")
    5.       └─pak:::remote(...)
    6.         └─pak:::restart_remote_if_needed()
    7.           └─pak:::new_remote_session()
    8.             └─pak:::load_private_packages()
    9.               └─pak:::load_private_package("processx", "c_")
   10.                 └─base::tryCatch(...)
   11.                   └─base (local) tryCatchList(expr, classes, parentenv, handlers)
   12.                     └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
   13.                       └─value[[3L]](cond)
  ── Error ('test-dock_from_renv.R:45:5'): dock_from_renv works ──────────────────
  Error in `(function (err) 
  {
      stop("Failed to parse 'renv.lock':\n", conditionMessage(err))
  })(structure(list(message = "parse error: premature EOF\n                                       {   \"R\": {     \"Version\": \"4.1.\n                     (right here) ------^\n", 
      call = NULL, traceback = c("Traceback (most recent calls last):", 
      "52: test_check(\"dockerfiler\")", "51: test_dir(\"testthat\", package = package, reporter = reporter, ", 
      "        ..., load_package = \"installed\")", "50: test_files(test_dir = path, test_paths = test_paths, test_package = package, ", 
      "        reporter = reporter, load_helpers = load_helpers, env = env, ", 
      "        stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        load_package = load_package, parallel = parallel)", 
      "49: test_files_serial(test_dir = test_dir, test_package = test_package, ", 
      "        test_paths = test_paths, load_helpers = load_helpers, reporter = reporter, ", 
      "        env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        desc = desc, load_package = load_package, error_call = error_call)", 
      "48: with_reporter(reporters$multi, lapply(test_paths, test_one_file, ", 
      "        env = env, desc = desc, error_call = error_call))", 
      "47: tryCatch(code, testthat_abort_reporter = function(cnd) {", 
      "        cat(conditionMessage(cnd), \"\\n\")", "        NULL", 
      "    })", "46: tryCatchList(expr, classes, parentenv, handlers)", 
      "45: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "44: doTryCatch(return(expr), name, parentenv, handler)", 
      "43: lapply(test_paths, test_one_file, env = env, desc = desc, error_call = error_call)", 
      "42: FUN(X[[i]], ...)", "41: source_file(path, env = env(env), desc = desc, error_call = error_call)", 
      "40: test_code(test = NULL, code = exprs, env = env, reporter = get_reporter() %||% ", 
      "        StopReporter$new())", "39: tryCatch(withCallingHandlers({", 
      "        eval(code, test_env)", "        if (!handled && !is.null(test)) {", 
      "            skip_empty()", "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "38: tryCatchList(expr, classes, parentenv, handlers)", 
      "37: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "36: doTryCatch(return(expr), name, parentenv, handler)", 
      "35: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "34: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "33: doTryCatch(return(expr), name, parentenv, handler)", 
      "32: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "31: eval(code, test_env)", "30: eval(code, test_env)", "29: test_that(\"dock_from_renv works\", ...) at test-dock_from_renv.R#37", 
      "28: test_code(desc, code, env = parent.frame(), reporter = reporter)", 
      "27: tryCatch(withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "26: tryCatchList(expr, classes, parentenv, handlers)", 
      "25: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "24: doTryCatch(return(expr), name, parentenv, handler)", 
      "23: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "22: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "21: doTryCatch(return(expr), name, parentenv, handler)", 
      "20: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "19: eval(code, test_env)", "18: eval(code, test_env)", "17: testthat::with_mocked_bindings(code = {", 
      "      out <- dock_from_renv(", "        lockfile = the_lockfile,", 
      "        FROM = \"rocker/verse\",", "        renv_version = \"0.0.0\"", 
      "      )", "    },", "    compact_sysreqs = function(...) \"fake sys reqs\",", 
      "    repos_as_character = function(...) \"fake repos\"", 
      "    ) at test-dock_from_renv.R#44", "16: out <- dock_from_renv(", 
      "      lockfile = the_lockfile,", "      FROM = \"rocker/verse\",", 
      "      renv_version = \"0.0.0\"", "    ) at test-dock_from_renv.R#45", 
      "15: dockerfiler::renv$lockfile_read(file = lockfile)", "14: renv_lockfile_read(file = file)", 
      "13: withCallingHandlers(json <- renv_json_read(text = contents), ", 
      "        error = function(err) {", "            stop(\"Failed to parse 'renv.lock':\\n\", conditionMessage(err))", 
      "        })", "12: renv_json_read(text = contents)", "11: catch(renv_json_read_jsonlite(file, text))", 
      "10: tryCatch(withCallingHandlers(expr, error = renv_error_capture), ", 
      "        error = renv_error_tag)", " 9: tryCatchList(expr, classes, parentenv, handlers)", 
      " 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      " 7: doTryCatch(return(expr), name, parentenv, handler)", 
      " 6: withCallingHandlers(expr, error = renv_error_capture)", 
      " 5: renv_json_read_jsonlite(file, text)", " 4: jsonlite::fromJSON(txt = text, simplifyVector = FALSE)", 
      " 3: parse_and_simplify(txt = txt, simplifyVector = simplifyVector, ", 
      "        simplifyDataFrame = simplifyDataFrame, simplifyMatrix = simplifyMatrix, ", 
      "        flatten = flatten, ...)", " 2: parseJSON(txt, bigint_as_char)", 
      " 1: parse_string(txt, bigint_as_char)")), class = c("simpleError", 
  "error", "condition")))`: Failed to parse 'renv.lock':
  parse error: premature EOF
                                         {   "R": {     "Version": "4.1.
                       (right here) ------^
  
  Backtrace:
      ▆
   1. ├─testthat::with_mocked_bindings(...) at test-dock_from_renv.R:44:3
   2. ├─dockerfiler::dock_from_renv(...) at test-dock_from_renv.R:45:5
   3. │ └─dockerfiler::renv$lockfile_read(file = lockfile)
   4. │   └─dockerfiler (local) renv_lockfile_read(file = file)
   5. │     ├─base::withCallingHandlers(...)
   6. │     └─dockerfiler (local) renv_json_read(text = contents)
   7. │       └─base::stop(jlerr)
   8. └─dockerfiler (local) `<fn>`(`<smplErrr>`)
  ── Error ('test-dock_from_renv.R:97:3'): dock_from_renv works with full dependencies ──
  Error in `(function (err) 
  {
      stop("Failed to parse 'renv.lock':\n", conditionMessage(err))
  })(structure(list(message = "parse error: premature EOF\n                                       {   \"R\": {     \"Version\": \"4.1.\n                     (right here) ------^\n", 
      call = NULL, traceback = c("Traceback (most recent calls last):", 
      "51: test_check(\"dockerfiler\")", "50: test_dir(\"testthat\", package = package, reporter = reporter, ", 
      "        ..., load_package = \"installed\")", "49: test_files(test_dir = path, test_paths = test_paths, test_package = package, ", 
      "        reporter = reporter, load_helpers = load_helpers, env = env, ", 
      "        stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        load_package = load_package, parallel = parallel)", 
      "48: test_files_serial(test_dir = test_dir, test_package = test_package, ", 
      "        test_paths = test_paths, load_helpers = load_helpers, reporter = reporter, ", 
      "        env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        desc = desc, load_package = load_package, error_call = error_call)", 
      "47: with_reporter(reporters$multi, lapply(test_paths, test_one_file, ", 
      "        env = env, desc = desc, error_call = error_call))", 
      "46: tryCatch(code, testthat_abort_reporter = function(cnd) {", 
      "        cat(conditionMessage(cnd), \"\\n\")", "        NULL", 
      "    })", "45: tryCatchList(expr, classes, parentenv, handlers)", 
      "44: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "43: doTryCatch(return(expr), name, parentenv, handler)", 
      "42: lapply(test_paths, test_one_file, env = env, desc = desc, error_call = error_call)", 
      "41: FUN(X[[i]], ...)", "40: source_file(path, env = env(env), desc = desc, error_call = error_call)", 
      "39: test_code(test = NULL, code = exprs, env = env, reporter = get_reporter() %||% ", 
      "        StopReporter$new())", "38: tryCatch(withCallingHandlers({", 
      "        eval(code, test_env)", "        if (!handled && !is.null(test)) {", 
      "            skip_empty()", "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "37: tryCatchList(expr, classes, parentenv, handlers)", 
      "36: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "35: doTryCatch(return(expr), name, parentenv, handler)", 
      "34: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "33: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "32: doTryCatch(return(expr), name, parentenv, handler)", 
      "31: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "30: eval(code, test_env)", "29: eval(code, test_env)", "28: test_that(\"dock_from_renv works with full dependencies\", {", 
      "      # testthat::skip_on_cran()", "      # skip_if_not(interactive())", 
      "      # Create Dockerfile", "    skip_if(is_rdevel, \"skip on R-devel\")", 
      "      out <- dock_from_renv(", "        dependencies = TRUE,", 
      "        lockfile = the_lockfile,", "        FROM = \"rocker/verse\",", 
      "      )", "      expect_s3_class(", "        out,", "        \"Dockerfile\"", 
      "      )", "      expect_s3_class(", "        out,", "        \"R6\"", 
      "      )", "      skip_if(is_rdevel, \"Skip R-devel\")", 
      "      #python3 is  a un-direct dependencies from custom_packages", 
      "      expect_true(  any(grepl(\"python3\",out$Dockerfile)))", 
      "    }) at test-dock_from_renv.R#92", "27: test_code(desc, code, env = parent.frame(), reporter = reporter)", 
      "26: tryCatch(withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "25: tryCatchList(expr, classes, parentenv, handlers)", 
      "24: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "23: doTryCatch(return(expr), name, parentenv, handler)", 
      "22: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "21: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "20: doTryCatch(return(expr), name, parentenv, handler)", 
      "19: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "18: eval(code, test_env)", "17: eval(code, test_env)", "16: out <- dock_from_renv(", 
      "      dependencies = TRUE,", "      lockfile = the_lockfile,", 
      "      FROM = \"rocker/verse\",", "    ) at test-dock_from_renv.R#97", 
      "15: dockerfiler::renv$lockfile_read(file = lockfile)", "14: renv_lockfile_read(file = file)", 
      "13: withCallingHandlers(json <- renv_json_read(text = contents), ", 
      "        error = function(err) {", "            stop(\"Failed to parse 'renv.lock':\\n\", conditionMessage(err))", 
      "        })", "12: renv_json_read(text = contents)", "11: catch(renv_json_read_jsonlite(file, text))", 
      "10: tryCatch(withCallingHandlers(expr, error = renv_error_capture), ", 
      "        error = renv_error_tag)", " 9: tryCatchList(expr, classes, parentenv, handlers)", 
      " 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      " 7: doTryCatch(return(expr), name, parentenv, handler)", 
      " 6: withCallingHandlers(expr, error = renv_error_capture)", 
      " 5: renv_json_read_jsonlite(file, text)", " 4: jsonlite::fromJSON(txt = text, simplifyVector = FALSE)", 
      " 3: parse_and_simplify(txt = txt, simplifyVector = simplifyVector, ", 
      "        simplifyDataFrame = simplifyDataFrame, simplifyMatrix = simplifyMatrix, ", 
      "        flatten = flatten, ...)", " 2: parseJSON(txt, bigint_as_char)", 
      " 1: parse_string(txt, bigint_as_char)")), class = c("simpleError", 
  "error", "condition")))`: Failed to parse 'renv.lock':
  parse error: premature EOF
                                         {   "R": {     "Version": "4.1.
                       (right here) ------^
  
  Backtrace:
      ▆
   1. ├─dockerfiler::dock_from_renv(...) at test-dock_from_renv.R:97:3
   2. │ └─dockerfiler::renv$lockfile_read(file = lockfile)
   3. │   └─dockerfiler (local) renv_lockfile_read(file = file)
   4. │     ├─base::withCallingHandlers(...)
   5. │     └─dockerfiler (local) renv_json_read(text = contents)
   6. │       └─base::stop(jlerr)
   7. └─dockerfiler (local) `<fn>`(`<smplErrr>`)
  ── Error ('test-dock_from_renv.R:165:5'): dock_from_renv works with specific renv ──
  Error in `(function (err) 
  {
      stop("Failed to parse 'renv.lock':\n", conditionMessage(err))
  })(structure(list(message = "parse error: premature EOF\n                                       {   \"R\": {     \"Version\": \"4.1.\n                     (right here) ------^\n", 
      call = NULL, traceback = c("Traceback (most recent calls last):", 
      "51: test_check(\"dockerfiler\")", "50: test_dir(\"testthat\", package = package, reporter = reporter, ", 
      "        ..., load_package = \"installed\")", "49: test_files(test_dir = path, test_paths = test_paths, test_package = package, ", 
      "        reporter = reporter, load_helpers = load_helpers, env = env, ", 
      "        stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        load_package = load_package, parallel = parallel)", 
      "48: test_files_serial(test_dir = test_dir, test_package = test_package, ", 
      "        test_paths = test_paths, load_helpers = load_helpers, reporter = reporter, ", 
      "        env = env, stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, ", 
      "        desc = desc, load_package = load_package, error_call = error_call)", 
      "47: with_reporter(reporters$multi, lapply(test_paths, test_one_file, ", 
      "        env = env, desc = desc, error_call = error_call))", 
      "46: tryCatch(code, testthat_abort_reporter = function(cnd) {", 
      "        cat(conditionMessage(cnd), \"\\n\")", "        NULL", 
      "    })", "45: tryCatchList(expr, classes, parentenv, handlers)", 
      "44: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "43: doTryCatch(return(expr), name, parentenv, handler)", 
      "42: lapply(test_paths, test_one_file, env = env, desc = desc, error_call = error_call)", 
      "41: FUN(X[[i]], ...)", "40: source_file(path, env = env(env), desc = desc, error_call = error_call)", 
      "39: test_code(test = NULL, code = exprs, env = env, reporter = get_reporter() %||% ", 
      "        StopReporter$new())", "38: tryCatch(withCallingHandlers({", 
      "        eval(code, test_env)", "        if (!handled && !is.null(test)) {", 
      "            skip_empty()", "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "37: tryCatchList(expr, classes, parentenv, handlers)", 
      "36: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "35: doTryCatch(return(expr), name, parentenv, handler)", 
      "34: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "33: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "32: doTryCatch(return(expr), name, parentenv, handler)", 
      "31: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "30: eval(code, test_env)", "29: eval(code, test_env)", "28: test_that(\"dock_from_renv works with specific renv\", {", 
      "    ", "      skip_if(is_rdevel, \"skip on R-devel\")", 
      "      # testthat::skip_on_cran()", "    the_lockfile1.0.0 <- system.file(\"renv_with_1.0.0.lock\",package = \"dockerfiler\")", 
      "    ", "    for (lf in list(the_lockfile,the_lockfile1.0.0)){", 
      "    for (renv_version in list(NULL,\"banana\",\"missing\")){", 
      "    ", "    ", "      if (!is.null(renv_version) && renv_version == \"missing\") {", 
      "        out <- dock_from_renv(lockfile = lf,", "                              FROM = \"rocker/verse\")", 
      "      } else{", "        out <- dock_from_renv(", "          lockfile = lf,", 
      "          FROM = \"rocker/verse\",", "          renv_version = renv_version", 
      "        )", "    ", "      }", "    socle_install_version <- \"remotes::install_version\\\\(\\\"renv\\\", version = \\\"\"", 
      "      if (lf == the_lockfile &    is.null(renv_version)) {", 
      "        test_string <- 'install.packages\\\\(c\\\\(\\\"renv\\\",\\\"remotes\\\"))'", 
      "      } else if (lf == the_lockfile1.0.0 & is.null(renv_version)) {", 
      "        test_string <- 'install.packages\\\\(c\\\\(\\\"renv\\\",\\\"remotes\\\"))'", 
      "      } else if (lf == the_lockfile &  renv_version == \"banana\") {", 
      "        test_string <-  paste0(socle_install_version,\"banana\"  ,\"\\\"\\\\)\")", 
      "      } else if (lf == the_lockfile1.0.0 & renv_version == \"banana\") {", 
      "        test_string <- paste0(socle_install_version,\"banana\",\"\\\"\\\\)\")", 
      "      } else if (lf == the_lockfile & renv_version == \"missing\") {", 
      "        test_string <-", "          paste0(", "            socle_install_version,dockerfiler::renv$the$metadata$version,\"\\\"\\\\)\"", 
      "          )", "      } else if (lf == the_lockfile1.0.0 & renv_version == \"missing\") {", 
      "        test_string <-paste0(socle_install_version,\"1.0.0\",\"\\\"\\\\)\")", 
      "      }", "    ", "      expect_true( any(   grepl(test_string , out$Dockerfile)    ),", 
      "                   info = paste(lf,\" & \",renv_version))", 
      "    ", "    ", "    }}", "    ", "    ", "    ", "    ", 
      "    }) at test-dock_from_renv.R#151", "27: test_code(desc, code, env = parent.frame(), reporter = reporter)", 
      "26: tryCatch(withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error), error = handle_fatal, ", 
      "        skip = function(e) {", "        })", "25: tryCatchList(expr, classes, parentenv, handlers)", 
      "24: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), ", 
      "        names[nh], parentenv, handlers[[nh]])", "23: doTryCatch(return(expr), name, parentenv, handler)", 
      "22: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])", 
      "21: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      "20: doTryCatch(return(expr), name, parentenv, handler)", 
      "19: withCallingHandlers({", "        eval(code, test_env)", 
      "        if (!handled && !is.null(test)) {", "            skip_empty()", 
      "        }", "    }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, ", 
      "        message = handle_message, error = handle_error)", 
      "18: eval(code, test_env)", "17: eval(code, test_env)", "16: out <- dock_from_renv(", 
      "      lockfile = lf,", "      FROM = \"rocker/verse\",", 
      "      renv_version = renv_version", "    ) at test-dock_from_renv.R#165", 
      "15: dockerfiler::renv$lockfile_read(file = lockfile)", "14: renv_lockfile_read(file = file)", 
      "13: withCallingHandlers(json <- renv_json_read(text = contents), ", 
      "        error = function(err) {", "            stop(\"Failed to parse 'renv.lock':\\n\", conditionMessage(err))", 
      "        })", "12: renv_json_read(text = contents)", "11: catch(renv_json_read_jsonlite(file, text))", 
      "10: tryCatch(withCallingHandlers(expr, error = renv_error_capture), ", 
      "        error = renv_error_tag)", " 9: tryCatchList(expr, classes, parentenv, handlers)", 
      " 8: tryCatchOne(expr, names, parentenv, handlers[[1L]])", 
      " 7: doTryCatch(return(expr), name, parentenv, handler)", 
      " 6: withCallingHandlers(expr, error = renv_error_capture)", 
      " 5: renv_json_read_jsonlite(file, text)", " 4: jsonlite::fromJSON(txt = text, simplifyVector = FALSE)", 
      " 3: parse_and_simplify(txt = txt, simplifyVector = simplifyVector, ", 
      "        simplifyDataFrame = simplifyDataFrame, simplifyMatrix = simplifyMatrix, ", 
      "        flatten = flatten, ...)", " 2: parseJSON(txt, bigint_as_char)", 
      " 1: parse_string(txt, bigint_as_char)")), class = c("simpleError", 
  "error", "condition")))`: Failed to parse 'renv.lock':
  parse error: premature EOF
                                         {   "R": {     "Version": "4.1.
                       (right here) ------^
  
  Backtrace:
      ▆
   1. ├─dockerfiler::dock_from_renv(...) at test-dock_from_renv.R:165:5
   2. │ └─dockerfiler::renv$lockfile_read(file = lockfile)
   3. │   └─dockerfiler (local) renv_lockfile_read(file = file)
   4. │     ├─base::withCallingHandlers(...)
   5. │     └─dockerfiler (local) renv_json_read(text = contents)
   6. │       └─base::stop(jlerr)
   7. └─dockerfiler (local) `<fn>`(`<smplErrr>`)
  ── Failure ('test-utils.R:5:3'): utils works ───────────────────────────────────
  grepl("test", res) is not TRUE
  
  `actual`:   FALSE
  `expected`: TRUE 
  ── Failure ('test-utils.R:14:3'): utils works ──────────────────────────────────
  grepl("test", res) is not TRUE
  
  `actual`:   FALSE
  `expected`: TRUE 
  ── Failure ('test-utils.R:23:3'): utils works ──────────────────────────────────
  grepl("test", res) is not TRUE
  
  `actual`:   FALSE
  `expected`: TRUE 
  
  [ FAIL 7 | WARN 3 | SKIP 2 | PASS 46 ]
  Error: Test failures
  In addition: Warning message:
  In dir.create(R_USER_CACHE_DIR) :
    cannot create dir '/var/folders/2b/t0kwbtmn3p7brv2mvx39c9cr0000gn/T//RtmpYyyHRK/filecef95c9c030b', reason 'No space left on device'
  Execution halted
  Warning message:
  In close.connection(con) :
    Problem closing connection:  No space left on device