tests/testthat/test_emuR-database.R

In emuR: Main Package of the EMU Speech Database Management System

context("testing database functions")

aeSampleRate = 20000

dbName = "ae"
path2demoData = file.path(tempdir(),
                          "emuR_demoData")
path2orig = file.path(tempdir(), 
                      "emuR_demoData", 
                      paste0(dbName, emuDB.suffix))
path2testData = file.path(tempdir(), 
                          "emuR_testthat")
path2db = file.path(path2testData, 
                    paste0(dbName, emuDB.suffix))

# extract internalVars from environment .emuR_pkgEnv
internalVars = get("internalVars", 
                   envir = .emuR_pkgEnv)

test_that("database functions work", {
  
  # delete, copy and load
  unlink(path2db, recursive = TRUE)
  unlink(file.path(path2testData, "fromLegacy"), 
         recursive = TRUE)
  file.copy(path2orig, 
            path2testData, 
            recursive = TRUE)
  ae = load_emuDB(path2db, 
                  inMemoryCache = internalVars$testingVars$inMemoryCache, 
                  verbose = FALSE)
  
  # convert and load legacy database
  convert_legacyEmuDB(emuTplPath = file.path(path2demoData, "legacy_ae", "ae.tpl"),
                      targetDir = file.path(path2testData, "fromLegacy"), 
                      dbUUID = ae$UUID, 
                      verbose = FALSE)
  aeFromLegacy = load_emuDB(file.path(path2testData, "fromLegacy", 
                                      paste0(dbName, emuDB.suffix)), 
                            verbose = FALSE)
  
  test_that("function get_legacyFilePath()",{
    primaryTrackFilePath = get_legacyFilePath("/path/to/db",
                                              'BLOCK*/SES*',
                                              c('BLOCK30', 'SES3042', '0001abc'), 
                                              'wav')
    expect_equal(primaryTrackFilePath, 
                 "/path/to/db/BLOCK30/SES3042/0001abc.wav")
    
    signalTrackFilePath = get_legacyFilePath("/path/to/db",
                                             'F0',
                                             c('BLOCK30', 'SES3042', '0001abc'), 
                                             'f0')
    expect_equal(signalTrackFilePath,
                 "/path/to/db/F0/0001abc.f0")
  })
  
  
  test_that("Converted emuDB is equal to original",{
    expect_equal(ae$dbName, aeFromLegacy$dbName)
    expect_equal(ae$UUI, aeFromLegacy$UUID)
    
    origItems = DBI::dbReadTable(ae$connection, "items")
    convItems = DBI::dbReadTable(aeFromLegacy$connection, "items")
    expect_equal(origItems, convItems)
    
    origLabels = DBI::dbReadTable(ae$connection, "labels")
    convLabels = DBI::dbReadTable(aeFromLegacy$connection, "labels")
    expect_equal(origLabels, convLabels)
    
  })
  
  test_that("properties of ae are correct",{
    bp = file.path(path2testData, 'ae_emuDB')
    nbp = normalizePath(path2db)
    
    expect_that(ae$dbName, is_equivalent_to('ae'))
    expect_that(ae$basePath, is_equivalent_to(nbp))
    sesss = list_sessionsDBI(ae)
    expect_that(nrow(sesss), is_equivalent_to(1))
    bndls = list_bundlesDBI(ae)
    expect_that(nrow(bndls), is_equivalent_to(7))
    itCntQ = paste0("SELECT count(*) ",
                    "FROM items ",
                    "WHERE db_uuid = '",ae$UUID,"'")
    
    itCntDf = DBI::dbGetQuery(ae$connection,itCntQ)
    itemCnt = itCntDf[[1]]
    liCntQ = paste0("SELECT count(*) ",
                    "FROM links ",
                    "WHERE db_uuid = '",ae$UUID,"'")
    liCntDf = DBI::dbGetQuery(ae$connection, liCntQ)
    linkCnt = liCntDf[[1]]
    expect_that(itemCnt, is_equivalent_to(736))
    expect_that(linkCnt, is_equivalent_to(785))
  })
  
  test_that("Create emuDB from scratch works",{
    create_emuDB('create_emuDB_test1', path2testData)
    t1BasePath = file.path(path2testData, 'create_emuDB_test1_emuDB')
    t1 = load_emuDB(t1BasePath)
    expect_that(t1$dbName, is_equivalent_to('create_emuDB_test1'))
    t1 = NULL
    unlink(t1BasePath, recursive = TRUE)
  })
  
  test_that("Data types are correct",{
    items = DBI::dbReadTable(ae$connection, 'items')
    
    expect_that(class(items[['seq_idx']]), is_equivalent_to('integer'))
    expect_that(class(items[['item_id']]), is_equivalent_to('integer'))
    expect_that(class(items[['sample_rate']]), is_equivalent_to('numeric'))
    expect_that(class(items[['sample_point']]), is_equivalent_to('integer'))
    expect_that(class(items[['sample_start']]), is_equivalent_to('integer'))
    expect_that(class(items[['sample_dur']]), is_equivalent_to('integer'))
    
    labels = DBI::dbReadTable(ae$connection, 'labels')
    expect_that(class(labels[['label_idx']]), is_equivalent_to('integer'))
    
    links = DBI::dbReadTable(ae$connection,'links')
    expect_that(class(links[['from_id']]), is_equivalent_to('integer'))
    expect_that(class(links[['to_id']]), is_equivalent_to('integer'))
  })
  
  test_that("Test ae samples",{
    
    # aeB1=get.bundle(sessionName='0000',bundleName='msajc003',dbUUID=.test_emu_ae_db_uuid)
    
    bundleAnnotDFs = load_bundleAnnotDFsDBI(ae, "0000", "msajc003")
    aeB1char = bundleAnnotDFsToAnnotJSONchar(ae, bundleAnnotDFs)
    aeB1 = jsonlite::fromJSON(aeB1char, simplifyVector = FALSE)
    
    expect_equivalent(aeB1[['sampleRate']], aeSampleRate)
    
    halfSample = 0.5 / aeSampleRate
    msajc015_lab_values = c(0.300000, 0.350276, 0.425417, 0.496601, 0.558601, 0.639601,
                            0.663601, 0.706601, 0.806601, 1.006101, 1.085101, 1.097601,
                            1.129101, 1.160101, 1.213101, 1.368101, 1.413095, 1.449550,
                            1.464601, 1.500731, 1.578583, 1.623228, 1.653718, 1.717601,
                            1.797463, 1.828601, 1.903635, 2.070101, 2.104101, 2.154601,
                            2.200911, 2.226601, 2.271132, 2.408601, 2.502214, 2.576618,
                            2.606558, 2.693704, 2.749004, 2.780766, 2.798504, 2.876593,
                            2.958101, 3.026668, 3.046168, 3.067703, 3.123168, 3.238668,
                            3.297668,3.456899) 
    msajc015_tone_events = c(0.531305, 1.486760, 1.609948, 2.445220, 2.910929, 3.110782, 
                             3.262078)
    lvCnt = length(msajc015_lab_values)
    teCnt = length(msajc015_tone_events)
    #msajc015_phonetic=ae[['items']][ae[['items']][['bundle']]=="msajc015" & ae[['items']][['level']]=='Phonetic',]
    msajc015_phonetic = DBI::dbGetQuery(ae$connection, 
                                        paste0("SELECT * ",
                                               "FROM items ",
                                               "WHERE db_uuid = '", ae$UUID, "' ",
                                               " AND session='0000' ",
                                               " AND bundle='msajc015' ",
                                               " AND level='Phonetic'"))
    rc = nrow(msajc015_phonetic)
    expect_equivalent(rc + 1, lvCnt)
    # order by sequence index
    msajc015_phonetic_ordered = msajc015_phonetic[order(msajc015_phonetic[['seq_idx']]),]
    rc = nrow(msajc015_phonetic_ordered)
    expect_equivalent(rc + 1, lvCnt)
    
    #msajc015_tone=ae[['items']][ae[['items']][['bundle']]=="msajc015" & ae[['items']][['level']]=='Tone',]
    msajc015_tone = DBI::dbGetQuery(ae$connection, 
                                    paste0("SELECT * ",
                                           "FROM items ",
                                           "WHERE db_uuid = '", ae$UUID, "' ",
                                           " AND session = '0000' ",
                                           " AND bundle = 'msajc015' ",
                                           " AND level = 'Tone'"))
    msajc015_tone_ordered = msajc015_tone[order(msajc015_tone[['seq_idx']]),]
    lvSq = 1:rc
    
    # check sequence
    for(i in lvSq){
      
      poSampleStart = msajc015_phonetic_ordered[i, 'sample_start']
      poSampleDur=msajc015_phonetic_ordered[i,'sample_dur']
      if(i < rc){
        poNextSampleStart = msajc015_phonetic_ordered[i + 1, 'sample_start']
        # TODO
        expect_equivalent(poNextSampleStart, poSampleStart + poSampleDur + 1)
        #expect_equivalent(poNextSampleStart,poSampleStart+poSampleDur+1)
      }
    }
    # check segment boundaries
    for(i in lvSq){
      lv = msajc015_lab_values[i]
      poSampleStart = msajc015_phonetic_ordered[i, 'sample_start']
      poSampleDur = msajc015_phonetic_ordered[i, 'sample_dur']
      poStart = (poSampleStart + 0.5) / aeSampleRate
      absFail = abs(poStart - lv)
      # accept deviation of at least half a sample
      expect_lt(absFail, halfSample)
    }
    # and the last value
    lv = msajc015_lab_values[lvCnt]
    poSampleEnd = msajc015_phonetic_ordered[rc, 'sample_start'] + msajc015_phonetic_ordered[rc, 'sample_dur'] + 1
    poEnd = (poSampleEnd + 0.5) / aeSampleRate
    absFail = abs(poEnd - lv)
    # accept deviation of at least half a sample
    expect_lt(absFail, halfSample)
    
    # check tone events
    teS = 1:teCnt
    for(i in teS){
      teTime = msajc015_tone_events[i]
      teLSample = msajc015_tone_ordered[i, 'sample_point']
      teLTime = teLSample / aeSampleRate
      absFail = abs(teLTime - teTime)
      expect_lt(absFail, halfSample)
    }
    
  })
  
  test_that("Test ae modify",{
    orgItems = DBI::dbGetQuery(ae$connection, 
                               paste0("SELECT * ",
                                      "FROM items ",
                                      "WHERE db_uuid = '",ae$UUID,"'"))
    orgLabels = DBI::dbGetQuery(ae$connection,
                                paste0("SELECT * ",
                                       "FROM labels ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    orgLinks = DBI::dbGetQuery(ae$connection,
                               paste0("SELECT * ",
                                      "FROM links ",
                                      "WHERE db_uuid = '",ae$UUID,"'"))
    
    expect_equivalent(nrow(orgItems),736)
    expect_equivalent(nrow(orgLinks),785)
    # b015=get.bundle(sessionName='0000',bundleName = 'msajc015',dbUUID = .test_emu_ae_db_uuid)
    bundleAnnotDFs = load_bundleAnnotDFsDBI(ae, 
                                            "0000", 
                                            "msajc015")
    b015char = bundleAnnotDFsToAnnotJSONchar(ae, bundleAnnotDFs)
    b015 = jsonlite::fromJSON(b015char, 
                              simplifyVector = FALSE, 
                              na = 'null')
    
    # select arbitrary item
    b015m = b015
    phoneticLvlIt10 = b015m[['levels']][[7]][['items']][[10]]
    lblOrg = phoneticLvlIt10[['labels']][[1]][['value']]
    b015m[['levels']][[7]][['items']][[10]][['labels']][[1]][['value']] = 'test!!'
    
    # convert to bundleAnnotDFs
    b015mChar = jsonlite::toJSON(b015m, 
                                 auto_unbox = TRUE, 
                                 pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015mChar[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015m)
    
    modItems = DBI::dbGetQuery(ae$connection, 
                               paste0("SELECT * ",
                                      "FROM items ",
                                      "WHERE db_uuid = '",ae$UUID,"'"))
    modLabels = DBI::dbGetQuery(ae$connection, 
                                paste0("SELECT * ",
                                       "FROM labels ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    modLinks = DBI::dbGetQuery(ae$connection, 
                               paste0("SELECT * ",
                                      "FROM links ",
                                      "WHERE db_uuid = '",ae$UUID,"'"))
    
    expect_equivalent(nrow(modItems), 736)
    expect_equivalent(nrow(modLinks), 785)
    
    # change only affects labels
    # items should be equal
    expect_equal(orgItems, modItems)
    # labels not
    cmLbls1 = compare::compare(orgLabels, 
                               modLabels, 
                               allowAll = TRUE)
    expect_false(cmLbls1$result)
    # links are not changed, should be equal to original
    expect_equal(orgLinks, modLinks)
    
    b015m[['levels']][[7]][['items']][[10]][['sampleDur']] = 99
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015m)
    # convert to bundleAnnotDFs
    b015mChar = jsonlite::toJSON(b015m, 
                                 auto_unbox = TRUE, 
                                 pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015mChar[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    
    mod2Items = DBI::dbGetQuery(ae$connection,
                                paste0("SELECT * ",
                                       "FROM items ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    mod2Labels = DBI::dbGetQuery(ae$connection,
                                 paste0("SELECT * ",
                                        "FROM labels ",
                                        "WHERE db_uuid = '",ae$UUID,"'"))
    mod2Links = DBI::dbGetQuery(ae$connection,
                                paste0("SELECT * ",
                                       "FROM links ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    
    expect_equivalent(nrow(mod2Items), 736)
    expect_equivalent(nrow(mod2Links), 785)
    #   
    #   # should all be equal to original 
    cm2 = compare::compare(orgItems, 
                           mod2Items,
                           allowAll = TRUE)
    expect_false(cm2$result)
    cmLbls2 = compare::compare(orgLabels,
                               mod2Labels,
                               allowAll = TRUE)
    expect_false(cmLbls2$result)
    cml2 = compare::compare(orgLinks,
                            mod2Links,
                            allowAll = TRUE)
    expect_true(cml2$result)
    
    # remove link
    b015Lks = b015m[['links']]
    b015LksM = list()
    for(b015Lk in b015Lks){
      if(!(b015Lk[['fromID']] == 177 & b015Lk[['toID']] == 224)){
        b015LksM[[length(b015LksM) + 1]] = b015Lk
      }
    }
    b015m2 = b015m
    b015m2[['links']] = b015LksM
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015m2)
    # convert to bundleAnnotDFs and store
    b015m2Char = jsonlite::toJSON(b015m2, 
                                  auto_unbox = TRUE, 
                                  pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015m2Char[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    
    mod3Items = DBI::dbGetQuery(ae$connection,
                                paste0("SELECT * ",
                                       "FROM items ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    mod3Labels = DBI::dbGetQuery(ae$connection,
                                 paste0("SELECT * ",
                                        "FROM labels ",
                                        "WHERE db_uuid = '",ae$UUID,"'"))
    mod3Links = DBI::dbGetQuery(ae$connection,
                                paste0("SELECT * ",
                                       "FROM links ",
                                       "WHERE db_uuid = '",ae$UUID,"'"))
    
    expect_equivalent(nrow(mod3Items), 736)
    expect_equivalent(nrow(mod3Links), 784)
    
    cm3 = compare::compare(mod3Items,
                           mod2Items,
                           allowAll = TRUE)
    expect_true(cm3$result)
    cmLbls3 = compare::compare(mod2Labels,
                               mod3Labels,
                               allowAll = TRUE)
    expect_true(cmLbls3$result)
    cml3 = compare::compare(mod3Links,
                            mod2Links,
                            allowAll = TRUE)
    expect_false(cml3$result)
    
    # insert the link again
    # b015m3=get.bundle(dbUUID = .test_emu_ae_db_uuid,sessionName = '0000',bundleName = 'msajc015')
    bundleAnnotDFs = load_bundleAnnotDFsDBI(ae, 
                                            "0000", 
                                            "msajc015")
    b015m3char = bundleAnnotDFsToAnnotJSONchar(ae, bundleAnnotDFs)
    b015m3 = jsonlite::fromJSON(b015m3char, 
                                simplifyVector = FALSE, 
                                na = 'null')
    
    b015m3Lks = b015m3[['links']]
    b015m3Lks[[length(b015m3Lks) + 1]] = list(fromID = 177,
                                              toID = 224)
    b015m3[['links']] = b015m3Lks
    
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015m3)
    # convert to bundleAnnotDFs and store
    b015m3Char = jsonlite::toJSON(b015m3, 
                                  auto_unbox = TRUE, 
                                  pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015m3Char[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    
    mod4Links=DBI::dbGetQuery(ae$connection, 
                              paste0("SELECT * ",
                                     "FROM links ",
                                     "WHERE db_uuid = '",ae$UUID,"'"))
    cml3 = compare::compare(orgLinks,
                            mod4Links,
                            allowAll = TRUE)
    expect_true(cml3$result)
    
    #   
    #   # TODO move segment boundaries, change links,etc...
    #   
    #   
    
    #   # store original bundle
    
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015)
    # convert to bundleAnnotDFs and store
    b015Char = jsonlite::toJSON(b015, 
                                auto_unbox = TRUE, 
                                pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015Char[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    
    #   
    modOrgItems = DBI::dbGetQuery(ae$connection,
                                  paste0("SELECT * ",
                                         "FROM items ",
                                         "WHERE db_uuid = '",ae$UUID,"'"))
    modOrgLabels = DBI::dbGetQuery(ae$connection,
                                   paste0("SELECT * ",
                                          "FROM labels ",
                                          "WHERE db_uuid = '",ae$UUID,"'"))
    modOrgLinks = DBI::dbGetQuery(ae$connection,
                                  paste0("SELECT * ",
                                         "FROM links ",
                                         "WHERE db_uuid = '",ae$UUID,"'"))
    
    expect_equivalent(nrow(modOrgItems), 736)
    expect_equivalent(nrow(modOrgLinks), 785)
    
    #   
    #   # should all be equal to original 
    cm2 = compare::compare(orgItems,
                           modOrgItems,
                           allowAll = TRUE)
    expect_true(cm2$result)
    cmLbls2 = compare::compare(dplyr::arrange(orgLabels, 
                                              bundle, 
                                              item_id), 
                               dplyr::arrange(modOrgLabels, 
                                              bundle, 
                                              item_id))
    compare::compare(orgLabels, 
                     modOrgLabels,
                     allowAll = TRUE)
    expect_true(cmLbls2$result)
    cml2 = compare::compare(orgLinks,
                            modOrgLinks,
                            allowAll = TRUE)
    expect_true(cml2$result)
    
    b015ModInsrt = b015
    # insert segment
    its = b015ModInsrt[['levels']][[7]][['items']]
    
    #b$levels[['Phonetic']][['items']][[9]]
    #$id
    #[1] 193
    #
    #$sampleStart
    #[1] 16132
    #  
    #$sampleDur
    #[1] 3989
    #
    #$labels
    #$labels[[1]]
    #$labels[[1]]$name
    #[1] "Phonetic"
    #
    #$labels[[1]]$value
    #[1] "ai"
    
    # split this item:
    # shrink item to length 3500
    b015ModInsrt[['levels']][[7]][['items']][[9]]$sampleDur = 3500
    b015ModInsrt[['levels']][[7]][['items']][[9]]$labels[[1]]$value = 'a'
    
    # shift items to the right to free index 10
    itCnt = length(b015ModInsrt[['levels']][[7]][['items']])
    shiftSeq = itCnt:10
    
    for(itIdx in shiftSeq){
      b015ModInsrt[['levels']][[7]][['items']][[itIdx+1]] = b015ModInsrt[['levels']][[7]][['items']][[itIdx]]
    }
    
    # insert item at index 10
    itLbl = list(name = 'Phonetic',
                 value = 'i')
    itLbls = list(itLbl)
    insertIt = list(id = 999,
                    sampleStart = 19633,
                    sampleDur = 488,
                    labels = itLbls)
    b015ModInsrt[['levels']][[7]][['items']][[10]] = insertIt
    
    # store.bundle.annotation(dbUUID=.test_emu_ae_db_uuid,bundle=b015ModInsrt)
    # convert to bundleAnnotDFs and store
    b015ModInsrtChar = jsonlite::toJSON(b015ModInsrt, 
                                        auto_unbox = TRUE, 
                                        pretty = TRUE)
    bundleAnnotDFs = annotJSONcharToBundleAnnotDFs(b015ModInsrtChar[1])
    remove_bundleAnnotDBI(ae, 
                          "0000", 
                          bundleName = "msajc015")
    store_bundleAnnotDFsDBI(ae, 
                            bundleAnnotDFs, 
                            "0000", 
                            "msajc015")
    
    # read again
    # b015Read=get.bundle(sessionName='0000',bundleName = 'msajc015',dbUUID = .test_emu_ae_db_uuid)
    bundleAnnotDFs = load_bundleAnnotDFsDBI(ae, 
                                            "0000", 
                                            "msajc015")
    b015ReadChar = bundleAnnotDFsToAnnotJSONchar(ae, bundleAnnotDFs)
    b015Read = jsonlite::fromJSON(b015ReadChar, 
                                  simplifyVector = FALSE, 
                                  na = 'null')
    rItCnt = length(b015Read[['levels']][[7]][['items']])
    # check insert sequence
    for(itIdx in 1:9){
      expect_equal(b015[['levels']][[7]][['items']][[itIdx]][['id']], 
                   b015Read[['levels']][[7]][['items']][[itIdx]][['id']])
    }
    expect_equivalent(b015Read[['levels']][[7]][['items']][[10]]$id, 999)
    
    for(itIdx in 11:rItCnt){
      expect_equal(b015[['levels']][[7]][['items']][[itIdx-1]][['id']],
                   b015Read[['levels']][[7]][['items']][[itIdx]][['id']])
    }
    
    
  })
  ######################
  # cleanup
  
  # delete vars to be safe (& to diconnect)
  DBI::dbDisconnect(ae$connection)
  DBI::dbDisconnect(aeFromLegacy$connection)
  ae = NULL
  aeFromLegacy = NULL
  
  unlink(file.path(path2testData, "fromLegacy"), recursive = TRUE)
  unlink(unlink(path2db, recursive = TRUE), recursive = TRUE)
})

test_that("store works correctly",{
  
  # delete, copy and load
  unlink(path2db, recursive = TRUE)
  unlink(file.path(path2testData, "fromStore"), 
         recursive = TRUE)
  file.copy(path2orig, 
            path2testData, 
            recursive = TRUE)
  ae = load_emuDB(path2db, 
                  inMemoryCache = internalVars$testingVars$inMemoryCache, 
                  verbose = FALSE)
  
  newFolderPath = file.path(path2testData, "fromStore")
  unlink(newFolderPath, recursive = TRUE)
  store(ae, 
        targetDir = newFolderPath, 
        verbose = FALSE)
  aeStored = load_emuDB(file.path(newFolderPath, "ae_emuDB"), 
                        verbose = FALSE)
  
  aeItems=DBI::dbGetQuery(ae$connection,paste0("SELECT * ",
                                               "FROM items ",
                                               "WHERE db_uuid = '",ae$UUID,"'"))
  aeLabels=DBI::dbGetQuery(ae$connection,paste0("SELECT * ",
                                                "FROM labels ",
                                                "WHERE db_uuid = '",ae$UUID,"'"))
  aeLinks=DBI::dbGetQuery(ae$connection,paste0("SELECT * ",
                                               "FROM links ",
                                               "WHERE db_uuid = '",ae$UUID,"'"))
  
  aeStoredItems=DBI::dbGetQuery(aeStored$connection,paste0("SELECT * ",
                                                           "FROM items ",
                                                           "WHERE db_uuid = '",aeStored$UUID,"'"))
  aeStoredLabels=DBI::dbGetQuery(aeStored$connection,paste0("SELECT * ",
                                                            "FROM labels ",
                                                            "WHERE db_uuid = '",aeStored$UUID,"'"))
  aeStoredLinks=DBI::dbGetQuery(aeStored$connection,paste0("SELECT * ",
                                                           "FROM links ",
                                                           "WHERE db_uuid = '",aeStored$UUID,"'"))
  
  # check that all tabels are the same
  # expect_equal(aeItems, aeStoredItems) # new index on items table results in different seq. of items hence:
  cres = compare::compare(aeItems, 
                          aeStoredItems, 
                          allowAll = TRUE)
  expect_true(cres$result)
  expect_equal(aeLabels, aeStoredLabels)
  expect_equal(aeLinks, aeStoredLinks)
  
  ####################
  # cleanup
  
  # delete vars to be safe (& to diconnect  ae = NULL
  DBI::dbDisconnect(aeStored$connection)
  DBI::dbDisconnect(ae$connection)
  aeStored = NULL
  ae = NULL
  unlink(file.path(path2testData, "fromStore"), recursive = TRUE)
  unlink(path2db, recursive = TRUE)
})

test_that("rename emuDB works correctly",{
  skip_on_cran() # for some reason fails on cran’s windows machines, but I confirmed that it works on windows. So skip.
  skip_on_os("windows")
  
  # delete, copy and load
  unlink(path2db, recursive = TRUE)
  unlink(file.path(path2testData, "fromStore"), 
         recursive = TRUE)
  file.copy(path2orig, 
            path2testData, 
            recursive = TRUE)
  
  rename_emuDB(path2db, "aeRename")
  newPath = file.path(path2testData, 
                      paste0("aeRename", "_emuDB"))
  
  DBconfig = jsonlite::fromJSON(file.path(newPath, "aeRename_DBconfig.json"), 
                                simplifyVector = FALSE)
  expect_equal(DBconfig$name, "aeRename")
  
  expect_true("aeRename_emuDB" %in% list.files(path2testData))
  expect_true("aeRename_emuDBcache.sqlite" %in% list.files(newPath))
  
  # cleanup
  unlink(newPath, recursive = TRUE)
})

test_that("rename bundles works correctly",{
  
  # delete, copy and load
  unlink(path2db, recursive = TRUE)
  unlink(file.path(path2testData, "fromStore"), 
         recursive = TRUE)
  file.copy(path2orig, 
            path2testData, 
            recursive = TRUE)
  
  db = load_emuDB(path2db, verbose = FALSE)
  bundles = list_bundles(db)
  # missing col
  expect_error(rename_bundles(db, bundles))
  bundles$name_new = paste0(bundles$name, "XXX")
  # bad bundle/session names
  bad_bundles = bundles
  bad_bundles[1,]$name = "bad_bundle_name"
  expect_error(rename_bundles(db, bad_bundles))
  bad_bundles = bundles
  bad_bundles[1,]$session = "bad_session_name"
  expect_error(rename_bundles(db, bad_bundles))
  
    
  rename_bundles(db, bundles)
  
  new_bundles = list_bundles(db)
  
  expect_true(all(stringr::str_detect(new_bundles$name, "XXX"))) 
  
  new_bundles = list_bundlesDBI(db)
  
  expect_true(all(stringr::str_detect(new_bundles$name, "XXX"))) 
  
  files = list_files(db)
  
  expect_true(all(stringr::str_detect(files$bundle, "XXX"))) 
  expect_true(all(stringr::str_detect(files$file, "XXX")))
  expect_true(all(stringr::str_detect(files$absolute_file_path, "XXX"))) 
  
  # cleanup
  DBI::dbDisconnect(db$connection)
  db = NULL
  unlink(path2db, recursive = TRUE)
})


test_that("load of read only emuDB works",{
  skip_on_cran() # probably won't work on windows (because of mode) so skip on cran
  skip_on_os("windows")
  
  # delete, copy and load
  unlink(path2db, recursive = TRUE)
  unlink(file.path(path2testData, "fromStore"), 
         recursive = TRUE)
  file.copy(path2orig, 
            path2testData, 
            recursive = TRUE)
  
  # change emuDB folder to r-x only for everyone
  Sys.chmod(path2db, mode = "555")
  ae = load_emuDB(path2db, 
                  inMemoryCache = internalVars$testingVars$inMemoryCache, 
                  verbose = FALSE)
  sl = query(ae, "Phonetic == n")
  expect_true("tbl_df" %in% class(sl))
  Sys.chmod(path2db, mode = "755") # change back
  
  # change emuDBcache.sqlite to 
  Sys.chmod(file.path(path2db, "ae_emuDBcache.sqlite"), mode = "555")
  ae = load_emuDB(path2db, 
                  inMemoryCache = internalVars$testingVars$inMemoryCache, 
                  verbose = FALSE)
  sl = query(ae, "Phonetic == n")
  expect_true("tbl_df" %in% class(sl))
  Sys.chmod(path2db, mode = "755") # change back
  
  # cleanup
  DBI::dbDisconnect(ae$connection)
  ae = NULL
  unlink(path2db, recursive = TRUE)
})