Running ‘testthat.R’ [6s/33s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(pins)
  > 
  > PerformanceReporter <- R6::R6Class(
  +   "PerformanceReporter",
  +   inherit = Reporter,
  +   public = list(
  +    results = list(
  +      context = character(0),
  +      time = numeric(0)
  +    ),
  +    last_context = NA_character_,
  +    last_test = NA_character_,
  +    last_time = Sys.time(),
  +    last_test_time = 0,
  +    n_ok = 0,
  +    n_skip = 0,
  +    n_warn = 0,
  +    n_fail = 0,
  + 
  +    start_context = function(context) {
  +      private$print_last_test()
  + 
  +      self$last_context <- context
  +      self$last_time <- Sys.time()
  +      cat(paste0("\nContext: ", context, "\n"))
  +    },
  + 
  +    add_result = function(context, test, result) {
  +      elapsed_time <- as.numeric(Sys.time()) - as.numeric(self$last_time)
  + 
  +      print_message = TRUE
  +      if (inherits(result, "expectation_failure") ||
  +          inherits(result, "expectation_error")) {
  +        self$n_fail <- self$n_fail + 1
  +      } else if (inherits(result, "expectation_skip")) {
  +        self$n_skip <- self$n_skip + 1
  +      } else if (inherits(result, "expectation_warning")) {
  +        self$n_warn <- self$n_warn + 1
  +      } else {
  +        print_message = FALSE
  +        self$n_ok <- self$n_ok + 1
  +      }
  + 
  +      if (print_message) {
  +        cat(
  +          paste0(test, ": ", private$expectation_type(result), ": ", result$message),
  +          "\n"
  +        )
  +      }
  + 
  +      if (identical(self$last_test, test)) {
  +        elapsed_time <- self$last_test_time + elapsed_time
  +        self$results$time[length(self$results$time)] <- elapsed_time
  +        self$last_test_time <- elapsed_time
  +      }
  +      else {
  +        private$print_last_test()
  + 
  +        self$results$context[length(self$results$context) + 1] <- self$last_context
  +        self$results$time[length(self$results$time) + 1] <- elapsed_time
  +        self$last_test_time <- elapsed_time
  +      }
  + 
  +      self$last_test <- test
  +      self$last_time <- Sys.time()
  +    },
  + 
  +    end_reporter = function() {
  +      private$print_last_test()
  + 
  +      cat("\n")
  +      data <- data.frame(
  +        context = self$results$context,
  +        time = self$results$time
  +      )
  + 
  +      summary <- aggregate(. ~ context, data, function(e) format(sum(e), width = "9", digits = "3", scientific = F))
  + 
  +      total <- format(sum(data$time), digits = "3", scientific = F)
  + 
  +      cat("\n")
  +      cat("--- Performance Summary  ----\n\n")
  +      print(as.data.frame(summary), row.names = FALSE)
  + 
  +      cat(paste0("\nTotal: ", total, "s\n"))
  + 
  +      cat("\n")
  +      cat("------- Tests Summary -------\n\n")
  +      self$cat_line("OK:       ", format(self$n_ok, width = 5))
  +      self$cat_line("Failed:   ", format(self$n_fail, width = 5))
  +      self$cat_line("Warnings: ", format(self$n_warn, width = 5))
  +      self$cat_line("Skipped:  ", format(self$n_skip, width = 5))
  +      cat("\n")
  +    }
  +   ),
  +   private = list(
  +    print_last_test = function() {
  +      if (!is.na(self$last_test) &&
  +          length(self$last_test) > 0 &&
  +          length(self$last_test_time) > 0) {
  +        cat(paste0(self$last_test, ": ", self$last_test_time, "\n"))
  +      }
  + 
  +      self$last_test <- NA_character_
  +    },
  +    expectation_type = function(exp) {
  +      stopifnot(is.expectation(exp))
  +      gsub("^expectation_", "", class(exp)[[1]])
  +    }
  +   )
  + )
  > 
  > test_check("pins", reporter = "performance")
  
  Context: board custom
  can board_register() a custom board: 0.0116457939147949
  can pin() with custom board: 0.169620037078857
  can pin_find() with custom board: 0.037600040435791
  can pin_get() with custom board: 0.00934553146362305
  can board_deregister() custom board: 0.00168871879577637
  
  Context: board datatxt
  can board_register() a data.txt board: 4.81245493888855
  can pin_get() iris from a data.txt board: 0.181955099105835
  can not evaluate expressions from data.txt board: 0.218121290206909
  can board_deregister() a data.txt board: 0.00136685371398926
  
  Context: board github
  can't register github board: skip: Reason: failed to register github board 
  can't register github board: 0.00177526473999023
  
  Context: board kaggle
  test kaggle board: skip: Reason: kaggle board is not registered 
  test kaggle board: 0.00139307975769043
  
  Context: board local
  local board is registered: 0.00268387794494629
  can pin() file with auto-generated name in local board: 0.0365006923675537
  can pin() file to local board: 0.00866127014160156
  can pin() data frame to local board: 0.00836324691772461
  can pin_get() a pin from local board: 0.00630736351013184
  can pin_find() the pin in any board: 0.31143045425415
  can pin_find() in local board: 0.00790619850158691
  can pin_remove() from local board: 0.00457000732421875
  
  Context: board metadata
  can roundtrip table metadata with no description: 0.1141676902771
  can roundtrip table metadata with description: 0.00279450416564941
  can roundtrip files metadata with no description: 0.0024714469909668
  can roundtrip files metadata with description: 0.00246500968933105
  can read empty metadata from empty text: 0.00337123870849609
  can read empty metadata from invalid text: 0.00184059143066406
  can read empty metadata from semi-valid text: 0.00188970565795898
  
  Context: board packages
  can pin_find() packages with empty search: 0.320838212966919
  trying URL 'https://cran.rstudio.com/src/contrib/hpiR_0.2.0.tar.gz'
  Content type 'application/x-gzip' length 1540852 bytes (1.5 MB)
  ==================================================
  downloaded 1.5 MB
  
  can pin_find() packages with search term: 0.14345908164978
  can pin_get() an specific resource: 11.615083694458
  
  Context: board rsc
  can't register rsconnect board: skip: Reason: failed to register rsconnect board 
  can't register rsconnect board: 0.00176215171813965
  
  Context: pin dataframe
  can pin() data frame: 0.0129127502441406
  can sanitize data frame names: 0.00173640251159668
  
  Context: pin find
  can pin_find() entries across all boards: 0.757264614105225
  
  Context: pin object
  can pin() object: 0.00760865211486816
  
  Context: pin owner
  can retrieve name with pin_content_name(): 0.00145506858825684
  can retrieve empty owner with pin_content_owner(): 0.0015103816986084
  can retrieve empty name with pin_content_owner(): 0.00153994560241699
  can parse simple names with pin_content_owner() and pin_content_name(): 0.00479578971862793
  
  Context: pin local
  can pin() remote URL: 4.27886486053467
  can pin() remote CSV with URL and name: error: Timeout was reached: Operation timed out after 3774 milliseconds with 0 out of 0 bytes received 
  can pin() remote CSV with URL: 0.187890768051147
  can pin() remote CSV with URL and name: 8.1793429851532
  
  
  --- Performance Summary  ----
  
          context      time
     board custom      0.23
    board datatxt      5.21
     board github   0.00178
     board kaggle   0.00139
      board local     0.386
   board metadata     0.129
   board packages      12.1
        board rsc   0.00176
    pin dataframe    0.0146
         pin find     0.757
        pin local      12.6
       pin object   0.00761
        pin owner    0.0093
  
  Total: 31.5s
  
  ------- Tests Summary -------
  
  OK:          51
  Failed:       1
  Warnings:     0
  Skipped:      3
  
  Error: Test failures
  Execution halted