# Tests for createConceptSetCohort(), cohortToJson(), and supporting internals

# ============================================================
# Test helpers
# ============================================================

make_cs_expr <- function(concept_ids = 201826L, domain = "Condition") {
  items <- lapply(concept_ids, function(cid) {
    list(
      concept = list(
        CONCEPT_ID               = cid,
        CONCEPT_NAME             = "",
        DOMAIN_ID                = domain,
        VOCABULARY_ID            = "",
        CONCEPT_CLASS_ID         = "",
        STANDARD_CONCEPT         = "S",
        STANDARD_CONCEPT_CAPTION = "Standard",
        CONCEPT_CODE             = "",
        INVALID_REASON           = "V",
        INVALID_REASON_CAPTION   = "Valid"
      ),
      isExcluded         = FALSE,
      includeDescendants = FALSE,
      includeMapped      = FALSE
    )
  })
  list(items = items)
}

# ============================================================
# domainToCriteria (internal)
# ============================================================

test_that("domainToCriteria maps all supported domains", {
  f <- tidyOhdsiSolutions:::domainToCriteria
  expect_equal(f("condition")$criteriaKey,   "ConditionOccurrence")
  expect_equal(f("drug")$criteriaKey,        "DrugExposure")
  expect_equal(f("procedure")$criteriaKey,   "ProcedureOccurrence")
  expect_equal(f("observation")$criteriaKey, "Observation")
  expect_equal(f("measurement")$criteriaKey, "Measurement")
  expect_equal(f("visit")$criteriaKey,       "VisitOccurrence")
  expect_equal(f("device")$criteriaKey,      "DeviceExposure")
})

test_that("domainToCriteria returns correct sourceKey for each domain", {
  f <- tidyOhdsiSolutions:::domainToCriteria
  expect_equal(f("condition")$sourceKey,   "ConditionSourceConcept")
  expect_equal(f("drug")$sourceKey,        "DrugSourceConcept")
  expect_equal(f("procedure")$sourceKey,   "ProcedureSourceConcept")
  expect_equal(f("observation")$sourceKey, "ObservationSourceConcept")
  expect_equal(f("measurement")$sourceKey, "MeasurementSourceConcept")
  expect_equal(f("visit")$sourceKey,       "VisitSourceConcept")
  expect_equal(f("device")$sourceKey,      "DeviceSourceConcept")
})

test_that("domainToCriteria is case-insensitive", {
  f <- tidyOhdsiSolutions:::domainToCriteria
  expect_equal(f("Condition")$criteriaKey, "ConditionOccurrence")
  expect_equal(f("DRUG")$criteriaKey,      "DrugExposure")
  expect_equal(f("Measurement")$criteriaKey, "Measurement")
})

test_that("domainToCriteria errors on unsupported domain", {
  expect_error(
    tidyOhdsiSolutions:::domainToCriteria("specimen"),
    "Unsupported domain"
  )
  expect_error(
    tidyOhdsiSolutions:::domainToCriteria(""),
    "Unsupported domain"
  )
})

# ============================================================
# buildCirceConceptSet (internal)
# ============================================================

test_that("buildCirceConceptSet returns correct top-level fields", {
  expr   <- make_cs_expr()
  result <- tidyOhdsiSolutions:::buildCirceConceptSet(expr, id = 5L, name = "Test CS")
  expect_equal(result$id, 5L)
  expect_equal(result$name, "Test CS")
  expect_type(result$expression$items, "list")
})

test_that("buildCirceConceptSet preserves item count", {
  expr   <- make_cs_expr(c(1L, 2L, 3L))
  result <- tidyOhdsiSolutions:::buildCirceConceptSet(expr)
  expect_length(result$expression$items, 3L)
})

test_that("buildCirceConceptSet errors when items are missing", {
  expect_error(
    tidyOhdsiSolutions:::buildCirceConceptSet(list(foo = "bar")),
    "items"
  )
})

# ============================================================
# getConceptSetDomains (internal)
# ============================================================

