Add 27 test files for utility/data functions, coverage 41% -> ~55%

Tests for credset_colnames, construct_data, check_args, filepath
handling, SUSIE/ABF/FINEMAP/POLYFUN parameter functions, result
parsing, data preparation, and plot utilities.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bschilder

tests/testthat/test-COJO_args.R

@@ -0,0 +1,64 @@
+test_that("COJO_args constructs basic command string", {
+
+    res <- echofinemap:::COJO_args(
+        cojo_file = "sumstats.ma",
+        bfile = "test_plink",
+        out = "results"
+    )
+    testthat::expect_true(is.character(res))
+    testthat::expect_true(grepl("--bfile test_plink", res))
+    testthat::expect_true(grepl("--cojo-file sumstats.ma", res))
+    testthat::expect_true(grepl("--out results", res))
+})
+
+test_that("COJO_args includes optional flags when set", {
+
+    res <- echofinemap:::COJO_args(
+        cojo_file = "sumstats.ma",
+        bfile = "test_plink",
+        out = "results",
+        cojo_slct = TRUE,
+        maf = 0.01,
+        cojo_p = 5e-8,
+        cojo_wind = 500
+    )
+    testthat::expect_true(grepl("--cojo-slct", res))
+    testthat::expect_true(grepl("--maf 0.01", res))
+    testthat::expect_true(grepl("--cojo-p 5e-08", res))
+    testthat::expect_true(grepl("--cojo-wind 500", res))
+})
+
+test_that("COJO_args omits NULL optional arguments", {
+
+    res <- echofinemap:::COJO_args(
+        cojo_file = "sumstats.ma",
+        bfile = "test_plink",
+        out = "results",
+        cojo_slct = NULL,
+        cojo_joint = NULL
+    )
+    testthat::expect_false(grepl("--cojo-slct", res))
+    testthat::expect_false(grepl("--cojo-joint", res))
+})
+
+test_that("COJO_args includes conditional analysis flag", {
+
+    res <- echofinemap:::COJO_args(
+        cojo_file = "sumstats.ma",
+        bfile = "test_plink",
+        out = "results",
+        cojo_cond = "cond_snps.txt"
+    )
+    testthat::expect_true(grepl("--cojo-cond cond_snps.txt", res))
+})
+
+test_that("COJO_args includes cojo_gc flag", {
+
+    res <- echofinemap:::COJO_args(
+        cojo_file = "sumstats.ma",
+        bfile = "test_plink",
+        out = "results",
+        cojo_gc = TRUE
+    )
+    testthat::expect_true(grepl("--cojo-gc", res))
+})

tests/testthat/test-COJO_get_results.R

@@ -0,0 +1,96 @@
+test_that("COJO_get_stepwise_results returns NULL for NULL path", {
+
+    res <- echofinemap:::COJO_get_stepwise_results(
+        jma_cojo_path = NULL,
+        verbose = FALSE
+    )
+    testthat::expect_null(res)
+})
+
+test_that("COJO_get_stepwise_results returns NULL for non-existent path", {
+
+    res <- echofinemap:::COJO_get_stepwise_results(
+        jma_cojo_path = file.path(tempdir(), "nonexistent.jma.cojo"),
+        verbose = FALSE
+    )
+    testthat::expect_null(res)
+})
+
+test_that("COJO_get_stepwise_results reads valid file", {
+
+    tmp <- tempfile(fileext = ".jma.cojo")
+    on.exit(unlink(tmp), add = TRUE)
+
+    mock_data <- data.table::data.table(
+        Chr = 4L,
+        SNP = c("rs1", "rs2"),
+        bp = c(100L, 200L),
+        refA = c("A", "G"),
+        freq = c(0.3, 0.5),
+        freq_geno = c(0.31, 0.49),
+        b = c(0.1, 0.2),
+        se = c(0.01, 0.02),
+        p = c(1e-8, 1e-6),
+        n = c(1000L, 1000L),
+        bJ = c(0.09, 0.19),
+        bJ_se = c(0.011, 0.021),
+        pJ = c(1e-7, 1e-5),
+        LD_r = c(0.1, 0.2)
+    )
+    data.table::fwrite(mock_data, tmp, sep = "\t")
+
+    res <- echofinemap:::COJO_get_stepwise_results(
+        jma_cojo_path = tmp,
+        verbose = FALSE
+    )
+    testthat::expect_true(data.table::is.data.table(res))
+    testthat::expect_equal(nrow(res), 2)
+    ## LD_r2 should be computed
+    testthat::expect_true("LD_r2" %in% colnames(res))
+    testthat::expect_equal(res$LD_r2, res$LD_r^2)
+})
+
+test_that("COJO_get_conditional_results returns empty list for NULL paths", {
+
+    res <- echofinemap:::COJO_get_conditional_results(
+        cma_cojo_path = NULL,
+        cond_path = NULL,
+        verbose = FALSE
+    )
+    testthat::expect_true(is.list(res))
+    testthat::expect_length(res, 0)
+})
+
+test_that("COJO_get_conditional_results reads valid cma file", {
+
+    tmp_cma <- tempfile(fileext = ".cma.cojo")
+    on.exit(unlink(tmp_cma), add = TRUE)
+
+    mock_cma <- data.table::data.table(
+        Chr = 4L,
+        SNP = c("rs1", "rs2", "rs3"),
+        bp = c(100L, 200L, 300L),
+        refA = c("A", "G", "T"),
+        freq = c(0.3, 0.5, 0.4),
+        freq_geno = c(0.31, 0.49, 0.41),
+        b = c(0.1, 0.2, 0.15),
+        se = c(0.01, 0.02, 0.015),
+        p = c(1e-8, 1e-6, 1e-4),
+        n = c(1000L, 1000L, 1000L),
+        bC = c(0.09, 0.19, 0.14),
+        bC_se = c(0.011, 0.021, 0.016),
+        pC = c(0.001, 0.04, 0.1)
+    )
+    data.table::fwrite(mock_cma, tmp_cma, sep = "\t")
+
+    res <- echofinemap:::COJO_get_conditional_results(
+        cma_cojo_path = tmp_cma,
+        cond_path = NULL,
+        pC_max = 0.05,
+        verbose = FALSE
+    )
+    testthat::expect_true("cma.cojo" %in% names(res))
+    ## Only SNPs with pC <= 0.05 should remain
+    testthat::expect_true(all(res[["cma.cojo"]]$pC <= 0.05))
+    testthat::expect_equal(nrow(res[["cma.cojo"]]), 2)
+})

