tests/testthat/test-alma-next.R

In almanac: Tools for Working with Recurrence Rules

test_that("can use a runion with no rules", {
  expect_identical(alma_next("2000-01-01", runion()), almanac_global_na_date)
  expect_identical(alma_next("2000-01-01", runion(), inclusive = TRUE), almanac_global_na_date)
})

test_that("next works with infinite dates", {
  expect_identical(alma_next(almanac_global_inf_date, daily()), almanac_global_na_date)

  expect_identical(alma_next(almanac_global_neg_inf_date, daily()), almanac_global_default_since)
  expect_identical(alma_next(almanac_global_neg_inf_date, daily(since = "1970-01-02")), new_date(1))

  # If a cache already exists...
  rrule <- daily()
  alma_next("1970-01-01", rrule, inclusive = TRUE)

  expect_identical(alma_next(almanac_global_inf_date, rrule), almanac_global_na_date)
  expect_identical(alma_next(almanac_global_neg_inf_date, rrule), almanac_global_default_since)
})

test_that("alma_next() works with missing dates", {
  expect_identical(alma_next(almanac_global_na_date, daily()), almanac_global_na_date)
})

test_that("alma_next() is vectorized", {
  rrule <- weekly() %>% recur_on_day_of_week("Friday")

  x <- as.Date(c("1970-01-01", "1970-01-03"))
  expect <- as.Date(c("1970-01-02", "1970-01-09"))

  expect_identical(alma_next(x, rrule), expect)
})

test_that("alma_next() respects `inclusive`", {
  rrule <- daily(since = "1970-01-01", until = "1970-01-05")

  x <- as.Date("1970-01-01")
  y <- as.Date("1970-01-05")

  expect_identical(alma_next(x, rrule, inclusive = TRUE), x)
  expect_identical(alma_next(x, rrule, inclusive = FALSE), x + 1)

  expect_identical(alma_next(y, rrule, inclusive = TRUE), y)
  expect_identical(alma_next(y, rrule, inclusive = FALSE), almanac_global_na_date)
})

test_that("next works when between the last occurrence and the until date", {
  # Previous weekend value before "2020-04-20" is "2020-04-18"
  # so we are between the last occurrence in the set and the until date.
  # There are no events left, so the result is a size 1 NA date.
  rule <- weekly(until = "2020-04-21") %>% recur_on_weekends()

  expect_identical(alma_next("2020-04-20", rule), almanac_global_na_date)
})

# ------------------------------------------------------------------------------

test_that("can use a runion with no rules", {
  expect_identical(alma_previous("2000-01-01", runion()), almanac_global_na_date)
  expect_identical(alma_previous("2000-01-01", runion(), inclusive = TRUE), almanac_global_na_date)
})

test_that("previous works with infinite dates", {
  until <- as.Date("2030-01-01")
  expect_identical(alma_previous(almanac_global_inf_date, daily(until = until)), until)

  # Guarantee a size 1 return value, but no previous events. Returns NA.
  expect_identical(alma_previous(almanac_global_neg_inf_date, daily()), almanac_global_na_date)
  expect_identical(alma_previous(almanac_global_neg_inf_date, daily(since = "1970-01-02")), almanac_global_na_date)

  # If a cache already exists...
  rrule <- daily(until = until)
  alma_previous("1970-01-01", rrule, inclusive = TRUE)

  expect_identical(alma_previous(almanac_global_inf_date, rrule), until)
  expect_identical(alma_previous(almanac_global_neg_inf_date, rrule), almanac_global_na_date)
})

test_that("alma_previous() works with missing dates", {
  expect_identical(alma_previous(almanac_global_na_date, daily()), almanac_global_na_date)
})

test_that("alma_previous() is vectorized", {
  rrule <- weekly() %>% recur_on_day_of_week("Friday")

  x <- as.Date(c("1970-01-03", "1970-01-10"))
  expect <- as.Date(c("1970-01-02", "1970-01-09"))

  expect_identical(alma_previous(x, rrule), expect)
})

test_that("alma_previous() respects `inclusive`", {
  rrule <- daily(since = "1970-01-01", until = "1970-01-05")

  x <- as.Date("1970-01-01")
  y <- as.Date("1970-01-05")

  expect_identical(alma_previous(x, rrule, inclusive = TRUE), x)
  expect_identical(alma_previous(x, rrule, inclusive = FALSE), almanac_global_na_date)

  expect_identical(alma_previous(y, rrule, inclusive = TRUE), y)
  expect_identical(alma_previous(y, rrule, inclusive = FALSE), y - 1)
})