tests/testthat/test-escape-ident.R

In stud-th/RHiveS2: dplyr backend for Hive

#testing if escapeing and quoting complies with dbplyr
#iported from  tidyverse/dbplyr/tests/testthat/test-escape.R
# Identifiers ------------------------------------------------------------------
source('utilities.R')

conn <- HiveS2_TestConnection()
ei <- function(...) unclass(dbplyr::escape(ident(c(...)), con = conn))

test_that("identifiers get identifier quoting", {
  expect_equal(ei("x"), '`x`')
})

test_that("identifiers are comma separated", {
  expect_equal(ei("x", "y"), '`x`, `y`')
})

test_that("identifier names become AS", {
  expect_equal(ei(x = "y"), '`y` AS `x`')
})

# Zero-length inputs ------------------------------------------------------

test_that("zero length inputs yield zero length output when not collapsed", {
  con <- conn
  expect_equal(dbplyr::sql_vector(sql(), collapse = NULL, con = con), sql())
  expect_equal(dbplyr::sql_vector(ident(), collapse = NULL, con = con), sql())
})

test_that("zero length inputs yield length-1 output when collapsed", {
  con <- conn

  expect_equal(dbplyr::sql_vector(sql(), parens = FALSE, collapse = "", con = con), sql(""))
  expect_equal(dbplyr::sql_vector(sql(), parens = TRUE, collapse = "", con = con), sql("()"))
  expect_equal(dbplyr::sql_vector(ident(), parens = FALSE, collapse = "", con = con), sql(""))
  expect_equal(dbplyr::sql_vector(ident(), parens = TRUE, collapse = "", con = con), sql("()"))
})

# Numeric ------------------------------------------------------------------

test_that("missing vaues become null", {
  con <- conn

  expect_equal(dbplyr::escape(NA, con = con), sql("NULL"))
  expect_equal(dbplyr::escape(NA_real_, con = con), sql("NULL"))
  expect_equal(dbplyr::escape(NA_integer_, con = con), sql("NULL"))
  expect_equal(dbplyr::escape(NA_character_, con = con), sql("NULL"))
})

test_that("-Inf and Inf are expanded and quoted", {
  con <- conn
  expect_equal(dbplyr::escape(Inf, con = con), sql("'Infinity'"))
  expect_equal(dbplyr::escape(-Inf, con = con), sql("'-Infinity'"))
})

test_that("can dbplyr::escape integer64 values", {
  con <- conn
  skip_if_not_installed("bit64")

  expect_equal(
    dbplyr::escape(bit64::as.integer64(NA), con = con),
    sql("NULL")
  )
  expect_equal(
    dbplyr::escape(bit64::as.integer64("123456789123456789"), con = con),
    sql("123456789123456789")
  )
})

# Logical -----------------------------------------------------------------

test_that("logical is SQL-99 compatible (by default)", {
  con <- conn
  expect_equal(dbplyr::escape(TRUE, con = con), sql("TRUE"))
  expect_equal(dbplyr::escape(FALSE, con = con), sql("FALSE"))
  expect_equal(dbplyr::escape(NA, con = con), sql("NULL"))
})

# Date-time ---------------------------------------------------------------

test_that("date and date-times are converted to ISO 8601", {
  con <- conn
  x1 <- ISOdatetime(2000, 1, 2, 3, 4, 5, tz = "US/Central")
  x2 <- as.Date(x1)
  expect_equal(dbplyr::escape(x1, con = con), sql("'2000-01-02T09:04:05Z'"))
  expect_equal(dbplyr::escape(x2, con = con), sql("'2000-01-02'"))
})

# Raw -----------------------------------------------------------------

test_that("raw is SQL-99 compatible (by default)", {
  con <- conn
  expect_equal(dbplyr::escape(blob::as_blob(raw(0)), con = con), sql("X''"))
  expect_equal(dbplyr::escape(blob::as_blob(as.raw(c(0x01, 0x02, 0x03))), con = con), sql("X'010203'"))
  expect_equal(dbplyr::escape(blob::as_blob(as.raw(c(0x00, 0xff))), con = con), sql("X'00ff'"))
})

# names_to_as() -----------------------------------------------------------

test_that("names_to_as() doesn't alias when ident name and value are identical", {
  x <- ident(name = "name")
  y <- sql("`name`")

  expect_equal(names_to_as(y, rlang::names2(x),  con = conn),  "`name`")
})

test_that("names_to_as() doesn't alias when ident name is missing", {
  x <- ident("*")
  y <- sql("`*`")

  expect_equal(names_to_as(y, rlang::names2(x), con = conn),  "`*`")
})

test_that("names_to_as() aliases when ident name and value are different", {
  x <- ident(new_name = "name")
  y <- sql(new_name = "`name`")

  expect_equal(names_to_as(y, rlang::names2(x),  con = conn),  "`name` AS `new_name`")
})

test_that("zero length inputs return correct clases", {
  expect_s3_class(ident(), "ident")
})

test_that("ident quotes", {
  con <- conn
  x1 <- ident("x")

  expect_equal(dbplyr::escape(x1, con = con), sql('`x`'))
  expect_equal(dbplyr::as.sql(x1), x1)
})