jwt-verify 0.1.3

#[cfg(test)]
mod tests {
    use crate::jwk::provider::JwkProvider;
    use crate::jwk::registry::{JwkProviderRegistry, RegistryError};
    use mockito::Server;
    use std::time::Duration;

    #[test]
    fn test_registry_new() {
        let registry = JwkProviderRegistry::new();
        assert_eq!(registry.count(), 0);
    }

    #[test]
    fn test_registry_register() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        // Register the provider
        let result = registry.register("test-id", provider);
        assert!(result.is_ok());

        // Check that the provider was registered
        assert_eq!(registry.count(), 1);
        assert!(registry.contains("test-id"));

        // Create another server instance
        let server2 = Server::new();

        // Try to register with the same ID (should fail)
        let provider2 = JwkProvider::new_with_base_url(
            &server2.url(),
            "test-issuer-2",
            Duration::from_secs(3600),
        )
        .expect("Failed to create JwkProvider");

        let result = registry.register("test-id", provider2);
        assert!(result.is_err());
        if let Err(RegistryError::ProviderAlreadyExists(id)) = result {
            assert_eq!(id, "test-id");
        } else {
            panic!("Expected ProviderAlreadyExists error");
        }
    }

    #[test]
    fn test_registry_register_new() {
        let registry = JwkProviderRegistry::new();

        // Register a new provider
        let result = registry.register_new(
            "test-id",
            "us-east-1",
            "us-east-1_example",
            Duration::from_secs(3600),
        );

        assert!(result.is_ok());
        assert_eq!(registry.count(), 1);
        assert!(registry.contains("test-id"));
    }

    #[test]
    fn test_registry_get() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Get the provider
        let result = registry.get("test-id");
        assert!(result.is_ok());

        // Try to get a non-existent provider
        let result = registry.get("non-existent");
        assert!(result.is_err());
        if let Err(RegistryError::ProviderNotFound(id)) = result {
            assert_eq!(id, "non-existent");
        } else {
            panic!("Expected ProviderNotFound error");
        }
    }

    #[test]
    fn test_registry_get_by_issuer() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Get the provider by issuer
        let result = registry.get_by_issuer("test-issuer");
        assert!(result.is_ok());

        // Try to get a non-existent issuer
        let result = registry.get_by_issuer("non-existent");
        assert!(result.is_err());
        if let Err(RegistryError::IssuerNotFound(issuer)) = result {
            assert_eq!(issuer, "non-existent");
        } else {
            panic!("Expected IssuerNotFound error");
        }
    }

    #[test]
    fn test_registry_find_provider_id_by_issuer() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Find the provider ID by issuer
        let result = registry.find_provider_id_by_issuer("test-issuer");
        assert!(result.is_ok());
        assert_eq!(result.unwrap(), "test-id");

        // Try to find a non-existent issuer
        let result = registry.find_provider_id_by_issuer("non-existent");
        assert!(result.is_err());
        if let Err(RegistryError::IssuerNotFound(issuer)) = result {
            assert_eq!(issuer, "non-existent");
        } else {
            panic!("Expected IssuerNotFound error");
        }
    }

    #[test]
    fn test_registry_remove() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Remove the provider
        let result = registry.remove("test-id");
        assert!(result.is_ok());

        // Check that the provider was removed
        assert_eq!(registry.count(), 0);
        assert!(!registry.contains("test-id"));

        // Try to remove a non-existent provider
        let result = registry.remove("non-existent");
        assert!(result.is_err());
        if let Err(RegistryError::ProviderNotFound(id)) = result {
            assert_eq!(id, "non-existent");
        } else {
            panic!("Expected ProviderNotFound error");
        }
    }

    #[test]
    fn test_registry_list_ids() {
        let registry = JwkProviderRegistry::new();

        // Create server instances
        let server1 = Server::new();
        let server2 = Server::new();

        // Create and register providers
        let provider1 = JwkProvider::new_with_base_url(
            &server1.url(),
            "test-issuer-1",
            Duration::from_secs(3600),
        )
        .expect("Failed to create JwkProvider");

        let provider2 = JwkProvider::new_with_base_url(
            &server2.url(),
            "test-issuer-2",
            Duration::from_secs(3600),
        )
        .expect("Failed to create JwkProvider");

        registry
            .register("test-id-1", provider1)
            .expect("Failed to register provider");
        registry
            .register("test-id-2", provider2)
            .expect("Failed to register provider");

        // List provider IDs
        let ids = registry.list_ids();
        assert_eq!(ids.len(), 2);
        assert!(ids.contains(&"test-id-1".to_string()));
        assert!(ids.contains(&"test-id-2".to_string()));
    }

    #[test]
    fn test_registry_create_validation_for_issuer() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new();

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Create validation for issuer
        let result = registry.create_validation_for_issuer(
            "test-issuer",
            Duration::from_secs(60),
            &vec!["test-client-id".to_string()],
        );
        assert!(result.is_ok());

        let validation = result.unwrap();
        assert!(validation.validate_exp);
        assert!(validation.validate_nbf);
        assert_eq!(validation.leeway, 60);

        // Check that the issuer is set correctly
        let iss_vec = validation.iss.as_ref().expect("Expected issuer to be set");
        assert_eq!(iss_vec.len(), 1);
        assert!(iss_vec.contains(&"test-issuer".to_string()));

        // Try to create validation for non-existent issuer
        let result = registry.create_validation_for_issuer(
            "non-existent",
            Duration::from_secs(60),
            &vec!["test-client-id".to_string()],
        );
        assert!(result.is_err());
        if let Err(RegistryError::IssuerNotFound(issuer)) = result {
            assert_eq!(issuer, "non-existent");
        } else {
            panic!("Expected IssuerNotFound error");
        }
    }

    #[tokio::test]
    async fn test_registry_prefetch() {
        let registry = JwkProviderRegistry::new();

        // Create a server instance
        let server = Server::new_async().await;

        // Create and register a provider
        let provider =
            JwkProvider::new_with_base_url(&server.url(), "test-issuer", Duration::from_secs(3600))
                .expect("Failed to create JwkProvider");

        registry
            .register("test-id", provider)
            .expect("Failed to register provider");

        // Prefetch for a specific provider
        let _result = registry.prefetch("test-id").await;
        // This will likely fail since we're not mocking the HTTP response,
        // but we're just testing the method call, not the actual prefetching

        // Try to prefetch for a non-existent provider
        let result = registry.prefetch("non-existent").await;
        assert!(result.is_err());
        if let Err(RegistryError::ProviderNotFound(id)) = result {
            assert_eq!(id, "non-existent");
        } else {
            panic!("Expected ProviderNotFound error");
        }
    }

    #[tokio::test]
    async fn test_registry_prefetch_all() {
        let registry = JwkProviderRegistry::new();

        // Create server instances
        let (server1, server2) = tokio::join!(Server::new_async(), Server::new_async());

        // Create and register providers
        let provider1 = JwkProvider::new_with_base_url(
            &server1.url(),
            "test-issuer-1",
            Duration::from_secs(3600),
        )
        .expect("Failed to create JwkProvider");

        let provider2 = JwkProvider::new_with_base_url(
            &server2.url(),
            "test-issuer-2",
            Duration::from_secs(3600),
        )
        .expect("Failed to create JwkProvider");

        registry
            .register("test-id-1", provider1)
            .expect("Failed to register provider");
        registry
            .register("test-id-2", provider2)
            .expect("Failed to register provider");

        // hydrate
        let results = registry.hydrate().await;
        assert_eq!(results.len(), 2);

        // Check that the results contain the expected provider IDs
        let ids: Vec<String> = results.iter().map(|(id, _)| id.clone()).collect();
        assert!(ids.contains(&"test-id-1".to_string()));
        assert!(ids.contains(&"test-id-2".to_string()));
    }
}