test_that("getConceptSetDomains returns unique lowercase domains", {
  expr <- list(items = list(
    list(concept = list(CONCEPT_ID = 1L, DOMAIN_ID = "Condition")),
    list(concept = list(CONCEPT_ID = 2L, DOMAIN_ID = "Condition")),
    list(concept = list(CONCEPT_ID = 3L, DOMAIN_ID = "Drug"))
  ))
  domains <- tidyOhdsiSolutions:::getConceptSetDomains(expr)
  expect_equal(sort(domains), c("condition", "drug"))
})

test_that("getConceptSetDomains lowercases domain", {
  expr    <- make_cs_expr()
  domains <- tidyOhdsiSolutions:::getConceptSetDomains(expr)
  expect_equal(domains, "condition")
})

# ============================================================
# buildEndStrategy (internal)
# ============================================================

test_that("buildEndStrategy observation_period_end_date returns DateOffset with 0", {
  result <- tidyOhdsiSolutions:::buildEndStrategy("observation_period_end_date")
  expect_equal(result$DateOffset$Offset, 0L)
  expect_equal(result$DateOffset$DateField, "EndDate")
})

test_that("buildEndStrategy fixed_exit startDate with offset", {
  result <- tidyOhdsiSolutions:::buildEndStrategy(
    "fixed_exit",
    endArgs = list(index = "startDate", offsetDays = 90)
  )
  expect_equal(result$DateOffset$DateField, "StartDate")
  expect_equal(result$DateOffset$Offset, 90L)
})

test_that("buildEndStrategy fixed_exit endDate", {
  result <- tidyOhdsiSolutions:::buildEndStrategy(
    "fixed_exit",
    endArgs = list(index = "endDate", offsetDays = 0)
  )
  expect_equal(result$DateOffset$DateField, "EndDate")
})

test_that("buildEndStrategy fixed_exit defaults offsetDays to 0", {
  result <- tidyOhdsiSolutions:::buildEndStrategy("fixed_exit", endArgs = list())
  expect_equal(result$DateOffset$Offset, 0L)
})

test_that("buildEndStrategy drug_exit returns CustomEra", {
  result <- tidyOhdsiSolutions:::buildEndStrategy(
    "drug_exit",
    endArgs   = list(persistenceWindow = 14, surveillanceWindow = 7),
    codesetId = 2L
  )
  expect_true("CustomEra" %in% names(result))
  expect_equal(result$CustomEra$GapDays, 14L)
  expect_equal(result$CustomEra$Offset, 7L)
  expect_equal(result$CustomEra$DrugCodesetId, 2L)
})

test_that("buildEndStrategy drug_exit daysSupplyOverride when provided", {
  result <- tidyOhdsiSolutions:::buildEndStrategy(
    "drug_exit",
    endArgs = list(daysSupplyOverride = 30)
  )
  expect_equal(result$CustomEra$DaysSupplyOverride, 30L)
})

test_that("buildEndStrategy drug_exit no daysSupplyOverride when not provided", {
  result <- tidyOhdsiSolutions:::buildEndStrategy("drug_exit", endArgs = list())
  expect_false("DaysSupplyOverride" %in% names(result$CustomEra))
})

test_that("buildEndStrategy errors on unknown end strategy", {
  expect_error(
    tidyOhdsiSolutions:::buildEndStrategy("unknown_strategy"),
    "arg"
  )
})

# ============================================================
# buildObservationWindow (internal)
# ============================================================

test_that("buildObservationWindow returns PriorDays and PostDays", {
  result <- tidyOhdsiSolutions:::buildObservationWindow(c(365L, 30L))
  expect_equal(result$PriorDays, 365L)
  expect_equal(result$PostDays, 30L)
})

test_that("buildObservationWindow defaults to c(0, 0)", {
  result <- tidyOhdsiSolutions:::buildObservationWindow()
  expect_equal(result$PriorDays, 0L)
  expect_equal(result$PostDays, 0L)
})

# ============================================================
# createConceptSetCohort — valid inputs
# ============================================================

