test(ib-fabric): expand fabric utility test enumerations (#2580)

Author: chet

Cargo.lock

@@ -48,6 +48,7 @@ tracing = { workspace = true }
 url = { workspace = true }
 
 [dev-dependencies]
+carbide-test-support = { path = "../test-support" }
 figment = { features = ["env", "test", "toml"], workspace = true }
 
 [lints]

crates/ib-fabric/Cargo.toml

@@ -49,3 +49,46 @@ impl IbError {
 }
 
 pub type IbResult<T> = Result<T, IbError>;
+
+#[cfg(test)]
+mod tests {
+    use carbide_test_support::value_scenarios;
+
+    use super::*;
+
+    #[derive(Clone, Copy, Debug)]
+    enum ErrorCase {
+        Fabric,
+        NotFound,
+        InvalidArgument,
+        NotImplemented,
+        Internal,
+    }
+
+    fn error_for(case: ErrorCase) -> IbError {
+        match case {
+            ErrorCase::Fabric => IbError::IBFabricError("ufm failed".to_string()),
+            ErrorCase::NotFound => IbError::NotFoundError {
+                kind: "Machine",
+                id: "machine-1".to_string(),
+            },
+            ErrorCase::InvalidArgument => IbError::InvalidArgument("bad pkey".to_string()),
+            ErrorCase::NotImplemented => IbError::NotImplemented,
+            ErrorCase::Internal => IbError::internal("unexpected state".to_string()),
+        }
+    }
+
+    #[test]
+    fn formats_ib_errors() {
+        value_scenarios!(
+            run = |case| error_for(case).to_string();
+            "user facing errors" {
+                ErrorCase::Fabric => "Failed to call IBFabricManager: ufm failed".to_string(),
+                ErrorCase::NotFound => "Machine not found: machine-1".to_string(),
+                ErrorCase::InvalidArgument => "Argument is invalid: bad pkey".to_string(),
+                ErrorCase::NotImplemented => "The function is not implemented".to_string(),
+                ErrorCase::Internal => "Internal error: unexpected state".to_string(),
+            }
+        );
+    }
+}

crates/ib-fabric/src/errors.rs

@@ -83,3 +83,127 @@ impl IBFabric for DisableIBFabric {
         Err(IbError::IBFabricError("ib fabric is disabled".to_string()))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use carbide_test_support::Outcome::*;
+    use carbide_test_support::{Case, check_cases_async};
+
+    use super::*;
+
+    #[derive(Clone, Copy, Debug)]
+    enum DisabledOperation {
+        GetFabricConfig,
+        GetNetwork,
+        GetNetworks,
+        BindPorts,
+        UpdateQos,
+        FindPort,
+        UnbindPorts,
+        Versions,
+        RawGet,
+    }
+
+    fn ib_network() -> IBNetwork {
+        IBNetwork {
+            name: "tenant".to_string(),
+            pkey: 1,
+            ipoib: true,
+            qos_conf: None,
+            associated_guids: None,
+            membership: None,
+        }
+    }
+
+    fn qos_conf() -> IBQosConf {
+        IBQosConf {
+            mtu: Default::default(),
+            service_level: Default::default(),
+            rate_limit: Default::default(),
+        }
+    }
+
+    async fn run_disabled_operation(operation: DisabledOperation) -> Result<(), String> {
+        let fabric = DisableIBFabric {};
+        match operation {
+            DisabledOperation::GetFabricConfig => fabric.get_fabric_config().await.map(|_| ()),
+            DisabledOperation::GetNetwork => fabric
+                .get_ib_network(1, GetPartitionOptions::default())
+                .await
+                .map(|_| ()),
+            DisabledOperation::GetNetworks => fabric
+                .get_ib_networks(GetPartitionOptions::default())
+                .await
+                .map(|_| ()),
+            DisabledOperation::BindPorts => {
+                fabric
+                    .bind_ib_ports(ib_network(), vec!["guid-1".to_string()])
+                    .await
+            }
+            DisabledOperation::UpdateQos => fabric.update_partition_qos_conf(1, &qos_conf()).await,
+            DisabledOperation::FindPort => fabric.find_ib_port(None).await.map(|_| ()),
+            DisabledOperation::UnbindPorts => {
+                fabric.unbind_ib_ports(1, vec!["guid-1".to_string()]).await
+            }
+            DisabledOperation::Versions => fabric.versions().await.map(|_| ()),
+            DisabledOperation::RawGet => fabric.raw_get("/app/ufm_version").await.map(|_| ()),
+        }
+        .map_err(|error| error.to_string())
+    }
+
+    #[tokio::test]
+    async fn disabled_fabric_rejects_operations() {
+        let disabled = "Failed to call IBFabricManager: ib fabric is disabled".to_string();
+        check_cases_async(
+            [
+                Case {
+                    scenario: "get fabric config",
+                    input: DisabledOperation::GetFabricConfig,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "get network",
+                    input: DisabledOperation::GetNetwork,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "get networks",
+                    input: DisabledOperation::GetNetworks,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "bind ports",
+                    input: DisabledOperation::BindPorts,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "update qos",
+                    input: DisabledOperation::UpdateQos,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "find port",
+                    input: DisabledOperation::FindPort,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "unbind ports",
+                    input: DisabledOperation::UnbindPorts,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "versions",
+                    input: DisabledOperation::Versions,
+                    expect: FailsWith(disabled.clone()),
+                },
+                Case {
+                    scenario: "raw get",
+                    input: DisabledOperation::RawGet,
+                    expect: FailsWith(disabled),
+                },
+            ],
+            run_disabled_operation,
+        )
+        .await;
+    }
+}

crates/ib-fabric/src/ib/disable.rs

@@ -176,3 +176,161 @@ impl IBFabricManager for IBFabricManagerImpl {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use async_trait::async_trait;
+    use carbide_secrets::SecretsError;
+    use carbide_test_support::Outcome::*;
+    use carbide_test_support::scenarios;
+
+    use super::*;
+
+    struct NoopCredentialReader;
+
+    #[async_trait]
+    impl CredentialReader for NoopCredentialReader {
+        async fn get_credentials(
+            &self,
+            _key: &CredentialKey,
+        ) -> Result<Option<Credentials>, SecretsError> {
+            Ok(None)
+        }
+    }
+
+    #[derive(Clone, Copy, Debug)]
+    enum ManagerCase {
+        ValidDisabled,
+        EmptyEndpointList,
+        MultipleEndpoints,
+        InvalidEndpoint,
+    }
+
+    #[derive(Debug, PartialEq)]
+    struct ManagerConfigSummary {
+        endpoint_count: usize,
+        manager_type: &'static str,
+        max_partition_per_tenant: i32,
+        allow_insecure_fabric_configuration: bool,
+        fabric_manager_run_interval_secs: u64,
+    }
+
+    fn credential_reader() -> Arc<dyn CredentialReader> {
+        Arc::new(NoopCredentialReader)
+    }
+
+    fn manager_type_name(manager_type: IBFabricManagerType) -> &'static str {
+        match manager_type {
+            IBFabricManagerType::Disable => "disable",
+            #[cfg(feature = "test-support")]
+            IBFabricManagerType::Mock => "mock",
+            IBFabricManagerType::Rest => "rest",
+        }
+    }
+
+    fn summarize_manager_config(config: IBFabricManagerConfig) -> ManagerConfigSummary {
+        ManagerConfigSummary {
+            endpoint_count: config.endpoints.len(),
+            manager_type: manager_type_name(config.manager_type),
+            max_partition_per_tenant: config.max_partition_per_tenant,
+            allow_insecure_fabric_configuration: config.allow_insecure_fabric_configuration,
+            fabric_manager_run_interval_secs: config.fabric_manager_run_interval.as_secs(),
+        }
+    }
+
+    fn config_for_case(case: ManagerCase) -> IBFabricManagerConfig {
+        let mut config = IBFabricManagerConfig::default();
+        match case {
+            ManagerCase::ValidDisabled => {
+                config.endpoints.insert(
+                    "fabric-a".to_string(),
+                    vec!["https://127.0.0.1:443".to_string()],
+                );
+            }
+            ManagerCase::EmptyEndpointList => {
+                config.endpoints.insert("fabric-a".to_string(), vec![]);
+            }
+            ManagerCase::MultipleEndpoints => {
+                config.endpoints.insert(
+                    "fabric-a".to_string(),
+                    vec![
+                        "https://127.0.0.1:443".to_string(),
+                        "https://127.0.0.2:443".to_string(),
+                    ],
+                );
+            }
+            ManagerCase::InvalidEndpoint => {
+                config
+                    .endpoints
+                    .insert("fabric-a".to_string(), vec!["not a uri".to_string()]);
+            }
+        }
+        config
+    }
+
+    fn create_manager(case: ManagerCase) -> Result<ManagerConfigSummary, &'static str> {
+        create_ib_fabric_manager(credential_reader(), config_for_case(case))
+            .map(|manager| summarize_manager_config(manager.get_config()))
+            .map_err(manager_error_kind)
+    }
+
+    fn manager_error_kind(error: eyre::Report) -> &'static str {
+        let error = error.to_string();
+        if error.contains("Exactly 1 endpoint") {
+            "endpoint-count"
+        } else if error.contains("not a valid HTTP(S) URI") {
+            "invalid-uri"
+        } else {
+            "unknown"
+        }
+    }
+
+    #[test]
+    fn default_manager_config_uses_disabled_defaults() {
+        assert_eq!(
+            summarize_manager_config(IBFabricManagerConfig::default()),
+            ManagerConfigSummary {
+                endpoint_count: 0,
+                manager_type: "disable",
+                max_partition_per_tenant: config::IBFabricConfig::default_max_partition_per_tenant(
+                ),
+                allow_insecure_fabric_configuration: false,
+                fabric_manager_run_interval_secs: 60,
+            }
+        );
+    }
+
+    #[test]
+    fn validates_manager_endpoints() {
+        scenarios!(create_manager:
+            "valid config" {
+                ManagerCase::ValidDisabled => Yields(ManagerConfigSummary {
+                    endpoint_count: 1,
+                    manager_type: "disable",
+                    max_partition_per_tenant: config::IBFabricConfig::default_max_partition_per_tenant(),
+                    allow_insecure_fabric_configuration: false,
+                    fabric_manager_run_interval_secs: 60,
+                }),
+            }
+
+            "invalid endpoints" {
+                ManagerCase::EmptyEndpointList => FailsWith("endpoint-count"),
+                ManagerCase::MultipleEndpoints => FailsWith("endpoint-count"),
+                ManagerCase::InvalidEndpoint => FailsWith("invalid-uri"),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn disabled_manager_returns_disabled_client() {
+        let manager =
+            create_ib_fabric_manager(credential_reader(), IBFabricManagerConfig::default())
+                .unwrap();
+        let client = manager.new_client("fabric-a").await.unwrap();
+
+        assert_eq!(
+            client.get_fabric_config().await.unwrap_err().to_string(),
+            "Failed to call IBFabricManager: ib fabric is disabled"
+        );
+    }
+}