refactor(verbose): prevent parameter printing when running tests by setting verbose = FALSE

Author: amyheather

R/choose_replications.R

@@ -257,6 +257,7 @@ ReplicationsAlgorithm <- R6Class("ReplicationsAlgorithm", list( # nolint: object
   #' @param initial_replications Number of initial replications to perform.
   #' @param look_ahead Minimum additional replications to look ahead.
   #' @param replication_budget Maximum allowed replications.
+  #' @param verbose Boolean, whether to print messages about parameters.
   initialize = function(
     param,
     metrics = c("mean_waiting_time_nurse",
@@ -265,7 +266,8 @@ ReplicationsAlgorithm <- R6Class("ReplicationsAlgorithm", list( # nolint: object
     desired_precision = 0.1,
     initial_replications = 3L,
     look_ahead = 5L,
-    replication_budget = 1000L
+    replication_budget = 1000L,
+    verbose = TRUE
   ) {
     self$param <- param
     self$metrics <- metrics
@@ -278,8 +280,10 @@ ReplicationsAlgorithm <- R6Class("ReplicationsAlgorithm", list( # nolint: object
     self$reps <- initial_replications
 
     # Print the parameters
-    print("Model parameters:")  # nolint: print_linter
-    print(self$param)
+    if (isTRUE(verbose)) {
+      print("Model parameters:")  # nolint: print_linter
+      print(self$param)
+    }
 
     # Check validity of provided parameters
     self$valid_inputs()
@@ -499,17 +503,20 @@ ReplicationsAlgorithm <- R6Class("ReplicationsAlgorithm", list( # nolint: object
 #' @param replications Number of times to run the model.
 #' @param desired_precision Desired mean deviation from confidence interval.
 #' @param metric Name of performance metric to assess.
+#' @param verbose Boolean, whether to print messages about parameters.
 #'
 #' @importFrom utils tail
 #'
 #' @return Dataframe with results from each replication.
 #' @export
 
 confidence_interval_method <- function(replications, desired_precision,
-                                       metric) {
+                                       metric, verbose = TRUE) {
   # Run model for specified number of replications
   param <- parameters(number_of_runs = replications)
-  print(param)
+  if (isTRUE(verbose)) {
+    print(param)
+  }
   results <- runner(param, use_future_seeding = FALSE)[["run_results"]]
 
   # Initialise list to store the results

tests/testthat/test-backtest-replications.R

@@ -14,7 +14,8 @@ test_that("results from confidence_interval_method are consistent", {
   rep_results <- suppressWarnings(confidence_interval_method(
     replications = 15L,
     desired_precision = 0.1,
-    metric = "mean_serve_time_nurse"
+    metric = "mean_serve_time_nurse",
+    verbose = FALSE
   ))
 
   # Import the expected results
@@ -42,7 +43,8 @@ test_that("results from ReplicationsAlgorithm are consistent", {
     desired_precision = 0.1,
     initial_replications = 15L,
     look_ahead = 0L,
-    replication_budget = 15L
+    replication_budget = 15L,
+    verbose = FALSE
   )
   suppressWarnings(alg$select())
   rep_results <- alg$summary_table

tests/testthat/test-backtest.R

@@ -81,7 +81,7 @@ test_that("results from scenario analysis match those previously generated", {
   )
 
   scenario_results <- as.data.frame(
-    run_scenarios(scenarios, base_list = param)
+    run_scenarios(scenarios, base_list = param, verbose = FALSE)
   )
 
   # Import the expected results

tests/testthat/test-functionaltest-replications.R

@@ -8,7 +8,8 @@ test_that("output from confidence_interval_method is as expected", {
   ci_df <- suppressWarnings(confidence_interval_method(
     replications = reps,
     desired_precision = 0.1,
-    metric = "mean_waiting_time_nurse"
+    metric = "mean_waiting_time_nurse",
+    verbose = FALSE
   ))
 
   # Check that the results dataframe has the right number of rows
@@ -33,7 +34,8 @@ test_that(
     man_df <- suppressWarnings(confidence_interval_method(
       replications = reps,
       desired_precision = desired_precision,
-      metric = metric
+      metric = metric,
+      verbose = FALSE
     ))
 
     # Run the algorithm (ignoring unsolved warnings)
@@ -43,7 +45,8 @@ test_that(
       desired_precision = desired_precision,
       initial_replications = reps,
       look_ahead = 0L,
-      replication_budget = reps
+      replication_budget = reps,
+      verbose = FALSE
     )
     suppressWarnings(alg$select())
 
@@ -63,7 +66,8 @@ test_that("ReplicationsAlgorithm initial_replications consistent to without", {
       desired_precision = 0.1,
       initial_replications = initial_replications,
       look_ahead = 10L,
-      replication_budget = 10L
+      replication_budget = 10L,
+      verbose = FALSE
     )
     suppressWarnings(alg$select())
     head(alg$summary_table, 10L)
@@ -83,7 +87,8 @@ test_that("running algorithm with < 3 replications has no solution", {
   alg <- ReplicationsAlgorithm$new(param = parameters(),
                                    initial_replications = 0L,
                                    replication_budget = 2L,
-                                   look_ahead = 0L)
+                                   look_ahead = 0L,
+                                   verbose = FALSE)
   # Check that it runs with a warning
   expect_warning(alg$select())
   # Check that there is no solution

tests/testthat/test-unittest-replications.R

@@ -6,7 +6,8 @@ patrick::with_parameters_test_that(
     # Calculate klimit
     calc <- ReplicationsAlgorithm$new(param = parameters(),
                                       look_ahead =  look_ahead,
-                                      initial_replications = n)$klimit()
+                                      initial_replications = n,
+                                      verbose = FALSE)$klimit()
     # Check that it meets our expected value
     expect_identical(calc, exp)
   },
@@ -21,7 +22,8 @@ patrick::with_parameters_test_that(
 patrick::with_parameters_test_that(
   "ReplicationsAlgorithm responds appropriately to invalid parameters",
   {
-    inputs <- c(list(param = parameters()), setNames(list(value), arg))
+    inputs <- c(list(param = parameters()), setNames(list(value), arg),
+                verbose = FALSE)
     expect_error(do.call(ReplicationsAlgorithm$new, inputs), msg)
   },
   patrick::cases(
@@ -47,7 +49,8 @@ test_that(
     expect_error(
       ReplicationsAlgorithm$new(param = parameters(),
                                 initial_replications = 10L,
-                                replication_budget = 9L),
+                                replication_budget = 9L,
+                                verbose = FALSE),
       "replication_budget must be less than initial_replications."
     )
   }
@@ -138,7 +141,8 @@ patrick::with_parameters_test_that(
     # Set threshold to 0.5, with provided look_ahead
     alg <- ReplicationsAlgorithm$new(param = parameters(),
                                      desired_precision = 0.5,
-                                     look_ahead = look_ahead)
+                                     look_ahead = look_ahead,
+                                     verbose = FALSE)
     # Get result from algorithm and compare to expected
     result <- alg$find_position(lst)
     expect_identical(result, exp)
@@ -170,6 +174,6 @@ patrick::with_parameters_test_that(
 
 
 test_that("find_position() fails if not supplied a list", {
-  alg <- ReplicationsAlgorithm$new(param = parameters())
+  alg <- ReplicationsAlgorithm$new(param = parameters(), verbose = FALSE)
   expect_error(alg$find_position(c(1L, 2L, 3L)))
 })