test_that("createConceptSetCohort returns a list with all required top-level fields", {
  cohort <- createConceptSetCohort(make_cs_expr())
  expected_names <- c(
    "ConceptSets", "PrimaryCriteria", "QualifiedLimit",
    "ExpressionLimit", "InclusionRules", "EndStrategy",
    "CensoringCriteria", "CollapseSettings", "CensorWindow"
  )
  expect_named(cohort, expected_names, ignore.order = TRUE)
})

test_that("createConceptSetCohort populates ConceptSets with the given name", {
  cohort <- createConceptSetCohort(make_cs_expr(), name = "My Cohort")
  expect_length(cohort$ConceptSets, 1L)
  expect_equal(cohort$ConceptSets[[1]]$name, "My Cohort")
})

test_that("createConceptSetCohort limit = 'first' sets Type to 'First'", {
  cohort <- createConceptSetCohort(make_cs_expr(), limit = "first")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "First")
  expect_equal(cohort$QualifiedLimit$Type, "First")
  expect_equal(cohort$ExpressionLimit$Type, "First")
})

test_that("createConceptSetCohort limit = 'all' sets Type to 'All'", {
  cohort <- createConceptSetCohort(make_cs_expr(), limit = "all")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "All")
})

test_that("createConceptSetCohort limit = 'last' sets Type to 'Last'", {
  cohort <- createConceptSetCohort(make_cs_expr(), limit = "last")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "Last")
})

test_that("createConceptSetCohort requiredObservation sets PriorDays and PostDays", {
  cohort <- createConceptSetCohort(make_cs_expr(), requiredObservation = c(365L, 30L))
  obs    <- cohort$PrimaryCriteria$ObservationWindow
  expect_equal(obs$PriorDays, 365L)
  expect_equal(obs$PostDays, 30L)
})

test_that("createConceptSetCohort end = observation_period_end_date gives DateOffset", {
  cohort <- createConceptSetCohort(make_cs_expr(), end = "observation_period_end_date")
  expect_true("DateOffset" %in% names(cohort$EndStrategy))
})

test_that("createConceptSetCohort end = fixed_exit respects endArgs", {
  cohort <- createConceptSetCohort(
    make_cs_expr(),
    end     = "fixed_exit",
    endArgs = list(index = "startDate", offsetDays = 180)
  )
  expect_equal(cohort$EndStrategy$DateOffset$DateField, "StartDate")
  expect_equal(cohort$EndStrategy$DateOffset$Offset, 180L)
})

test_that("createConceptSetCohort end = drug_exit gives CustomEra", {
  expr   <- make_cs_expr(domain = "Drug")
  cohort <- createConceptSetCohort(
    expr,
    end     = "drug_exit",
    endArgs = list(persistenceWindow = 30, surveillanceWindow = 0)
  )
  expect_true("CustomEra" %in% names(cohort$EndStrategy))
  expect_equal(cohort$EndStrategy$CustomEra$GapDays, 30L)
})

test_that("createConceptSetCohort addSourceCriteria doubles criteria list length", {
  expr          <- make_cs_expr()
  cohort_plain  <- createConceptSetCohort(expr, addSourceCriteria = FALSE)
  cohort_source <- createConceptSetCohort(expr, addSourceCriteria = TRUE)
  n_plain  <- length(cohort_plain$PrimaryCriteria$CriteriaList)
  n_source <- length(cohort_source$PrimaryCriteria$CriteriaList)
  expect_equal(n_source, n_plain * 2L)
})

