diff --git a/tests/integration/src/federation/identity_provider.rs b/tests/integration/src/federation/identity_provider.rs index 92c67c61d..417e72555 100644 --- a/tests/integration/src/federation/identity_provider.rs +++ b/tests/integration/src/federation/identity_provider.rs @@ -11,60 +11,31 @@ // limitations under the License. // // SPDX-License-Identifier: Apache-2.0 -//! Test identity provider creation. +//! Test identity provider API. -use eyre::Result; -use tracing_test::traced_test; +mod create; +mod delete; +mod get; +mod issuer; +mod list; +mod update; use openstack_keystone_core_types::federation::IdentityProviderCreate; -use crate::common::get_state; -use crate::create_domain; -use crate::federation::create_identity_provider; - -/// Every identity provider creation also upserts a shared, table-global -/// `mapping` row (id `dummy`) used by the legacy v3 federation protocol -/// entries, via `INSERT ... ON CONFLICT (id) DO NOTHING`. The row is -/// created by the first identity provider and every subsequent one must -/// hit -- and tolerate -- that conflict instead of surfacing it as a -/// creation failure. -/// -/// Regression test for a bug where `on_conflict(..).do_nothing_on(..)` -/// combined with sea-orm's `RETURNING`-based insert path turned "no rows -/// returned because of the conflict" into a hard `DbErr::RecordNotInserted`, -/// making every identity provider creation after the first one fail with a -/// 500. Fixed by using `on_conflict_do_nothing_on`, whose `TryInsert::exec` -/// maps that outcome to `TryInsertResult::Conflicted` instead of an error. -#[traced_test] -#[tokio::test] -async fn test_create_second_identity_provider_does_not_fail_on_shared_legacy_row() -> Result<()> { - let (state, _tmp) = get_state().await?; - let domain = create_domain!(state)?; - - let first = create_identity_provider( - &state, - IdentityProviderCreate { - name: uuid::Uuid::new_v4().simple().to_string(), - domain_id: Some(domain.id.clone()), - ..Default::default() - }, - ) - .await?; - assert!(!first.id.is_empty()); - - // This is the call that used to 500 once the "dummy" mapping row - // already existed from the first creation above. - let second = create_identity_provider( - &state, - IdentityProviderCreate { - name: uuid::Uuid::new_v4().simple().to_string(), - domain_id: Some(domain.id.clone()), - ..Default::default() - }, - ) - .await?; - assert!(!second.id.is_empty()); - assert_ne!(first.id, second.id); +pub(super) fn unique() -> String { + uuid::Uuid::new_v4().simple().to_string() +} - Ok(()) +pub(super) fn idp( + domain_id: Option<&str>, + issuer: Option<&str>, + enabled: bool, +) -> IdentityProviderCreate { + IdentityProviderCreate { + name: unique(), + domain_id: domain_id.map(Into::into), + bound_issuer: issuer.map(Into::into), + enabled, + ..Default::default() + } } diff --git a/tests/integration/src/federation/identity_provider/create.rs b/tests/integration/src/federation/identity_provider/create.rs new file mode 100644 index 000000000..b59045c55 --- /dev/null +++ b/tests/integration/src/federation/identity_provider/create.rs @@ -0,0 +1,127 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider creation. + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone_core::auth::ExecutionContext; +use openstack_keystone_core_types::federation::IdentityProviderCreate; + +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +/// Every identity provider creation also upserts a shared, table-global +/// `mapping` row (id `dummy`) used by the legacy v3 federation protocol +/// entries, via `INSERT ... ON CONFLICT (id) DO NOTHING`. The row is +/// created by the first identity provider and every subsequent one must +/// hit -- and tolerate -- that conflict instead of surfacing it as a +/// creation failure. +/// +/// Regression test for a bug where `on_conflict(..).do_nothing_on(..)` +/// combined with sea-orm's `RETURNING`-based insert path turned "no rows +/// returned because of the conflict" into a hard `DbErr::RecordNotInserted`, +/// making every identity provider creation after the first one fail with a +/// 500. Fixed by using `on_conflict_do_nothing_on`, whose `TryInsert::exec` +/// maps that outcome to `TryInsertResult::Conflicted` instead of an error. +#[traced_test] +#[tokio::test] +async fn test_create_second_identity_provider_does_not_fail_on_shared_legacy_row() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + + let first = create_identity_provider( + &state, + IdentityProviderCreate { + name: uuid::Uuid::new_v4().simple().to_string(), + domain_id: Some(domain.id.clone()), + ..Default::default() + }, + ) + .await?; + assert!(!first.id.is_empty()); + + // This is the call that used to 500 once the "dummy" mapping row + // already existed from the first creation above. + let second = create_identity_provider( + &state, + IdentityProviderCreate { + name: uuid::Uuid::new_v4().simple().to_string(), + domain_id: Some(domain.id.clone()), + ..Default::default() + }, + ) + .await?; + assert!(!second.id.is_empty()); + assert_ne!(first.id, second.id); + + Ok(()) +} + +/// Supplied fields are stored and readable back; an explicit id is honoured +/// and cannot be reused. +#[traced_test] +#[tokio::test] +async fn test_create_persists_fields() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + let id = uuid::Uuid::new_v4().simple().to_string(); + let issuer = format!("https://{id}.example.com"); + + let created = create_identity_provider( + &state, + IdentityProviderCreate { + id: Some(id.clone()), + name: id.clone(), + domain_id: Some(domain.id.clone()), + enabled: true, + bound_issuer: Some(issuer.clone()), + oidc_client_id: Some("client".into()), + oidc_scopes: Some(vec!["openid".into(), "email".into()]), + ..Default::default() + }, + ) + .await?; + assert_eq!(id, created.id); + + let got = fed + .get_identity_provider(&ctx, &id) + .await? + .ok_or_else(|| eyre::eyre!("idp missing"))?; + assert_eq!(id, got.name); + assert_eq!(Some(domain.id.clone()), got.domain_id); + assert!(got.enabled); + assert_eq!(Some(issuer), got.bound_issuer); + assert_eq!(Some("client".to_string()), got.oidc_client_id); + assert_eq!( + Some(vec!["openid".to_string(), "email".to_string()]), + got.oidc_scopes + ); + + let dup = fed + .create_identity_provider( + &ctx, + IdentityProviderCreate { + id: Some(id.clone()), + name: uuid::Uuid::new_v4().simple().to_string(), + ..Default::default() + }, + ) + .await; + assert!(dup.is_err(), "{dup:?}"); + Ok(()) +} diff --git a/tests/integration/src/federation/identity_provider/delete.rs b/tests/integration/src/federation/identity_provider/delete.rs new file mode 100644 index 000000000..ffce95f8d --- /dev/null +++ b/tests/integration/src/federation/identity_provider/delete.rs @@ -0,0 +1,53 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider deletion. + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone_core::auth::ExecutionContext; +use openstack_keystone_core::federation::FederationProviderError; + +use super::idp; +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +/// Delete removes the identity provider; second delete is not found. +#[traced_test] +#[tokio::test] +async fn test_delete() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + + let created = create_identity_provider(&state, idp(Some(&domain.id), None, true)).await?; + fed.delete_identity_provider(&ctx, &created.id).await?; + assert!( + fed.get_identity_provider(&ctx, &created.id) + .await? + .is_none() + ); + + let res = fed.delete_identity_provider(&ctx, &created.id).await; + assert!( + matches!( + res, + Err(FederationProviderError::IdentityProviderNotFound(_)) + ), + "{res:?}" + ); + Ok(()) +} diff --git a/tests/integration/src/federation/identity_provider/get.rs b/tests/integration/src/federation/identity_provider/get.rs new file mode 100644 index 000000000..c998372ee --- /dev/null +++ b/tests/integration/src/federation/identity_provider/get.rs @@ -0,0 +1,60 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider retrieval. + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone_core::auth::ExecutionContext; + +use super::{idp, unique}; +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +/// Get returns the created data, and `None` for unknown id. +#[traced_test] +#[tokio::test] +async fn test_get() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + + let issuer = format!("https://{}.example.com", unique()); + let created = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), true)).await?; + let got = fed + .get_identity_provider(&ctx, &created.id) + .await? + .ok_or_else(|| eyre::eyre!("idp missing"))?; + assert_eq!(created.id, got.id); + assert_eq!(created.name, got.name); + assert_eq!(Some(domain.id.clone()), got.domain_id); + assert_eq!(Some(issuer.clone()), got.bound_issuer); + assert!(got.enabled); + + // Global (no domain) IdP is read back with an empty domain. + let global = create_identity_provider(&state, idp(None, None, false)).await?; + let got = fed + .get_identity_provider(&ctx, &global.id) + .await? + .ok_or_else(|| eyre::eyre!("global idp missing"))?; + assert_eq!(None, got.domain_id); + assert_eq!(None, got.bound_issuer); + assert!(!got.enabled); + + assert!(fed.get_identity_provider(&ctx, "missing").await?.is_none()); + Ok(()) +} diff --git a/tests/integration/src/federation/identity_provider/issuer.rs b/tests/integration/src/federation/identity_provider/issuer.rs new file mode 100644 index 000000000..f88b98628 --- /dev/null +++ b/tests/integration/src/federation/identity_provider/issuer.rs @@ -0,0 +1,241 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider issuer lookup and uniqueness. + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone::keystone::ServiceState; +use openstack_keystone_core::auth::ExecutionContext; +use openstack_keystone_core::federation::FederationProviderError; +use openstack_keystone_core_types::federation::IdentityProviderUpdate; + +use super::{idp, unique}; +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +async fn by_issuer( + state: &ServiceState, + domain_id: &str, + issuer: &str, +) -> Result, FederationProviderError> { + Ok(state + .provider + .get_federation_provider() + .get_identity_provider_by_issuer(&ExecutionContext::internal(state), domain_id, issuer) + .await? + .map(|i| i.id)) +} + +/// A domain scoped match wins over a global one with the same issuer. +#[traced_test] +#[tokio::test] +async fn test_by_issuer_domain_precedes_global() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let issuer = format!("https://{}.example.com", unique()); + + let global = create_identity_provider(&state, idp(None, Some(&issuer), true)).await?; + // Only the global one exists: it is returned for any domain. + assert_eq!( + Some(global.id.clone()), + by_issuer(&state, &domain.id, &issuer).await? + ); + + let scoped = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), true)).await?; + assert_eq!( + Some(scoped.id.clone()), + by_issuer(&state, &domain.id, &issuer).await? + ); + + // Another domain does not see the scoped one. + let other = create_domain!(state)?; + assert_eq!( + Some(global.id.clone()), + by_issuer(&state, &other.id, &issuer).await? + ); + Ok(()) +} + +/// Unknown issuer and disabled identity provider both resolve to `None`. +#[traced_test] +#[tokio::test] +async fn test_by_issuer_none_for_unknown_and_disabled() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let issuer = format!("https://{}.example.com", unique()); + + assert_eq!(None, by_issuer(&state, &domain.id, &issuer).await?); + + let _disabled = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), false)).await?; + assert_eq!(None, by_issuer(&state, &domain.id, &issuer).await?); + + // IdPs without bound_issuer (global and domain scoped) never match. + let _no_issuer = create_identity_provider(&state, idp(Some(&domain.id), None, true)).await?; + let _global_no_issuer = create_identity_provider(&state, idp(None, None, true)).await?; + assert_eq!(None, by_issuer(&state, &domain.id, &issuer).await?); + Ok(()) +} + +/// Two enabled IdPs of the same scope cannot share an issuer; a disabled one +/// can, but cannot be re-enabled while the issuer is taken. +#[traced_test] +#[tokio::test] +async fn test_issuer_conflict() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let issuer = format!("https://{}.example.com", unique()); + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + + let first = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), true)).await?; + + let dup = fed + .create_identity_provider(&ctx, idp(Some(&domain.id), Some(&issuer), true)) + .await; + assert!( + matches!(dup, Err(FederationProviderError::Conflict(_))), + "{dup:?}" + ); + + // Same issuer in another scope is fine. + let _global = create_identity_provider(&state, idp(None, Some(&issuer), true)).await?; + + // Disabled duplicate allowed ... + let retired = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), false)).await?; + // ... but re-enabling it conflicts. + let res = fed + .update_identity_provider( + &ctx, + &retired.id, + IdentityProviderUpdate { + enabled: Some(true), + ..Default::default() + }, + ) + .await; + assert!( + matches!(res, Err(FederationProviderError::Conflict(_))), + "{res:?}" + ); + + // Once the first is disabled, re-enabling succeeds. + fed.update_identity_provider( + &ctx, + &first.id, + IdentityProviderUpdate { + enabled: Some(false), + ..Default::default() + }, + ) + .await?; + let res = fed + .update_identity_provider( + &ctx, + &retired.id, + IdentityProviderUpdate { + enabled: Some(true), + ..Default::default() + }, + ) + .await?; + assert!(res.enabled); + Ok(()) +} + +/// A disabled IdP of the domain is not replaced by an enabled global one with +/// the same issuer. +#[traced_test] +#[tokio::test] +async fn test_by_issuer_disabled_domain_idp_blocks_global() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let issuer = format!("https://{}.example.com", unique()); + + let _global = create_identity_provider(&state, idp(None, Some(&issuer), true)).await?; + let _scoped = + create_identity_provider(&state, idp(Some(&domain.id), Some(&issuer), false)).await?; + assert_eq!(None, by_issuer(&state, &domain.id, &issuer).await?); + Ok(()) +} + +/// Changing `bound_issuer` to a value used by an enabled peer conflicts, while +/// unrelated updates on a (disabled) duplicate keep working. +#[traced_test] +#[tokio::test] +async fn test_issuer_conflict_on_update() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let taken = format!("https://{}.example.com", unique()); + let other = format!("https://{}.example.com", unique()); + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + + let _first = + create_identity_provider(&state, idp(Some(&domain.id), Some(&taken), true)).await?; + let second = + create_identity_provider(&state, idp(Some(&domain.id), Some(&other), true)).await?; + + // Moving onto the taken issuer conflicts ... + let res = fed + .update_identity_provider( + &ctx, + &second.id, + IdentityProviderUpdate { + bound_issuer: Some(Some(taken.clone())), + ..Default::default() + }, + ) + .await; + assert!( + matches!(res, Err(FederationProviderError::Conflict(_))), + "{res:?}" + ); + // ... and leaves the old issuer in place. + assert_eq!( + Some(second.id.clone()), + by_issuer(&state, &domain.id, &other).await? + ); + // Re-setting its own issuer is not a conflict with itself. + fed.update_identity_provider( + &ctx, + &second.id, + IdentityProviderUpdate { + bound_issuer: Some(Some(other.clone())), + ..Default::default() + }, + ) + .await?; + + // A disabled duplicate can be renamed. + let retired = + create_identity_provider(&state, idp(Some(&domain.id), Some(&taken), false)).await?; + let renamed = fed + .update_identity_provider( + &ctx, + &retired.id, + IdentityProviderUpdate { + name: Some(unique()), + ..Default::default() + }, + ) + .await?; + assert!(!renamed.enabled); + Ok(()) +} diff --git a/tests/integration/src/federation/identity_provider/list.rs b/tests/integration/src/federation/identity_provider/list.rs new file mode 100644 index 000000000..15e6d35dd --- /dev/null +++ b/tests/integration/src/federation/identity_provider/list.rs @@ -0,0 +1,146 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider listing. + +use std::collections::HashSet; + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone_core::auth::ExecutionContext; +use openstack_keystone_core_types::ListPagination; +use openstack_keystone_core_types::federation::IdentityProviderListParameters; + +use super::{idp, unique}; +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +/// List filters: name, bound_issuer, domain_ids (incl. global) and paging. +#[traced_test] +#[tokio::test] +async fn test_list_filters() -> Result<()> { + let (state, _tmp) = get_state().await?; + let d1 = create_domain!(state)?; + let d2 = create_domain!(state)?; + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + let issuer = format!("https://{}.example.com", unique()); + + let a = create_identity_provider(&state, idp(Some(&d1.id), Some(&issuer), true)).await?; + let b = create_identity_provider(&state, idp(Some(&d1.id), None, true)).await?; + let c = create_identity_provider(&state, idp(Some(&d2.id), None, true)).await?; + let g = create_identity_provider(&state, idp(None, None, true)).await?; + + let ids = |v: Vec| { + v.into_iter().map(|i| i.id).collect::>() + }; + let list = |p: IdentityProviderListParameters| { + let fed = &fed; + let ctx = &ctx; + async move { fed.list_identity_providers(ctx, &p).await } + }; + + let all = ids(list(IdentityProviderListParameters::default()).await?); + for i in [&a.id, &b.id, &c.id, &g.id] { + assert!(all.contains(i)); + } + + let by_name = ids(list(IdentityProviderListParameters { + name: Some(b.name.clone()), + ..Default::default() + }) + .await?); + assert_eq!(HashSet::from([b.id.clone()]), by_name); + + let by_iss = ids(list(IdentityProviderListParameters { + bound_issuer: Some(issuer.clone()), + ..Default::default() + }) + .await?); + assert_eq!(HashSet::from([a.id.clone()]), by_iss); + + let by_d1 = ids(list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d1.id.clone())])), + ..Default::default() + }) + .await?); + assert_eq!(HashSet::from([a.id.clone(), b.id.clone()]), by_d1); + + let d2_and_global = ids(list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d2.id.clone()), None])), + ..Default::default() + }) + .await?); + assert_eq!(HashSet::from([c.id.clone(), g.id.clone()]), d2_and_global); + + // The provider contract is "up to limit + 1 rows" (one extra row lets the + // API layer tell whether another page exists). + let page = list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d1.id.clone())])), + pagination: ListPagination { + limit: Some(1), + ..Default::default() + }, + ..Default::default() + }) + .await?; + assert_eq!(2, page.len()); + + // Marker is exclusive: the page after the first entry holds the rest. + let first = page[0].id.clone(); + let next = list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d1.id.clone())])), + pagination: ListPagination { + limit: Some(10), + marker: Some(first.clone()), + ..Default::default() + }, + ..Default::default() + }) + .await?; + assert_eq!(1, next.len()); + assert_ne!(first, next[0].id); + + // Exact boundary: asking for as many rows as exist returns no more. + let exact = list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d1.id.clone())])), + pagination: ListPagination { + limit: Some(2), + ..Default::default() + }, + ..Default::default() + }) + .await?; + assert_eq!(2, exact.len()); + + // Reverse paging: marker is exclusive and rows precede it, ascending. + let mut d1_ids = vec![a.id.clone(), b.id.clone()]; + d1_ids.sort(); + let prev = list(IdentityProviderListParameters { + domain_ids: Some(HashSet::from([Some(d1.id.clone())])), + pagination: ListPagination { + limit: Some(10), + marker: Some(d1_ids[1].clone()), + page_reverse: true, + }, + ..Default::default() + }) + .await?; + assert_eq!( + vec![d1_ids[0].clone()], + prev.into_iter().map(|i| i.id).collect::>() + ); + Ok(()) +} diff --git a/tests/integration/src/federation/identity_provider/update.rs b/tests/integration/src/federation/identity_provider/update.rs new file mode 100644 index 000000000..5da861248 --- /dev/null +++ b/tests/integration/src/federation/identity_provider/update.rs @@ -0,0 +1,134 @@ +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// SPDX-License-Identifier: Apache-2.0 +//! Test identity provider update. + +use eyre::Result; +use tracing_test::traced_test; + +use openstack_keystone_core::auth::ExecutionContext; +use openstack_keystone_core::federation::FederationProviderError; +use openstack_keystone_core_types::federation::IdentityProviderUpdate; + +use super::{idp, unique}; +use crate::common::get_state; +use crate::create_domain; +use crate::federation::create_identity_provider; + +/// Update changes only the supplied fields and can clear optional ones. +#[traced_test] +#[tokio::test] +async fn test_update() -> Result<()> { + let (state, _tmp) = get_state().await?; + let domain = create_domain!(state)?; + let fed = state.provider.get_federation_provider(); + let ctx = ExecutionContext::internal(&state); + + let created = + create_identity_provider(&state, idp(Some(&domain.id), Some("https://i"), true)).await?; + let new_name = unique(); + + let updated = fed + .update_identity_provider( + &ctx, + &created.id, + IdentityProviderUpdate { + name: Some(new_name.clone()), + ..Default::default() + }, + ) + .await?; + assert_eq!(new_name, updated.name); + assert_eq!(Some("https://i".to_string()), updated.bound_issuer); + assert!(updated.enabled); + + let cleared = fed + .update_identity_provider( + &ctx, + &created.id, + IdentityProviderUpdate { + bound_issuer: Some(None), + ..Default::default() + }, + ) + .await?; + assert_eq!(None, cleared.bound_issuer); + let fetched = fed + .get_identity_provider(&ctx, &created.id) + .await? + .ok_or_else(|| eyre::eyre!("idp missing"))?; + assert_eq!(None, fetched.bound_issuer); + + // Disabling persists. + let disabled = fed + .update_identity_provider( + &ctx, + &created.id, + IdentityProviderUpdate { + enabled: Some(false), + ..Default::default() + }, + ) + .await?; + assert!(!disabled.enabled); + let fetched = fed + .get_identity_provider(&ctx, &created.id) + .await? + .ok_or_else(|| eyre::eyre!("idp missing"))?; + assert!(!fetched.enabled); + + // Other fields can be set and cleared. + let set = fed + .update_identity_provider( + &ctx, + &created.id, + IdentityProviderUpdate { + oidc_client_id: Some(Some("client".into())), + oidc_scopes: Some(Some(vec!["openid".into()])), + jwks_url: Some(Some("https://jwks.example.com".into())), + ..Default::default() + }, + ) + .await?; + assert_eq!(Some("client".to_string()), set.oidc_client_id); + assert_eq!(Some(vec!["openid".to_string()]), set.oidc_scopes); + let cleared = fed + .update_identity_provider( + &ctx, + &created.id, + IdentityProviderUpdate { + oidc_client_id: Some(None), + oidc_scopes: Some(None), + ..Default::default() + }, + ) + .await?; + assert_eq!(None, cleared.oidc_client_id); + assert_eq!(None, cleared.oidc_scopes); + assert_eq!( + Some("https://jwks.example.com".to_string()), + cleared.jwks_url + ); + + let res = fed + .update_identity_provider(&ctx, "missing", IdentityProviderUpdate::default()) + .await; + assert!( + matches!( + res, + Err(FederationProviderError::IdentityProviderNotFound(_)) + ), + "{res:?}" + ); + Ok(()) +}