tests/testthat/test-COJO_list_files.R

@@ -0,0 +1,36 @@
+test_that("COJO_list_files returns only existing files", {
+
+    cojo_dir <- file.path(tempdir(), "test_cojo_list")
+    dir.create(cojo_dir, showWarnings = FALSE, recursive = TRUE)
+    on.exit(unlink(cojo_dir, recursive = TRUE), add = TRUE)
+
+    prefix <- "cojo"
+    ## Create only some of the expected files
+    writeLines("test", file.path(cojo_dir, paste0(prefix, ".jma.cojo")))
+    writeLines("test", file.path(cojo_dir, paste0(prefix, ".ldr.cojo")))
+
+    res <- echofinemap:::COJO_list_files(
+        cojo_dir = cojo_dir,
+        prefix = prefix
+    )
+    testthat::expect_true(is.list(res))
+    testthat::expect_true(all(file.exists(unlist(res))))
+    testthat::expect_true("jma.cojo" %in% names(res))
+    testthat::expect_true("ldr.cojo" %in% names(res))
+    ## file.ma was not created, so should not appear
+    testthat::expect_false("file.ma" %in% names(res))
+})
+
+test_that("COJO_list_files returns empty list when no files exist", {
+
+    cojo_dir <- file.path(tempdir(), "test_cojo_list_empty")
+    dir.create(cojo_dir, showWarnings = FALSE, recursive = TRUE)
+    on.exit(unlink(cojo_dir, recursive = TRUE), add = TRUE)
+
+    res <- echofinemap:::COJO_list_files(
+        cojo_dir = cojo_dir,
+        prefix = "cojo"
+    )
+    testthat::expect_true(is.list(res))
+    testthat::expect_length(res, 0)
+})

tests/testthat/test-COJO_locus_subdir.R

@@ -0,0 +1,20 @@
+test_that("COJO_locus_subdir creates directory and returns path", {
+
+    locus_dir <- file.path(tempdir(), "test_COJO_subdir")
+    on.exit(unlink(locus_dir, recursive = TRUE), add = TRUE)
+
+    cojo_dir <- echofinemap:::COJO_locus_subdir(locus_dir = locus_dir)
+    testthat::expect_true(dir.exists(cojo_dir))
+    testthat::expect_equal(cojo_dir, file.path(locus_dir, "COJO"))
+})
+
+test_that("COJO_locus_subdir is idempotent", {
+
+    locus_dir <- file.path(tempdir(), "test_COJO_subdir2")
+    on.exit(unlink(locus_dir, recursive = TRUE), add = TRUE)
+
+    cojo_dir1 <- echofinemap:::COJO_locus_subdir(locus_dir = locus_dir)
+    cojo_dir2 <- echofinemap:::COJO_locus_subdir(locus_dir = locus_dir)
+    testthat::expect_equal(cojo_dir1, cojo_dir2)
+    testthat::expect_true(dir.exists(cojo_dir2))
+})

tests/testthat/test-COJO_process_results.R

