From 0f426473050ca873894da2cc69a8fa4239338439 Mon Sep 17 00:00:00 2001 From: jwildfire Date: Thu, 7 Feb 2019 13:07:04 -0800 Subject: [PATCH 1/6] initial commit for refactor --- R/generateSettings.R | 71 +++++++++----------------- R/setSettingsValue.R | 31 +++++++++++ man/detectStandard.Rd | 1 - man/generateSettings.Rd | 10 ++-- man/setSettingsValue.Rd | 31 +++++++++++ tests/testthat/test_generateSettings.R | 5 ++ tests/testthat/test_setSettingsValue.R | 40 +++++++++++++++ 7 files changed, 136 insertions(+), 53 deletions(-) create mode 100644 R/setSettingsValue.R create mode 100644 man/setSettingsValue.Rd create mode 100644 tests/testthat/test_setSettingsValue.R diff --git a/R/generateSettings.R b/R/generateSettings.R index c10a4c70..f59dec9b 100644 --- a/R/generateSettings.R +++ b/R/generateSettings.R @@ -6,15 +6,16 @@ #' #' @param standard The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"} #' @param chart The chart for which standards should be generated ("eDish" only for now) . Default: \code{"eDish"}. +#' @param requiredOnly Only include required settings? Default: \code{TRUE}. #' @param partial Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}. -#' @param partial_cols Optional character vector of the matched cols if partial is TRUE. It will not be used if partial is FALSE Default: \code{NULL}. +#' @param partial_keys Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}. #' @return A list containing the appropriate settings for the selected chart #' #' @examples #' #' generateSettings(standard="SDTM") #' generateSettings(standard="SdTm") #also ok -#' generateSettings(standard="SDTM", partial=TRUE, partial_cols = c("USUBJID","TEST","STRESN")) +#' generateSettings(standard="SDTM", partial=TRUE, partial_keys = c("id_col","measure_col","value_col")) #' generateSettings(standard="ADaM") #' #' generateSettings(standard="a different standard") @@ -30,26 +31,31 @@ #' #' @export -generateSettings <- function(standard="None", chart="eDish", partial=FALSE, partial_cols=NULL){ +generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, partial=FALSE, partial_keys=NULL){ if(tolower(chart)!="edish"){ stop(paste0("Can't generate settings for the specified chart ('",chart,"'). Only the 'eDish' chart is supported for now.")) } - # Check that partial_cols is supplied if partial is true - if (is.null(partial_cols) & partial ) { - stop("partial_cols must be supplied if the standard is partial") + # Check that partial_keys is supplied if partial is true + if (is.null(partial_keys) & partial ) { + stop("partial_keys must be supplied if the standard is partial") } - metadata <- safetyGraphics::getSettingsMetadata( + standard<-lowcase(standard) + dataMappings <- safetyGraphics::getSettingsMetadata( charts = chart, - cols=c("text_key","adam","sdtm"), - filter_expr = .data$adam != '' & .data$sdtm != '' - ) + cols=c("text_key",standard) + ) %>% + filter(ifelse(requiredOnly, setting_required, TRUE))%>% + rename("column_name" = standard)%>% + filter(.data$column_name != '')%>% + mutate(selectedFlag = ifelse(partial, .data$text_key %in% .data$partial_keys, TRUE)) %>% + mutate(key=str_split(.data$text_key, "--")) # Split on -- for multi-level handling - hierarchical_metadata <- str_split(metadata$text_key, "--") - - settings<-list( + #hierarchical_metadata <- str_split(metadata$text_key, "--") + shells<-list() + shells[["edish"]]<-list( id_col = NULL, value_col = NULL, measure_col = NULL, @@ -78,42 +84,11 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part warningText = "Caution: This interactive graphic is not validated. Any clinical recommendations based on this tool should be confirmed using your organizations standard operating procedures." ) - potential_settings <- settings - - standard_low <- tolower(standard) - - if (standard_low == "adam" | standard_low == "sdtm") { - - for (row in hierarchical_metadata) { - if (length(row) == 1) { - potential_settings[row] <- filter(metadata,.data$text_key == !!row)[[standard_low]] - } else if (length(row) == 2) { - potential_settings[row[[1]]][[1]][row[[2]]] <- filter(metadata, grepl(!!row[[2]],.data$text_key))[[standard_low]] - } else{ - stop("Three level setting nests are not currently supported") - } - - } + # loop through dataMappings and apply them to the correct shell as appropriate + for(row in dataMappings%>%filter(selectedFlag)){ + setSettingValue(settings = shells[[chart]], key = row$key, value = row$columnName) } - if(partial) { - - settings_names <- names(settings) - - potential_names <- names(potential_settings) - - for(i in 1:length(settings)) { - if (potential_settings[i] %in% partial_cols) { - settings[[which(settings_names == potential_names[i])]] <- potential_settings[[i]] - } - } - - } else { - - settings <- potential_settings - - } - - return(settings) + return(shell[[chart]]) } \ No newline at end of file diff --git a/R/setSettingsValue.R b/R/setSettingsValue.R new file mode 100644 index 00000000..5f9e7302 --- /dev/null +++ b/R/setSettingsValue.R @@ -0,0 +1,31 @@ +#' Set the value for a given named parameter +#' +#' Sets the value for a named parameter (\code{key}) to given \code{value} in a list (\code{settings}) +#' +#' @param key a list (like those provided by \code{getSettingKeys()}) defining the position of parameter in the settings object. +#' @param value the value to set +#' @param settings The settings list used to generate a chart like \code{eDISH()} +#' @return the updated settings object +#' +#' +#' @examples +#' safetyGraphics:::setSettingValue(key=list("a","b"), value="notMyValue", settings=list(a=list(b="myValue"))) #returns list(a=list(b="notMyValue"))) +#' +#' testSettings<-generateSettings(standard="AdAM") +#' safetyGraphics:::setSettingValue(list("id_col"),"customID",testSettings) +#' safetyGraphics:::setSettingValue(list("measure_values","ALP"),"Alanine Aminotransferase",testSettings) +#' safetyGraphics:::setSettingValue(list("myCustomSetting"),"customized",testSettings) #adds myCustomSetting to testSettings +#' +#' @keywords internal + + +setSettingsValue <- function(key, value, settings){ + firstKey <- key[[1]] + if(length(key)==1){ + settings[[firstKey]]<-value + return(settings) + }else{ + settings[[firstKey]]<-setSettingsValue(settings = settings[[firstKey]],key = key[2:length(key)], value) + return(settings) + } +} \ No newline at end of file diff --git a/man/detectStandard.Rd b/man/detectStandard.Rd index 2d95265e..8536045e 100644 --- a/man/detectStandard.Rd +++ b/man/detectStandard.Rd @@ -23,7 +23,6 @@ This function attempts to detect the data CDISC clinical standard used in a give This function compares the columns in the provided \code{"data"} with the required columns for a given data standard/domain combination. The function is designed to work with the SDTM and AdAM CDISC() standards for clinical trial data. Currently, "labs" is the only domain supported. } \examples{ - detectStandard(adlbc)[["standard"]] #AdAM detectStandard(iris)[["standard"]] #none diff --git a/man/generateSettings.Rd b/man/generateSettings.Rd index 60223b46..d772208c 100644 --- a/man/generateSettings.Rd +++ b/man/generateSettings.Rd @@ -4,17 +4,19 @@ \alias{generateSettings} \title{Generate a settings object based on a data standard} \usage{ -generateSettings(standard = "None", chart = "eDish", partial = FALSE, - partial_cols = NULL) +generateSettings(standard = "None", chart = "eDish", + requiredOnly = TRUE, partial = FALSE, partial_keys = NULL) } \arguments{ \item{standard}{The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"}} \item{chart}{The chart for which standards should be generated ("eDish" only for now) . Default: \code{"eDish"}.} +\item{requiredOnly}{Only include required settings? Default: \code{TRUE}.} + \item{partial}{Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}.} -\item{partial_cols}{Optional character vector of the matched cols if partial is TRUE. It will not be used if partial is FALSE Default: \code{NULL}.} +\item{partial_keys}{Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}.} } \value{ A list containing the appropriate settings for the selected chart @@ -29,7 +31,7 @@ The function is designed to work with the SDTM and AdAM CDISC( Date: Thu, 7 Feb 2019 14:27:58 -0800 Subject: [PATCH 2/6] update tests --- R/generateSettings.R | 21 +++++++++++---------- R/setSettingsValue.R | 4 ++++ tests/testthat/test_generateSettings.R | 2 -- tests/testthat/test_setSettingsValue.R | 17 +++++++++++++---- 4 files changed, 28 insertions(+), 16 deletions(-) diff --git a/R/generateSettings.R b/R/generateSettings.R index f59dec9b..75d09d4c 100644 --- a/R/generateSettings.R +++ b/R/generateSettings.R @@ -41,19 +41,20 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, stop("partial_keys must be supplied if the standard is partial") } - standard<-lowcase(standard) + standard<-tolower(standard) + chart<-tolower(chart) + dataMappings <- safetyGraphics::getSettingsMetadata( charts = chart, - cols=c("text_key",standard) + cols=c("text_key",standard,"setting_required") ) %>% - filter(ifelse(requiredOnly, setting_required, TRUE))%>% + filter(ifelse(requiredOnly, .data$setting_required, TRUE))%>% rename("column_name" = standard)%>% filter(.data$column_name != '')%>% mutate(selectedFlag = ifelse(partial, .data$text_key %in% .data$partial_keys, TRUE)) %>% - mutate(key=str_split(.data$text_key, "--")) + filter(selectedFlag) - # Split on -- for multi-level handling - #hierarchical_metadata <- str_split(metadata$text_key, "--") + #hierarchical_metadata <- str_split(metadata$text_key, "--") shells<-list() shells[["edish"]]<-list( id_col = NULL, @@ -75,7 +76,7 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, analysisFlag = list(value_col=NULL, values=list()), - x_options = c("LT", "AST", "ALP"), + x_options = c("ALT", "AST", "ALP"), y_options = c("TB", "ALP"), visit_window = 30, r_ratio_filter = TRUE, @@ -86,9 +87,9 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, # loop through dataMappings and apply them to the correct shell as appropriate - for(row in dataMappings%>%filter(selectedFlag)){ - setSettingValue(settings = shells[[chart]], key = row$key, value = row$columnName) + for(row in 1:nrow(dataMappings)){ + shells[[chart]]<-setSettingsValue(settings = shells[[chart]], key = textKeysToList(dataMappings[row,"text_key"])[[1]], value = dataMappings[row, "column_name"]) } - return(shell[[chart]]) + return(shells[[chart]]) } \ No newline at end of file diff --git a/R/setSettingsValue.R b/R/setSettingsValue.R index 5f9e7302..adb109bc 100644 --- a/R/setSettingsValue.R +++ b/R/setSettingsValue.R @@ -20,6 +20,10 @@ setSettingsValue <- function(key, value, settings){ + stopifnot( + typeof(settings)=="list" + ) + firstKey <- key[[1]] if(length(key)==1){ settings[[firstKey]]<-value diff --git a/tests/testthat/test_generateSettings.R b/tests/testthat/test_generateSettings.R index 18026d81..76499cae 100644 --- a/tests/testthat/test_generateSettings.R +++ b/tests/testthat/test_generateSettings.R @@ -71,8 +71,6 @@ test_that("data mappings are null when setting=none, character otherwise",{ #Testing failure when partial is true with no specified columns expect_error(partial_settings_no_cols <- generateSettings(standard="ADaM", partial=TRUE)) - - }) test_that("check the required_only option",{ diff --git a/tests/testthat/test_setSettingsValue.R b/tests/testthat/test_setSettingsValue.R index f5401da0..193d2d3a 100644 --- a/tests/testthat/test_setSettingsValue.R +++ b/tests/testthat/test_setSettingsValue.R @@ -30,11 +30,20 @@ test_that("can set nested values",{ }) test_that("can set nested values that didn't previously exist",{ - expect_equal(setSettingsValue(list("a","z"), 456, testSettings1)[["a"]][["x"]], 456) - expect_equal(setSettingsValue(list("d","test"), 456, testSettings1)[["a"]][["x"]], 456) + expect_equal(setSettingsValue(list("a","z"), 456, testSettings1)[["a"]][["z"]], 456) }) -test_that("can't set nested values when a parent isn't a list",{ - expect_false(TRUE) +test_that("but can't set nested values when a parent is missing or isn't a list",{ + expect_error(setSettingsValue(list("d","test"), 456, testSettings1)[["d"]][["test"]]) # d doesn't exist, so this doesn't work. user could set d to list() and then set test to 456 ... + expect_error(setSettingsValue(list("b","z"), 456, testSettings1)) # can't replace a scalar (b="hi mom") with a list (b=list(z=456)) }) + +test_that("can set nested values in an unnamed list",{ + expect_true(FALSE) +}) + +test_that("can set nested values in an unnamed list that didn't previously exist",{ + expect_true(FALSE) +}) + \ No newline at end of file From ccc6baa94e1a757f50251a8dcad94ee2a09bd379 Mon Sep 17 00:00:00 2001 From: jwildfire Date: Fri, 8 Feb 2019 07:12:35 -0800 Subject: [PATCH 3/6] updating tests --- R/generateSettings.R | 39 +++++++++++--------- tests/testthat/test_generateSettings.R | 49 +++++++++++++++----------- 2 files changed, 52 insertions(+), 36 deletions(-) diff --git a/R/generateSettings.R b/R/generateSettings.R index 75d09d4c..5602241f 100644 --- a/R/generateSettings.R +++ b/R/generateSettings.R @@ -41,20 +41,26 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, stop("partial_keys must be supplied if the standard is partial") } + # Coerce options to lowercase standard<-tolower(standard) chart<-tolower(chart) - dataMappings <- safetyGraphics::getSettingsMetadata( - charts = chart, - cols=c("text_key",standard,"setting_required") - ) %>% - filter(ifelse(requiredOnly, .data$setting_required, TRUE))%>% - rename("column_name" = standard)%>% - filter(.data$column_name != '')%>% - mutate(selectedFlag = ifelse(partial, .data$text_key %in% .data$partial_keys, TRUE)) %>% - filter(selectedFlag) - - #hierarchical_metadata <- str_split(metadata$text_key, "--") + # Build a table of data mappings for the selected standard and partial settings + if(standard != "none"){ + dataMappings <- safetyGraphics::getSettingsMetadata( + charts = chart, + cols=c("text_key",standard,"setting_required") + ) %>% + filter(ifelse(requiredOnly, .data$setting_required, TRUE))%>% + rename("column_name" = standard)%>% + filter(.data$column_name != '') + + if(partial){ + dataMappings<-dataMappings%>%filter(.data$text_key %in% partial_keys) + } + } + + # build shell settings for each chart (move these to /data eventually?) shells<-list() shells[["edish"]]<-list( id_col = NULL, @@ -85,11 +91,12 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, warningText = "Caution: This interactive graphic is not validated. Any clinical recommendations based on this tool should be confirmed using your organizations standard operating procedures." ) - # loop through dataMappings and apply them to the correct shell as appropriate - - for(row in 1:nrow(dataMappings)){ - shells[[chart]]<-setSettingsValue(settings = shells[[chart]], key = textKeysToList(dataMappings[row,"text_key"])[[1]], value = dataMappings[row, "column_name"]) + # loop through dataMappings and apply them to the shell + if(standard != "none"){ + for(row in 1:nrow(dataMappings)){ + shells[[chart]]<-setSettingsValue(settings = shells[[chart]], key = textKeysToList(dataMappings[row,"text_key"])[[1]], value = dataMappings[row, "column_name"]) + } } - + return(shells[[chart]]) } \ No newline at end of file diff --git a/tests/testthat/test_generateSettings.R b/tests/testthat/test_generateSettings.R index 76499cae..afbf03ae 100644 --- a/tests/testthat/test_generateSettings.R +++ b/tests/testthat/test_generateSettings.R @@ -26,47 +26,56 @@ test_that("a warning is thrown if chart isn't eDish",{ }) test_that("data mappings are null when setting=none, character otherwise",{ - column_setting_names<-c("id_col", "value_col", "measure_col", "normal_col_low", "normal_col_high", "studyday_col", "visit_col", "visitn_col") + data_setting_keys<-c("id_col", "value_col", "measure_col", "normal_col_low", "normal_col_high", "studyday_col","measure_values--ALT","measure_values--ALP","measure_values--TB","measure_values--AST") none_settings <- generateSettings(standard="None") - for(name in column_setting_names){ - expect_null(none_settings[[name]]) + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_null(getSettingValue(settings=none_settings,key=key)) } sdtm_settings <- generateSettings(standard="SDTM") - for(name in column_setting_names){ - expect_is(sdtm_settings[[name]],"character") + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_is(getSettingValue(settings=sdtm_settings,key=key),"character") } + sdtm_settings2 <- generateSettings(standard="SdTm") - for(name in column_setting_names){ - expect_is(sdtm_settings2[[name]],"character") + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_is(getSettingValue(settings=sdtm_settings2,key=key),"character") } + adam_settings <- generateSettings(standard="ADaM") - for(name in column_setting_names){ - expect_is(adam_settings[[name]],"character") + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_is(getSettingValue(settings=adam_settings,key=key),"character") } adam_settings2 <- generateSettings(standard="ADAM") - for(name in column_setting_names){ - expect_is(adam_settings2[[name]],"character") + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_is(getSettingValue(settings=adam_settings2,key=key),"character") } + # Test Partial Spec Match - partial_adam_settings <- generateSettings(standard="SDTM", partial=TRUE, partial_cols = c("USUBJID","TEST")) - for(name in column_setting_names){ - - if (name %in% c("id_col","measure_col")) { - expect_is(partial_adam_settings[[name]],"character") + partial_adam_settings <- generateSettings(standard="adam", partial=TRUE, partial_keys = c("id_col","measure_col","measure_values--ALT")) + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + if (text_key %in% c("id_col","measure_col","measure_values--ALT")) { + expect_is(getSettingValue(settings=partial_adam_settings,key=key),"character") } else { - expect_null(partial_adam_settings[[name]]) + expect_null(getSettingValue(settings=partial_adam_settings,key=key)) } } #Testing that partial cols are only used when partial=TRUE - full_adam_partial_cols <- generateSettings(standard="ADaM", partial_cols = c("USUBJID","TEST")) - for(name in column_setting_names){ - expect_is(full_adam_partial_cols[[name]],"character") + full_adam_partial_cols <- generateSettings(standard="ADaM", partial_keys = c("id_col","measure_col","measure_values--ALT")) + for(text_key in data_setting_keys){ + key<-textKeysToList(text_key)[[1]] + expect_is(getSettingValue(settings=full_adam_partial_cols,key=key),"character") } #Testing failure when partial is true with no specified columns From a10a128933fcce31f53bfca06a7edc5a30c70b43 Mon Sep 17 00:00:00 2001 From: jwildfire Date: Fri, 8 Feb 2019 08:10:55 -0800 Subject: [PATCH 4/6] a few more tests. remove requiredOnly option for now. --- R/generateSettings.R | 5 ++--- man/generateSettings.Rd | 6 ++---- tests/testthat/test_generateSettings.R | 5 ----- tests/testthat/test_setSettingsValue.R | 27 ++++++++++++++++++++++---- 4 files changed, 27 insertions(+), 16 deletions(-) diff --git a/R/generateSettings.R b/R/generateSettings.R index 5602241f..7c819186 100644 --- a/R/generateSettings.R +++ b/R/generateSettings.R @@ -6,7 +6,6 @@ #' #' @param standard The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"} #' @param chart The chart for which standards should be generated ("eDish" only for now) . Default: \code{"eDish"}. -#' @param requiredOnly Only include required settings? Default: \code{TRUE}. #' @param partial Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}. #' @param partial_keys Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}. #' @return A list containing the appropriate settings for the selected chart @@ -31,7 +30,7 @@ #' #' @export -generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, partial=FALSE, partial_keys=NULL){ +generateSettings <- function(standard="None", chart="eDish", partial=FALSE, partial_keys=NULL){ if(tolower(chart)!="edish"){ stop(paste0("Can't generate settings for the specified chart ('",chart,"'). Only the 'eDish' chart is supported for now.")) } @@ -51,7 +50,7 @@ generateSettings <- function(standard="None", chart="eDish", requiredOnly=TRUE, charts = chart, cols=c("text_key",standard,"setting_required") ) %>% - filter(ifelse(requiredOnly, .data$setting_required, TRUE))%>% + filter(.data$setting_required)%>% rename("column_name" = standard)%>% filter(.data$column_name != '') diff --git a/man/generateSettings.Rd b/man/generateSettings.Rd index d772208c..68d223e1 100644 --- a/man/generateSettings.Rd +++ b/man/generateSettings.Rd @@ -4,16 +4,14 @@ \alias{generateSettings} \title{Generate a settings object based on a data standard} \usage{ -generateSettings(standard = "None", chart = "eDish", - requiredOnly = TRUE, partial = FALSE, partial_keys = NULL) +generateSettings(standard = "None", chart = "eDish", partial = FALSE, + partial_keys = NULL) } \arguments{ \item{standard}{The data standard for which to create settings. Valid options are "SDTM", "AdAM" or "None". Default: \code{"SDTM"}} \item{chart}{The chart for which standards should be generated ("eDish" only for now) . Default: \code{"eDish"}.} -\item{requiredOnly}{Only include required settings? Default: \code{TRUE}.} - \item{partial}{Boolean for whether or not the standard is a partial standard. Default: \code{FALSE}.} \item{partial_keys}{Optional character vector of the matched settings if partial is TRUE. Settings should be identified using the text_key format described in ?settingsMetadata. Setting is ignored when partial is FALSE. Default: \code{NULL}.} diff --git a/tests/testthat/test_generateSettings.R b/tests/testthat/test_generateSettings.R index afbf03ae..22232fbd 100644 --- a/tests/testthat/test_generateSettings.R +++ b/tests/testthat/test_generateSettings.R @@ -81,8 +81,3 @@ test_that("data mappings are null when setting=none, character otherwise",{ #Testing failure when partial is true with no specified columns expect_error(partial_settings_no_cols <- generateSettings(standard="ADaM", partial=TRUE)) }) - -test_that("check the required_only option",{ - expect_true(FALSE) -}) - \ No newline at end of file diff --git a/tests/testthat/test_setSettingsValue.R b/tests/testthat/test_setSettingsValue.R index 193d2d3a..1165c9c9 100644 --- a/tests/testthat/test_setSettingsValue.R +++ b/tests/testthat/test_setSettingsValue.R @@ -1,8 +1,7 @@ context("Tests for the setSettingValue() function") library(safetyGraphics) -testSettings1<-list(a=list(x="sue",y="sam"), b="hi mom", c=123) -testSDTM <- generateSettings(standard="SDTM") +testSettings1<-list(a=list(x="sue",y="sam"), b="hi mom", c=123, unnamed=list("Apples","Oranges")) test_that("function throws an error if the settings object isn't a list",{ expect_error(setSettingsValue(key="testKey",value="abc", settings=c("NotAList"))) @@ -39,11 +38,31 @@ test_that("but can't set nested values when a parent is missing or isn't a list" }) test_that("can set nested values in an unnamed list",{ - expect_true(FALSE) + expect_equal(setSettingsValue(list("unnamed",1), 456, testSettings1)[["unnamed"]][[1]], 456) # [[1]] is overwritten + expect_equal(setSettingsValue(list("unnamed",1), 456, testSettings1)[["unnamed"]][[2]], "Oranges") #original value in [[2]] is unchanged }) test_that("can set nested values in an unnamed list that didn't previously exist",{ - expect_true(FALSE) + expect_true(setSettingsValue(list("unnamed",3), TRUE, testSettings1)[["unnamed"]][[3]]) #[[3]] added + + expect_true(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[5]]) #this works, [[4]] and [[5]] are Null + expect_null(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[4]]) #this works, [[4]] and [[5]] are Null + expect_null(setSettingsValue(list("unnamed",5), TRUE, testSettings1)[["unnamed"]][[4]]) #this works, [[4]] and [[5]] are Null }) + +test_that("sanity checks using a real setting object",{ + testSDTM <- generateSettings(standard="SDTM") + testSDTM <-setSettingsValue(list("id_col"), "customID", testSDTM) + testSDTM <-setSettingsValue(list("measure_values","ALP"), "Alpine", testSDTM) + testSDTM <-setSettingsValue(list("filters"), list(), testSDTM) + testSDTM <-setSettingsValue(list("filters",1), "RACE", testSDTM) + testSDTM <-setSettingsValue(list("customSetting"), "customized!", testSDTM) + + + expect_equal(testSDTM[["id_col"]],"customID") + expect_equal(testSDTM[["measure_values"]][["ALP"]],"Alpine") + expect_equal(testSDTM[["filters"]][[1]],"RACE") + expect_equal(testSDTM[["customSetting"]],"customized!") +}) \ No newline at end of file From a2592cd70d20fb928cdcd9d375e2bff335c74d40 Mon Sep 17 00:00:00 2001 From: jwildfire Date: Fri, 8 Feb 2019 08:13:51 -0800 Subject: [PATCH 5/6] tweak validation test to use required variable --- tests/testthat/test_validateSettings.R | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/testthat/test_validateSettings.R b/tests/testthat/test_validateSettings.R index 619ebdfd..9dcd151a 100644 --- a/tests/testthat/test_validateSettings.R +++ b/tests/testthat/test_validateSettings.R @@ -50,7 +50,7 @@ test_that("field checks fail when expected",{ expect_equal(failedChecks[[1]][['check']],"'_values' field from setting found in data?") expect_equal(failedChecks[[1]][['text_key']],"measure_values--ALP") - invalidFieldSettings$visit_values <- list(test="not a visit",test2="still not a visit") + invalidFieldSettings$id_values <- list(test="not an id",test2="still not an id") fieldFailed2<-validateSettings(data=adlbc,settings=invalidFieldSettings) failedChecks2 = fieldFailed2[["checkList"]]%>%keep(~!.x[["valid"]]) expect_false(fieldFailed[["valid"]]) From 90ab6fc7b0dc48dfc7304be3b9656b721e26d2c9 Mon Sep 17 00:00:00 2001 From: jwildfire Date: Fri, 8 Feb 2019 08:46:13 -0800 Subject: [PATCH 6/6] all tests/checks passing. fix #135 #151 --- R/generateSettings.R | 11 +++++++---- R/setSettingsValue.R | 14 ++++++++------ man/generateSettings.Rd | 3 ++- man/setSettingsValue.Rd | 13 ++++++++----- tests/testthat/test_generateSettings.R | 6 ++++++ tests/testthat/test_setSettingsValue.R | 2 ++ 6 files changed, 33 insertions(+), 16 deletions(-) diff --git a/R/generateSettings.R b/R/generateSettings.R index 7c819186..ac5530d1 100644 --- a/R/generateSettings.R +++ b/R/generateSettings.R @@ -14,8 +14,9 @@ #' #' generateSettings(standard="SDTM") #' generateSettings(standard="SdTm") #also ok -#' generateSettings(standard="SDTM", partial=TRUE, partial_keys = c("id_col","measure_col","value_col")) #' generateSettings(standard="ADaM") +#' pkeys<- c("id_col","measure_col","value_col") +#' generateSettings(standard="adam", partial=TRUE, partial_keys=pkeys) #' #' generateSettings(standard="a different standard") #' #returns shell settings list with no data mapping @@ -45,7 +46,8 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part chart<-tolower(chart) # Build a table of data mappings for the selected standard and partial settings - if(standard != "none"){ + standardList<-c("adam","sdtm") #TODO: automatically generate this from metadata + if(standard %in% standardList){ dataMappings <- safetyGraphics::getSettingsMetadata( charts = chart, cols=c("text_key",standard,"setting_required") @@ -59,7 +61,8 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part } } - # build shell settings for each chart (move these to /data eventually?) + # build shell settings for each chart + # TODO: move these to `/data` eventually shells<-list() shells[["edish"]]<-list( id_col = NULL, @@ -91,7 +94,7 @@ generateSettings <- function(standard="None", chart="eDish", partial=FALSE, part ) # loop through dataMappings and apply them to the shell - if(standard != "none"){ + if(standard %in% standardList){ for(row in 1:nrow(dataMappings)){ shells[[chart]]<-setSettingsValue(settings = shells[[chart]], key = textKeysToList(dataMappings[row,"text_key"])[[1]], value = dataMappings[row, "column_name"]) } diff --git a/R/setSettingsValue.R b/R/setSettingsValue.R index adb109bc..8052d237 100644 --- a/R/setSettingsValue.R +++ b/R/setSettingsValue.R @@ -7,14 +7,16 @@ #' @param settings The settings list used to generate a chart like \code{eDISH()} #' @return the updated settings object #' -#' #' @examples -#' safetyGraphics:::setSettingValue(key=list("a","b"), value="notMyValue", settings=list(a=list(b="myValue"))) #returns list(a=list(b="notMyValue"))) +#' testSet<-list(a=list(b="myValue")) +#' safetyGraphics:::setSettingsValue(key=list("a","b"), value="notMyValue", settings=testSet) +#' #returns list(a=list(b="notMyValue"))) #' -#' testSettings<-generateSettings(standard="AdAM") -#' safetyGraphics:::setSettingValue(list("id_col"),"customID",testSettings) -#' safetyGraphics:::setSettingValue(list("measure_values","ALP"),"Alanine Aminotransferase",testSettings) -#' safetyGraphics:::setSettingValue(list("myCustomSetting"),"customized",testSettings) #adds myCustomSetting to testSettings +#' adamSettings<-generateSettings(standard="AdAM") +#' safetyGraphics:::setSettingsValue(list("id_col"),"customID",adamSettings) +#' safetyGraphics:::setSettingsValue(list("measure_values","ALP"),"Alanine Aminotrans",adamSettings) +#' safetyGraphics:::setSettingsValue(list("myCustomSetting"),"customized",adamSettings) +#' #adds myCustomSetting to adamSettings #' #' @keywords internal diff --git a/man/generateSettings.Rd b/man/generateSettings.Rd index 68d223e1..f4bb5e9c 100644 --- a/man/generateSettings.Rd +++ b/man/generateSettings.Rd @@ -29,8 +29,9 @@ The function is designed to work with the SDTM and AdAM CDISC(