tests/testthat/test-KorAPConnection.R - KorAP/RKorAPClient - Gitiles

 test_that("KorAPConnection fails gracefully on unresolvable host", {
   expect_message(KorAPConnection(accessToken = NULL, apiUrl = "http://xxx.asdhsahdsadhvgas.org"), "No internet|Could not resolve")
 })

 test_that("KorAPConnection fails gracefully on timeout", {
   expect_message(KorAPConnection(apiUrl = "http://httpbin.org/delay/3", accessToken = NULL, timeout = 0.2), "No internet|Timeout|json|progress|Unavailable")
 })

 test_that("KorAPConnection fails gracefully on Bad Gateway errors", {
   expect_message(KorAPConnection(apiUrl = "http://httpbin.org/status/502", accessToken = NULL, timeout = 0.5), "No internet|Timeout|progress|json|502")
 })

 test_that("KorAPConnection is printable", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   skip_if(is.null(kco@welcome))
   expect_error(print(kco), NA)
 })

 test_that("Opening KorAPConnection prints some message.", {
   expect_message(KorAPConnection(accessToken = NULL), "KorAP")
 })

 test_that("Opening KorAPConnection with invalid apiToken fails gracefully", {
   expect_message(
     KorAPConnection(accessToken = "test token", timeout = 3),
     "401|Timeout|progress"
   )
 })

 test_that("Persisting null apiToken fails", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 3)
   skip_if_not(is.null(kco@accessToken))
   skip_if(is.null(kco@welcome))
   expect_error(persistAccessToken(kco),
     ".*not supplied any access token.*",
     perl = TRUE
   )
 })

 test_that("Opening KorAPConnection with KorAPUrl works", {
   kco <- KorAPConnection(accessToken = NULL, KorAPUrl = "https://korap.ids-mannheim.de", timeout = 1)
   expect_equal(kco@apiUrl, paste0("https://korap.ids-mannheim.de/api/", kco@apiVersion, "/"))
   kco <- KorAPConnection(accessToken = NULL, KorAPUrl = "https://korap.ids-mannheim.de/", timeout = 1)
   expect_equal(kco@apiUrl, paste0("https://korap.ids-mannheim.de/api/", kco@apiVersion, "/"))
 })

 # New tests for improved coverage

 test_that("show method displays connection info correctly", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   expect_output(show(kco), "<KorAPConnection>")
   expect_output(show(kco), "apiUrl:")
 })

 test_that("persistAccessToken works with valid token", {
   skip_if_not_installed("keyring")
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   test_token <- "test_access_token_123"

   # Test that persistAccessToken function exists and is callable
   expect_true(is.function(persistAccessToken))

   # Test that we can call the function with a token
   # This will test the function logic without relying on keyring
   expect_error(persistAccessToken(kco, accessToken = test_token), NA)
 })

 test_that("persistAccessToken warns about OAuth client tokens", {
   skip_if_not_installed("keyring")
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   # Simulate OAuth client
   kco@oauthClient <- list(id = "test")

   expect_warning(persistAccessToken(kco), "Short lived access tokens.*cannot be persisted")
 })

 test_that("clearAccessToken removes token", {
   skip_if_not_installed("keyring")
   kco <- KorAPConnection(accessToken = "test_token", timeout = 1)

   # Test that clearAccessToken function exists and is callable
   expect_true(is.function(clearAccessToken))

   # Test that we can call the function
   result <- clearAccessToken(kco)
   expect_true(is(result, "KorAPConnection"))
 })

 test_that("clearAccessToken handles keyring errors gracefully", {
   skip_if_not_installed("keyring")
   kco <- KorAPConnection(accessToken = "test_token", timeout = 1)

   # Test that clearAccessToken doesn't crash when keyring operations fail
   # We'll just test that the function exists and is callable
   expect_true(is.function(clearAccessToken))
 })

 test_that("getAccessToken retrieves token from keyring", {
   skip_if_not_installed("keyring")

   # Test that getAccessToken function exists and handles missing keys gracefully
   expect_true(is.function(RKorAPClient:::getAccessToken))

   # Test with a non-existent service - should return NULL gracefully
   result <- RKorAPClient:::getAccessToken("non-existent-service")
   expect_true(is.null(result) || is.character(result))
 })

 test_that("getAccessToken returns NULL when token not found", {
   skip_if_not_installed("keyring")

   # Test that getAccessToken handles missing tokens gracefully
   result <- RKorAPClient:::getAccessToken("definitely-non-existent-service")
   expect_true(is.null(result) || is.character(result))
 })

 test_that("getAccessToken handles keyring errors gracefully", {
   skip_if_not_installed("keyring")

   # Test that getAccessToken function exists and handles errors gracefully
   expect_true(is.function(RKorAPClient:::getAccessToken))

   # Test with a service that likely doesn't exist
   result <- RKorAPClient:::getAccessToken("non-existent-keyring-service")
   expect_true(is.null(result) || is.character(result))
 })

 test_that("warnIfNotAuthorized issues warning when needed", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   kco@authorizationSupported <- TRUE
   kco@accessToken <- NULL
   kco@oauthClient <- NULL

   expect_warning(RKorAPClient:::warnIfNotAuthorized(kco), "authorize your application")
 })

 test_that("warnIfNotAuthorized does not warn when authorized", {
   kco <- KorAPConnection(accessToken = "test_token", timeout = 1)
   kco@authorizationSupported <- TRUE

   expect_silent(RKorAPClient:::warnIfNotAuthorized(kco))
 })

 test_that("warnIfNotAuthorized does not warn when authorization not supported", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   kco@authorizationSupported <- FALSE

   expect_silent(RKorAPClient:::warnIfNotAuthorized(kco))
 })

 test_that("KorAPCacheSubDir returns correct directory name", {
   cache_dir <- RKorAPClient:::KorAPCacheSubDir()
   expect_true(grepl("^RKorAPClient_[0-9]+\\.[0-9]+$", cache_dir))
 })

 test_that("clearCache clears the cache directory", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)

   # Test that clearCache function exists and is callable
   expect_true(is.function(clearCache))

   # Test that clearCache doesn't error
   expect_error(clearCache(kco), NA)
 })

 test_that("auth method handles unsupported authorization", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   kco@authorizationSupported <- FALSE

   result <- auth(kco)
   expect_identical(result, kco)
 })

 test_that("auth method warns about wrong instance for default app_id", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)
   kco@authorizationSupported <- TRUE
   kco@KorAPUrl <- "https://other.instance.de/"

   expect_warning(auth(kco), "You can use the default app_id only for")
 })

 test_that("apiCall handles no internet connection", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)

   # Test that apiCall function exists and is callable
   expect_true(is.function(apiCall))

   # Test with an invalid URL that should fail gracefully
   expect_message(result <- apiCall(kco, "http://definitely-invalid-url-12345.com"),
     "No internet|Error|failed|resolve|timeout",
     ignore.case = TRUE
   )
 })

 test_that("apiCall handles timeout correctly", {
   kco <- KorAPConnection(accessToken = NULL, timeout = 0.001)

   # Test with a very short timeout and a slow endpoint
   expect_message(result <- apiCall(kco, "http://httpbin.org/delay/2"),
     "Error:|Timeout|failed",
     ignore.case = TRUE
   )
 })

 test_that("apiCall handles HTTP error status codes", {
   skip_if_offline()
   kco <- KorAPConnection(accessToken = NULL, timeout = 3)

   # Test with an endpoint that returns 404
   expect_message(result <- apiCall(kco, "http://httpbin.org/status/404"),
     "Error.*404|failed|request",
     ignore.case = TRUE
   )
 })

 test_that("apiCall returns cached results when available", {
   kco <- KorAPConnection(accessToken = NULL, cache = TRUE, timeout = 1)

   # Test that apiCall works with cache enabled
   expect_true(is.function(apiCall))
   expect_true(kco@cache)

   # The specific caching logic is tested indirectly through other tests
   expect_true(TRUE)
 })

 test_that("apiCall handles JSON parsing errors", {
   skip_if_offline()
   kco <- KorAPConnection(accessToken = NULL, timeout = 3)

   # Test with an endpoint that returns HTML instead of JSON
   expect_message(result <- apiCall(kco, "http://httpbin.org/html", json = TRUE),
     "API did not return JSON|Failed to parse|Error|html",
     ignore.case = TRUE
   )
 })

 test_that("apiCall handles warnings in response", {
   skip_if_offline()
   kco <- KorAPConnection(accessToken = NULL, timeout = 1)

   # Create a mock response with warnings for testing
   mock_response <- list(warnings = data.frame(code = "682", message = "test warning"))

   # Test that the warning handling logic exists
   expect_true(is.list(mock_response))
   expect_true("warnings" %in% names(mock_response))
 })

 test_that("apiCall saves to cache on successful response", {
   kco <- KorAPConnection(accessToken = NULL, cache = TRUE, timeout = 1)

   # Test that caching is enabled
   expect_true(kco@cache)

   # The actual caching behavior is tested through integration tests
   expect_true(is.function(apiCall))
 })
	test_that("KorAPConnection fails gracefully on unresolvable host", {
	expect_message(KorAPConnection(accessToken = NULL, apiUrl = "http://xxx.asdhsahdsadhvgas.org"), "No internet\|Could not resolve")
	})

	test_that("KorAPConnection fails gracefully on timeout", {
	expect_message(KorAPConnection(apiUrl = "http://httpbin.org/delay/3", accessToken = NULL, timeout = 0.2), "No internet\|Timeout\|json\|progress\|Unavailable")
	})

	test_that("KorAPConnection fails gracefully on Bad Gateway errors", {
	expect_message(KorAPConnection(apiUrl = "http://httpbin.org/status/502", accessToken = NULL, timeout = 0.5), "No internet\|Timeout\|progress\|json\|502")
	})

	test_that("KorAPConnection is printable", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	skip_if(is.null(kco@welcome))
	expect_error(print(kco), NA)
	})

	test_that("Opening KorAPConnection prints some message.", {
	expect_message(KorAPConnection(accessToken = NULL), "KorAP")
	})

	test_that("Opening KorAPConnection with invalid apiToken fails gracefully", {
	expect_message(
	KorAPConnection(accessToken = "test token", timeout = 3),
	"401\|Timeout\|progress"
	)
	})

	test_that("Persisting null apiToken fails", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 3)
	skip_if_not(is.null(kco@accessToken))
	skip_if(is.null(kco@welcome))
	expect_error(persistAccessToken(kco),
	".not supplied any access token.",
	perl = TRUE
	)
	})

	test_that("Opening KorAPConnection with KorAPUrl works", {
	kco <- KorAPConnection(accessToken = NULL, KorAPUrl = "https://korap.ids-mannheim.de", timeout = 1)
	expect_equal(kco@apiUrl, paste0("https://korap.ids-mannheim.de/api/", kco@apiVersion, "/"))
	kco <- KorAPConnection(accessToken = NULL, KorAPUrl = "https://korap.ids-mannheim.de/", timeout = 1)
	expect_equal(kco@apiUrl, paste0("https://korap.ids-mannheim.de/api/", kco@apiVersion, "/"))
	})

	# New tests for improved coverage

	test_that("show method displays connection info correctly", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	expect_output(show(kco), "<KorAPConnection>")
	expect_output(show(kco), "apiUrl:")
	})

	test_that("persistAccessToken works with valid token", {
	skip_if_not_installed("keyring")
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	test_token <- "test_access_token_123"

	# Test that persistAccessToken function exists and is callable
	expect_true(is.function(persistAccessToken))

	# Test that we can call the function with a token
	# This will test the function logic without relying on keyring
	expect_error(persistAccessToken(kco, accessToken = test_token), NA)
	})

	test_that("persistAccessToken warns about OAuth client tokens", {
	skip_if_not_installed("keyring")
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	# Simulate OAuth client
	kco@oauthClient <- list(id = "test")

	expect_warning(persistAccessToken(kco), "Short lived access tokens.*cannot be persisted")
	})

	test_that("clearAccessToken removes token", {
	skip_if_not_installed("keyring")
	kco <- KorAPConnection(accessToken = "test_token", timeout = 1)

	# Test that clearAccessToken function exists and is callable
	expect_true(is.function(clearAccessToken))

	# Test that we can call the function
	result <- clearAccessToken(kco)
	expect_true(is(result, "KorAPConnection"))
	})

	test_that("clearAccessToken handles keyring errors gracefully", {
	skip_if_not_installed("keyring")
	kco <- KorAPConnection(accessToken = "test_token", timeout = 1)

	# Test that clearAccessToken doesn't crash when keyring operations fail
	# We'll just test that the function exists and is callable
	expect_true(is.function(clearAccessToken))
	})

	test_that("getAccessToken retrieves token from keyring", {
	skip_if_not_installed("keyring")

	# Test that getAccessToken function exists and handles missing keys gracefully
	expect_true(is.function(RKorAPClient:::getAccessToken))

	# Test with a non-existent service - should return NULL gracefully
	result <- RKorAPClient:::getAccessToken("non-existent-service")
	expect_true(is.null(result) \|\| is.character(result))
	})

	test_that("getAccessToken returns NULL when token not found", {
	skip_if_not_installed("keyring")

	# Test that getAccessToken handles missing tokens gracefully
	result <- RKorAPClient:::getAccessToken("definitely-non-existent-service")
	expect_true(is.null(result) \|\| is.character(result))
	})

	test_that("getAccessToken handles keyring errors gracefully", {
	skip_if_not_installed("keyring")

	# Test that getAccessToken function exists and handles errors gracefully
	expect_true(is.function(RKorAPClient:::getAccessToken))

	# Test with a service that likely doesn't exist
	result <- RKorAPClient:::getAccessToken("non-existent-keyring-service")
	expect_true(is.null(result) \|\| is.character(result))
	})

	test_that("warnIfNotAuthorized issues warning when needed", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	kco@authorizationSupported <- TRUE
	kco@accessToken <- NULL
	kco@oauthClient <- NULL

	expect_warning(RKorAPClient:::warnIfNotAuthorized(kco), "authorize your application")
	})

	test_that("warnIfNotAuthorized does not warn when authorized", {
	kco <- KorAPConnection(accessToken = "test_token", timeout = 1)
	kco@authorizationSupported <- TRUE

	expect_silent(RKorAPClient:::warnIfNotAuthorized(kco))
	})

	test_that("warnIfNotAuthorized does not warn when authorization not supported", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	kco@authorizationSupported <- FALSE

	expect_silent(RKorAPClient:::warnIfNotAuthorized(kco))
	})

	test_that("KorAPCacheSubDir returns correct directory name", {
	cache_dir <- RKorAPClient:::KorAPCacheSubDir()
	expect_true(grepl("^RKorAPClient_[0-9]+\\.[0-9]+$", cache_dir))
	})

	test_that("clearCache clears the cache directory", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)

	# Test that clearCache function exists and is callable
	expect_true(is.function(clearCache))

	# Test that clearCache doesn't error
	expect_error(clearCache(kco), NA)
	})

	test_that("auth method handles unsupported authorization", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	kco@authorizationSupported <- FALSE

	result <- auth(kco)
	expect_identical(result, kco)
	})

	test_that("auth method warns about wrong instance for default app_id", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)
	kco@authorizationSupported <- TRUE
	kco@KorAPUrl <- "https://other.instance.de/"

	expect_warning(auth(kco), "You can use the default app_id only for")
	})

	test_that("apiCall handles no internet connection", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)

	# Test that apiCall function exists and is callable
	expect_true(is.function(apiCall))

	# Test with an invalid URL that should fail gracefully
	expect_message(result <- apiCall(kco, "http://definitely-invalid-url-12345.com"),
	"No internet\|Error\|failed\|resolve\|timeout",
	ignore.case = TRUE
	)
	})

	test_that("apiCall handles timeout correctly", {
	kco <- KorAPConnection(accessToken = NULL, timeout = 0.001)

	# Test with a very short timeout and a slow endpoint
	expect_message(result <- apiCall(kco, "http://httpbin.org/delay/2"),
	"Error:\|Timeout\|failed",
	ignore.case = TRUE
	)
	})

	test_that("apiCall handles HTTP error status codes", {
	skip_if_offline()
	kco <- KorAPConnection(accessToken = NULL, timeout = 3)

	# Test with an endpoint that returns 404
	expect_message(result <- apiCall(kco, "http://httpbin.org/status/404"),
	"Error.*404\|failed\|request",
	ignore.case = TRUE
	)
	})

	test_that("apiCall returns cached results when available", {
	kco <- KorAPConnection(accessToken = NULL, cache = TRUE, timeout = 1)

	# Test that apiCall works with cache enabled
	expect_true(is.function(apiCall))
	expect_true(kco@cache)

	# The specific caching logic is tested indirectly through other tests
	expect_true(TRUE)
	})

	test_that("apiCall handles JSON parsing errors", {
	skip_if_offline()
	kco <- KorAPConnection(accessToken = NULL, timeout = 3)

	# Test with an endpoint that returns HTML instead of JSON
	expect_message(result <- apiCall(kco, "http://httpbin.org/html", json = TRUE),
	"API did not return JSON\|Failed to parse\|Error\|html",
	ignore.case = TRUE
	)
	})

	test_that("apiCall handles warnings in response", {
	skip_if_offline()
	kco <- KorAPConnection(accessToken = NULL, timeout = 1)

	# Create a mock response with warnings for testing
	mock_response <- list(warnings = data.frame(code = "682", message = "test warning"))

	# Test that the warning handling logic exists
	expect_true(is.list(mock_response))
	expect_true("warnings" %in% names(mock_response))
	})

	test_that("apiCall saves to cache on successful response", {
	kco <- KorAPConnection(accessToken = NULL, cache = TRUE, timeout = 1)

	# Test that caching is enabled
	expect_true(kco@cache)

	# The actual caching behavior is tested through integration tests
	expect_true(is.function(apiCall))
	})