test: Add resource provider integration tests

tests/integration/src/resource/domain/create.rs

@@ -16,6 +16,9 @@
 use eyre::Result;
 use tracing_test::traced_test;
 
+use openstack_keystone_core::auth::ExecutionContext;
+use openstack_keystone_core_types::resource::DomainCreateBuilder;
+
 use crate::common::get_state;
 
 #[traced_test]
@@ -35,3 +38,45 @@ async fn test_create() -> Result<()> {
     assert!(domain.enabled);
     Ok(())
 }
+
+#[traced_test]
+#[tokio::test]
+async fn test_create_invalid_name_too_long() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+
+    let result = state
+        .provider
+        .get_resource_provider()
+        .create_domain(
+            &ExecutionContext::internal(&state),
+            DomainCreateBuilder::default()
+                .name("x".repeat(256))
+                .build()?,
+        )
+        .await;
+    assert!(
+        result.is_err(),
+        "creating a domain with an over-length name is rejected"
+    );
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_create_invalid_empty_name() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+
+    let result = state
+        .provider
+        .get_resource_provider()
+        .create_domain(
+            &ExecutionContext::internal(&state),
+            DomainCreateBuilder::default().name("").build()?,
+        )
+        .await;
+    assert!(
+        result.is_err(),
+        "creating a domain with an empty name is rejected"
+    );
+    Ok(())
+}

tests/integration/src/resource/domain/get.rs

@@ -56,3 +56,48 @@ async fn test_get_domain_missing() -> Result<()> {
     );
     Ok(())
 }
+
+#[traced_test]
+#[tokio::test]
+async fn test_find_domain_by_name() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+
+    let res = state
+        .provider
+        .get_resource_provider()
+        .find_domain_by_name(&ExecutionContext::internal(&state), &domain.name)
+        .await?
+        .expect("domain found by name");
+    assert_eq!(res.id, domain.id);
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_find_domain_by_name_missing() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+
+    let res = state
+        .provider
+        .get_resource_provider()
+        .find_domain_by_name(&ExecutionContext::internal(&state), "no-such-domain")
+        .await?;
+    assert!(res.is_none(), "an unknown domain name returns None");
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_get_domain_enabled() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+
+    let enabled = state
+        .provider
+        .get_resource_provider()
+        .get_domain_enabled(&ExecutionContext::internal(&state), &domain.id)
+        .await?;
+    assert!(enabled, "a newly created domain is enabled");
+    Ok(())
+}

tests/integration/src/resource/project/create.rs

@@ -16,6 +16,9 @@
 use eyre::Result;
 use tracing_test::traced_test;
 
+use openstack_keystone_core::auth::ExecutionContext;
+use openstack_keystone_core_types::resource::ProjectCreateBuilder;
+
 use crate::common::get_state;
 use crate::create_domain;
 use crate::create_project;
@@ -32,3 +35,51 @@ async fn test_create() -> Result<()> {
     assert!(project.enabled);
     Ok(())
 }
+
+#[traced_test]
+#[tokio::test]
+async fn test_create_invalid_name_too_long() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+
+    let result = state
+        .provider
+        .get_resource_provider()
+        .create_project(
+            &ExecutionContext::internal(&state),
+            ProjectCreateBuilder::default()
+                .name("x".repeat(256))
+                .domain_id(domain.id.clone())
+                .build()?,
+        )
+        .await;
+    assert!(
+        result.is_err(),
+        "creating a project with an over-length name is rejected"
+    );
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_create_invalid_empty_name() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+
+    let result = state
+        .provider
+        .get_resource_provider()
+        .create_project(
+            &ExecutionContext::internal(&state),
+            ProjectCreateBuilder::default()
+                .name("")
+                .domain_id(domain.id.clone())
+                .build()?,
+        )
+        .await;
+    assert!(
+        result.is_err(),
+        "creating a project with an empty name is rejected"
+    );
+    Ok(())
+}

tests/integration/src/resource/project/get.rs

@@ -59,3 +59,90 @@ async fn test_get_project_missing() -> Result<()> {
     );
     Ok(())
 }
+
+#[traced_test]
+#[tokio::test]
+async fn test_get_project_by_name() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+    let project = create_project!(state, domain.id.clone())?;
+
+    let res = state
+        .provider
+        .get_resource_provider()
+        .get_project_by_name(
+            &ExecutionContext::internal(&state),
+            &project.name,
+            &domain.id,
+        )
+        .await?
+        .expect("project found by name");
+    assert_eq!(res.id, project.id);
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_get_project_by_name_missing() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+
+    let res = state
+        .provider
+        .get_resource_provider()
+        .get_project_by_name(
+            &ExecutionContext::internal(&state),
+            "no-such-project",
+            &domain.id,
+        )
+        .await?;
+    assert!(res.is_none(), "an unknown project name returns None");
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_get_project_parents() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+    let parent = create_project!(state, domain.id.clone())?;
+    let child = create_project!(state, domain.id.clone(), parent.id.clone())?;
+
+    let parents = state
+        .provider
+        .get_resource_provider()
+        .get_project_parents(&ExecutionContext::internal(&state), &child.id)
+        .await?
+        .expect("parents returned");
+    assert!(
+        parents.iter().any(|p| p.id == parent.id),
+        "the parent project is in the chain"
+    );
+    Ok(())
+}
+
+#[traced_test]
+#[tokio::test]
+async fn test_get_project_parents_multi_level() -> Result<()> {
+    let (state, _tmp) = get_state().await?;
+    let domain = create_domain!(state)?;
+    let grandparent = create_project!(state, domain.id.clone())?;
+    let parent = create_project!(state, domain.id.clone(), grandparent.id.clone())?;
+    let child = create_project!(state, domain.id.clone(), parent.id.clone())?;
+
+    let parents = state
+        .provider
+        .get_resource_provider()
+        .get_project_parents(&ExecutionContext::internal(&state), &child.id)
+        .await?
+        .expect("parents returned");
+    assert!(
+        parents.iter().any(|p| p.id == parent.id),
+        "the parent project is in the ancestor chain"
+    );
+    assert!(
+        parents.iter().any(|p| p.id == grandparent.id),
+        "the grandparent project is in the ancestor chain"
+    );
+    Ok(())
+}