refactor resource access

Author: sweb

rust/operator-binary/src/crd/affinity.rs

@@ -25,20 +25,18 @@ pub fn get_affinity(cluster_name: &str, role: &ZookeeperRole) -> StackableAffini
 #[cfg(test)]
 mod tests {
 
-    use std::{collections::BTreeMap, str::FromStr};
+    use std::collections::BTreeMap;
 
     use stackable_operator::{
         commons::affinity::StackableAffinity,
         k8s_openapi::{
             api::core::v1::{PodAffinityTerm, PodAntiAffinity, WeightedPodAffinityTerm},
             apimachinery::pkg::apis::meta::v1::LabelSelector,
         },
-        v2::types::operator::RoleGroupName,
     };
 
-    use crate::{
-        crd::affinity::ZookeeperRole,
-        zk_controller::test_support::{minimal_zk, validated_cluster},
+    use crate::zk_controller::test_support::{
+        minimal_zk, server_rolegroup_config, validated_cluster,
     };
 
     #[test]
@@ -99,9 +97,9 @@ mod tests {
             node_selector: None,
         };
 
-        let default_group = RoleGroupName::from_str("default").expect("valid role group name");
-        let affinity = validated_cluster(&zk).role_group_configs[&ZookeeperRole::Server]
-            [&default_group]
+        let validated = validated_cluster(&zk);
+        let affinity = server_rolegroup_config(&validated, "default")
+            .1
             .config
             .affinity
             .clone();

rust/operator-binary/src/zk_controller.rs

@@ -393,16 +393,18 @@ pub fn error_policy(
 /// Shared helpers for building validated test clusters from minimal YAML fixtures.
 #[cfg(test)]
 pub(crate) mod test_support {
+    use std::str::FromStr;
+
     use stackable_operator::{
         cli::OperatorEnvironmentOptions, commons::networking::DomainName,
-        utils::cluster_info::KubernetesClusterInfo,
+        utils::cluster_info::KubernetesClusterInfo, v2::types::operator::RoleGroupName,
     };
 
     use crate::{
-        crd::{authentication::DereferencedAuthenticationClasses, v1alpha1},
+        crd::{ZookeeperRole, authentication::DereferencedAuthenticationClasses, v1alpha1},
         zk_controller::{
             dereference::DereferencedObjects,
-            validate::{ValidatedCluster, validate},
+            validate::{ValidatedCluster, ZookeeperRoleGroupConfig, validate},
         },
     };
 
@@ -471,24 +473,36 @@ pub(crate) mod test_support {
         )
         .expect("validate should succeed for the test fixture")
     }
+
+    /// Looks up the validated, merged config of the named `server` role group together with its
+    /// parsed [`RoleGroupName`] — the standard `(name, config)` inputs to the
+    /// `build_server_rolegroup_*` functions. Panics if the group does not exist.
+    pub fn server_rolegroup_config<'a>(
+        validated: &'a ValidatedCluster,
+        role_group: &str,
+    ) -> (RoleGroupName, &'a ZookeeperRoleGroupConfig) {
+        let role_group_name = RoleGroupName::from_str(role_group).expect("valid role group name");
+        let config = validated
+            .role_group_configs
+            .get(&ZookeeperRole::Server)
+            .and_then(|groups| groups.get(&role_group_name))
+            .unwrap_or_else(|| panic!("server role group {role_group:?} should exist"));
+        (role_group_name, config)
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::{
-        collections::{BTreeMap, BTreeSet},
-        str::FromStr,
-    };
+    use std::collections::{BTreeMap, BTreeSet};
 
-    use stackable_operator::{
-        k8s_openapi::api::core::v1::ConfigMap, v2::types::operator::RoleGroupName,
-    };
+    use stackable_operator::k8s_openapi::api::core::v1::ConfigMap;
 
     use super::*;
     use crate::zk_controller::{
         build::properties::zoo_cfg,
         test_support::{
-            cluster_info, minimal_zk, validated_cluster, validated_cluster_with_client_auth,
+            cluster_info, minimal_zk, server_rolegroup_config, validated_cluster,
+            validated_cluster_with_client_auth,
         },
         validate::ValidatedCluster,
     };
@@ -967,9 +981,7 @@ mod tests {
     /// pinned separately (`test_server_lines_use_myid_offset_across_rolegroups`,
     /// `test_seeded_operator_defaults`).
     fn zoo_cfg_map(validated: &ValidatedCluster, role_group: &str) -> BTreeMap<String, String> {
-        let role_group_name = RoleGroupName::from_str(role_group).expect("valid role group name");
-        let rolegroup_config =
-            &validated.role_group_configs[&ZookeeperRole::Server][&role_group_name];
+        let (_, rolegroup_config) = server_rolegroup_config(validated, role_group);
         let server_addresses = zoo_cfg::server_addresses(validated, &cluster_info());
         zoo_cfg::build(validated, rolegroup_config, &server_addresses)
     }
@@ -1167,9 +1179,8 @@ mod tests {
 
     /// Builds the rolegroup `ConfigMap` for the named server role group of a validated cluster.
     fn config_map_for(validated_cluster: &ValidatedCluster, role_group: &str) -> ConfigMap {
-        let role_group_name = RoleGroupName::from_str(role_group).expect("valid role group name");
-        let rolegroup_config =
-            &validated_cluster.role_group_configs[&ZookeeperRole::Server][&role_group_name];
+        let (role_group_name, rolegroup_config) =
+            server_rolegroup_config(validated_cluster, role_group);
 
         config_map::build_server_rolegroup_config_map(
             validated_cluster,

rust/operator-binary/src/zk_controller/build/properties/zoo_cfg.rs

@@ -177,18 +177,15 @@ impl ValidatedCluster {
 
 #[cfg(test)]
 mod tests {
-    use std::str::FromStr;
-
-    use stackable_operator::v2::types::operator::RoleGroupName;
-
     use super::*;
-    use crate::zk_controller::test_support::{cluster_info, minimal_zk, validated_cluster};
+    use crate::zk_controller::test_support::{
+        cluster_info, minimal_zk, server_rolegroup_config, validated_cluster,
+    };
 
     /// Validates `yaml` into a [`ValidatedCluster`] and returns its `server` `default` role group.
     fn validated_with_default_rg(yaml: &str) -> (ValidatedCluster, ZookeeperRoleGroupConfig) {
         let validated = validated_cluster(&minimal_zk(yaml));
-        let rg_name = RoleGroupName::from_str("default").expect("valid role group name");
-        let rg = validated.role_group_configs[&ZookeeperRole::Server][&rg_name].clone();
+        let rg = server_rolegroup_config(&validated, "default").1.clone();
         (validated, rg)
     }
 

rust/operator-binary/src/zk_controller/build/resource/service.rs

@@ -118,12 +118,9 @@ pub(crate) fn build_server_rolegroup_metrics_service(
 
 #[cfg(test)]
 mod tests {
-    use std::str::FromStr;
-
     use super::*;
-    use crate::{
-        crd::ZookeeperRole,
-        zk_controller::test_support::{minimal_zk, validated_cluster},
+    use crate::zk_controller::test_support::{
+        minimal_zk, server_rolegroup_config, validated_cluster,
     };
 
     const DEFAULT_ZK: &str = r#"
@@ -157,7 +154,7 @@ mod tests {
     #[test]
     fn headless_service_shape() {
         let validated = validated_cluster(&minimal_zk(DEFAULT_ZK));
-        let rg = RoleGroupName::from_str("default").expect("valid role group name");
+        let (rg, _) = server_rolegroup_config(&validated, "default");
         let service = build_server_rolegroup_headless_service(&validated, &rg);
 
         assert_eq!(
@@ -193,9 +190,8 @@ mod tests {
     #[test]
     fn metrics_service_shape_and_prometheus_annotations() {
         let validated = validated_cluster(&minimal_zk(DEFAULT_ZK));
-        let rg = RoleGroupName::from_str("default").expect("valid role group name");
-        let rg_config = validated.role_group_configs[&ZookeeperRole::Server][&rg].clone();
-        let service = build_server_rolegroup_metrics_service(&validated, &rg, &rg_config);
+        let (rg, rg_config) = server_rolegroup_config(&validated, "default");
+        let service = build_server_rolegroup_metrics_service(&validated, &rg, rg_config);
 
         assert_eq!(
             service.metadata.name.as_deref(),

rust/operator-binary/src/zk_controller/build/resource/statefulset.rs

@@ -457,15 +457,16 @@ pub fn build_server_rolegroup_statefulset(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::zk_controller::test_support::{minimal_zk, validated_cluster};
+    use crate::zk_controller::test_support::{
+        minimal_zk, server_rolegroup_config, validated_cluster,
+    };
 
     /// Builds the `default` server StatefulSet for `yaml` and returns the ConfigMap name mounted by
     /// its `log-config` volume.
     fn log_config_map_name(yaml: &str) -> String {
         let validated = validated_cluster(&minimal_zk(yaml));
-        let rg_name = RoleGroupName::from_str("default").expect("valid role group name");
-        let rg = validated.role_group_configs[&ZookeeperRole::Server][&rg_name].clone();
-        build_server_rolegroup_statefulset(&validated, &rg_name, &rg)
+        let (rg_name, rg) = server_rolegroup_config(&validated, "default");
+        build_server_rolegroup_statefulset(&validated, &rg_name, rg)
             .expect("statefulset builds")
             .spec
             .and_then(|spec| spec.template.spec)
@@ -540,9 +541,8 @@ mod tests {
 
     fn build_sts(yaml: &str, role_group: &str) -> StatefulSet {
         let validated = validated_cluster(&minimal_zk(yaml));
-        let rg_name = RoleGroupName::from_str(role_group).expect("valid role group name");
-        let rg = validated.role_group_configs[&ZookeeperRole::Server][&rg_name].clone();
-        build_server_rolegroup_statefulset(&validated, &rg_name, &rg).expect("statefulset builds")
+        let (rg_name, rg) = server_rolegroup_config(&validated, role_group);
+        build_server_rolegroup_statefulset(&validated, &rg_name, rg).expect("statefulset builds")
     }
 
     fn zookeeper_container(

rust/operator-binary/src/zk_controller/validate.rs

@@ -599,7 +599,9 @@ mod tests {
     use stackable_operator::k8s_openapi::apimachinery::pkg::api::resource::Quantity;
 
     use super::*;
-    use crate::zk_controller::test_support::{minimal_zk, try_validate, validated_cluster};
+    use crate::zk_controller::test_support::{
+        minimal_zk, server_rolegroup_config, try_validate, validated_cluster,
+    };
 
     #[test]
     fn enabling_vector_without_aggregator_name_fails_validation() {
@@ -658,17 +660,11 @@ mod tests {
     }
 
     /// Looks up the validated, merged config of a single server role group by name.
-    fn server_role_group(
-        validated: &ValidatedCluster,
+    fn server_role_group<'a>(
+        validated: &'a ValidatedCluster,
         role_group: &str,
-    ) -> ZookeeperRoleGroupConfig {
-        let role_group_name = RoleGroupName::from_str(role_group).expect("valid role group name");
-        validated
-            .role_group_configs
-            .get(&ZookeeperRole::Server)
-            .and_then(|groups| groups.get(&role_group_name))
-            .unwrap_or_else(|| panic!("server role group {role_group:?} should exist"))
-            .clone()
+    ) -> &'a ZookeeperRoleGroupConfig {
+        server_rolegroup_config(validated, role_group).1
     }
 
     /// Mirrors the `resources` integration test (which can no longer use >16 character role-group