test_that("createConceptSetCohort multi-domain expression yields one criteria per domain", {
  items <- list(
    list(
      concept = list(CONCEPT_ID = 100L, CONCEPT_NAME = "", DOMAIN_ID = "Condition",
                     VOCABULARY_ID = "", CONCEPT_CLASS_ID = "", STANDARD_CONCEPT = "",
                     STANDARD_CONCEPT_CAPTION = "", CONCEPT_CODE = "",
                     INVALID_REASON = "", INVALID_REASON_CAPTION = ""),
      isExcluded = FALSE, includeDescendants = FALSE, includeMapped = FALSE
    ),
    list(
      concept = list(CONCEPT_ID = 200L, CONCEPT_NAME = "", DOMAIN_ID = "Drug",
                     VOCABULARY_ID = "", CONCEPT_CLASS_ID = "", STANDARD_CONCEPT = "",
                     STANDARD_CONCEPT_CAPTION = "", CONCEPT_CODE = "",
                     INVALID_REASON = "", INVALID_REASON_CAPTION = ""),
      isExcluded = FALSE, includeDescendants = FALSE, includeMapped = FALSE
    )
  )
  cohort <- createConceptSetCohort(list(items = items))
  expect_equal(length(cohort$PrimaryCriteria$CriteriaList), 2L)
})

test_that("createConceptSetCohort CollapseSettings is ERA", {
  cohort <- createConceptSetCohort(make_cs_expr())
  expect_equal(cohort$CollapseSettings$CollapseType, "ERA")
})

test_that("createConceptSetCohort InclusionRules is empty list", {
  cohort <- createConceptSetCohort(make_cs_expr())
  expect_equal(cohort$InclusionRules, list())
})

# ============================================================
# createConceptSetCohort — error cases
# ============================================================

test_that("createConceptSetCohort errors when expression has no items element", {
  expect_error(createConceptSetCohort(list()), "`items`")
})

test_that("createConceptSetCohort errors when items is empty", {
  expect_error(
    createConceptSetCohort(list(items = list())),
    "at least one item"
  )
})

test_that("createConceptSetCohort errors when name is NA", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), name = NA_character_),
    "`name`"
  )
})

test_that("createConceptSetCohort errors when name has length > 1", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), name = c("a", "b")),
    "`name`"
  )
})

test_that("createConceptSetCohort errors when requiredObservation has wrong length", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), requiredObservation = c(0L)),
    "length 2"
  )
})

test_that("createConceptSetCohort errors when requiredObservation is negative", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), requiredObservation = c(-1L, 0L)),
    "non-negative"
  )
})

test_that("createConceptSetCohort errors when endArgs is not a list", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), endArgs = "not a list"),
    "`endArgs`"
  )
})

test_that("createConceptSetCohort errors when addSourceCriteria is NA", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), addSourceCriteria = NA),
    "TRUE or FALSE"
  )
})

test_that("createConceptSetCohort errors on invalid limit value", {
  expect_error(
    createConceptSetCohort(make_cs_expr(), limit = "random"),
    "arg"
  )
})

# ============================================================
# cohortToJson
# ============================================================

test_that("cohortToJson returns a character string", {
  cohort <- createConceptSetCohort(make_cs_expr())
  json   <- cohortToJson(cohort)
  expect_type(json, "character")
  expect_length(json, 1L)
})

test_that("cohortToJson output is valid JSON", {
  cohort <- createConceptSetCohort(make_cs_expr())
  json   <- cohortToJson(cohort)
  parsed <- jsonlite::fromJSON(json, simplifyVector = FALSE)
  expect_type(parsed, "list")
})

test_that("cohortToJson output contains the cohort name", {
  cohort <- createConceptSetCohort(make_cs_expr(), name = "Unique Name 42")
  json   <- cohortToJson(cohort)
  expect_match(json, "Unique Name 42")
})

test_that("cohortToJson output contains ConceptSets key", {
  cohort <- createConceptSetCohort(make_cs_expr())
  json   <- cohortToJson(cohort)
  expect_match(json, "ConceptSets")
})

test_that("cohortToJson output contains PrimaryCriteria key", {
  cohort <- createConceptSetCohort(make_cs_expr())
  json   <- cohortToJson(cohort)
  expect_match(json, "PrimaryCriteria")
})

# ============================================================
# cohortFromConceptSet — valid inputs
# ============================================================

test_that("cohortFromConceptSet returns all required top-level fields", {
  csList <- list("Diabetes" = make_cs_expr())
  cohort <- cohortFromConceptSet(csList)
  expected_names <- c(
    "ConceptSets", "PrimaryCriteria", "QualifiedLimit",
    "ExpressionLimit", "InclusionRules", "EndStrategy",
    "CensoringCriteria", "CollapseSettings", "CensorWindow"
  )
  expect_named(cohort, expected_names, ignore.order = TRUE)
})

