如何测试调用Sys.time()的R包函数？有哪些替代测试方法？

Great question! Testing functions that emit system time for progress updates can feel tricky at first, but there are reliable ways to handle this with testthat and other tools. Let’s walk through your options:

1. Mocking Sys.time() with testthat + mockery #

The most straightforward approach for existing functions is to mock the Sys.time() call so it returns a fixed, predictable value instead of the real system time. Here’s how to do it with the mockery package (which plays nicely with testthat):

First, let’s assume your function looks something like this:

progress_function <- function() {
  cat("Progress update at:", Sys.time(), "\n")
  # Your algorithm logic here
  return(TRUE)
}

Then your test case would look like this:

library(testthat)
library(mockery)

test_that("progress_function outputs the expected fixed time", {
  # Define a static time we want to test with
  fixed_time <- as.POSIXct("2024-05-20 09:30:00")
  
  # Create a mock version of Sys.time() that returns our fixed time
  mock_sys_time <- mock(fixed_time)
  
  # Run the function with our mocked Sys.time()
  with_mock(Sys.time = mock_sys_time, {
    result <- progress_function()
    
    # Verify the output includes our fixed time
    expect_output(result, fixed_time)
    
    # Optional: Check that Sys.time() was actually called once
    expect_called(mock_sys_time, times = 1)
  })
})

2. Using lubridate’s freeze_time() #

Another handy tool is lubridate’s freeze_time() function, which "freezes" the system time for the duration of your test. This avoids mocking individual functions and feels more natural if your function relies on multiple time-based calls:

library(testthat)
library(lubridate)

test_that("progress_function uses frozen system time", {
  fixed_time <- ymd_hms("2024-05-20 09:30:00")
  
  # Freeze time to our fixed value
  freeze_time(fixed_time)
  # Ensure we unfreeze time after the test finishes
  on.exit(thaw_time())
  
  result <- progress_function()
  expect_output(result, fixed_time)
})

3. Better: Refactor to use dependency injection #

If you’re still working on the function design, a cleaner approach is to make Sys.time() an optional parameter. This lets you pass in a fixed time directly during testing, no mocking required:

# Refactored function with optional time parameter
progress_function <- function(current_time = Sys.time()) {
  cat("Progress update at:", current_time, "\n")
  # Your algorithm logic here
  return(TRUE)
}

# Test case becomes simple and readable
test_that("progress_function uses provided time", {
  fixed_time <- as.POSIXct("2024-05-20 09:30:00")
  result <- progress_function(current_time = fixed_time)
  expect_output(result, fixed_time)
})

This is my favorite approach because it makes the function more flexible and tests more maintainable.

4. Testing format instead of exact time #

If you don’t care about the exact time value just that it’s formatted correctly, you can use a regular expression to validate the output format:

test_that("progress_function outputs a valid timestamp", {
  result <- progress_function()
  # Match standard POSIXct format (e.g., 2024-05-20 09:30:00)
  expect_output(result, "\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}")
})

What if the function doesn’t call Sys.time()? #

If your function has no dependency on system time, your testing workflow simplifies a lot:

• You won’t need any mocking, time-freezing, or parameter adjustments related to time.
• You can focus entirely on testing the core algorithm logic: verifying input-output mappings, edge cases, error handling, and performance.
• Tests will be more stable, since they won’t be affected by system time changes or clock drift.

内容的提问来源于stack exchange，提问作者EB2127