scim-server 0.5.3

//! Unit tests for the MCP integration module.

#[cfg(feature = "mcp")]
mod tests {
    use scim_server::ScimServer;
    use scim_server::mcp_integration::ScimMcpServer;
    use scim_server::providers::StandardResourceProvider;
    use scim_server::resource_handlers::create_user_resource_handler;
    use scim_server::storage::InMemoryStorage;
    use serde_json::json;

    #[tokio::test]
    async fn test_mcp_server_creation() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![scim_server::multi_tenant::ScimOperation::Create],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);
        assert_eq!(mcp_server.server_info().name, "SCIM Server");
    }

    #[tokio::test]
    async fn test_mcp_tools_list() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let scim_server = ScimServer::new(provider).unwrap();
        let mcp_server = ScimMcpServer::new(scim_server);

        let tools = mcp_server.get_tools();
        assert!(!tools.is_empty());

        let tool_names: Vec<_> = tools
            .iter()
            .filter_map(|t| t.get("name").and_then(|n| n.as_str()))
            .collect();
        assert!(tool_names.contains(&"scim_create_user"));
        assert!(tool_names.contains(&"scim_get_user"));
        assert!(tool_names.contains(&"scim_list_users"));
    }

    #[tokio::test]
    async fn test_mcp_tool_execution() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::List,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Test get schemas tool
        let result = mcp_server.execute_tool("scim_get_schemas", json!({})).await;
        assert!(result.success);

        // Test list users tool
        let result = mcp_server.execute_tool("scim_list_users", json!({})).await;
        assert!(result.success);
    }

    #[tokio::test]
    async fn test_mcp_user_conditional_update_raw_version() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::Update,
                    scim_server::multi_tenant::ScimOperation::Read,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Create a user first
        let create_args = json!({
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "test.user@example.com",
                "active": true,
                "name": {
                    "givenName": "Test",
                    "familyName": "User"
                }
            }
        });

        let create_result = mcp_server
            .execute_tool("scim_create_user", create_args)
            .await;
        assert!(create_result.success, "User creation should succeed");

        let created_user = create_result.content;
        let user_id = created_user["id"].as_str().unwrap();

        // Get the user to retrieve current version in ETag format
        let get_args = json!({
            "user_id": user_id
        });

        let get_result = mcp_server.execute_tool("scim_get_user", get_args).await;
        assert!(get_result.success, "User get should succeed");

        let user_data = get_result.content;
        let etag_version = user_data["meta"]["version"].as_str().unwrap();

        // Extract raw version from ETag format (remove W/" and ")
        let raw_version = if etag_version.starts_with("W/\"") && etag_version.ends_with("\"") {
            &etag_version[3..etag_version.len() - 1]
        } else {
            etag_version
        };

        // Test conditional update with raw version - should succeed
        let update_args = json!({
            "user_id": user_id,
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "test.user@example.com",
                "active": true,
                "name": {
                    "givenName": "Test",
                    "familyName": "Updated"
                }
            },
            "expected_version": raw_version
        });

        let update_result = mcp_server
            .execute_tool("scim_update_user", update_args)
            .await;

        // Add diagnostic output
        println!("Raw version extracted: '{}'", raw_version);
        println!("ETag version from get: '{}'", etag_version);
        println!("Update result success: {}", update_result.success);
        if !update_result.success {
            println!("Update error: {}", update_result.content);
        }

        assert!(
            update_result.success,
            "Conditional update with correct raw version should succeed. Error: {}",
            if update_result.success {
                "none".to_string()
            } else {
                update_result.content.to_string()
            }
        );

        // Verify the update actually happened
        let updated_user = update_result.content;
        assert_eq!(
            updated_user["name"]["familyName"].as_str().unwrap(),
            "Updated"
        );

        // Test conditional update with wrong raw version - should fail
        let wrong_update_args = json!({
            "user_id": user_id,
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "test.user@example.com",
                "active": true,
                "name": {
                    "givenName": "Test",
                    "familyName": "ShouldFail"
                }
            },
            "expected_version": "wrong_version_123"
        });

        let wrong_update_result = mcp_server
            .execute_tool("scim_update_user", wrong_update_args)
            .await;
        assert!(
            !wrong_update_result.success,
            "Conditional update with wrong version should fail"
        );
        assert!(
            wrong_update_result.content["error"]
                .as_str()
                .unwrap()
                .contains("modified by another client")
        );
    }

    #[tokio::test]
    async fn test_mcp_user_conditional_delete_raw_version() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::Delete,
                    scim_server::multi_tenant::ScimOperation::Read,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Create a user first
        let create_args = json!({
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "delete.test@example.com",
                "active": true
            }
        });

        let create_result = mcp_server
            .execute_tool("scim_create_user", create_args)
            .await;
        assert!(create_result.success);

        let created_user = create_result.content;
        let user_id = created_user["id"].as_str().unwrap();

        // Get current version
        let get_args = json!({
            "user_id": user_id
        });

        let get_result = mcp_server
            .execute_tool("scim_get_user", get_args.clone())
            .await;
        assert!(get_result.success);

        let user_data = get_result.content;
        let etag_version = user_data["meta"]["version"].as_str().unwrap();

        // Extract raw version from ETag format
        let raw_version = if etag_version.starts_with("W/\"") && etag_version.ends_with("\"") {
            &etag_version[3..etag_version.len() - 1]
        } else {
            etag_version
        };

        // Test conditional delete with wrong version first - should fail
        let wrong_delete_args = json!({
            "user_id": user_id,
            "expected_version": "wrong_version_456"
        });

        let wrong_delete_result = mcp_server
            .execute_tool("scim_delete_user", wrong_delete_args)
            .await;
        assert!(
            !wrong_delete_result.success,
            "Conditional delete with wrong version should fail"
        );

        // Test conditional delete with correct raw version - should succeed
        let delete_args = json!({
            "user_id": user_id,
            "expected_version": raw_version
        });

        let delete_result = mcp_server
            .execute_tool("scim_delete_user", delete_args)
            .await;
        assert!(
            delete_result.success,
            "Conditional delete with correct raw version should succeed"
        );

        // Verify user is actually deleted
        let verify_get_result = mcp_server.execute_tool("scim_get_user", get_args).await;
        assert!(!verify_get_result.success, "User should be deleted");
    }

    #[tokio::test]
    async fn test_mcp_version_format_consistency() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::List,
                    scim_server::multi_tenant::ScimOperation::Read,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Create a user
        let create_args = json!({
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "format.test@example.com",
                "active": true
            }
        });

        let create_result = mcp_server
            .execute_tool("scim_create_user", create_args)
            .await;
        assert!(create_result.success);

        let created_user = create_result.content;
        let user_id = created_user["id"].as_str().unwrap();

        // Test list_users - should return raw format versions
        let list_result = mcp_server.execute_tool("scim_list_users", json!({})).await;
        assert!(list_result.success);

        let users_list = list_result.content.as_array().unwrap();
        let test_user = users_list
            .iter()
            .find(|u| u["id"] == user_id)
            .expect("Should find test user in list");

        let list_version = test_user["meta"]["version"].as_str().unwrap();

        // List operation should return raw format (no W/" prefix)
        assert!(
            !list_version.starts_with("W/\""),
            "List operation should return raw version format, got: {}",
            list_version
        );

        // Test get_user - currently returns ETag format
        let get_args = json!({
            "user_id": user_id
        });

        let get_result = mcp_server.execute_tool("scim_get_user", get_args).await;
        assert!(get_result.success);

        let get_user = get_result.content;
        let get_version = get_user["meta"]["version"].as_str().unwrap();

        // Extract raw part from both versions for comparison
        let list_raw = list_version;
        let get_raw = if get_version.starts_with("W/\"") && get_version.ends_with("\"") {
            &get_version[3..get_version.len() - 1]
        } else {
            get_version
        };

        // The underlying raw versions should be identical
        assert_eq!(
            list_raw, get_raw,
            "Raw version should be same between list ({}) and get ({})",
            list_raw, get_raw
        );
    }

    #[tokio::test]
    async fn test_mcp_etag_and_raw_version_compatibility() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::Update,
                    scim_server::multi_tenant::ScimOperation::Read,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Create a user
        let create_args = json!({
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "compat.test@example.com",
                "active": true,
                "name": {
                    "givenName": "Compat",
                    "familyName": "Test"
                }
            }
        });

        let create_result = mcp_server
            .execute_tool("scim_create_user", create_args)
            .await;
        assert!(create_result.success);

        let created_user = create_result.content;
        let user_id = created_user["id"].as_str().unwrap();

        // Get current version in ETag format
        let get_args = json!({
            "user_id": user_id
        });

        let get_result = mcp_server
            .execute_tool("scim_get_user", get_args.clone())
            .await;
        assert!(get_result.success);

        let user_data = get_result.content;
        let etag_version = user_data["meta"]["version"].as_str().unwrap();

        // Extract raw version
        let _raw_version = if etag_version.starts_with("W/\"") && etag_version.ends_with("\"") {
            &etag_version[3..etag_version.len() - 1]
        } else {
            etag_version
        };

        // Test that both ETag and raw formats work for conditional updates
        // First update with ETag format
        let etag_update_args = json!({
            "user_id": user_id,
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "compat.test@example.com",
                "active": true,
                "name": {
                    "givenName": "Compat",
                    "familyName": "ETagUpdated"
                }
            },
            "expected_version": etag_version
        });

        let etag_update_result = mcp_server
            .execute_tool("scim_update_user", etag_update_args)
            .await;
        // Note: This might fail due to the current bug, but the test documents expected behavior
        if etag_update_result.success {
            assert_eq!(
                etag_update_result.content["name"]["familyName"]
                    .as_str()
                    .unwrap(),
                "ETagUpdated"
            );

            // Get new version for next test
            let get_result2 = mcp_server
                .execute_tool("scim_get_user", get_args.clone())
                .await;
            assert!(get_result2.success);
            let new_etag_version = get_result2.content["meta"]["version"].as_str().unwrap();
            let new_raw_version =
                if new_etag_version.starts_with("W/\"") && new_etag_version.ends_with("\"") {
                    &new_etag_version[3..new_etag_version.len() - 1]
                } else {
                    new_etag_version
                };

            // Test update with raw format
            let raw_update_args = json!({
                "user_id": user_id,
                "user_data": {
                    "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                    "userName": "compat.test@example.com",
                    "active": true,
                    "name": {
                        "givenName": "Compat",
                        "familyName": "RawUpdated"
                    }
                },
                "expected_version": new_raw_version
            });

            let raw_update_result = mcp_server
                .execute_tool("scim_update_user", raw_update_args)
                .await;
            assert!(
                raw_update_result.success,
                "Update with raw version should succeed"
            );
            assert_eq!(
                raw_update_result.content["name"]["familyName"]
                    .as_str()
                    .unwrap(),
                "RawUpdated"
            );
        } else {
            // Document the current limitation
            println!(
                "Note: ETag format conditional update currently fails - this is the bug we're investigating"
            );
            println!(
                "Error: {}",
                etag_update_result.content["error"]
                    .as_str()
                    .unwrap_or("unknown")
            );
        }
    }

    #[tokio::test]
    async fn test_conditional_update_accepts_correct_version() {
        let storage = InMemoryStorage::new();
        let provider = StandardResourceProvider::new(storage);
        let mut scim_server = ScimServer::new(provider).unwrap();

        let user_schema = scim_server
            .get_schema_by_id("urn:ietf:params:scim:schemas:core:2.0:User")
            .unwrap()
            .clone();

        let user_handler = create_user_resource_handler(user_schema);
        scim_server
            .register_resource_type(
                "User",
                user_handler,
                vec![
                    scim_server::multi_tenant::ScimOperation::Create,
                    scim_server::multi_tenant::ScimOperation::Update,
                    scim_server::multi_tenant::ScimOperation::Read,
                ],
            )
            .unwrap();

        let mcp_server = ScimMcpServer::new(scim_server);

        // Create a user first
        let create_args = json!({
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "version.test@example.com",
                "active": true,
                "name": {
                    "givenName": "Version",
                    "familyName": "Test"
                }
            }
        });

        let create_result = mcp_server
            .execute_tool("scim_create_user", create_args)
            .await;
        assert!(create_result.success, "User creation should succeed");

        let created_user = create_result.content;
        let user_id = created_user["id"].as_str().unwrap();
        let initial_version = created_user["meta"]["version"].as_str().unwrap();

        // Extract raw version from ETag format
        let raw_version = if initial_version.starts_with("W/\"") && initial_version.ends_with("\"")
        {
            &initial_version[3..initial_version.len() - 1]
        } else {
            initial_version
        };

        println!(
            "🧪 TEST: Initial version: '{}', Raw version: '{}'",
            initial_version, raw_version
        );

        // Test conditional update with correct version - THIS SHOULD SUCCEED
        let update_args = json!({
            "user_id": user_id,
            "user_data": {
                "schemas": ["urn:ietf:params:scim:schemas:core:2.0:User"],
                "userName": "version.test@example.com",
                "active": true,
                "name": {
                    "givenName": "Version",
                    "familyName": "Updated"
                }
            },
            "expected_version": raw_version
        });

        let update_result = mcp_server
            .execute_tool("scim_update_user", update_args)
            .await;

        println!("🧪 TEST: Update result success: {}", update_result.success);
        if !update_result.success {
            println!("🧪 TEST: Update error: {}", update_result.content);
        }

        // This assertion should pass - but currently fails due to the bug
        assert!(
            update_result.success,
            "Conditional update with CORRECT version should SUCCEED, but it failed with: {}",
            update_result.content
        );

        // Verify the update actually happened
        let updated_user = update_result.content;
        assert_eq!(
            updated_user["name"]["familyName"].as_str().unwrap(),
            "Updated",
            "User should be updated"
        );

        // Verify version changed after successful update
        let new_version = updated_user["meta"]["version"].as_str().unwrap();
        assert_ne!(
            initial_version, new_version,
            "Version should change after successful update"
        );
    }
}