Nothing
##' testthat tests for database.DBconfig
##'
context("testing database.DBconfig functions")
dbName = 'ae'
useInMemoryCache = FALSE
path2orig = file.path(tempdir(),
"emuR_demoData",
paste0(dbName, emuDB.suffix))
path2testData = file.path(tempdir(), "emuR_testthat")
path2db = file.path(path2testData,
paste0(dbName, emuDB.suffix))
##############################
test_that("get_levelDefinition returns correct levelDef", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
#########################
# get dbObj
dbConfig = load_DBconfig(ae)
ld = get_levelDefinition(ae, 'Phonetic')
expect_equal(ld$name, 'Phonetic')
expect_equal(ld$type, 'SEGMENT')
expect_equal(ld$attributeDefinitions[[1]]$name, 'Phonetic')
expect_equal(ld$attributeDefinitions[[1]]$type, 'STRING')
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for ssffTrackDefinitions", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
expect_error(add_ssffTrackDefinition(ae, 'fm'))
expect_error(add_ssffTrackDefinition(ae, 'fm', 'bla'))
expect_error(add_ssffTrackDefinition(ae,
'newTrackName',
'badColName',
'pit',
onTheFlyFunctionName = 'mhsF0',
interactive = TRUE,
verbose = FALSE))
add_ssffTrackDefinition(ae,
'newTrackName',
'pitch',
'pit',
onTheFlyFunctionName = 'mhsF0',
interactive = FALSE,
verbose = FALSE)
pitFilePaths = list.files(path2db,
pattern = 'pit$',
recursive = TRUE)
expect_equal(length(pitFilePaths), 7)
})
test_that("list = C(R)UD", {
df = list_ssffTrackDefinitions(ae)
expect_equal(df$name, c('dft','fm', 'newTrackName'))
expect_equal(df$columnName, c('dft','fm', 'pitch'))
expect_equal(df$fileExtension, c('dft','fms', 'pit'))
})
test_that("remove = CRU(D)", {
# bad name
expect_error(remove_ssffTrackDefinition(ae, name="asdf"))
remove_ssffTrackDefinition(ae,
name = "newTrackName",
deleteFiles = TRUE)
# check that _DBconfig entry is deleted
dbConfig = load_DBconfig(ae)
expect_equal(dbConfig$ssffTrackDefinitions[[1]]$name, "dft")
expect_equal(dbConfig$ssffTrackDefinitions[[2]]$name, "fm")
# check that files have been deleted
filePaths = list_files(ae, "pit")
expect_equal(nrow(filePaths), 0)
})
test_that("remove = CRU(D) with force", {
remove_linkDefinition(ae,
"Intermediate",
"Word",
force = TRUE,
verbose = FALSE)
remove_linkDefinition(ae,
"Word",
"Syllable",
force = TRUE,
verbose = FALSE)
remove_levelDefinition(ae,
"Word",
force = TRUE,
verbose = FALSE)
# check items table
df = DBI::dbGetQuery(ae$connection, paste0("SELECT * ",
"FROM items ",
"WHERE level = 'Word'"))
expect_equal(nrow(df), 0)
# TODO: probably should also check labels table
# check annot json
ajson = jsonlite::fromJSON(file.path(path2db,
"0000_ses",
"msajc003_bndl",
"msajc003_annot.json"),
simplifyVector = FALSE)
expect_false(ajson$levels[[4]]$name == "Word")
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for levelDefinitions", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
expect_error(add_levelDefinition(ae, 'Phonetic', 'SEGM')) # bad type
expect_error(add_levelDefinition(ae, 'Phonetic', 'SEGMENT')) # already exists
add_levelDefinition(ae, 'Phonetic2', 'SEGMENT', verbose = FALSE)
dbConfig = load_DBconfig(ae)
expect_equal(length(dbConfig$levelDefinitions), 10)
})
test_that("list = C(R)UD", {
df = list_levelDefinitions(ae)
expect_equal(as.vector(df$name[8:10]),
c('Tone',
'Foot',
'Phonetic2'))
expect_equal(as.vector(df$type[8:10]),
c('EVENT',
'ITEM',
'SEGMENT'))
expect_equal(as.vector(df$nrOfAttrDefs[1:4]),
c(1, 1, 1, 3))
})
test_that("remove = CRU(D)", {
expect_error(remove_levelDefinition(ae, name="asdf")) # bad name
expect_error(remove_levelDefinition(ae, name="Phonetic")) # linkDef present
DBI::dbExecute(ae$connection, paste0("INSERT INTO session ",
"VALUES (",
" '", ae$UUID, "', ",
"'0001')")) # add item
DBI::dbExecute(ae$connection, paste0("INSERT INTO bundle ",
"VALUES (",
" '", ae$UUID, "', ",
" '0001', ",
" 'fakeBundle', ",
" 'fakeBundle.wav', ",
" 20000, ",
" '785c7cdb6d4bd5e8b5cd7c56a5946ddf' ",
")")) # add item
DBI::dbExecute(ae$connection, paste0("INSERT INTO items ",
"VALUES (",
" '", ae$UUID, "', ",
" '0001', ",
" 'fakeBundle', ",
" 1, ",
" 'Phonetic2', ",
" 'ITEM', ",
" 20000, ",
" 1, ",
" NULL, ",
" NULL, ",
" NULL",
")")) # add item
expect_error(remove_levelDefinition(ae, name = "Phonetic2")) # item present
DBI::dbExecute(ae$connection, paste0("DELETE FROM items ",
"WHERE db_uuid = '", ae$UUID, "'")) # items present
remove_levelDefinition(ae, name = "Phonetic2", verbose = FALSE)
dbConfig = load_DBconfig(ae)
expect_equal(length(dbConfig$levelDefinition), 9)
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for attributeDefinitions", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
expect_error(add_attributeDefinition(ae,
'Word',
'Word',
verbose = FALSE)) # present attrDef
add_attributeDefinition(ae,
'Word',
'testAttrDef',
verbose = FALSE)
df = list_attributeDefinitions(ae, 'Word')
expect_true('testAttrDef' %in% df$name)
})
test_that("list = C(R)UD", {
df = list_attributeDefinitions(ae, 'Word')
expect_equal(df$name, c('Word', 'Accent', 'Text', 'testAttrDef'))
expect_equal(df$type, c('STRING', 'STRING', 'STRING', 'STRING'))
expect_equal(df$hasLabelGroups, c(FALSE, FALSE, FALSE, FALSE))
expect_equal(df$hasLegalLabels, c(FALSE, FALSE, FALSE, FALSE))
})
test_that("remove = CRU(D)", {
expect_error(remove_attributeDefinition(ae,
'Word',
'Word',
verbose = FALSE))
expect_error(remove_attributeDefinition(ae,
'Word',
'Accent',
verbose = FALSE))
remove_attributeDefinition(ae, 'Word',
'testAttrDef',
force = TRUE,
verbose = FALSE)
df = list_attributeDefinitions(ae, 'Word')
expect_equal(nrow(df), 3)
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for legalLabels", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("set = (C)RUD", {
# non character vector causes error:
expect_error(set_legalLabels(ae,
levelName = 'Word',
attributeDefinitionName = 'Word',
legalLabels=c(1:3)))
set_legalLabels(ae,
levelName = 'Word',
attributeDefinitionName = 'Word',
legalLabels=c('A', 'B', 'C'))
})
test_that("get = C(R)UD", {
ll = get_legalLabels(ae,
levelName = 'Word',
attributeDefinitionName = 'Word')
expect_equal(ll, c('A', 'B', 'C'))
})
test_that("remove = CRU(D)", {
remove_legalLabels(ae,
levelName = 'Word',
attributeDefinitionName = 'Word')
ll = get_legalLabels(ae,
levelName = 'Word',
attributeDefinitionName = 'Word')
expect_true(is.na(ll))
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for labelGroups", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
# bad call already def. labelGroup
expect_error(add_attrDefLabelGroup(ae,
levelName = 'Phoneme',
attributeDefinitionName = 'Phoneme',
labelGroupName = 'vowel',
labelGroupValues = c('sdf', 'f')))
add_attrDefLabelGroup(ae,
levelName = 'Word',
attributeDefinitionName = 'Word',
labelGroupName = 'newGroup',
labelGroupValues = c('sdf', 'f'))
})
test_that("list = C(R)UD", {
df = list_attrDefLabelGroups(ae,
levelName = 'Utterance',
attributeDefinitionName = 'Utterance')
expect_equal(nrow(df), 0)
df = list_attrDefLabelGroups(ae,
levelName = 'Phoneme',
attributeDefinitionName = 'Phoneme')
expect_equal(nrow(df), 6)
expect_true(df[6,]$values == "H")
df = list_attrDefLabelGroups(ae,
levelName = 'Word',
attributeDefinitionName = 'Word')
expect_true(df[1,]$name == "newGroup")
expect_true(df[1,]$values == "sdf; f")
})
test_that("remove = CRU(D)", {
expect_error(remove_attrDefLabelGroup(ae,
levelName = 'Word',
attributeDefinitionName = 'Word',
labelGroupName = 'notThere'))
remove_attrDefLabelGroup(ae,
levelName = 'Word',
attributeDefinitionName = 'Word',
labelGroupName = 'newGroup')
df = list_attrDefLabelGroups(ae,
levelName = 'Word',
attributeDefinitionName = 'Word')
expect_equal(nrow(df), 0)
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for linkDefinitions", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
# bad call (bad type)
expect_error(add_linkDefinition(ae, "ONE_TO_TWO"))
# bad call (link exists)
expect_error(add_linkDefinition(ae, "ONE_TO_ONE",
superlevelName ="Syllable",
sublevelName = "Tone"))
# bad call undefined superlevelName
expect_error(add_linkDefinition(ae, "ONE_TO_MANY",
superlevelName ="undefinedLevel",
sublevelName = "Tone"))
add_linkDefinition(ae, "ONE_TO_MANY",
superlevelName ="Phoneme",
sublevelName = "Tone")
})
test_that("list = C(R)UD", {
df = list_linkDefinitions(ae)
expect_equal(ncol(df), 3)
expect_equal(nrow(df), 10)
expect_true(df$type[10] == "ONE_TO_MANY")
expect_true(df$superlevelName[10] == "Phoneme")
expect_true(df$sublevelName[10] == "Tone")
})
test_that("remove = CRU(D)", {
# bad call -> bad superlevelName
expect_error(remove_linkDefinition(ae,
superlevelName ="badName",
sublevelName = "Tone"))
# bad call -> bad sublevelName
expect_error(remove_linkDefinition(ae,
superlevelName ="Word",
sublevelName = "badName"))
# bad call -> links present
expect_error(remove_linkDefinition(ae,
superlevelName ="Syllable",
sublevelName = "Tone"))
remove_linkDefinition(ae,
superlevelName ="Phoneme",
sublevelName = "Tone")
df = list_linkDefinitions(ae)
expect_equal(ncol(df), 3)
expect_equal(nrow(df), 9)
})
test_that("remove = CRU(D) with force", {
remove_linkDefinition(ae,
"Word",
"Syllable",
force = TRUE,
verbose = FALSE)
remove_linkDefinition(ae,
"Syllable",
"Phoneme",
force = TRUE,
verbose = FALSE)
ldefs = list_linkDefinitions(ae)
expect_false("Word" %in% ldefs$superlevelName)
expect_false("Phoneme" %in% ldefs$sublevelName)
# TODO: should probably check annot json files & cache as well..
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
##############################
test_that("CRUD operations work for labelGroups", {
# delete, copy and load
unlink(path2db, recursive = TRUE)
file.copy(path2orig,
path2testData,
recursive = TRUE)
ae = load_emuDB(path2db,
inMemoryCache = useInMemoryCache,
verbose = FALSE)
test_that("add = (C)RUD", {
add_labelGroup(ae,
name = 'testLG',
values = c('a', 'b', 'c'))
})
test_that("list = C(R)UD", {
df = list_labelGroups(ae)
expect_true(df$name == 'testLG')
expect_true(df$values =='a; b; c')
})
test_that("remove = CRU(D)", {
# bad call -> bad name
expect_error(remove_labelGroup(ae,
name = 'badName'))
remove_labelGroup(ae,
name = 'testLG')
df = list_labelGroups(ae)
expect_equal(nrow(df), 0)
})
# cleanup
DBI::dbDisconnect(ae$connection)
ae = NULL
unlink(path2db, recursive = TRUE)
})
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.