test: decouple builder tests from crd::merged_config via validated_cluster()

Author: maltesander

rust/operator-binary/src/controller/build/properties/hbase_env.rs

@@ -62,33 +62,18 @@ pub fn build(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        controller::build::properties::test_support::{config_overrides, minimal_hbase},
-        crd::v1alpha1,
-    };
-
-    fn master_merged_config(hbase: &v1alpha1::HbaseCluster) -> AnyServiceConfig {
-        hbase
-            .merged_config(&HbaseRole::Master, "default", "simple-hdfs")
-            .expect("merged config for the minimal master group")
-    }
-
-    fn region_server_merged_config(hbase: &v1alpha1::HbaseCluster) -> AnyServiceConfig {
-        hbase
-            .merged_config(&HbaseRole::RegionServer, "default", "simple-hdfs")
-            .expect("merged config for the minimal region server group")
-    }
+    use crate::controller::build::properties::test_support::{merged_config, validated_cluster};
 
     #[test]
     fn renders_operator_defaults() {
-        let hbase = minimal_hbase();
-        let merged = master_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::Master);
         let env = build(
-            &merged,
+            merged,
             &HbaseRole::Master,
             false,
             "-Xtest".to_string(),
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         )
         .unwrap();
         assert!(env.contains("export HBASE_MANAGES_ZK=\"false\""), "{env}");
@@ -97,29 +82,29 @@ mod tests {
 
     #[test]
     fn renders_region_server_opts() {
-        let hbase = minimal_hbase();
-        let merged = region_server_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::RegionServer);
         let env = build(
-            &merged,
+            merged,
             &HbaseRole::RegionServer,
             false,
             "-Xtest".to_string(),
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         )
         .unwrap();
         assert!(env.contains("export HBASE_REGIONSERVER_OPTS="), "{env}");
     }
 
     #[test]
     fn user_override_appears() {
-        let hbase = minimal_hbase();
-        let merged = master_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::Master);
         let env = build(
-            &merged,
+            merged,
             &HbaseRole::Master,
             false,
             "-Xtest".to_string(),
-            config_overrides(&[("CUSTOM_VAR", "custom_value")]),
+            [("CUSTOM_VAR", "custom_value")].into(),
         )
         .unwrap();
         assert!(env.contains("export CUSTOM_VAR=\"custom_value\""), "{env}");

rust/operator-binary/src/controller/build/properties/hbase_site.rs

