Rename fn to ensure_max_string_length

Author: sbernauer

crates/stackable-operator/CHANGELOG.md

@@ -7,7 +7,7 @@ All notable changes to this project will be documented in this file.
 ### Added
 
 - Add the Cargo feature `kube-cel` that enables the `cel` feature on the `kube` crate ([#1259]).
-- Add `length_enforcement::ensure_max_length` and `Key::shortened_to_valid_length` helper functions ([#1260]).
+- Add `length_enforcement::ensure_max_string_length` and `Key::shortened_to_valid_length` helper functions ([#1260]).
 
 [#1259]: https://github.com/stackabletech/operator-rs/pull/1259
 [#1260]: https://github.com/stackabletech/operator-rs/pull/1260

crates/stackable-operator/src/kvp/key.rs

@@ -3,7 +3,7 @@ use std::{fmt::Display, ops::Deref, str::FromStr, sync::LazyLock};
 use regex::Regex;
 use snafu::{ResultExt, Snafu, ensure};
 
-use crate::utils::length_enforcement::ensure_max_length;
+use crate::utils::length_enforcement::ensure_max_string_length;
 
 const KEY_PREFIX_MAX_LEN: usize = 253;
 const KEY_NAME_MAX_LEN: usize = 63;
@@ -139,7 +139,7 @@ impl Deref for Key {
 impl Key {
     /// (Optionally) shortens the `prefix` and `name` to make sure they produce a valid [`Key`].
     ///
-    /// See [`ensure_max_length`] for details on the shortening algorithm.
+    /// See [`ensure_max_string_length`] for details on the shortening algorithm.
     pub fn shortened_to_valid_length(
         prefix: Option<&str>,
         name: impl Into<String>,
@@ -148,7 +148,7 @@ impl Key {
         // name, shortening won't make it one. In particular, a prefix must end in a letters-only
         // TLD, but the appended hash adds a hyphen and probably digits, very likely being an
         // invalid result.
-        let name = ensure_max_length(name, KEY_NAME_MAX_LEN, 8);
+        let name = ensure_max_string_length(name, KEY_NAME_MAX_LEN, 8);
 
         let key = match prefix {
             Some(prefix) => format!("{prefix}/{name}"),

crates/stackable-operator/src/utils/length_enforcement.rs

@@ -11,7 +11,7 @@ use sha2::{Digest, Sha256};
 /// # Panics
 ///
 /// Panics if `max_length_bytes < 1 /* character */ + 1 /* dash */ + hash_length`.
-pub fn ensure_max_length(
+pub fn ensure_max_string_length(
     original: impl Into<String>,
     max_length_bytes: usize,
     hash_length: usize,
@@ -63,102 +63,108 @@ mod test {
     use super::*;
 
     #[test]
-    fn test_ensure_max_length() {
+    fn ensure_max_string_length_ascii() {
         // empty resource name, no hash length
-        assert_eq!(String::new(), ensure_max_length(String::new(), 2, 0));
+        assert_eq!(String::new(), ensure_max_string_length(String::new(), 2, 0));
 
         // resource_name.len() <= max_length
         assert_eq!(
             "abcdef".to_owned(),
-            ensure_max_length("abcdef".to_owned(), 6, 4)
+            ensure_max_string_length("abcdef".to_owned(), 6, 4)
         );
 
         // hash_length == 0
         assert_eq!(
             "abcdef".to_owned(),
-            ensure_max_length("abcdefg".to_owned(), 6, 0)
+            ensure_max_string_length("abcdefg".to_owned(), 6, 0)
         );
 
         // hash appended with dash
         assert_eq!(
             "a-7d1a".to_owned(),
-            ensure_max_length("abcdefg".to_owned(), 6, 4)
+            ensure_max_string_length("abcdefg".to_owned(), 6, 4)
         );
 
         // hash appended without an extra dash
         assert_eq!(
             "ab-a1b1".to_owned(),
-            ensure_max_length("ab-defgh".to_owned(), 7, 4)
+            ensure_max_string_length("ab-defgh".to_owned(), 7, 4)
         );
 
         // hash appended without an extra dash
         // In this case, the result is one character shorter than the maximum length.
         assert_eq!(
             "a-3951".to_owned(),
-            ensure_max_length("a-cdefgh".to_owned(), 7, 4)
+            ensure_max_string_length("a-cdefgh".to_owned(), 7, 4)
         );
 
         // hash appended without an extra dash
         // The two dashes in the given resource name are intentionally kept.
         assert_eq!(
             "a--f7a0".to_owned(),
-            ensure_max_length("a--defgh".to_owned(), 7, 4)
+            ensure_max_string_length("a--defgh".to_owned(), 7, 4)
         );
 
         // A hash_length longer than the produced hash string may not produce the desired result.
         // Just use sensible values!
         assert_eq!(
             "aaaaaaaaa-d476ce01c3787bcab054a2cf48d6af6dd303a0eb549e21a74125132f79d90c36".to_owned(),
-            ensure_max_length("a".repeat(1011), 1010, 1000)
+            ensure_max_string_length("a".repeat(1011), 1010, 1000)
         );
     }
 
     /// The maximum length is measured in bytes, so multi-byte characters must not be split up by
     /// the truncation. This can make the result shorter than the maximum length.
     #[test]
-    fn test_ensure_max_length_with_multi_byte_characters() {
+    fn ensure_max_string_length_with_multi_byte_characters() {
         // The two byte characters fit exactly into the maximum length.
-        assert_eq!("äöü".to_owned(), ensure_max_length("äöü".to_owned(), 6, 4));
+        assert_eq!(
+            "äöü".to_owned(),
+            ensure_max_string_length("äöü".to_owned(), 6, 4)
+        );
 
         // Truncating after 5 bytes would split up the "ü", so it is dropped entirely.
-        assert_eq!("äö".to_owned(), ensure_max_length("äöü".to_owned(), 5, 0));
+        assert_eq!(
+            "äö".to_owned(),
+            ensure_max_string_length("äöü".to_owned(), 5, 0)
+        );
 
         // The 5 bytes reserved for the name only fit "äö", of which the "ö" is then replaced by
         // the dash, so the result is two bytes shorter than the maximum length.
         assert_eq!(
             "ä-e109".to_owned(),
-            ensure_max_length("äöüäöü".to_owned(), 9, 4)
+            ensure_max_string_length("äöüäöü".to_owned(), 9, 4)
         );
 
         // hash appended with dash, three byte characters
         assert_eq!(
             "日-9efa".to_owned(),
-            ensure_max_length("日本語日本語".to_owned(), 10, 4)
+            ensure_max_string_length("日本語日本語".to_owned(), 10, 4)
         );
 
         // hash appended with dash, four byte characters
         assert_eq!(
             "🚀-a13c".to_owned(),
-            ensure_max_length("🚀🚀🚀🚀".to_owned(), 13, 4)
+            ensure_max_string_length("🚀🚀🚀🚀".to_owned(), 13, 4)
         );
 
         // The trailing dash of the truncated name is replaced by the dash which separates the
         // hash.
         assert_eq!(
             "aä-f726".to_owned(),
-            ensure_max_length("aä-öüb".to_owned(), 8, 4)
+            ensure_max_string_length("aä-öüb".to_owned(), 8, 4)
         );
 
         // The truncated name is "aä-ö", so the "ö" is dropped and the existing dash is reused.
         assert_eq!(
             "aä-ae0c".to_owned(),
-            ensure_max_length("aä-öüäöü".to_owned(), 10, 4)
+            ensure_max_string_length("aä-öüäöü".to_owned(), 10, 4)
         );
 
         // The truncation does not leave any character, so only the hash is returned.
         assert_eq!(
             "d24d".to_owned(),
-            ensure_max_length("🚀🚀🚀".to_owned(), 6, 4)
+            ensure_max_string_length("🚀🚀🚀".to_owned(), 6, 4)
         );
     }
 }

crates/stackable-operator/src/v2/role_group_utils.rs

@@ -6,7 +6,7 @@ use super::types::{
     },
     operator::{ClusterName, RoleGroupName, RoleName},
 };
-use crate::{attributed_string_type, utils::length_enforcement::ensure_max_length};
+use crate::{attributed_string_type, utils::length_enforcement::ensure_max_string_length};
 
 attributed_string_type! {
     QualifiedRoleGroupName,
@@ -79,7 +79,7 @@ impl ResourceNames {
         );
         // `concatenated_name` contains only ASCII characters.
         assert!(concatenated_name.is_ascii());
-        let sanitized_name = ensure_max_length(
+        let sanitized_name = ensure_max_string_length(
             concatenated_name,
             QualifiedRoleGroupName::MAX_LENGTH,
             HASH_LENGTH,