test_that("cohortFromConceptSet populates ConceptSets from named list", {
  csList <- list("Diabetes" = make_cs_expr(), "Hypertension" = make_cs_expr(317009L))
  cohort <- cohortFromConceptSet(csList)
  expect_length(cohort$ConceptSets, 2L)
  expect_equal(cohort$ConceptSets[[1]]$name, "Diabetes")
  expect_equal(cohort$ConceptSets[[2]]$name, "Hypertension")
})

test_that("cohortFromConceptSet assigns incremental codeset IDs", {
  csList <- list("A" = make_cs_expr(), "B" = make_cs_expr(100L), "C" = make_cs_expr(200L))
  cohort <- cohortFromConceptSet(csList)
  expect_equal(cohort$ConceptSets[[1]]$id, 0L)
  expect_equal(cohort$ConceptSets[[2]]$id, 1L)
  expect_equal(cohort$ConceptSets[[3]]$id, 2L)
})

test_that("cohortFromConceptSet limit = 'earliest' sets Type to 'First'", {
  cohort <- cohortFromConceptSet(list("A" = make_cs_expr()), limit = "earliest")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "First")
  expect_equal(cohort$QualifiedLimit$Type, "First")
  expect_equal(cohort$ExpressionLimit$Type, "First")
})

test_that("cohortFromConceptSet limit = 'all' sets Type to 'All'", {
  cohort <- cohortFromConceptSet(list("A" = make_cs_expr()), limit = "all")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "All")
})

test_that("cohortFromConceptSet limit = 'latest' sets Type to 'Last'", {
  cohort <- cohortFromConceptSet(list("A" = make_cs_expr()), limit = "latest")
  expect_equal(cohort$PrimaryCriteria$PrimaryCriteriaLimit$Type, "Last")
})

test_that("cohortFromConceptSet requiredObservation sets PriorDays and PostDays", {
  cohort <- cohortFromConceptSet(list("A" = make_cs_expr()), requiredObservation = c(365L, 30L))
  obs    <- cohort$PrimaryCriteria$ObservationWindow
  expect_equal(obs$PriorDays, 365L)
  expect_equal(obs$PostDays, 30L)
})

test_that("cohortFromConceptSet end strategies work", {
  csList <- list("A" = make_cs_expr())
  cohort_obs <- cohortFromConceptSet(csList, end = "observation_period_end_date")
  expect_true("DateOffset" %in% names(cohort_obs$EndStrategy))

  cohort_fix <- cohortFromConceptSet(csList, end = "fixed_exit",
                                     endArgs = list(index = "startDate", offsetDays = 90))
  expect_equal(cohort_fix$EndStrategy$DateOffset$Offset, 90L)

  cohort_drug <- cohortFromConceptSet(list("Drug CS" = make_cs_expr(domain = "Drug")),
                                      end = "drug_exit",
                                      endArgs = list(persistenceWindow = 14))
  expect_true("CustomEra" %in% names(cohort_drug$EndStrategy))
})

test_that("cohortFromConceptSet builds criteria from all concept sets", {
  csList <- list(
    "Conditions" = make_cs_expr(201826L, domain = "Condition"),
    "Drugs"      = make_cs_expr(1503297L, domain = "Drug")
  )
  cohort <- cohortFromConceptSet(csList)
  # 2 concept sets, each 1 domain -> 2 criteria entries
  expect_equal(length(cohort$PrimaryCriteria$CriteriaList), 2L)
  # First criteria should be ConditionOccurrence (codeset 0)
  expect_equal(cohort$PrimaryCriteria$CriteriaList[[1]]$ConditionOccurrence$CodesetId, 0L)
  # Second criteria should be DrugExposure (codeset 1)
  expect_equal(cohort$PrimaryCriteria$CriteriaList[[2]]$DrugExposure$CodesetId, 1L)
})

