You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: jwt.rs
    path of file: ./repos/graphql-engine/v3/hasura-authn-jwt/src
    
    the code of the file until where you have to start completion: use std::collections::HashMap;
use std::time::Duration;

use axum::http::{HeaderMap, HeaderValue};
use axum::response::IntoResponse;
use cookie::{self, Cookie};
use hasura_authn_core::{Role, SessionVariable, SessionVariableValue};
use jsonptr::Pointer;
use jsonwebtoken::{self as jwt, decode, DecodingKey, Validation};
use jwt::decode_header;
use lazy_static::lazy_static;
use reqwest::header::{AUTHORIZATION, COOKIE};
use reqwest::StatusCode;
use schemars::gen::SchemaGenerator;
use schemars::schema::{Schema, SchemaObject};

use schemars::JsonSchema;
use serde::{de::Error as SerdeDeError, Deserialize, Deserializer, Serialize, Serializer};
use serde_json::Value;
use std::collections::HashSet;
use thiserror::Error;
use tracing_util::{ErrorVisibility, SpanVisibility, TraceableError};
use url::Url;

/// Name of the key, which is by default used to lookup the Hasura claims
/// in the claims obtained after decoding the JWT.
const DEFAULT_HASURA_CLAIMS_NAMESPACE: &str = "https://hasura.io/jwt/claims";

lazy_static! {
    /// Make top level JSON pointer of the `DEFAULT_HASURA_CLAIMS_NAMESPACE`
    /// by escaping the `/` by `~1`.
    pub(crate) static ref DEFAULT_HASURA_CLAIMS_NAMESPACE_POINTER: String =
        "/".to_owned() + &DEFAULT_HASURA_CLAIMS_NAMESPACE.replace('/', "~1");
}

#[derive(Debug, Error)]
pub enum Error {
    #[error("Error decoding the `Authorization` header - {0}")]
    ErrorDecodingAuthorizationHeader(jwt::errors::Error),
    #[error("`kid` (Key ID) header claim not found in the header")]
    KidHeaderNotFound,
    #[error("Expected the Hasura claims to be a String when `claimsFormat` is `stringifiedJson`")]
    ExpectedStringifiedJson,
    #
    
    async fn test_jwt_claims_namespace_path() {
        let alg = jwt::Algorithm::HS256;

        let jwt_secret_config_str = indoc! {r#"
            {
               "key": {
                 "fixed": {
                    "algorithm": "HS256",
                    "key": {
                       "value": "token"
                    }
                 }
               },
               "tokenLocation": {
                  "type": "BearerAuthorization"
               },
               "claimsConfig": {
                  "namespace": {
                     "claimsFormat": "Json",
                     "location": "/foo/hasuraClaims"
                  }
               }
            }
            "#};

        let jwt_config = serde_json::from_str(jwt_secret_config_str).unwrap();

        let hasura_claims = get_default_hasura_claims();
        let claims_str = r#"
                            {
                              "sub": "1234567890",
                              "name": "John Doe",
                              "iat": 1693439022,
                              "exp": 1916239022,
                              "foo": {
                                 "hasuraClaims": {
                                    "x-hasura-default-role": "user",
                                    "x-hasura-allowed-roles": ["foo", "bar", "user"],
                                    "x-hasura-user-id": "1"
                                 }
                              }
                            }"#;
        let claims: Claims = serde_json::from_str(claims_str).unwrap();

        let jwt_header = jwt::Header {
            alg,
            ..Default::default()
        };
        let encoded_claims = encode(
            &jwt_header,
            &claims,
            &EncodingKey::from_secret("token".as_ref()),
        )
        .unwrap();

        let http_client = reqwest::Client::new();

        let decoded_claims =
            decode_and_parse_hasura_claims(&http_client, jwt_config, encoded_claims)
                .await
                .unwrap();
        assert_eq!(hasura_claims, decoded_claims)
    }