/home/runner/work/tenet/tenet/tenet-aws/src/services/quality_attribute.rs

Source
//! Quality attribute service for business logic operations
//!
//! Handles quality attribute management with authorization and validation.

use std::sync::Arc;

use crate::{
    ApiError,
    db::{
        TenetDatabase,
        project::ProjectRepository,
        quality_attribute::QualityAttributeRepository,
        quality_component_link::QualityComponentLinkRepository,
        traits::{
            ProjectRepositoryTrait, QualityAttributeRepositoryTrait,
            QualityComponentLinkRepositoryTrait,
        },
    },
    models::{
        organisation::OrganisationId,
        profile::UserId,
        project::ProjectId,
        quality_attribute::{
            CreateQualityAttributeRequest, QualityAttribute, QualityAttributeId,
            UpdateQualityAttributeRequest,
        },
    },
    services::unified_component::UnifiedComponentService,
};

const MAX_QUALITY_ATTRIBUTES: usize = 10;

/// Service for quality attribute business logic
#[derive(Clone)]
pub struct QualityAttributeService {
    #[cfg(not(test))]
    unified: UnifiedComponentService,
    #[cfg(test)]
    unified: Option<UnifiedComponentService>,
    attribute_repo: Arc<dyn QualityAttributeRepositoryTrait>,
    link_repo: Arc<dyn QualityComponentLinkRepositoryTrait>,
    project_repo: Arc<dyn ProjectRepositoryTrait>,
}

impl QualityAttributeService {
    /// Create a new QualityAttributeService
    pub fn new(database: TenetDatabase) -> Self {
        Self {
            #[cfg(not(test))]
            unified: UnifiedComponentService::new(database.clone()),
            #[cfg(test)]
            unified: Some(0UnifiedComponentService::new0(database.clone())),
            attribute_repo: Arc::new(QualityAttributeRepository::new(database.clone())),
            link_repo: Arc::new(QualityComponentLinkRepository::new(database.clone())),
            project_repo: Arc::new(ProjectRepository::new(database.clone())),
        }
    }

    #[cfg(test)]
    pub fn new_with_repos(
        attribute_repo: Arc<dyn QualityAttributeRepositoryTrait>,
        link_repo: Arc<dyn QualityComponentLinkRepositoryTrait>,
        project_repo: Arc<dyn ProjectRepositoryTrait>,
    ) -> Self {
        Self {
            unified: None,
            attribute_repo,
            link_repo,
            project_repo,
        }
    }

    /// Verify project exists
    async fn verify_project_exists(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
    ) -> Result<(), ApiError> {
        if !self.project_repo.project_exists(org_id, project_id).await?0 {
            return Err(ApiError::NotFound(format!(
                "Project {} not found",
                project_id
            )));
        }
        Ok(())
    }

    fn validate_priority(priority: i32) -> Result<(), ApiError> {
        if !(1..=10).contains(&priority) {
            return Err(ApiError::InvalidRequest(
                "Priority must be between 1 and 10".to_string(),
            ));
        }
        Ok(())
    }

    fn normalize_name(name: &str) -> String {
        name.trim().to_lowercase()
    }