test_that("cohortFromConceptSet addSourceCriteria doubles criteria per concept set", {
  csList <- list("A" = make_cs_expr())
  cohort_plain  <- cohortFromConceptSet(csList, addSourceCriteria = FALSE)
  cohort_source <- cohortFromConceptSet(csList, addSourceCriteria = TRUE)
  expect_equal(length(cohort_source$PrimaryCriteria$CriteriaList),
               length(cohort_plain$PrimaryCriteria$CriteriaList) * 2L)
})

test_that("cohortFromConceptSet output can be serialized to valid JSON", {
  csList <- list("Diabetes" = make_cs_expr(), "Hypertension" = make_cs_expr(317009L))
  cohort <- cohortFromConceptSet(csList)
  json   <- cohortToJson(cohort)
  expect_type(json, "character")
  parsed <- jsonlite::fromJSON(json, simplifyVector = FALSE)
  expect_type(parsed, "list")
  expect_match(json, "Diabetes")
  expect_match(json, "Hypertension")
})

# ============================================================
# cohortFromConceptSet — error cases
# ============================================================

test_that("cohortFromConceptSet errors when input is not a named list", {
  expect_error(cohortFromConceptSet(list(make_cs_expr())), "named list")
  expect_error(cohortFromConceptSet(data.frame()), "named list")
  expect_error(cohortFromConceptSet("not a list"), "named list")
})

test_that("cohortFromConceptSet errors when list is empty", {
  expect_error(cohortFromConceptSet(stats::setNames(list(), character(0))),
               "at least one element")
})

test_that("cohortFromConceptSet errors when an element has no items", {
  expect_error(
    cohortFromConceptSet(list("Bad" = list(foo = "bar"))),
    "items"
  )
})

test_that("cohortFromConceptSet errors when items is empty", {
  expect_error(
    cohortFromConceptSet(list("Bad" = list(items = list()))),
    "at least one item"
  )
})

test_that("cohortFromConceptSet errors on invalid limit", {
  expect_error(
    cohortFromConceptSet(list("A" = make_cs_expr()), limit = "random"),
    "arg"
  )
})

test_that("cohortFromConceptSet errors on bad requiredObservation", {
  expect_error(
    cohortFromConceptSet(list("A" = make_cs_expr()), requiredObservation = c(-1, 0)),
    "non-negative"
  )
  expect_error(
    cohortFromConceptSet(list("A" = make_cs_expr()), requiredObservation = c(0)),
    "length 2"
  )
})

test_that("cohortFromConceptSet errors on bad endArgs", {
  expect_error(
    cohortFromConceptSet(list("A" = make_cs_expr()), endArgs = "not a list"),
    "`endArgs`"
  )
})

test_that("cohortFromConceptSet errors on bad addSourceCriteria", {
  expect_error(
    cohortFromConceptSet(list("A" = make_cs_expr()), addSourceCriteria = NA),
    "TRUE or FALSE"
  )
})

# ============================================================
# CirceR integration tests (skipped if CirceR not available)
# ============================================================

# Helper: build a realistic concept set expression from a data.frame
make_cs_df <- function(concept_id, name, domain, vocab = "SNOMED") {
  data.frame(
    concept_id       = concept_id,
    concept_name     = name,
    domain_id        = domain,
    vocabulary_id    = vocab,
    standard_concept = "S",
    descendants      = TRUE,
    stringsAsFactors = FALSE
  )
}

# Helper: validate JSON round-trips through CirceR and generates SQL
circe_validate <- function(json) {
  expr <- CirceR::cohortExpressionFromJson(json)
  sql  <- CirceR::buildCohortQuery(
    json, options = CirceR::createGenerateOptions(generateStats = FALSE)
  )
  list(expression = expr, sql = sql)
}

