Nothing
# Test claims_validation modes: "strict", "warn", "none"
# Validates that requested claims supplied via the OIDC claims parameter
# (OIDC Core ยง5.5) are checked against returned ID token / userinfo.
# --- Unit tests for extract_essential_claims() --------------------------------
test_that("extract_essential_claims: extracts essential id_token claims from list", {
claims <- list(
id_token = list(
auth_time = list(essential = TRUE),
acr = list(values = c("urn:mace:incommon:iap:silver")),
email = NULL
),
userinfo = list(
given_name = list(essential = TRUE),
email = NULL
)
)
result <- shinyOAuth:::extract_essential_claims(claims, "id_token")
expect_equal(result, "auth_time")
result <- shinyOAuth:::extract_essential_claims(claims, "userinfo")
expect_equal(result, "given_name")
})
test_that("extract_essential_claims: returns empty for no essential claims", {
claims <- list(
id_token = list(
email = NULL,
acr = list(values = c("something"))
)
)
result <- shinyOAuth:::extract_essential_claims(claims, "id_token")
expect_equal(result, character(0))
})
test_that("extract_essential_claims: returns empty for NULL claims", {
result <- shinyOAuth:::extract_essential_claims(NULL, "id_token")
expect_equal(result, character(0))
})
test_that("extract_essential_claims: returns empty for missing target", {
claims <- list(userinfo = list(email = list(essential = TRUE)))
result <- shinyOAuth:::extract_essential_claims(claims, "id_token")
expect_equal(result, character(0))
})
test_that("extract_essential_claims: handles JSON string input", {
json <- '{"id_token":{"auth_time":{"essential":true},"sub":null}}'
result <- shinyOAuth:::extract_essential_claims(json, "id_token")
expect_equal(result, "auth_time")
})
test_that("extract_essential_claims: handles multiple essential claims", {
claims <- list(
id_token = list(
auth_time = list(essential = TRUE),
email = list(essential = TRUE),
acr = list(values = c("something")),
sub = NULL,
nonce = list(essential = TRUE)
)
)
result <- shinyOAuth:::extract_essential_claims(claims, "id_token")
expect_equal(sort(result), sort(c("auth_time", "email", "nonce")))
})
test_that("extract_essential_claims: essential = FALSE is not essential", {
claims <- list(
id_token = list(
auth_time = list(essential = FALSE)
)
)
result <- shinyOAuth:::extract_essential_claims(claims, "id_token")
expect_equal(result, character(0))
})
test_that("oauth_client defaults to warn for enforceable claim requests", {
prov <- make_test_provider(use_pkce = TRUE, use_nonce = TRUE)
warned <- FALSE
cli <- withCallingHandlers(
oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid",
claims = list(
id_token = list(auth_time = list(essential = TRUE)),
userinfo = list(email_verified = list(value = TRUE))
)
),
warning = function(w) {
warned <<- TRUE
invokeRestart("muffleWarning")
}
)
expect_false(warned)
expect_equal(cli@claims_validation, "warn")
})
test_that("oauth_client does not warn when enforceable claims opt into validation", {
prov <- make_test_provider(use_pkce = TRUE, use_nonce = TRUE)
expect_no_warning(
oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid",
claims = list(
id_token = list(auth_time = list(essential = TRUE)),
userinfo = list(email_verified = list(value = TRUE))
),
claims_validation = "warn"
)
)
})
test_that("oauth_client rejects enforceable id_token claims without ID token validation", {
prov <- oauth_provider(
name = "test",
auth_url = "https://example.com/auth",
token_url = "https://example.com/token",
issuer = "https://example.com",
use_nonce = FALSE,
id_token_validation = FALSE,
token_auth_style = "body",
use_pkce = TRUE
)
expect_error(
oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid",
claims = list(
id_token = list(auth_time = list(essential = TRUE))
)
),
"validate ID tokens|id_token_validation|use_nonce"
)
for (mode in c("warn", "strict")) {
expect_error(
oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid",
claims = list(
id_token = list(auth_time = list(essential = TRUE))
),
claims_validation = mode
),
"validate ID tokens|id_token_validation|use_nonce"
)
}
})
test_that("oauth_client allows userinfo-only claims validation without ID token validation", {
expect_no_error(
make_test_client(
claims = list(
userinfo = list(email_verified = list(value = TRUE))
),
claims_validation = "strict"
)
)
})
# --- Unit tests for validate_essential_claims() -------------------------------
test_that("validate_essential_claims: 'none' mode skips validation entirely", {
cli <- make_test_client(
claims = list(
id_token = list(auth_time = list(essential = TRUE))
),
claims_validation = "none"
)
# Should not error or warn even when essential claims are missing
result <- NULL
warned <- FALSE
result <- withCallingHandlers(
tryCatch(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"id_token"
),
error = function(e) {
NULL
}
),
warning = function(w) {
warned <<- TRUE
invokeRestart("muffleWarning")
}
)
expect_false(warned)
})
test_that("validate_essential_claims: 'strict' mode errors on missing essential id_token claims", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE),
email = list(essential = TRUE)
)
),
claims_validation = "strict"
)
# Both claims missing
expect_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"id_token"
),
class = "shinyOAuth_id_token_error"
)
})
test_that("validate_essential_claims: 'strict' mode errors on missing essential userinfo claims", {
cli <- make_test_client(
claims = list(
userinfo = list(
given_name = list(essential = TRUE)
)
),
claims_validation = "strict"
)
expect_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1", email = "a@b.c"),
"userinfo"
),
class = "shinyOAuth_userinfo_error"
)
})
test_that("validate_essential_claims: 'strict' mode passes when all essential claims present", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE),
email = list(essential = TRUE)
)
),
claims_validation = "strict"
)
# Should not error
expect_no_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1", auth_time = 1234567890, email = "a@b.c"),
"id_token"
)
)
})
test_that("validate_essential_claims: 'warn' mode warns on missing essential claims", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE)
)
),
claims_validation = "warn"
)
# Reset frequency so the warning fires
rlang::reset_warning_verbosity("claims-validation-missing-id_token")
expect_warning(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"id_token"
),
regexp = "Essential claims missing"
)
})
test_that("validate_essential_claims: 'warn' mode does not error", {
cli <- make_test_client(
claims = list(
userinfo = list(
given_name = list(essential = TRUE)
)
),
claims_validation = "warn"
)
rlang::reset_warning_verbosity("claims-validation-missing-userinfo")
expect_no_error(
suppressWarnings(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"userinfo"
)
)
)
})
test_that("validate_essential_claims: skips when no enforceable claim requirements in spec", {
cli <- make_test_client(
claims = list(
id_token = list(
email = NULL,
profile = list(locale = "nl-BE")
)
),
claims_validation = "strict"
)
# No essential or value/value claim constraints -> nothing to validate
expect_no_error(
shinyOAuth:::validate_essential_claims(cli, list(sub = "user1"), "id_token")
)
})
test_that("validate_essential_claims: skips when client has no claims", {
cli <- make_test_client(
claims = NULL,
claims_validation = "strict"
)
# No claims at all -> nothing to validate
expect_no_error(
shinyOAuth:::validate_essential_claims(cli, list(sub = "user1"), "id_token")
)
})
test_that("validate_essential_claims: error message lists missing claims", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE),
acr = list(essential = TRUE)
)
),
claims_validation = "strict"
)
err <- tryCatch(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"id_token"
),
error = function(e) e
)
expect_s3_class(err, "shinyOAuth_id_token_error")
expect_match(conditionMessage(err), "auth_time")
expect_match(conditionMessage(err), "acr")
})
test_that("validate_essential_claims: partially present essential claims", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE),
email = list(essential = TRUE)
)
),
claims_validation = "strict"
)
# auth_time present, email missing
expect_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1", auth_time = 12345),
"id_token"
),
regexp = "email"
)
})
test_that("validate_essential_claims: 'strict' mode errors on mismatched requested claim value", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
acr = list(values = c("urn:example:gold", "urn:example:silver"))
)
),
claims_validation = "strict"
)
expect_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1", acr = "urn:example:bronze"),
"id_token"
),
regexp = "Requested claim values not satisfied"
)
})
test_that("validate_essential_claims: 'strict' mode errors when value-constrained claim is missing", {
cli <- make_test_client(
claims = list(
userinfo = list(
zoneinfo = list(value = "Europe/Brussels")
)
),
claims_validation = "strict"
)
expect_error(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1"),
"userinfo"
),
regexp = "zoneinfo is missing"
)
})
test_that("validate_essential_claims: 'warn' mode warns on mismatched requested claim value", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
email_verified = list(value = TRUE)
)
),
claims_validation = "warn"
)
rlang::reset_warning_verbosity("claims-validation-missing-id_token")
expect_warning(
shinyOAuth:::validate_essential_claims(
cli,
list(sub = "user1", email_verified = FALSE),
"id_token"
),
regexp = "Requested claim values not satisfied"
)
})
test_that("validate_essential_claims: accepts matching requested claim values", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
acr = list(values = c("urn:example:gold", "urn:example:silver")),
email_verified = list(value = TRUE)
)
),
claims_validation = "strict"
)
expect_no_error(
shinyOAuth:::validate_essential_claims(
cli,
list(
sub = "user1",
acr = "urn:example:silver",
email_verified = TRUE
),
"id_token"
)
)
})
# --- Integration tests via handle_callback() ----------------------------------
test_that("claims_validation = 'strict' errors during handle_callback for missing validated ID token essential claims", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
auth_time = list(essential = TRUE)
)
),
claims_validation = "strict"
)
tok <- valid_browser_token()
url <- shinyOAuth:::prepare_call(cli, browser_token = tok)
enc <- parse_query_param(url, "state")
# Mock token exchange returning an ID token without auth_time
# We need id_token_validation = FALSE so it doesn't fail on signature
# Create a minimal JWT payload without auth_time
# Note: gsub removes newlines that jsonlite::base64url_enc may insert
header <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(list(alg = "none", typ = "JWT"), auto_unbox = TRUE)
)
)
payload <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(
list(
sub = "user1",
iss = "https://issuer.example.com",
aud = "abc",
exp = as.numeric(Sys.time()) + 3600,
iat = as.numeric(Sys.time())
),
auto_unbox = TRUE
)
)
)
fake_jwt <- paste(header, payload, "", sep = ".")
expect_error(
testthat::with_mocked_bindings(
validate_id_token = function(...) {
invisible(TRUE)
},
swap_code_for_token_set = function(client, code, code_verifier) {
list(
access_token = "t",
token_type = "Bearer",
id_token = fake_jwt,
expires_in = 3600
)
},
.package = "shinyOAuth",
shinyOAuth:::handle_callback(
cli,
code = "ok",
payload = enc,
browser_token = tok
)
),
class = "shinyOAuth_id_token_error"
)
})
test_that("claims_validation = 'strict' errors during handle_callback for mismatched validated ID token claim values", {
cli <- make_test_client(
use_nonce = TRUE,
claims = list(
id_token = list(
acr = list(values = c("urn:example:gold", "urn:example:silver"))
)
),
claims_validation = "strict"
)
tok <- valid_browser_token()
url <- shinyOAuth:::prepare_call(cli, browser_token = tok)
enc <- parse_query_param(url, "state")
header <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(list(alg = "none", typ = "JWT"), auto_unbox = TRUE)
)
)
payload <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(
list(
sub = "user1",
iss = "https://issuer.example.com",
aud = "abc",
acr = "urn:example:bronze",
exp = as.numeric(Sys.time()) + 3600,
iat = as.numeric(Sys.time())
),
auto_unbox = TRUE
)
)
)
fake_jwt <- paste(header, payload, "", sep = ".")
expect_error(
testthat::with_mocked_bindings(
validate_id_token = function(...) {
invisible(TRUE)
},
swap_code_for_token_set = function(client, code, code_verifier) {
list(
access_token = "t",
token_type = "Bearer",
id_token = fake_jwt,
expires_in = 3600
)
},
.package = "shinyOAuth",
shinyOAuth:::handle_callback(
cli,
code = "ok",
payload = enc,
browser_token = tok
)
),
class = "shinyOAuth_id_token_error"
)
})
test_that("claims_validation = 'none' does not error for missing ID token essential claims in handle_callback", {
cli <- make_test_client(
claims = list(
id_token = list(
auth_time = list(essential = TRUE)
)
),
claims_validation = "none"
)
tok <- valid_browser_token()
url <- shinyOAuth:::prepare_call(cli, browser_token = tok)
enc <- parse_query_param(url, "state")
header <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(list(alg = "none", typ = "JWT"), auto_unbox = TRUE)
)
)
payload <- gsub(
"\n",
"",
jsonlite::base64url_enc(
jsonlite::toJSON(
list(
sub = "user1",
iss = "https://example.com",
aud = "abc",
exp = as.numeric(Sys.time()) + 3600,
iat = as.numeric(Sys.time())
),
auto_unbox = TRUE
)
)
)
fake_jwt <- paste(header, payload, "", sep = ".")
result <- testthat::with_mocked_bindings(
swap_code_for_token_set = function(client, code, code_verifier) {
list(
access_token = "my_access_token",
token_type = "Bearer",
id_token = fake_jwt,
expires_in = 3600
)
},
.package = "shinyOAuth",
shinyOAuth:::handle_callback(
cli,
code = "ok",
payload = enc,
browser_token = tok
)
)
expect_true(S7::S7_inherits(result, OAuthToken))
expect_equal(result@access_token, "my_access_token")
})
# --- OAuthClient validation ---------------------------------------------------
test_that("claims_validation defaults to 'none' when no enforceable claims are requested", {
prov <- make_test_provider()
cli <- oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid"
)
expect_equal(cli@claims_validation, "none")
})
test_that("claims_validation defaults to 'warn' when enforceable claims are requested", {
prov <- make_test_provider(use_pkce = TRUE, use_nonce = TRUE)
cli <- oauth_client(
provider = prov,
client_id = "abc",
client_secret = "",
redirect_uri = "http://localhost:8100",
scopes = "openid",
claims = list(
userinfo = list(email_verified = list(value = TRUE))
)
)
expect_equal(cli@claims_validation, "warn")
})
test_that("invalid claims_validation value is rejected by oauth_client()", {
expect_error(
make_test_client(claims_validation = "invalid")
)
})
test_that("claims_validation accepts 'strict', 'warn', 'none'", {
for (mode in c("strict", "warn", "none")) {
cli <- make_test_client(claims_validation = mode)
expect_equal(cli@claims_validation, mode)
}
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.