Nothing
testthat::test_that("Function check_tags throws an error if the provided tags
argument is not a list", {
# nolint start
testthat::expect_error(
check_tags(tags = "test_tag"),
regexp = "Tags parameter must be an unnamed list of tags. For example: tags <- list('my_tag_1', 'my_tag_2')",
fixed = TRUE
)
# nolint end
})
testthat::test_that("Function check_settings throws error when expected", {
# Check if the function throws an error if settings argument is not a list
testthat::expect_error(
check_settings(settings = "test_string"),
regexp = "Settings must be provided as a list.",
fixed = TRUE
)
# Check if it throws an appropriate error if the provided settings list
# contains an element with invalid name
testthat::expect_error(
check_settings(settings = list(
locked = FALSE,
controlled = FALSE,
width = 10L
)),
regexp = "Argument width is not a valid settings field.",
fixed = TRUE
)
# Check if the function check_settings throws an error when settings list
# elements have invalid types
valid_input_names <- c(
"locked", "controlled", "use_interruptible_instances",
"use_memoization", "allow_network_access",
"use_elastic_disk", "location", "intermediate_files"
)
settings_field_types <- list(
locked = "logical",
controlled = "logical",
use_interruptible_instances = "logical",
use_memoization = "logical",
allow_network_access = "logical",
location = "character",
intermediate_files = "list"
)
for (field in names(settings_field_types)) {
# provide settings as a list with a field containing some invalid value
# (for example, integer)
input_list <- list()
input_list[[field]] <- 10L
# nolint start
testthat::expect_error(
check_settings(settings = input_list),
regexp = glue::glue("Assertion on '{field}' failed: Must be of type '{settings_field_types[field]}' (or 'NULL'), not 'integer'."),
fixed = TRUE
)
# nolint end
if (field == "intermediate_files") {
# check error message if retention field is not valid (not character)
input_intermediate_files <- list(
intermediate_files = list(retention = 15L)
)
# nolint start
testthat::expect_error(
check_settings(settings = input_intermediate_files),
regexp = glue::glue("Assertion on 'intermediate_files$retention' failed: Must be of type 'character' (or 'NULL'), not '{typeof(input_intermediate_files$intermediate_files$retention)}'."),
fixed = TRUE
)
# nolint end
# check error message if duration field is not valid (not character)
input_intermediate_files <- list(
intermediate_files =
list(duration = "24")
)
# nolint start
testthat::expect_error(
check_settings(settings = input_intermediate_files),
regexp = glue::glue("Assertion on 'intermediate_files$duration' failed: Must be of type 'integer' (or 'NULL'), not '{typeof(input_intermediate_files$intermediate_files$duration)}'."),
fixed = TRUE
)
# nolint end
}
}
})
test_that("check_limit function passes when limit is valid", {
testthat::expect_silent(check_limit(limit = 5L))
testthat::expect_silent(check_limit(limit = 56))
})
test_that("check_limit function throws error when limit is not valid", {
negative_limit <- list(limit = -1)
string_limit <- list(limit = "limit")
big_limit <- list(limit = 1500)
testthat::expect_error(
do.call(check_limit, negative_limit),
regexp = "Limit must be integer number between 1 and 100.",
fixed = TRUE
)
testthat::expect_error(
do.call(check_limit, string_limit),
regexp = "Limit must be integer number between 1 and 100.",
fixed = TRUE
)
testthat::expect_error(
do.call(check_limit, big_limit),
regexp = "Limit must be integer number between 1 and 100.",
fixed = TRUE
)
})
test_that("check_offset function passes when offset is valid", {
testthat::expect_silent(check_offset(offset = 1L))
testthat::expect_silent(check_offset(offset = 90))
})
test_that("check_offset function throws error when offset is not valid", {
negative_offset <- list(offset = -10)
string_offset <- list(offset = "offset")
testthat::expect_error(
do.call(check_offset, negative_offset),
regexp = "Offset must be integer number >= 0.",
fixed = TRUE
)
testthat::expect_error(
do.call(check_offset, string_offset),
regexp = "Offset must be integer number >= 0.",
fixed = TRUE
)
})
test_that("check_folder_name function works", {
testthat::expect_silent(check_folder_name(name = "New_folder"))
testthat::expect_silent(check_folder_name(name = "MyFolder"))
})
test_that("check_folder_name function throws error when expected", {
missing_name <- list(name = NULL)
int_name <- list(name = 123)
invalid_start_name <- list(name = "__inputs")
spaces_in_name <- list(name = "Another new folder")
testthat::expect_error(
do.call(check_folder_name, missing_name),
regexp = "Please provide the folder's name.",
fixed = TRUE
)
testthat::expect_error(
do.call(check_folder_name, int_name),
regexp = "Assertion on 'name' failed: Must be of type 'string', not 'double'.", # nolint
fixed = TRUE
)
testthat::expect_error(
do.call(check_folder_name, invalid_start_name),
regexp = "The folder name cannot start with \"__\"",
fixed = TRUE
)
testthat::expect_error(
do.call(check_folder_name, spaces_in_name),
regexp = "The folder name cannot contain spaces in the name.",
fixed = TRUE
)
})
test_that("check_metadata function throws error when metadata is not valid", {
missing_metadata <- list(metadata = list(NULL))
string_metadata <- list(metadata = "test")
int_metadata <- list(metadata = 123)
# nolint start
msg <- "Metadata parameter must be a named list of key-value pairs. For example: metadata <- list(metadata_key_1 = 'metadata_value_1', metadata_key_2 = 'metadata_value_2')"
# nolint end
testthat::expect_error(
do.call(check_metadata, missing_metadata),
regexp = msg,
fixed = TRUE
)
testthat::expect_error(
do.call(check_metadata, string_metadata),
regexp = msg,
fixed = TRUE
)
testthat::expect_error(
do.call(check_metadata, int_metadata),
regexp = msg,
fixed = TRUE
)
})
test_that("transform_multiple_vals function works", {
# Test with metadata example
metadata_values <- list(
metadata.disease_type = "Acute Myeloma",
metadata.sample_id = "some-id",
metadata.metadata_field = c("some other value1", "some-value2")
)
transformed_metadata <- transform_multiple_vals(metadata_values)
testthat::expect_equal(length(names(transformed_metadata)), 4)
testthat::expect_true(names(transformed_metadata)[3] == names(transformed_metadata)[4]) # nolint
testthat::expect_equal(transformed_metadata[[1]], "Acute%20Myeloma")
testthat::expect_equal(transformed_metadata[[2]], metadata_values[[2]])
testthat::expect_equal(transformed_metadata[[3]], "some%20other%20value1")
# Test with tags example
tags_values <- list(tags = list("index files", "suggested"))
transformed_tags <- transform_multiple_vals(tags_values)
testthat::expect_equal(length(names(transformed_tags)), 2)
testthat::expect_equal(transformed_tags[[1]], "index%20files")
testthat::expect_equal(transformed_tags[[2]], "suggested")
})
test_that("check_download_path function throws error when parameters are not valid", { # nolint
# Negative test use case for directory_path parameter
testthat::expect_error(
check_download_path(
directory_path = "non-existent-directory"
),
"Destination directory non-existent-directory does not exist."
)
# Negative test use cases for filename parameter
# 1) is_missing returns TRUE
filename_invalid_values <- c(NA, NULL)
for (filename in filename_invalid_values) {
testthat::expect_error(
check_download_path(directory_path = tempdir(), filename = filename),
"The filename parameter is missing."
)
}
# 2) is_missing returns FALSE, but the filename parameter value is not valid
filename_invalid_values <- list(
15L,
c("test_file_1.txt", "test_file_2.txt"),
list("test_file.txt")
)
for (filename in filename_invalid_values) {
testthat::expect_error(
check_download_path(directory_path = tempdir(), filename = filename),
"The filename parameter should be a length-one string."
)
}
})
test_that("check_retry_count function throws error when count is invalid", {
# Negative test use cases for count parameter
invalid_retry_count <- c(-1, "retry", 0, FALSE)
for (retry_count in invalid_retry_count) {
testthat::expect_error(
check_retry_params(
input = retry_count,
parameter_to_validate = "count"
),
"retry_count parameter must be a positive integer number."
)
}
})
test_that("check_retry_params function throws error when timeout is not valid", { # nolint
# Negative test use cases for timeout parameter
invalid_retry_timeout <- c(-1, "retry", 0, FALSE)
for (retry_timeout in invalid_retry_timeout) {
testthat::expect_error(
check_retry_params(
input = retry_timeout,
parameter_to_validate = "timeout"
),
"retry_timeout parameter must be a positive integer number."
)
}
})
test_that("check_app_copy_strategy function throws error when provided strategy is invalid", { # nolint
# Negative test use cases for missing strategy parameter
testthat::expect_error(
check_app_copy_strategy(
strategy = NULL
),
"Please provide the copy strategy"
)
# Negative test use case for invalid strategy parameter
# Valid values: clone, direct_clone, direct, transient
supported_app_copy_strategies <- getOption("sevenbridges2")$APP_COPY_STRATEGIES # nolint
invalid_strategy_param <- "test_strategy"
testthat::expect_error(
check_app_copy_strategy(
strategy = invalid_strategy_param
),
label = "The provided copy strategy (test_strategy) is not supported. Please use one of the following strategies: clone, direct, clone_direct, transient" # nolint
)
})
test_that("check_file_path function throws error when provided file_path parameter is not valid", { # nolint
# Negative test use case for invalid file_path parameter
invalid_file_path <- "/path/to/nonexisting-file.cwl"
testthat::expect_error(
check_file_path(
file_path = invalid_file_path
),
label = "File {magenta /path/to/nonexisting-file.cwl} does not exist."
)
})
test_that("check_volume_params works", {
# Pass invalid args, volume_type
testthat::expect_error(check_volume_params(args = NULL))
testthat::expect_error(check_volume_params(
args = list("arg1" = "arg1"),
volume_type = "some-other-type"
))
# Test with valid params
valid_args <- list(
name = "volume_name",
bucket = "bucket_name",
prefix = "",
access_mode = "RW",
description = NULL,
properties = list("some-property" = "value"),
endpoint = "some-endpoint",
root_url = "some-url",
credentials = list("key" = "just-string")
)
testthat::expect_no_error(check_volume_params(args = valid_args))
# Create invalid params list
invalid_args <- list(
name = 123,
bucket = list("some-name"),
container = list("some-container"),
prefix = NA,
access_mode = "some-other",
description = FALSE,
properties = c("some-property" = "value"),
endpoint = list("some-endpoint"),
root_url = TRUE,
credentials = "just-string"
)
# Pass invalid name
testthat::expect_error(check_volume_params(args = invalid_args["name"]))
# Pass invalid bucket (volume_type = s3)
testthat::expect_error(
check_volume_params(args = c(valid_args["name"], invalid_args["bucket"]))
)
# Pass invalid container (volume_type = azure)
testthat::expect_error(
check_volume_params(
volume_type = "azure",
args = c(valid_args["name"], invalid_args["container"])
)
)
# Pass invalid prefix
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["prefix"]
))
)
# Pass invalid access_mode
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["access_mode"]
))
)
# Pass invalid description
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["description"]
))
)
# Pass invalid properties
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["properties"]
))
)
# Pass invalid endpoint
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["endpoint"]
))
)
# Pass invalid root_url
testthat::expect_error(
check_volume_params(args = c(
valid_args["name"],
valid_args["bucket"],
invalid_args["root_url"]
))
)
})
test_that("transform_configuration_param works", {
# Provide configuration as valid list
config_list <- list(
"field1" = "value1",
"field2" = 123,
"field3" = list(
"subfield" = "subfield-value"
),
"field4" = "something"
)
transformed_str <- transform_configuration_param(configuration = config_list)
testthat::expect_type(transformed_str, "character")
testthat::expect_true(startsWith(transformed_str, prefix = "{\n"))
# Provide configuration as path to JSON file
config_json_path <- testthat::test_path(
file.path("test_data", "volumes_configuration_params.json")
)
testthat::skip_on_ci()
transformed_str <- transform_configuration_param(configuration = config_json_path) # nolint
testthat::expect_type(transformed_str, "character")
testthat::expect_true(startsWith(transformed_str, prefix = "{\n"))
})
test_that("transform_configuration_param throws error when needed", {
# Provide configuration as NULL
testthat::expect_error(
transform_configuration_param(configuration = NULL),
regexp = "Invalid configuration parameter! \n Please provide a string path to the JSON file or a named list.", # nolint
fixed = TRUE
)
# Provide configuration as empty list
testthat::expect_error(
transform_configuration_param(configuration = list()),
regexp = "Invalid configuration parameter! \n Please provide a string path to the JSON file or a named list.", # nolint
fixed = TRUE
)
# Provide configuration as unnamed list
testthat::expect_error(
transform_configuration_param(configuration = list("unnamed list")),
regexp = "Invalid configuration parameter! \n Please provide a string path to the JSON file or a named list.", # nolint
fixed = TRUE
)
# Provide configuration as invalid json path
config_path <- file.path("unnoun", "path", "to", "file.json")
testthat::expect_error(
transform_configuration_param(configuration = config_path)
)
# Provide configuration as non-string type
testthat::expect_error(
transform_configuration_param(configuration = c("field1", "field2"))
)
})
test_that("check_upload_params throws error when needed", {
too_big_size <- getOption("sevenbridges2")$MAXIMUM_OBJECT_SIZE + 1
too_big_part_size <- getOption("sevenbridges2")$MAXIMUM_PART_SIZE + 1
too_small_part_size <- getOption("sevenbridges2")$MINIMUM_PART_SIZE - 1
# Setup test parameters for test
test_no_size <- list(size = NULL, part_size = 1000)
test_bad_size <- list(size = "Bad_size", part_size = 1000)
test_negative_size <- list(size = -5, part_size = 1000)
test_too_big_size <- list(size = too_big_size, part_size = 1000)
test_no_part_size <- list(size = 1000, part_size = NULL)
test_bad_part_size <- list(size = 1000, part_size = "Bad_size")
test_negative_part_size <- list(size = 1000, part_size = -1000)
test_too_big_part_size <- list(size = 1000, part_size = too_big_part_size)
test_too_small_part_size <- list(size = 1000, part_size = too_small_part_size)
# Edge case for part length
part_size <- getOption("sevenbridges2")$MINIMUM_PART_SIZE
size <- (part_size * getOption("sevenbridges2")$MAXIMUM_TOTAL_PARTS) + getOption("sevenbridges2")$MINIMUM_PART_SIZE # nolint
test_bad_part_length <- list(size = size, part_size = part_size)
# Fails when no size is provided
testthat::expect_error(do.call(check_upload_params, test_no_size))
# Fails when bad size is provided
testthat::expect_error(do.call(check_upload_params, test_bad_size))
# Fails when negative size is provided
testthat::expect_error(do.call(check_upload_params, test_negative_size))
# Fails when too big size is provided
testthat::expect_error(
do.call(check_upload_params, test_too_big_size),
regexp = "File size must be between 0 - 5497558138880 (5TB), inclusive",
fixed = TRUE
)
# Fails when no part size is provided
testthat::expect_error(do.call(check_upload_params, test_no_part_size))
# Fails when bad part size is provided
testthat::expect_error(do.call(check_upload_params, test_bad_part_size))
# Fails when negative part size is provided
testthat::expect_error(do.call(check_upload_params, test_negative_part_size))
# Fails when too big part size is provided
testthat::expect_error(
do.call(check_upload_params, test_too_big_part_size),
regexp = "Parameter part_size must be 5 MB to 5 GB, last part can be < 5 MB", # nolint
fixed = TRUE
)
# Fails when too small part size is provided
testthat::expect_error(
do.call(check_upload_params, test_too_small_part_size),
regexp = "Parameter part_size must be 5 MB to 5 GB, last part can be < 5 MB", # nolint
fixed = TRUE
)
# Fails when part length is too big
testthat::expect_error(
do.call(check_upload_params, test_bad_part_length),
regexp = "Total number of parts must be from 1 to 10,000 (inclusive). Please modify part_size.", # nolint
fixed = TRUE
)
})
test_that("check_and_transform_datetime works as expected", {
# Fails when no datetime is provided
testthat::expect_error(check_and_transform_datetime(),
regexp = "Date is required!",
fixed = TRUE
)
# Check if character returns character back
time <- "2016-04-01 14:25:50"
testthat::expect_equal(check_and_transform_datetime(time),
expected = "2016-04-01 14:25:50"
)
# Check if Date/time returns character back
time <- as.POSIXct("2016-04-01 14:25:50", tz = "UTC")
testthat::expect_equal(check_and_transform_datetime(time),
expected = "2016-04-01 14:25:50"
)
})
# nolint start
test_that("check_and_process_file_details throws error for invalid name type", {
file_with_wrong_name <- list2env(as.list(setup_file_obj), envir = new.env())
file_with_wrong_name$name <- 123
testthat::expect_error(
check_and_process_file_details(file_with_wrong_name),
regexp = "Assertion on 'file$name' failed: Must be of type 'string', not 'double'.",
fixed = TRUE
)
})
test_that("check_and_process_file_details throws error for invalid tags type", {
file_with_invalid_tags <- list2env(as.list(setup_file_obj), envir = new.env())
file_with_invalid_tags$tags <- "test-tag"
testthat::expect_error(
check_and_process_file_details(file_with_invalid_tags),
regexp = "Assertion on 'file$tags' failed: Must be of type 'list', not 'character'.",
fixed = TRUE
)
})
test_that("check_and_process_file_details throws error for invalid metadata type", {
file_with_invalid_metadata <- list2env(as.list(setup_file_obj), envir = new.env())
file_with_invalid_metadata$metadata <- c("sample_id", "acdc")
testthat::expect_error(
check_and_process_file_details(file_with_invalid_metadata),
regexp = "Assertion on 'file$metadata' failed: Must be of type 'list', not 'character'.",
fixed = TRUE
)
})
test_that("check_and_process_file_details works as expected", {
# Call the function with a valid File object
result <- check_and_process_file_details(setup_file_obj)
# Create the expected result list
expected_result <- list(
id = "file-id",
name = "File name",
tags = list("tag_1"),
metadata = list(
sbg_public_files_category = "test",
reference_genome = "HG19_Broad_variant",
sample_id = "HCC1143_1M",
case_id = "CCLE-HCC1143",
investigation = "CCLE-BRCA"
)
)
# Check that the result is a list
testthat::expect_type(result, "list")
# Check that the result matches the expected result
testthat::expect_equal(result, expected_result)
})
# nolint end
test_that("check_response_and_notify_user throws an error when expected", {
test_valid_files_param <- list("file_id_1", "file_id_2", "file_id_3")
test_valid_res_param <- list(items = list(
list(error = list(status = 404, code = 5002, message = "Requested file does not exist.")), # nolint
list(resource = list(id = "file_id_2")),
list(error = list(status = 404, code = 5002, message = "Requested file does not exist.")) # nolint
))
# Fails when no files are provided
testthat::expect_error(check_response_and_notify_user(res = test_valid_res_param), # nolint
regexp = "Files parameter is required.",
fixed = TRUE
)
# Fails when res parameter is not provided
testthat::expect_error(check_response_and_notify_user(files = test_valid_files_param), # nolint
regexp = "Res parameter is required.",
fixed = TRUE
)
# Fails when bad files parameter is provided (list of numeric values)
test_bad_files_param_1 <- list(1, 2, 3)
testthat::expect_error(
check_response_and_notify_user(files = test_bad_files_param_1, res = test_valid_res_param), # nolint
regexp = "Assertion on 'files' failed: May only contain the following types: {character}, but element 1 has type 'numeric'.", # nolint
fixed = TRUE
)
# Fails when bad files parameter is provided (vector of strings)
test_bad_files_param_2 <- c("file_1_id", "file_2_id", "file_3_id")
testthat::expect_error(
check_response_and_notify_user(files = test_bad_files_param_2, res = test_valid_res_param), # nolint
regexp = "Assertion on 'files' failed: Must be of type 'list', not 'character'.", # nolint
fixed = TRUE
)
# Fails when bad res parameter is provided
test_bad_res_param <- 42
testthat::expect_error(
check_response_and_notify_user(files = test_valid_files_param, res = test_bad_res_param), # nolint
regexp = "Assertion on 'res' failed: Must be of type 'list', not 'double'.", # nolint
fixed = TRUE
)
})
test_that("check_response_and_notify_user works as expected", {
files <- list("file_id_1", "file_id_2", "file_id_3")
res <- list(items = list(
list(error = list(status = 404, code = 5002, message = "Requested file does not exist.")), # nolint
list(resource = list(id = "file_id_2")),
list(error = list(status = 404, code = 5002, message = "Requested file does not exist.")) # nolint
))
# Generates the expected console output
testthat::skip_on_ci()
testthat::skip_on_cran()
testthat::expect_snapshot(check_response_and_notify_user(files, res))
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.