test_that("CirceR accepts cohortFromConceptSet — single condition concept set", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("T2DM" = make_cs_df(201826L, "T2DM", "Condition")))
  json <- cohortToJson(cohortFromConceptSet(cs, limit = "earliest",
                                            requiredObservation = c(365, 0)))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — multiple concept sets", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list(
    "T2DM"      = make_cs_df(201826L,  "T2DM",      "Condition"),
    "Metformin"  = make_cs_df(1503297L, "Metformin",  "Drug", "RxNorm")
  ))
  json <- cohortToJson(cohortFromConceptSet(cs, limit = "all"))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — fixed_exit end strategy", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("T2DM" = make_cs_df(201826L, "T2DM", "Condition")))
  json <- cohortToJson(cohortFromConceptSet(
    cs, end = "fixed_exit", endArgs = list(index = "startDate", offsetDays = 180)
  ))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — drug_exit end strategy", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("Metformin" = make_cs_df(1503297L, "Metformin", "Drug", "RxNorm")))
  json <- cohortToJson(cohortFromConceptSet(
    cs, end = "drug_exit",
    endArgs = list(persistenceWindow = 30, surveillanceWindow = 7)
  ))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — drug_exit with daysSupplyOverride", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("Metformin" = make_cs_df(1503297L, "Metformin", "Drug", "RxNorm")))
  json <- cohortToJson(cohortFromConceptSet(
    cs, end = "drug_exit",
    endArgs = list(persistenceWindow = 14, surveillanceWindow = 0, daysSupplyOverride = 60)
  ))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — latest event limit", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("T2DM" = make_cs_df(201826L, "T2DM", "Condition")))
  json <- cohortToJson(cohortFromConceptSet(cs, limit = "latest"))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — with source criteria", {
  skip_if_not_installed("CirceR")
  cs <- toConceptSets(list("T2DM" = make_cs_df(201826L, "T2DM", "Condition")))
  json <- cohortToJson(cohortFromConceptSet(cs, addSourceCriteria = TRUE))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts cohortFromConceptSet — multi-domain single concept set", {
  skip_if_not_installed("CirceR")
  df <- data.frame(
    concept_id       = c(201826L, 1503297L),
    concept_name     = c("T2DM", "Metformin"),
    domain_id        = c("Condition", "Drug"),
    vocabulary_id    = c("SNOMED", "RxNorm"),
    standard_concept = c("S", "S"),
    descendants      = c(TRUE, TRUE),
    stringsAsFactors = FALSE
  )
  cs <- toConceptSets(list("Mixed" = df))
  json <- cohortToJson(cohortFromConceptSet(cs))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts createConceptSetCohort — single expression", {
  skip_if_not_installed("CirceR")
  expr <- toConceptSet(make_cs_df(201826L, "T2DM", "Condition"), name = "T2DM")
  json <- cohortToJson(createConceptSetCohort(expr, name = "T2DM", limit = "first"))
  res <- circe_validate(json)
  expect_s4_class(res$expression, "jobjRef")
  expect_true(nchar(res$sql) > 0)
})

test_that("CirceR accepts createConceptSetCohort — all end strategies", {
  skip_if_not_installed("CirceR")
  expr <- toConceptSet(make_cs_df(201826L, "T2DM", "Condition"), name = "T2DM")

  # observation_period_end_date
  json_obs <- cohortToJson(createConceptSetCohort(expr, end = "observation_period_end_date"))
  res_obs <- circe_validate(json_obs)
  expect_true(nchar(res_obs$sql) > 0)

  # fixed_exit
  json_fix <- cohortToJson(createConceptSetCohort(
    expr, end = "fixed_exit", endArgs = list(index = "endDate", offsetDays = 90)
  ))
  res_fix <- circe_validate(json_fix)
  expect_true(nchar(res_fix$sql) > 0)

  # drug_exit
  drug_expr <- toConceptSet(make_cs_df(1503297L, "Metformin", "Drug", "RxNorm"), name = "Metformin")
  json_drug <- cohortToJson(createConceptSetCohort(
    drug_expr, name = "Metformin", end = "drug_exit",
    endArgs = list(persistenceWindow = 14)
  ))
  res_drug <- circe_validate(json_drug)
  expect_true(nchar(res_drug$sql) > 0)
})