    fn normalize_optional_string(value: Option<String>) -> Option<String> {
        value.and_then(|value| {2
            let trimmed = value.trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
    }

    fn normalize_optional_string_for_update(value: Option<String>) -> Option<String> {
        value.map(|value| {1
            let trimmed = value.trim();
            if trimmed.is_empty() {
                String::new()
            } else {
                trimmed.to_string()
            }
        })
    }

    fn normalize_constraints(value: Option<Vec<String>>) -> Option<Vec<String>> {
        value
            .map(|constraints| {3
                constraints
                    .into_iter()
                    .map3(|item| item.trim().to_string())
                    .filter3(|item| !item.is_empty())
                    .collect::<Vec<String>>()
            })
            .filter(|constraints| !constraints3.is_empty3())
    }

    // =========================================================================
    // Quality Attribute Operations
    // =========================================================================

    /// Create a new quality attribute
    pub async fn create_quality_attribute(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
        _user_id: &UserId,
        request: &CreateQualityAttributeRequest,
    ) -> Result<QualityAttribute, ApiError> {
        self.verify_project_exists(org_id, project_id).await?0;

        let name = request.name.trim();
        if name.is_empty() {
            return Err(ApiError::InvalidRequest(
                "Quality attribute name cannot be empty".to_string(),
            ));
        }
        Self::validate_priority(request.priority)?0;

        let existing = self.attribute_repo.list_by_project(project_id).await?0;
        if existing.len() >= MAX_QUALITY_ATTRIBUTES {
            return Err(ApiError::InvalidRequest(format!(
                "Projects can have at most {} quality attributes",
                MAX_QUALITY_ATTRIBUTES
            )));
        }

        let normalized_name = Self::normalize_name(name);
        if existing
            .iter()
            .any19(|attr| Self::normalize_name(&attr.name) == normalized_name)
        {
            return Err(ApiError::InvalidRequest(format!(
                "Quality attribute '{}' already exists",
                name
            )));
        }
        let attribute = QualityAttribute::new(
            org_id.clone(),
            project_id.clone(),
            name.to_string(),
            request.priority,
            Self::normalize_optional_string(request.description.clone()),
            Self::normalize_constraints(request.constraints.clone()),
        );

        let request = CreateQualityAttributeRequest {
            name: attribute.name.clone(),
            priority: attribute.priority,
            description: attribute.description.clone(),
            constraints: attribute.constraints.clone(),
        };
        #[cfg(not(test))]
        {
            return self
                .unified
                .create_quality_attribute(org_id, project_id, _user_id, &request)
                .await;
        }
        #[cfg(test)]
        {
            if let Some(unified0) = &self.unified {
                return unified
                    .create_quality_attribute(org_id, project_id, _user_id, &request)
                    .await;
            }

            self.attribute_repo.create(&attribute).await?0;

            Ok(attribute)
        }
    }

    /// Get a quality attribute by ID
    pub async fn get_quality_attribute(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
        quality_attribute_id: &QualityAttributeId,
        _user_id: &UserId,
    ) -> Result<QualityAttribute, ApiError> {
        #[cfg(not(test))]
        {
            return self
                .unified
                .get_quality_attribute(org_id, project_id, quality_attribute_id)
                .await;
        }
        #[cfg(test)]
        {
            if let Some(unified0) = &self.unified {
                return unified
                    .get_quality_attribute(org_id, project_id, quality_attribute_id)
                    .await;
            }

            self.attribute_repo
                .get(org_id, project_id, quality_attribute_id)
                .await?0
                .ok_or_else(|| {1
                    ApiError::NotFound(format!(
                        "Quality attribute {} not found",
                        quality_attribute_id
                    ))
                })
        }
    }

    /// List all quality attributes for a project
    pub async fn list_quality_attributes(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
        _user_id: &UserId,
    ) -> Result<Vec<QualityAttribute>, ApiError> {
        #[cfg(not(test))]
        {
            return self
                .unified
                .list_quality_attributes(org_id, project_id)
                .await;
        }
        #[cfg(test)]
        {
            if let Some(unified0) = &self.unified {
                return unified.list_quality_attributes(org_id, project_id).await;
            }
            self.verify_project_exists(org_id, project_id).await?0;

            self.attribute_repo.list_by_project(project_id).await
        }
    }

    /// Update a quality attribute
    pub async fn update_quality_attribute(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
        quality_attribute_id: &QualityAttributeId,
        _user_id: &UserId,
        request: UpdateQualityAttributeRequest,
    ) -> Result<QualityAttribute, ApiError> {
        self.verify_project_exists(org_id, project_id).await?0;

        let existing = self
            .attribute_repo
            .get(org_id, project_id, quality_attribute_id)
            .await?0
            .ok_or_else(|| {0
                ApiError::NotFound(format!(
                    "Quality attribute {} not found",
                    quality_attribute_id
                ))
            })?;

        if let Some(priority) = request.priority {
            Self::validate_priority(priority)?1;
        }

        let mut other_attributes = self.attribute_repo.list_by_project(project_id).await?0;
        other_attributes2.retain2(|attr| attr.id != existing.id);

        if let Some(ref name1) = request.name {
            let trimmed = name.trim();
            if trimmed.is_empty() {
                return Err(ApiError::InvalidRequest(
                    "Quality attribute name cannot be empty".to_string(),
                ));
            }
            let normalized = Self::normalize_name(trimmed);
            if other_attributes
                .iter()
                .any(|attr| Self::normalize_name(&attr.name) == normalized)
            {
                return Err(ApiError::InvalidRequest(format!(
                    "Quality attribute '{}' already exists",
                    trimmed
                )));
            }
        }

        let normalized_constraints = request
            .constraints
            .map(|constraints| Self::normalize_constraints1(Some(constraints)1).unwrap_or_default1());

        let update_request = UpdateQualityAttributeRequest {
            name: request.name.map(|name| name.trim()1.to_string1()),
            priority: request.priority,
            description: Self::normalize_optional_string_for_update(request.description),
            constraints: normalized_constraints,
        };

        #[cfg(not(test))]
        {
            return self
                .unified
                .update_quality_attribute(
                    org_id,
                    project_id,
                    _user_id,
                    quality_attribute_id,
                    update_request,
                )
                .await;
        }
        #[cfg(test)]
        {
            if let Some(unified0) = &self.unified {
                return unified
                    .update_quality_attribute(
                        org_id,
                        project_id,
                        _user_id,
                        quality_attribute_id,
                        update_request,
                    )
                    .await;
            }

            self.attribute_repo
                .update(org_id, project_id, quality_attribute_id, update_request)
                .await?0
                .ok_or_else(|| {0
                    ApiError::NotFound(format!(
                        "Quality attribute {} not found",
                        quality_attribute_id
                    ))
                })
        }
    }

    /// Delete a quality attribute (and its links)
    pub async fn delete_quality_attribute(
        &self,
        org_id: &OrganisationId,
        project_id: &ProjectId,
        quality_attribute_id: &QualityAttributeId,
        _user_id: &UserId,
    ) -> Result<(), ApiError> {
        self.attribute_repo
            .get(org_id, project_id, quality_attribute_id)
            .await?0
            .ok_or_else(|| {0
                ApiError::NotFound(format!(
                    "Quality attribute {} not found",
                    quality_attribute_id
                ))
            })?;

        self.link_repo
            .delete_all_for_quality(quality_attribute_id)
            .await?0;
        #[cfg(not(test))]
        {
            return self
                .unified
                .delete_quality_attribute(org_id, project_id, _user_id, quality_attribute_id)
                .await;
        }
        #[cfg(test)]
        {
            if let Some(unified0) = &self.unified {
                return unified
                    .delete_quality_attribute(org_id, project_id, _user_id, quality_attribute_id)
                    .await;
            }

            self.attribute_repo
                .delete(org_id, project_id, quality_attribute_id)
                .await?0;

            Ok(())
        }
    }
}

// =============================================================================
// Tests
// =============================================================================

#[cfg(test)]
mod tests {
    use super::*;
    use crate::db::in_memory::{
        InMemoryMemberRepository, InMemoryOrganisationRepository, InMemoryProjectRepository,
        InMemoryQualityAttributeRepository, InMemoryQualityComponentLinkRepository,
    };
    use crate::db::traits::QualityComponentLinkRepositoryTrait;
    use crate::models::{
        component::ComponentId, organisation::Organisation, project::Project,
        quality_component_link::QualityComponentLink,
        quality_component_link::QualityLinkComponentType, role::Role,
    };
    use crate::test_support::{
        fixtures::{add_member, seed_org_project_with_admin},
        must_ok,
    };
    use std::sync::Arc;

    fn setup_service(
        _org_repo: InMemoryOrganisationRepository,
        _member_repo: InMemoryMemberRepository,
        project_repo: InMemoryProjectRepository,
        attribute_repo: InMemoryQualityAttributeRepository,
        link_repo: InMemoryQualityComponentLinkRepository,
    ) -> QualityAttributeService {
        QualityAttributeService::new_with_repos(
            Arc::new(attribute_repo),
            Arc::new(link_repo),
            Arc::new(project_repo),
        )
    }

    fn seed_org_and_project(
        org_repo: &InMemoryOrganisationRepository,
        member_repo: &InMemoryMemberRepository,
        project_repo: &InMemoryProjectRepository,
    ) -> (Organisation, Project, UserId) {
        let seeded = seed_org_project_with_admin(org_repo, member_repo, project_repo);
        (seeded.org, seeded.project, seeded.admin_user)
    }

    #[allure_rs::allure_parent_suite("tenet-aws")]
    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_create_and_list_quality_attributes() {
        let org_repo = InMemoryOrganisationRepository::default();
        let member_repo = InMemoryMemberRepository::default();
        let project_repo = InMemoryProjectRepository::default();
        let attribute_repo = InMemoryQualityAttributeRepository::default();
        let link_repo = InMemoryQualityComponentLinkRepository::default();

        let service = setup_service(
            org_repo.clone(),
            member_repo.clone(),
            project_repo.clone(),
            attribute_repo,
            link_repo,
        );

        let (org, project, user_id) = seed_org_and_project(&org_repo, &member_repo, &project_repo);

        let request = CreateQualityAttributeRequest {
            name: "Security".to_string(),
            priority: 1,
            description: Some("Protect data".to_string()),
            constraints: Some(vec!["No secrets in logs".to_string()]),
        };

        let created = must_ok(
            service
                .create_quality_attribute(&org.id, &project.id, &user_id, &request)
                .await,
        );
        assert_eq!(created.name, "Security");

        let list = must_ok(
            service
                .list_quality_attributes(&org.id, &project.id, &user_id)
                .await,
        );
        assert_eq!(list.len(), 1);
        assert_eq!(list[0].id, created.id);
    }

    #[allure_rs::allure_parent_suite("tenet-aws")]
    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_quality_attribute_unique_name_allows_duplicate_priority() {
        let org_repo = InMemoryOrganisationRepository::default();
        let member_repo = InMemoryMemberRepository::default();
        let project_repo = InMemoryProjectRepository::default();
        let attribute_repo = InMemoryQualityAttributeRepository::default();
        let link_repo = InMemoryQualityComponentLinkRepository::default();

        let service = setup_service(
            org_repo.clone(),
            member_repo.clone(),
            project_repo.clone(),
            attribute_repo,
            link_repo,
        );

        let (org, project, user_id) = seed_org_and_project(&org_repo, &member_repo, &project_repo);

        let base_request = CreateQualityAttributeRequest {
            name: "Security".to_string(),
            priority: 1,
            description: None,
            constraints: None,
        };

        must_ok(
            service
                .create_quality_attribute(&org.id, &project.id, &user_id, &base_request)
                .await,
        );

        let duplicate_name = CreateQualityAttributeRequest {
            name: "security".to_string(),
            priority: 2,
            description: None,
            constraints: None,
        };
        let result = service
            .create_quality_attribute(&org.id, &project.id, &user_id, &duplicate_name)
            .await;
        assert!(matches!(result, Err(ApiError::InvalidRequest(_))));

        let duplicate_priority = CreateQualityAttributeRequest {
            name: "Performance".to_string(),
            priority: 1,
            description: None,
            constraints: None,
        };
        let result = service
            .create_quality_attribute(&org.id, &project.id, &user_id, &duplicate_priority)
            .await;
        assert!(result.is_ok(), "duplicate priorities should be allowed");
    }

    #[allure_rs::allure_parent_suite("tenet-aws")]
    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_quality_attribute_limit() {
        let org_repo = InMemoryOrganisationRepository::default();
        let member_repo = InMemoryMemberRepository::default();
        let project_repo = InMemoryProjectRepository::default();
        let attribute_repo = InMemoryQualityAttributeRepository::default();
        let link_repo = InMemoryQualityComponentLinkRepository::default();

        let service = setup_service(
            org_repo.clone(),
            member_repo.clone(),
            project_repo.clone(),
            attribute_repo,
            link_repo,
        );

        let (org, project, user_id) = seed_org_and_project(&org_repo, &member_repo, &project_repo);

        for idx in 1..=10 {
            let request = CreateQualityAttributeRequest {
                name: format!("Quality {}", idx),
                priority: idx,
                description: None,
                constraints: None,
            };
            must_ok(
                service
                    .create_quality_attribute(&org.id, &project.id, &user_id, &request)
                    .await,
            );
        }

        let extra = CreateQualityAttributeRequest {
            name: "Extra".to_string(),
            priority: 10,
            description: None,
            constraints: None,
        };
        let result = service
            .create_quality_attribute(&org.id, &project.id, &user_id, &extra)
            .await;
        assert!(matches!(result, Err(ApiError::InvalidRequest(_))));
    }

    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_get_update_and_validation_paths() {
        let org_repo = InMemoryOrganisationRepository::default();
        let member_repo = InMemoryMemberRepository::default();
        let project_repo = InMemoryProjectRepository::default();
        let attribute_repo = InMemoryQualityAttributeRepository::default();
        let link_repo = InMemoryQualityComponentLinkRepository::default();

        let service = setup_service(
            org_repo.clone(),
            member_repo.clone(),
            project_repo.clone(),
            attribute_repo,
            link_repo,
        );

        let (org, project, user_id) = seed_org_and_project(&org_repo, &member_repo, &project_repo);
        let first = must_ok(
            service
                .create_quality_attribute(
                    &org.id,
                    &project.id,
                    &user_id,
                    &CreateQualityAttributeRequest {
                        name: "Security".to_string(),
                        priority: 1,
                        description: Some("Protect data".to_string()),
                        constraints: Some(vec!["encrypted".to_string()]),
                    },
                )
                .await,
        );
        let second = must_ok(
            service
                .create_quality_attribute(
                    &org.id,
                    &project.id,
                    &user_id,
                    &CreateQualityAttributeRequest {
                        name: "Performance".to_string(),
                        priority: 2,
                        description: None,
                        constraints: None,
                    },
                )
                .await,
        );

        let fetched = must_ok(
            service
                .get_quality_attribute(&org.id, &project.id, &first.id, &user_id)
                .await,
        );
        assert_eq!(fetched.id, first.id);

        let updated = must_ok(
            service
                .update_quality_attribute(
                    &org.id,
                    &project.id,
                    &first.id,
                    &user_id,
                    UpdateQualityAttributeRequest {
                        name: Some("Security Updated".to_string()),
                        priority: Some(3),
                        description: Some("".to_string()),
                        constraints: Some(vec![" ".to_string(), "auditable".to_string()]),
                    },
                )
                .await,
        );
        assert_eq!(updated.name, "Security Updated");
        assert_eq!(updated.priority, 3);
        assert_eq!(updated.description, None);
        assert_eq!(updated.constraints, Some(vec!["auditable".to_string()]));

        let duplicate_priority = service
            .update_quality_attribute(
                &org.id,
                &project.id,
                &first.id,
                &user_id,
                UpdateQualityAttributeRequest {
                    name: None,
                    priority: Some(second.priority),
                    description: None,
                    constraints: None,
                },
            )
            .await;
        assert!(
            duplicate_priority.is_ok(),
            "updating to an existing priority should be allowed"
        );

        let invalid_priority = service
            .update_quality_attribute(
                &org.id,
                &project.id,
                &first.id,
                &user_id,
                UpdateQualityAttributeRequest {
                    name: None,
                    priority: Some(11),
                    description: None,
                    constraints: None,
                },
            )
            .await;
        assert!(matches!0(invalid_priority, Err(ApiError::InvalidRequest(_))));
    }

    #[allure_rs::allure_test]
    #[tokio::test]
    async fn test_delete_quality_attribute_auth_is_enforced_at_boundary_and_cleans_links() {
        let org_repo = InMemoryOrganisationRepository::default();
        let member_repo = InMemoryMemberRepository::default();
        let project_repo = InMemoryProjectRepository::default();
        let attribute_repo = InMemoryQualityAttributeRepository::default();
        let link_repo = InMemoryQualityComponentLinkRepository::default();

        let service = setup_service(
            org_repo.clone(),
            member_repo.clone(),
            project_repo.clone(),
            attribute_repo,
            link_repo.clone(),
        );

        let (org, project, admin_user) =
            seed_org_and_project(&org_repo, &member_repo, &project_repo);
        let member_user = add_member(
            &member_repo,
            &org.id,
            "550e8400-e29b-41d4-a716-446655440001",
            Role::User,
            Some(admin_user.clone()),
        );

        let attribute = must_ok(
            service
                .create_quality_attribute(
                    &org.id,
                    &project.id,
                    &admin_user,
                    &CreateQualityAttributeRequest {
                        name: "Maintainability".to_string(),
                        priority: 4,
                        description: None,
                        constraints: None,
                    },
                )
                .await,
        );

        let link = QualityComponentLink::new(
            org.id.clone(),
            project.id.clone(),
            attribute.id.clone(),
            ComponentId::new(),
            QualityLinkComponentType::Container,
            None,
            Some("linked".to_string()),
        );
        must_ok(link_repo.create(&link).await);
        assert_eq!(
            must_ok(link_repo.list_by_quality(&attribute.id).await).len(),
            1
        );

        let deleted = service
            .delete_quality_attribute(&org.id, &project.id, &attribute.id, &member_user)
            .await;
        assert!(deleted.is_ok());

        assert!(
            service
                .get_quality_attribute(&org.id, &project.id, &attribute.id, &member_user)
                .await
                .is_err()
        );
        assert!(must_ok(link_repo.list_by_quality(&attribute.id).await).is_empty());
    }
}

Coverage Report

Created: 2026-03-25 23:22