fakeJqueryDep <- htmlDependency("jquery", "1.11.3", c(href="shared"), script = "jquery.js")
fakeTagFunction <- tagFunction(function(){ span("inner span") })
test_that("safeListToEnv and safeEnvToList undo each other", {
x <- structure(
list(
A = 1,
B = 2
),
class = "test_class",
extra_dep = list(42),
other_dep = "exists"
)
xExpected <- x
xEnv <- safeListToEnv(x, "extra_class")
expect_type(xEnv, "environment")
expect_s3_class(xEnv, "test_class")
expect_s3_class(xEnv, "extra_class")
expect_equal(names(xEnv), c("A", "B"))
})
test_that("asTagEnv upgrades objects", {
expect_error(asTagEnv(list()), "does not accept")
expect_error(asTagEnv(tagList()), "does not accept")
x <- div(class = "test_class", span(class = "inner"))
xTagEnv <- asTagEnv(x)
expect_s3_class(xTagEnv, "shiny.tag.env")
expect_s3_class(xTagEnv, "shiny.tag")
expect_null(xTagEnv$parent)
expect_equal(xTagEnv$envKey, obj_address(xTagEnv))
expect_equal(xTagEnv$name, x$name)
expect_equal(xTagEnv$attribs, x$attribs)
expect_equal(length(xTagEnv$children), length(x$children))
lapply(xTagEnv$children, function(child) {
expect_s3_class(child, "shiny.tag.env")
expect_equal(child$parent$envKey, xTagEnv$envKey)
})
})
## Cycles are not tested for anymore. Keeping in case they are brought back
# test_that("asTagEnv finds cycles", {
# x <- div(class = "test_class", span(class = "inner"))
# xTagEnv <- asTagEnv(x)
# expect_error(asTagEnv(xTagEnv), NA)
# testSpanEnv <- xTagEnv$children[[1]]
# xTagEnv$children[[2]] <- testSpanEnv
# xTagEnv$children[[3]] <- testSpanEnv
# expect_error(asTagEnv(xTagEnv), "Duplicate tag environment found")
# expect_equal_tags(
# tagEnvToTags(xTagEnv),
# div(
# class = "test_class",
# span(class = "inner"),
# span(class = "inner"),
# span(class = "inner")
# )
# )
# # make a cycle
# testSpanEnv$children[[1]] <- xTagEnv
# expect_error(asTagEnv(xTagEnv), "Duplicate tag environment")
# })
test_that("tagQuery() root values", {
expect_error(tagQuery(div()), NA)
expect_error(tagQuery(list()), "initial set")
expect_error(tagQuery(tagList()), "initial set")
expect_error(tagQuery(tagList(div())), NA)
expect_error(tagQuery(5), "initial set")
expect_error(tagQuery("a"), "initial set")
expect_error(tagQuery(fakeJqueryDep), "initial set")
expect_error(tagQuery(fakeTagFunction), "initial set")
x <- tagQuery(div(span(), a()))$find("span")
# expect_equal_tags(x$selectedTags(), tagListPrintAsList(span()))
# expect_equal_tags(x$selectedTags(), tagListPrintAsList(div(span(), a())))
# supply a tag query object
expect_equal_tags(tagQuery(x)$selectedTags(), x$selectedTags())
expect_equal_tags(tagQuery(x)$allTags(), x$allTags())
# supply a list of tag envs
tagEnvs <- list()
x$each(function(el, i) { tagEnvs[[length(tagEnvs) + 1]] <<- el})
expect_equal_tags(tagQuery(tagEnvs)$selectedTags(), x$selectedTags())
expect_equal_tags(tagQuery(tagEnvs)$allTags(), x$allTags())
# supply a single tag env
expect_equal_tags(tagQuery(tagEnvs[[1]])$selectedTags(), x$selectedTags())
expect_equal_tags(tagQuery(tagEnvs[[1]])$allTags(), x$allTags())
})
test_that("tagQuery() structure", {
x <- tagQuery(div())
expect_s3_class(x, "shiny.tag.query")
lapply(x, function(xI) { expect_true(is.function(xI)) })
})
test_that("tagQuery()$find()", {
x <- tagQuery(div(span("a"), span("b")))
# Make sure the found elements do not persist
newX <- x$find("span")
expect_failure(
expect_equal_tags(
x$selectedTags(),
newX$selectedTags()
)
)
x <- x$find("span")
expect_equal(x$length(), 2)
expect_length(x$selectedTags(), 2)
expect_equal_tags(
x$selectedTags(),
tagListPrintAsList(span("a"), span("b"))
)
ul <- tags$ul
li <- tags$li
x <- tagQuery(div(div(div(ul(li("a"), li("b"), li("c"))))))
expect_equal(x$length(), 1)
expect_length(x$selectedTags(), 1)
x <- x$find("div")
expect_equal(x$length(), 2)
expect_length(x$selectedTags(), 2)
x <- x$find("div")
expect_equal(x$length(), 1)
expect_length(x$selectedTags(), 1)
x <- tagQuery(
div(
class = "outer",
div(a(span(p("text1")))),
div(a(p("text2")))
)
)
x <- x$find("a")
expect_equal(x$length(), 2)
expect_length(x$selectedTags(), 2)
x <- x$resetSelected()
x <- x$find("a > p")
expect_equal(x$length(), 1)
expect_length(x$selectedTags(), 1)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(p("text2")))
x <- x$resetSelected()
x <- x$find("a > > p")
expect_equal(x$length(), 1)
expect_length(x$selectedTags(), 1)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(p("text1")))
x <- x$resetSelected()
x <- x$find("div > *")
expect_equal(x$length(), 2)
expect_length(x$selectedTags(), 2)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(a(span(p("text1"))), a(p("text2"))))
x <- x$resetSelected()
x <- x$find("div>>p")
expect_equal(x$length(), 1)
expect_length(x$selectedTags(), 1)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(p("text2")))
})
test_that("tagQuery()$filter()", {
x <- tagQuery(div(span(1), span(2), span(3), span(4), span(5)))
x <- x$find("span")
expect_length(x$selectedTags(), 5)
# keep the even found elements
x <- x$filter(function(item, i) {
# is even
(i %% 2) == 0
})
expect_length(x$selectedTags(), 2)
# keep the filtered even elements. Should only have the 4th one remaining
x <- x$filter(function(item, i) {
# is even
(i %% 2) == 0
})
expect_length(x$selectedTags(), 1)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(span(4)))
})
test_that("tagQuery()$children() & tagQuery()$parent()", {
x <- tagQuery(
div(class="outer",
div(class="a",
span(class="A", "1"),
span(class="B", "2")),
div(class = "b",
span(class = "C", "3"),
span(class = "D", "4")
)
)
)
x <- x$find("div")
expect_length(x$selectedTags(), 2)
x <- x$children()
expect_length(x$selectedTags(), 4)
expect_equal_tags(
x$selectedTags(),
tagListPrintAsList(
span(class = "A", "1"),
span(class = "B", "2"),
span(class = "C", "3"),
span(class = "D", "4")
)
)
x <- x$parent()
expect_length(x$selectedTags(), 2)
x <- x$children(".C")
expect_length(x$selectedTags(), 1)
x <- x$parent()
expect_length(x$selectedTags(), 1)
secondDiv <- div(class = "b", span(class = "C", "3"), span(class = "D", "4"))
expect_equal_tags(x$selectedTags(), tagListPrintAsList(secondDiv))
x <- x$resetSelected()$find("span")$parents(".b")
expect_length(x$selectedTags(), 1)
expect_equal_tags(x$selectedTags(), tagListPrintAsList(secondDiv))
})
test_that("tagQuery()$parents() && tagQuery()$closest()", {
xTags <-
div(class = "outer",
div(class = "inner",
p(class="p",
span("a"), span("b"), span("c"), span("d"), span("e")
)
)
)
x <- tagQuery(xTags)
expect_length(x$selectedTags(), 1)
xc <- x$find("span")$closest("div")
expect_length(xc$selectedTags(), 1)
expect_true(xc$hasClass("inner"))
xc <- x$find("span")$closest()
expect_length(xc$selectedTags(), 5)
xc$each(function(el, i) {
expect_equal(el$name, "span")
})
xp <- x$find("span")$parents("div")
expect_length(xp$selectedTags(), 2)
expect_equal(xp$hasClass("outer"), c(FALSE, TRUE))
expect_equal(xp$hasClass("inner"), c(TRUE, FALSE))
x <- x$find("span")$parents()
expect_length(x$selectedTags(), 3)
expect_equal_tags(
x$selectedTags(),
tagListPrintAsList(
xTags$children[[1]]$children[[1]],
xTags$children[[1]],
xTags
)
)
x <- x$resetSelected()$find("span")$parents(".outer")
expect_length(x$selectedTags(), 1)
expect_equal_tags(
x$selectedTags(),
tagListPrintAsList(xTags)
)
})
test_that("tagQuery()$siblings()", {
xTags <- tagList(
span("a"),
span("b"),
span("c"),
span("d"),
span("e")
)
x <- tagQuery(xTags)
expect_length(x$selectedTags(), 5)
x <- x$siblings()
expect_length(x$selectedTags(), 5)
xTags <- tagList(
span("a"),
span("b"),
span("c", class = "middle"),
span("d"),
span("e")
)
x <- tagQuery(xTags)
expect_length(x$selectedTags(), 5)
x <- x$filter(".middle")
expect_length(x$selectedTags(), 1)
x <- x$siblings()
expect_length(x$selectedTags(), 4)
})
test_that("tagQuery()$addClass()", {
xTags <-
div(class = "outer",
div(class = "inner",
span("a"), span("b"), span("c"), span("d"), span("e")
)
)
x <- tagQuery(xTags)
expect_length(x$selectedTags(), 1)
x <- x$find("div.inner")$addClass("test-class")
expect_length(x$selectedTags(), 1)
expect_equal(x$selectedTags()[[1]]$attribs$class, "inner test-class")
expect_silent({
x$addClass(NULL)
x$removeClass(NULL)
x$toggleClass(NULL)
expect_equal(x$hasClass(NULL), c(FALSE))
})
expect_silent({
x$addClass(character(0))
x$removeClass(character(0))
x$toggleClass(character(0))
expect_equal(x$hasClass(character(0)), c(FALSE))
})
expect_equal_tags(
tagQuery(
div(class="A", class="B", "text")
)$
addClass("C")$
removeClass("B")$
allTags(),
div(class = "A C", "text")
)
})
test_that("tagQuery()$hasClass(), $toggleClass(), $removeClass()", {
xTags <-
div(class = "outer",
div(class = "A B",
span(class = "odd", "a"),
span(class = "even", "b"),
span(class = "odd", "c"),
span(class = "even", "d"),
span(class = "odd", "e")
)
)
x <- tagQuery(xTags)
x <- x$find("div.A")
expect_length(x$selectedTags(), 1)
expect_equal(x$hasClass("B A"), TRUE)
expect_equal(x$hasClass("A B"), TRUE)
expect_equal(x$hasClass("B"), TRUE)
expect_equal(x$hasClass("A"), TRUE)
expect_equal(x$hasClass("C"), FALSE)
x <- x$resetSelected()$find("span")
expect_equal(x$hasClass("even"), c(FALSE, TRUE, FALSE, TRUE, FALSE))
expect_equal(x$hasClass("odd"), c(TRUE, FALSE, TRUE, FALSE, TRUE))
x$toggleClass("even odd")
expect_equal(x$hasClass("even"), c(TRUE, FALSE, TRUE, FALSE, TRUE))
expect_equal(x$hasClass("odd"), c(FALSE, TRUE, FALSE, TRUE, FALSE))
x$removeClass("even")
expect_equal(x$hasClass("even"), c(FALSE, FALSE, FALSE, FALSE, FALSE))
expect_equal(x$hasClass("odd"), c(FALSE, TRUE, FALSE, TRUE, FALSE))
x$removeClass("other odd")
expect_equal(x$hasClass("odd"), c(FALSE, FALSE, FALSE, FALSE, FALSE))
})
test_that("tagQuery()$addAttrs(), $removeAttrs(), $s", {
xTags <- tagList(
span(key = "value - a", "a"),
span(key = "value - b", "b"),
span( "c"),
span( "d"),
span(key = "value - e", "e")
)
x <- tagQuery(xTags)
expect_length(x$selectedTags(), 5)
expect_equal(x$hasAttrs("key"), c(TRUE, TRUE, FALSE, FALSE, TRUE))
x$addAttrs(key2 = "val2", key3 = "val3")
expect_equal(x$hasAttrs("key"), c(TRUE, TRUE, FALSE, FALSE, TRUE))
expect_equal(x$hasAttrs("key2"), c(TRUE, TRUE, TRUE, TRUE, TRUE))
expect_equal(x$hasAttrs("key3"), c(TRUE, TRUE, TRUE, TRUE, TRUE))
x$removeAttrs(c("key", "key3"))
expect_equal(x$hasAttrs("key"), c(FALSE, FALSE, FALSE, FALSE, FALSE))
expect_equal(x$hasAttrs("key2"), c(TRUE, TRUE, TRUE, TRUE, TRUE))
expect_equal(x$hasAttrs("key3"), c(FALSE, FALSE, FALSE, FALSE, FALSE))
})
test_that("tagQuery()$append()", {
xTags <- div(span("child"))
x <- tagQuery(xTags)
newa <- span("a")
x$append(newa)
expect_equal_tags(
x$allTags(),
div(span("child"), newa)
)
new1 <- div("new1")
new2 <- div("new2")
x$append(new1, new2)
expect_equal_tags(
x$allTags(),
div(span("child"), newa, new1, new2)
)
})
test_that("tagQuery()$prepend()", {
xTags <- div(span("child"))
x <- tagQuery(xTags)
newa <- span("a")
x$prepend(newa)
expect_equal_tags(
x$allTags(),
div(newa, span("child"))
)
new1 <- div("new1")
new2 <- div("new2")
x$prepend(new1, new2)
expect_equal_tags(
x$allTags(),
div(new1, new2, newa, span("child"))
)
})
test_that("tagQuery()$each()", {
xTags <- div(span("a"), h1("title"), span("b"))
x <- tagQuery(xTags)
x <- x$find("span")
expect_error(x$each("4"), "function")
expect_error(x$each(function(item) {}), "two")
expect_error(x$each(function(...) {}), NA)
x$each(function(el, i) {
el$children <- lapply(el$children, toupper)
"ignored"
})
expect_equal_tags(
x$allTags(),
div(span("A"), h1("title"), span("B"))
)
})
test_that("tagQuery()$allTags() & tagQuery()$rebuild()", {
xTags <- div(span("a"), h1("title"), span("b"))
x <- tagQuery(xTags)
x$each(function(root, i) {
# add a child to the root
root$children[[length(root$children) + 1]] <- div("test")
})
# retrieve the root (and direct children) from graph
rootChildren <- x$allTags()$children
lastChild <- rootChildren[[length(rootChildren)]]
# make sure the last child is a tag env (not a standard tag)
expect_false(isTagEnv(lastChild))
# make sure it equals what was manually added
expect_equal_tags(lastChild, div("test"))
})
test_that("tagQuery()$remove()", {
xTags <-
div(
span("a"),
span("b", class = "A"),
span("c"),
span("d", class = "A"),
span("e")
)
x <- tagQuery(xTags)$find("span")
expect_equal(x$length(), 5)
expect_length(x$selectedTags(), 5)
x <- x$filter(".A")$remove()
expect_equal(x$length(), 0)
expect_length(x$selectedTags(), 0)
expect_equal_tags(
x$allTags(),
div(span("a"), span("c"), span("e"))
)
x <- x$resetSelected()$find("span")
expect_equal(x$length(), 3)
expect_length(x$selectedTags(), 3)
x <- x$remove()
expect_equal_tags(
x$allTags(),
div()
)
# https://github.com/rstudio/htmltools/issues/346
# `isTagEnv("Barret")` is `FALSE`
html <- div(tags$label("Carson"), "Barret")
# Remove the label
x <- tagQuery(html)$find("label")$remove()
expect_equal_tags(x$allTags(), div("Barret"))
})
test_that("tagQuery()$after()", {
xTags <- div()
x <- tagQuery(xTags)
newa <- span("a")
x$after(newa)
expect_equal_tags(
x$allTags(),
tagList(xTags, newa)
)
new1 <- div("new1")
new2 <- div("new2")
x$after(new1, new2)
expect_equal_tags(
x$allTags(),
tagList(xTags, new1, new2, newa)
)
})
test_that("tagQuery()$before()", {
xTags <- div()
x <- tagQuery(xTags)
newa <- span("a")
x$before(newa)
expect_equal_tags(
x$allTags(),
tagList(newa, xTags)
)
new1 <- div("new1")
new2 <- div("new2")
x$before(new1, new2)
expect_equal_tags(
x$allTags(),
tagList(newa, new1, new2, xTags)
)
})
test_that("tagQuery(x)$allTags()", {
xTags <- tagList(
fakeJqueryDep,
div(
fakeTagFunction
)
)
x <- tagQuery(xTags)
expect_equal_tags(
x$allTags(),
tagList(!!!xTags)
)
})
test_that("tagQuery() objects inherit from each other objects", {
xTags <- div(span("text"))
x <- tagQuery(xTags)$find("span")
y <- tagQuery(x)
zEnv <- NULL
wEnvs <- NULL
x$each(function(el, i) {
zEnv <<- el
wEnvs <<- append(wEnvs, list(el))
})
z <- tagQuery(zEnv)
w <- tagQuery(wEnvs)
y$addClass("extra")
expected <- div(span(class="extra", "text"))
expect_equal_tags(x$selectedTags(), tagListPrintAsList(!!!expected$children))
expect_equal_tags(y$selectedTags(), tagListPrintAsList(!!!expected$children))
expect_equal_tags(z$selectedTags(), tagListPrintAsList(!!!expected$children))
expect_equal_tags(w$selectedTags(), tagListPrintAsList(!!!expected$children))
expect_equal_tags(x$allTags(), expected)
expect_equal_tags(y$allTags(), expected)
expect_equal_tags(z$allTags(), expected)
expect_equal_tags(w$allTags(), expected)
})
test_that("tagQuery() objects can not inherit from mixed objects", {
xTags <- div(span("text"), span("extra"))
x <- tagQuery(xTags)$find("span")
y <- tagQuery(xTags)$find("span")
xEnv <- NULL
x$each(function(el, i) {
xEnv <<- el
})
yEnv <- NULL
y$each(function(el, i) {
yEnv <<- el
})
expect_error(
tagQuery(tagList(
div(),
xEnv
)),
"not be a mix"
)
expect_error(
tagQuery(tagList(
xEnv,
yEnv
)),
"share the same root"
)
})
test_that("rebuilding tag envs after inserting children is done", {
xTags <- div(div(), div())
expect_equal_tags(
tagQuery(xTags)$find("div")$before(span())$allTags(),
div(span(), div(), span(), div())
)
expect_equal_tags(
tagQuery(xTags)$find("div")$replaceWith(span())$allTags(),
div(span(), span())
)
expect_equal_tags(
tagQuery(xTags)$find("div")$after(span())$allTags(),
div(div(), span(), div(), span())
)
})
test_that("tagQuery() print method displays custom output for selected tags", {
local_edition(3)
expect_snapshot_output(print(
tagQuery(div(span()))
))
expect_snapshot_output(print(
tagQuery(div(span()))$find("span")
))
expect_snapshot_output(print(
tagQuery(div(span()))$find("empty")
))
})
test_that("tagQuery() allows for tags with extra top level items and will preserve them", {
html <- div(span())
html$test <- "extra"
html <- c(list(first = TRUE), html)
class(html) <- "shiny.tag"
# Test different removal types: setting the value to NULL and removing the value from the envir completely.
for (removeType in c("set", "rm")) {
expect_error(
tagQuery(html)$each(function(el, i) {
switch(removeType,
set = {
el$name <- NULL
},
rm = {
rm(list = "name", envir = el)
}
)
})$allTags(),
"lost its `$name`", fixed = TRUE
)
for (missing_key in c("__not_a_match__", "attribs", "children")) {
htmlQ <- tagQuery(html)
if (missing_key %in% names(html)) {
htmlQ$each(function(el, i) {
switch(removeType,
set = {
el[[missing_key]] <- NULL
},
rm = {
rm(list = missing_key, envir = el)
}
)
el[[missing_key]] <- NULL
})
}
htmlPostQ <- htmlQ$allTags()
html_out <- html
if (missing_key == "attribs") html_out$attribs <- dots_list()
if (missing_key == "children") html_out$children <- list()
# expect first three names to be standard tag names
expect_equal(names(htmlPostQ)[1:3], names(div()))
# expect all other names to be included somewhere
expect_setequal(names(htmlPostQ), names(html_out))
# If done in the same order, it should be equal
back_to_orig <- htmlPostQ[names(html_out)]
class(back_to_orig) <- "shiny.tag"
expect_equal(back_to_orig, html_out)
}
}
})
test_that("tag methods do not unexpectedly alter tag envs", {
expect_equal_tags(
tagEnvToTags(tagAppendAttributes(asTagEnv(div()), key = "a")),
tagAppendAttributes(div(), key = "a")
)
expect_equal_tags(
tagHasAttribute(asTagEnv(div(key = "a")), "key"),
tagHasAttribute(div(key = "a"), "key")
)
expect_equal_tags(
tagGetAttribute(asTagEnv(div(key = "a")), "key"),
tagGetAttribute(div(key = "a"), "key")
)
expect_equal_tags(
tagEnvToTags(tagAppendChild(asTagEnv(div()), span())),
tagAppendChild(div(), span())
)
expect_equal_tags(
tagEnvToTags(tagAppendChildren(asTagEnv(div()), span(), h1())),
tagAppendChildren(div(), span(), h1())
)
expect_equal_tags(
tagEnvToTags(tagSetChildren(asTagEnv(div()), span(), h1())),
tagSetChildren(div(), span(), h1())
)
expect_equal_tags(
tagEnvToTags(tagInsertChildren(asTagEnv(div()), span(), h1(), after = 12)),
tagInsertChildren(div(), span(), h1(), after = 12)
)
})
test_that("adding a class does not reorder attribs", {
# No class
expect_equal_tags(
tagQuery(div(test = "A", "text"))$addClass("foo")$allTags(),
div(test = "A", class = "foo", "text")
)
# One class
expect_equal_tags(
tagQuery(div(class = "bar", test = "A", "text"))$addClass("foo")$allTags(),
div(class="bar foo", test = "A", "text")
)
# Multiple classes
expect_equal_tags(
tagQuery(div(class = "bar", test = "A", class = "baz", "text"))$addClass("foo")$allTags(),
div(class = "bar baz foo", test = "A", "text")
)
})
test_that("flattenTagsRaw() and flattenTags() do not drop html deps", {
emptyDiv <- div()
emptySpan <- span()
testSpan <- span("test")
otherObj <- HTML("test")
fakeDep <- function(i) {
ret <- fakeJqueryDep
ret$i <- i
ret
}
# `flattenTagsRaw()` moves html deps on tag lists to children
htmlRaw <- tagList(
emptyDiv,
tagAppendChild(emptySpan, fakeDep(1)),
tagAppendChild(testSpan, fakeDep(2)),
otherObj,
fakeDep(3)
)
htmlDependencies(emptySpan) <- list(fakeDep(1))
htmlDependencies(testSpan) <- list(fakeDep(2))
html <- tagList(
emptyDiv,
emptySpan,
testSpan,
otherObj
)
htmlDependencies(html) <- list(fakeDep(3))
expect_equal(flattenTags(html), html)
expect_equal(flattenTagsRaw(html), htmlRaw)
})
test_that("flattenTagsRaw(): tag list html deps are not lost when tag children are squashed", {
# https://github.com/rstudio/htmltools/issues/301
a_dep <- htmlDependency(name = "A", version = 1, src = "a.js")
b_dep <- htmlDependency(name = "B", version = 2, src = "b.js")
c_dep <- htmlDependency(name = "C", version = 3, src = "c.js")
d_dep <- htmlDependency(name = "D", version = 4, src = "d.js")
z <- div("Z")
z$children <- list(attachDependencies(list("z1"), d_dep))
children <-
attachDependencies(
list(
attachDependencies(list("X", "Y"), a_dep),
z
),
list(b_dep, c_dep)
)
html <- div("test", children)
tq_html <- tagQuery(html)$allTags()
tq_deps <- findDependencies(tq_html$children)
expect_length(tq_deps, 4)
expect_equal(tq_deps, list(a_dep, d_dep, b_dep, c_dep))
})
#
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.