@@ -113,40 +113,19 @@ pub fn build(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        controller::build::properties::test_support::{config_overrides, minimal_hbase},
-        crd::v1alpha1,
-    };
-
-    fn master_merged_config(hbase: &v1alpha1::HbaseCluster) -> AnyServiceConfig {
-        hbase
-            .merged_config(&HbaseRole::Master, "default", "simple-hdfs")
-            .expect("merged config for the minimal master group")
-    }
-
-    fn region_server_merged_config(hbase: &v1alpha1::HbaseCluster) -> AnyServiceConfig {
-        hbase
-            .merged_config(&HbaseRole::RegionServer, "default", "simple-hdfs")
-            .expect("merged config for the minimal region server group")
-    }
-
-    fn rest_server_merged_config(hbase: &v1alpha1::HbaseCluster) -> AnyServiceConfig {
-        hbase
-            .merged_config(&HbaseRole::RestServer, "default", "simple-hdfs")
-            .expect("merged config for the minimal rest server group")
-    }
+    use crate::controller::build::properties::test_support::{merged_config, validated_cluster};
 
     #[test]
     fn renders_operator_defaults() {
-        let hbase = minimal_hbase();
-        let merged = master_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::Master);
         let xml = build(
             &HbaseRole::Master,
-            &merged,
+            merged,
             BTreeMap::new(),
             BTreeMap::new(),
             None,
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         );
         assert!(
             xml.contains("<name>hbase.cluster.distributed</name>\n    <value>true</value>"),
@@ -160,15 +139,15 @@ mod tests {
 
     #[test]
     fn renders_region_server_bind_settings() {
-        let hbase = minimal_hbase();
-        let merged = region_server_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::RegionServer);
         let xml = build(
             &HbaseRole::RegionServer,
-            &merged,
+            merged,
             BTreeMap::new(),
             BTreeMap::new(),
             None,
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         );
         assert!(
             xml.contains("<name>hbase.regionserver.ipc.address</name>\n    <value>0.0.0.0</value>"),
@@ -184,15 +163,15 @@ mod tests {
 
     #[test]
     fn renders_rest_server_endpoint() {
-        let hbase = minimal_hbase();
-        let merged = rest_server_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::RestServer);
         let xml = build(
             &HbaseRole::RestServer,
-            &merged,
+            merged,
             BTreeMap::new(),
             BTreeMap::new(),
             None,
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         );
         assert!(
             xml.contains(
@@ -204,15 +183,15 @@ mod tests {
 
     #[test]
     fn user_override_wins() {
-        let hbase = minimal_hbase();
-        let merged = master_merged_config(&hbase);
+        let validated_cluster = validated_cluster();
+        let merged = merged_config(&validated_cluster, &HbaseRole::Master);
         let xml = build(
             &HbaseRole::Master,
-            &merged,
+            merged,
             BTreeMap::new(),
             BTreeMap::new(),
             None,
-            config_overrides(&[("hbase.cluster.distributed", "false")]),
+            [("hbase.cluster.distributed", "false")].into(),
         );
         assert!(
             xml.contains("<name>hbase.cluster.distributed</name>\n    <value>false</value>"),

rust/operator-binary/src/controller/build/properties/mod.rs

@@ -60,19 +60,17 @@ mod tests {
 
 #[cfg(test)]
 pub(crate) mod test_support {
-    use stackable_operator::v2::config_overrides::KeyValueConfigOverrides;
+    use stackable_operator::{
+        commons::networking::DomainName, utils::cluster_info::KubernetesClusterInfo,
+    };
 
-    use crate::crd::v1alpha1;
-
-    /// Builds a [`KeyValueConfigOverrides`] from `(key, value)` pairs for tests.
-    pub fn config_overrides(pairs: &[(&str, &str)]) -> KeyValueConfigOverrides {
-        KeyValueConfigOverrides {
-            overrides: pairs
-                .iter()
-                .map(|(k, v)| (k.to_string(), v.to_string()))
-                .collect(),
-        }
-    }
+    use crate::{
+        controller::{
+            ValidatedCluster, dereference::DereferencedObjects, validate::validate_cluster,
+        },
+        crd::{AnyServiceConfig, HbaseRole, v1alpha1},
+        zookeeper::ZookeeperConnectionInformation,
+    };
 
     /// A minimal three-role HbaseCluster used to drive the per-file builder tests.
     pub const MINIMAL_HBASE_YAML: &str = r#"
@@ -82,6 +80,7 @@ kind: HbaseCluster
 metadata:
   name: hbase
   namespace: default
+  uid: c2c8c5c0-0b5a-4b1e-9f3e-1a2b3c4d5e6f
 spec:
   image:
     productVersion: 2.6.3
@@ -105,4 +104,35 @@ spec:
     pub fn minimal_hbase() -> v1alpha1::HbaseCluster {
         serde_yaml::from_str(MINIMAL_HBASE_YAML).expect("invalid test HbaseCluster YAML")
     }
+
+    pub fn cluster_info() -> KubernetesClusterInfo {
+        KubernetesClusterInfo {
+            cluster_domain: DomainName::try_from("cluster.local").unwrap(),
+        }
+    }
+
+    /// Runs the real validation pipeline once over [`minimal_hbase`], with a fixed
+    /// dereferenced ZooKeeper connection (and no OPA), so the per-file builder tests can
+    /// pull merged configs straight from the [`ValidatedCluster`] instead of re-merging by
+    /// hand via `crd::merged_config`.
+    pub fn validated_cluster() -> ValidatedCluster {
+        validate_cluster(
+            &minimal_hbase(),
+            "oci.example.org",
+            &cluster_info(),
+            DereferencedObjects {
+                zookeeper_connection_information: ZookeeperConnectionInformation::for_tests(),
+                hbase_opa_config: None,
+            },
+        )
+        .expect("validate should succeed for the minimal fixture")
+    }
+
+    /// The merged [`AnyServiceConfig`] for the `default` role group of `role`.
+    pub fn merged_config<'a>(
+        validated_cluster: &'a ValidatedCluster,
+        role: &HbaseRole,
+    ) -> &'a AnyServiceConfig {
+        &validated_cluster.role_group_configs[role]["default"].config
+    }
 }

rust/operator-binary/src/controller/build/properties/security_properties.rs

@@ -44,28 +44,27 @@ pub fn build(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::controller::build::properties::test_support::config_overrides;
 
     #[test]
     fn injects_master_dns_cache_ttl() {
         assert_eq!(
-            build(&HbaseRole::Master, config_overrides(&[])).unwrap(),
+            build(&HbaseRole::Master, KeyValueConfigOverrides::default()).unwrap(),
             "networkaddress.cache.negative.ttl=0\nnetworkaddress.cache.ttl=5\n"
         );
     }
 
     #[test]
     fn injects_regionserver_dns_cache_ttl() {
         assert_eq!(
-            build(&HbaseRole::RegionServer, config_overrides(&[])).unwrap(),
+            build(&HbaseRole::RegionServer, KeyValueConfigOverrides::default()).unwrap(),
             "networkaddress.cache.negative.ttl=0\nnetworkaddress.cache.ttl=10\n"
         );
     }
 
     #[test]
     fn injects_restserver_dns_cache_ttl() {
         assert_eq!(
-            build(&HbaseRole::RestServer, config_overrides(&[])).unwrap(),
+            build(&HbaseRole::RestServer, KeyValueConfigOverrides::default()).unwrap(),
             "networkaddress.cache.negative.ttl=0\nnetworkaddress.cache.ttl=30\n"
         );
     }
@@ -75,7 +74,7 @@ mod tests {
         assert_eq!(
             build(
                 &HbaseRole::Master,
-                config_overrides(&[("networkaddress.cache.ttl", "60")])
+                [("networkaddress.cache.ttl", "60")].into()
             )
             .unwrap(),
             "networkaddress.cache.negative.ttl=0\nnetworkaddress.cache.ttl=60\n"

rust/operator-binary/src/controller/build/properties/ssl_client.rs

@@ -13,7 +13,6 @@ pub fn build(settings: BTreeMap<String, String>, overrides: KeyValueConfigOverri
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::controller::build::properties::test_support::config_overrides;
 
     #[test]
     fn settings_appear_in_xml() {
@@ -22,7 +21,7 @@ mod tests {
                 "ssl.client.truststore.type".to_string(),
                 "pkcs12".to_string(),
             )]),
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         );
         assert!(
             xml.contains("<name>ssl.client.truststore.type</name>\n    <value>pkcs12</value>"),
@@ -34,7 +33,7 @@ mod tests {
     fn user_override_appears_in_xml() {
         let xml = build(
             BTreeMap::new(),
-            config_overrides(&[("ssl.client.keystore.type", "jks")]),
+            [("ssl.client.keystore.type", "jks")].into(),
         );
         assert!(
             xml.contains("<name>ssl.client.keystore.type</name>\n    <value>jks</value>"),

rust/operator-binary/src/controller/build/properties/ssl_server.rs

@@ -13,13 +13,12 @@ pub fn build(settings: BTreeMap<String, String>, overrides: KeyValueConfigOverri
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::controller::build::properties::test_support::config_overrides;
 
     #[test]
     fn settings_appear_in_xml() {
         let xml = build(
             BTreeMap::from([("ssl.server.keystore.type".to_string(), "pkcs12".to_string())]),
-            config_overrides(&[]),
+            KeyValueConfigOverrides::default(),
         );
         assert!(
             xml.contains("<name>ssl.server.keystore.type</name>\n    <value>pkcs12</value>"),
@@ -31,7 +30,7 @@ mod tests {
     fn user_override_appears_in_xml() {
         let xml = build(
             BTreeMap::new(),
-            config_overrides(&[("ssl.server.keystore.type", "jks")]),
+            [("ssl.server.keystore.type", "jks")].into(),
         );
         assert!(
             xml.contains("<name>ssl.server.keystore.type</name>\n    <value>jks</value>"),

rust/operator-binary/src/zookeeper.rs

@@ -53,6 +53,20 @@ pub struct ZookeeperConnectionInformation {
     port: u16,
 }
 
+#[cfg(test)]
+impl ZookeeperConnectionInformation {
+    /// A fixed connection used by the per-file builder tests, so they don't need a live
+    /// ZooKeeper/ZNode discovery `ConfigMap`.
+    pub(crate) fn for_tests() -> Self {
+        Self {
+            hosts: "simple-zk-server-default-0.simple-zk-server-default.default.svc.cluster.local"
+                .to_owned(),
+            chroot: "/znode-test".to_owned(),
+            port: 2282,
+        }
+    }
+}
+
 impl ZookeeperConnectionInformation {
     pub async fn retrieve(hbase: &v1alpha1::HbaseCluster, client: &Client) -> Result<Self> {
         let zk_discovery_cm_name = &hbase.spec.cluster_config.zookeeper_config_map_name;