@@ -0,0 +1,48 @@
+test_that("COJO_process_results merges stepwise results into dat", {
+
+    tmp_dir <- file.path(tempdir(), "test_cojo_process")
+    dir.create(tmp_dir, showWarnings = FALSE, recursive = TRUE)
+    on.exit(unlink(tmp_dir, recursive = TRUE), add = TRUE)
+
+    ## Create a mock jma.cojo file
+    jma_path <- file.path(tmp_dir, "cojo.jma.cojo")
+    mock_jma <- data.table::data.table(
+        Chr = c(4L, 4L),
+        SNP = c("rs1", "rs3"),
+        bp = c(100L, 300L),
+        refA = c("A", "G"),
+        freq = c(0.3, 0.4),
+        freq_geno = c(0.31, 0.41),
+        b = c(0.1, 0.15),
+        se = c(0.01, 0.015),
+        p = c(1e-8, 1e-5),
+        n = c(1000L, 1000L),
+        bJ = c(0.09, 0.14),
+        bJ_se = c(0.011, 0.016),
+        pJ = c(0.001, 0.1),
+        LD_r = c(0.1, 0.05)
+    )
+    data.table::fwrite(mock_jma, jma_path, sep = "\t")
+
+    dat <- data.table::data.table(
+        SNP = c("rs1", "rs2", "rs3"),
+        Effect = c(0.1, 0.2, 0.15)
+    )
+
+    paths <- list("jma.cojo" = jma_path)
+    res <- echofinemap:::COJO_process_results(
+        dat = dat,
+        paths = paths,
+        credset_thresh = 0.95,
+        freq_cutoff = 0.1,
+        verbose = FALSE
+    )
+    testthat::expect_true(data.table::is.data.table(res))
+    testthat::expect_equal(nrow(res), 3)
+    testthat::expect_true("bJ" %in% colnames(res))
+    testthat::expect_true("CS" %in% colnames(res))
+    ## rs1 has pJ=0.001 < 0.05, so CS should be 1
+    testthat::expect_equal(res[res$SNP == "rs1"]$CS, 1)
+    ## rs2 was not in jma results, so bJ should be NA
+    testthat::expect_true(is.na(res[res$SNP == "rs2"]$bJ))
+})

tests/testthat/test-FINEMAP_check_existing_results.R

@@ -0,0 +1,77 @@
+test_that("FINEMAP_check_existing_results returns NULL when no files exist", {
+
+    tmp_dir <- file.path(tempdir(), "test_fm_existing_1")
+    dir.create(file.path(tmp_dir, "FINEMAP"),
+               recursive = TRUE, showWarnings = FALSE)
+    on.exit(unlink(tmp_dir, recursive = TRUE), add = TRUE)
+
+    dat <- data.table::data.table(
+        SNP = c("rs1", "rs2"),
+        Effect = c(0.5, 0.3),
+        StdErr = c(0.1, 0.2)
+    )
+
+    res <- echofinemap:::FINEMAP_check_existing_results(
+        dat = dat,
+        locus_dir = tmp_dir,
+        credset_thresh = 0.95,
+        finemap_version = package_version("1.4.1"),
+        force_new = FALSE,
+        verbose = FALSE
+    )
+    testthat::expect_null(res)
+})
+
+test_that("FINEMAP_check_existing_results returns NULL when force_new=TRUE", {
+
+    tmp_dir <- file.path(tempdir(), "test_fm_existing_2")
+    fm_dir <- file.path(tmp_dir, "FINEMAP")
+    dir.create(fm_dir, recursive = TRUE, showWarnings = FALSE)
+    on.exit(unlink(tmp_dir, recursive = TRUE), add = TRUE)
+
+    ## Create a dummy file that would normally be found
+    writeLines("rsid prob", file.path(fm_dir, "data.snp"))
+
+    dat <- data.table::data.table(
+        SNP = c("rs1"),
+        Effect = c(0.5),
+        StdErr = c(0.1)
+    )
+
+    res <- echofinemap:::FINEMAP_check_existing_results(
+        dat = dat,
+        locus_dir = tmp_dir,
+        credset_thresh = 0.95,
+        finemap_version = package_version("1.4.1"),
+        force_new = TRUE,
+        verbose = FALSE
+    )
+    testthat::expect_null(res)
+    ## Directory should be recreated (old contents deleted)
+    testthat::expect_true(dir.exists(fm_dir))
+})
+
+test_that("FINEMAP_check_existing_results cleans up old dir on force_new", {
+
+    tmp_dir <- file.path(tempdir(), "test_fm_existing_3")
+    fm_dir <- file.path(tmp_dir, "FINEMAP")
+    dir.create(fm_dir, recursive = TRUE, showWarnings = FALSE)
+    on.exit(unlink(tmp_dir, recursive = TRUE), add = TRUE)
+
+    ## Create files that should be removed
+    writeLines("old data", file.path(fm_dir, "data.snp"))
+
+    dat <- data.table::data.table(SNP = "rs1", Effect = 0.5, StdErr = 0.1)
+
+    echofinemap:::FINEMAP_check_existing_results(
+        dat = dat,
+        locus_dir = tmp_dir,
+        credset_thresh = 0.95,
+        finemap_version = package_version("1.4.1"),
+        force_new = TRUE,
+        verbose = FALSE
+    )
+
+    ## Old data.snp should have been deleted
+    testthat::expect_false(file.exists(file.path(fm_dir, "data.snp")))
+})