tests/testthat/test-utils.R

In tidygeocoder: Geocoding Made Easy

test_that("Check API Parameter Reference Dataset", {
  
  # the api_name and method parameters should never be NA or blank
  expect_true(!any(is.na(tidygeocoder::api_parameter_reference$api_name)))
  expect_true(!any(is.na(tidygeocoder::api_parameter_reference$method)))
  
  # check for duplicates
  unique_api_param_rows <- nrow(tidygeocoder::api_parameter_reference[c('method', 'generic_name')])
  api_param_rows <- nrow(tidygeocoder::api_parameter_reference)
  
  expect_equal(unique_api_param_rows, api_param_rows)
})


# check that batch functions all exist and have a batch_limit default value
test_that('check batch function maps', {

  for (method in names(tidygeocoder:::batch_func_map)) {
    # label to include in error message so we know which method failed
    method_label = paste0('method = "', method, '"', ' ')
    
    expect_true(method %in% tidygeocoder::batch_limit_reference[['method']], label = method_label)
    expect_true(method %in% tidygeocoder::api_parameter_reference[['method']], label = method_label)
    expect_true(is.function(tidygeocoder:::batch_func_map[[method]]), label = method_label)
  }
  
  for (method in names(tidygeocoder:::reverse_batch_func_map)) {
    # label to include in error message so we know which method failed
    method_label = paste0('method = "', method, '"', ' ')
    
    expect_true(method %in% tidygeocoder::batch_limit_reference[['method']], label = method_label)
    expect_true(method %in% tidygeocoder::api_parameter_reference[['method']], label = method_label)
    expect_true(is.function(tidygeocoder:::reverse_batch_func_map[[method]]), label = method_label)
  }
  
})


test_that('Check Reference Datasets', {
  # Services that require an API key should have an api_key parameter
  # defined in api_parameter_reference and also have an environmental variable 
  # (where the key value will be read from) declared in api_key_reference
  expect_setequal(get_services_requiring_key(), tidygeocoder::api_key_reference[['method']])
  
  # make sure these datasets are unique on 'method'
  expect_equal(
    length(unique(tidygeocoder::api_key_reference[['method']])), 
    nrow(tidygeocoder::api_key_reference)
  )
  expect_equal(
    length(unique(tidygeocoder::batch_limit_reference[['method']])), 
    nrow(tidygeocoder::batch_limit_reference)
  )
  expect_equal(
    length(unique(tidygeocoder::min_time_reference[['method']])), 
    nrow(tidygeocoder::min_time_reference)
  )
})


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

# Check the package_addresses() and unpackage_inputs() functions
# with some duplicate addresses
test_that("Test Duplicate and Blank/NA Address Handling", {
  
  messy_addresses <- c('','', NA, tidygeocoder::sample_addresses$addr, 
      NA, '', NA, tidygeocoder::sample_addresses$addr)
  
  addr_pack <- tidygeocoder:::package_addresses(address = messy_addresses)
  
  # create NA lat long fields
  results <- tidygeocoder::geo(messy_addresses, no_query = TRUE, unique_only = TRUE)[, c('lat', 'long')]
  
  unpacked <- tidygeocoder:::unpackage_inputs(addr_pack, results, return_inputs = TRUE)
  
  # check data types and lengths
  expect_true(is.list(addr_pack))
  expect_length(addr_pack, 2)
  expect_true(tibble::is_tibble(addr_pack$unique))
  expect_true(tibble::is_tibble(addr_pack$crosswalk))
  
  # check number of rows in datasets
  expect_equal(nrow(addr_pack$unique), length(unique(messy_addresses[!(messy_addresses %in% c(NA, ''))])))
  expect_equal(nrow(addr_pack$crosswalk), length(messy_addresses))
  expect_equal(nrow(unpacked), length(messy_addresses))
  
  # check output column names
  expect_equal(colnames(unpacked), c('address', colnames(results)))
  
})

# make sure the address handler throws errors when it should
test_that("Test Address Packaging Errors", {

  # mixing 'address' argument with address component arguments
  expect_error(tidygeocoder:::package_addresses(address = c('xyz'), city = c('abc')))
  # mismatched lengths of arguments
  expect_error(tidygeocoder:::package_addresses(city = c('xyz', 'abc'), state = c('abc')))
})

test_that("Test API Query Creation Functions", {
  
  cust_arg_list <- list(cust1 = '123')
  address_val <- '1500 Rushmore St'
  
  # proper census parameter
  census_addr_param <- create_api_parameter('census', 'address', 'xyz')
  expect_true(is.list(census_addr_param))
  expect_equal(length(census_addr_param), 1)
  
  # improper census parameter. expect an empty list output
  census_bad_addr_param <- create_api_parameter('census', 'country', 'xyz')
  expect_true(is.list(census_bad_addr_param))
  expect_equal(length(census_bad_addr_param), 0)
  
  
  # loop through all methods and produce queries
  for (method in unique(tidygeocoder::api_parameter_reference[['method']])) {
    # label to include in error message so we know which method failed
    method_label = paste0('method = "', method, '"', ' ')
    
    # test overlap between generic and custom parameters
    expect_warning(tidygeocoder::get_api_query(method,
       generic_parameters = list(address = 'abc'),
       custom_parameters = tidygeocoder:::create_api_parameter(method, 'address', 'ghj')))
    
    
    default_q <- tidygeocoder::get_api_query(method)
    custom_q <- tidygeocoder::get_api_query(method, custom_parameters = cust_arg_list)
    address_q <- tidygeocoder::get_api_query(method, generic_parameters = list(address = address_val))

    expect_named(custom_q)
    expect_named(address_q)
    
    # all outputs should be lists
    expect_true(is.list(default_q))
    expect_true(is.list(custom_q))
    expect_true(is.list(address_q))
    
    # custom_parameters and generic_parameters arguments should just be 
    # adding to the default_q list
    expect_mapequal(custom_q, c(default_q, cust_arg_list))
    
    # for mapbox/tomtom the address is removed from parameters and put 
    # into the API URL so this test doesn't apply
    if (!method %in% c('mapbox', 'tomtom')) {
      expect_mapequal(address_q, c(default_q, 
        tidygeocoder:::create_api_parameter(method, 'address', address_val)))
    }
    
    if (length(default_q) > 0) expect_message(display_named_list(default_q), label = method_label)
    expect_message(display_named_list(custom_q), label = method_label)
    if (length(address_q) > 0) expect_message(display_named_list(address_q), label = method_label)
  }
})

## Miscellaneous functions

test_that("Test Miscellaneous Functions", {
  
  # na value function for return NA data
  num_rows <- 3
  na_vals <- tidygeocoder:::get_na_value('lat', 'long', rows = num_rows)
  expect_true(tibble::is_tibble(na_vals))
  expect_true(nrow(na_vals) == num_rows)
  
})