compat: Add support for some more types.

src/v/cluster/partition_balancer_types.h

@@ -55,6 +55,12 @@ struct partition_balancer_violations
           : id(id)
           , unavailable_since(unavailable_since) {}
 
+        friend std::ostream&
+        operator<<(std::ostream& o, const unavailable_node& u) {
+            fmt::print(o, "{{ id: {} since: {} }}", u.id, u.unavailable_since);
+            return o;
+        }
+
         auto serde_fields() { return std::tie(id, unavailable_since); }
 
         bool operator==(const unavailable_node& other) const {
@@ -72,6 +78,15 @@ struct partition_balancer_violations
           : id(id)
           , disk_used_percent(disk_used_percent) {}
 
+        friend std::ostream& operator<<(std::ostream& o, const full_node& f) {
+            fmt::print(
+              o,
+              "{{ id: {} disk_used_percent: {} }}",
+              f.id,
+              f.disk_used_percent);
+            return o;
+        }
+
         auto serde_fields() { return std::tie(id, disk_used_percent); }
 
         bool operator==(const full_node& other) const {
@@ -90,6 +105,16 @@ struct partition_balancer_violations
       : unavailable_nodes(std::move(un))
       , full_nodes(std::move(fn)) {}
 
+    friend std::ostream&
+    operator<<(std::ostream& o, const partition_balancer_violations& v) {
+        fmt::print(
+          o,
+          "{{ unavailable_nodes: {} full_nodes: {} }}",
+          v.unavailable_nodes,
+          v.full_nodes);
+        return o;
+    }
+
     auto serde_fields() { return std::tie(unavailable_nodes, full_nodes); }
 
     bool operator==(const partition_balancer_violations& other) const {
@@ -162,6 +187,18 @@ struct partition_balancer_overview_reply
         return error == other.error && last_tick_time == other.last_tick_time
                && status == other.status && violations == other.violations;
     }
+
+    friend std::ostream&
+    operator<<(std::ostream& o, const partition_balancer_overview_reply& rep) {
+        fmt::print(
+          o,
+          "{{ error: {} last_tick_time: {} status: {} violations: {}}}",
+          rep.error,
+          rep.last_tick_time,
+          rep.status,
+          rep.violations);
+        return o;
+    }
 };
 
 } // namespace cluster

src/v/cluster/tests/serialization_rt_test.cc

@@ -662,110 +662,6 @@ random_create_partitions_configuration() {
     }
     return cpc;
 }
-security::scram_credential random_credential() {
-    return security::scram_credential(
-      random_generators::get_bytes(256),
-      random_generators::get_bytes(256),
-      random_generators::get_bytes(256),
-      random_generators::get_int(1, 10));
-}
-
-security::resource_type random_resource_type() {
-    return random_generators::random_choice<security::resource_type>(
-      {security::resource_type::cluster,
-       security::resource_type::group,
-       security::resource_type::topic,
-       security::resource_type::transactional_id});
-}
-
-security::pattern_type random_pattern_type() {
-    return random_generators::random_choice<security::pattern_type>(
-      {security::pattern_type::literal, security::pattern_type::prefixed});
-}
-
-security::resource_pattern random_resource_pattern() {
-    return {
-      random_resource_type(),
-      random_generators::gen_alphanum_string(10),
-      random_pattern_type()};
-}
-
-security::acl_principal random_acl_principal() {
-    return {
-      security::principal_type::user,
-      random_generators::gen_alphanum_string(12)};
-}
-security::acl_host create_acl_host() {
-    return security::acl_host(ss::net::inet_address("127.0.0.1"));
-}
-security::acl_operation random_acl_operation() {
-    return random_generators::random_choice<security::acl_operation>(
-      {security::acl_operation::all,
-       security::acl_operation::alter,
-       security::acl_operation::alter_configs,
-       security::acl_operation::describe_configs,
-       security::acl_operation::cluster_action,
-       security::acl_operation::create,
-       security::acl_operation::remove,
-       security::acl_operation::read,
-       security::acl_operation::idempotent_write,
-       security::acl_operation::describe});
-}
-
-security::acl_permission random_acl_permission() {
-    return random_generators::random_choice<security::acl_permission>(
-      {security::acl_permission::allow, security::acl_permission::deny});
-}
-
-security::acl_entry random_acl_entry() {
-    return {
-      random_acl_principal(),
-      create_acl_host(),
-      random_acl_operation(),
-      random_acl_permission()};
-}
-security::acl_binding random_acl_binding() {
-    return {random_resource_pattern(), random_acl_entry()};
-}
-security::resource_pattern_filter random_resource_pattern_filter() {
-    auto resource = tests::random_optional(
-      [] { return random_resource_type(); });
-
-    auto name = tests::random_optional(
-      [] { return random_generators::gen_alphanum_string(14); });
-
-    auto pattern = tests::random_optional([] {
-        using ret_t = std::variant<
-          security::pattern_type,
-          security::resource_pattern_filter::pattern_match>;
-        if (tests::random_bool()) {
-            return ret_t(random_pattern_type());
-        } else {
-            return ret_t(security::resource_pattern_filter::pattern_match{});
-        }
-    });
-
-    return {resource, std::move(name), pattern};
-}
-
-security::acl_entry_filter random_acl_entry_filter() {
-    auto principal = tests::random_optional(
-      [] { return random_acl_principal(); });
-
-    auto host = tests::random_optional([] { return create_acl_host(); });
-
-    auto operation = tests::random_optional(
-      [] { return random_acl_operation(); });
-
-    auto permission = tests::random_optional(
-      [] { return random_acl_permission(); });
-
-    return {std::move(principal), host, operation, permission};
-}
-
-security::acl_binding_filter random_acl_binding_filter() {
-    return {random_resource_pattern_filter(), random_acl_entry_filter()};
-}
 std::vector<ss::sstring> random_strings() {
     auto cnt = random_generators::get_int(0, 20);
     std::vector<ss::sstring> ret;
@@ -1074,14 +970,14 @@ SEASTAR_THREAD_TEST_CASE(serde_reflection_roundtrip) {
     {
         cluster::create_acls_cmd_data data;
         for (auto i = 0, mi = random_generators::get_int(5, 25); i < mi; ++i) {
-            data.bindings.push_back(random_acl_binding());
+            data.bindings.push_back(tests::random_acl_binding());
         }
         roundtrip_test(data);
     }
     {
         cluster::delete_acls_cmd_data data;
         for (auto i = 0, mi = random_generators::get_int(5, 25); i < mi; ++i) {
-            data.filters.push_back(random_acl_binding_filter());
+            data.filters.push_back(tests::random_acl_binding_filter());
         }
         roundtrip_test(data);
     }
@@ -1639,7 +1535,7 @@ SEASTAR_THREAD_TEST_CASE(serde_reflection_roundtrip) {
     {
         cluster::create_acls_cmd_data create_acls_data{};
         for (auto i = 0, mi = random_generators::get_int(20); i < mi; ++i) {
-            create_acls_data.bindings.push_back(random_acl_binding());
+            create_acls_data.bindings.push_back(tests::random_acl_binding());
         }
         cluster::create_acls_request data{
           create_acls_data, random_timeout_clock_duration()};
@@ -1656,7 +1552,8 @@ SEASTAR_THREAD_TEST_CASE(serde_reflection_roundtrip) {
     {
         cluster::delete_acls_cmd_data delete_acls_data{};
         for (auto i = 0, mi = random_generators::get_int(20); i < mi; ++i) {
-            delete_acls_data.filters.push_back(random_acl_binding_filter());
+            delete_acls_data.filters.push_back(
+              tests::random_acl_binding_filter());
         }
         cluster::delete_acls_request data{
           delete_acls_data, random_timeout_clock_duration()};
@@ -1665,7 +1562,7 @@ SEASTAR_THREAD_TEST_CASE(serde_reflection_roundtrip) {
     {
         std::vector<security::acl_binding> bindings;
         for (auto i = 0, mi = random_generators::get_int(20); i < mi; ++i) {
-            bindings.push_back(random_acl_binding());
+            bindings.push_back(tests::random_acl_binding());
         }
         cluster::delete_acls_result data{
           .error = cluster::errc::join_request_dispatch_error,
@@ -1678,7 +1575,7 @@ SEASTAR_THREAD_TEST_CASE(serde_reflection_roundtrip) {
         for (auto i = 0, mi = random_generators::get_int(20); i < mi; ++i) {
             std::vector<security::acl_binding> bindings;
             for (auto j = 0, mj = random_generators::get_int(20); j < mj; ++j) {
-                bindings.push_back(random_acl_binding());
+                bindings.push_back(tests::random_acl_binding());
             }
             results.push_back(cluster::delete_acls_result{
               .error = cluster::errc::join_request_dispatch_error,
@@ -2426,26 +2323,27 @@ SEASTAR_THREAD_TEST_CASE(commands_serialization_test) {
 
         roundtrip_cmd<cluster::create_user_cmd>(
           tests::random_named_string<security::credential_user>(),
-          random_credential());
+          tests::random_credential());
 
         roundtrip_cmd<cluster::delete_user_cmd>(
           tests::random_named_string<security::credential_user>(), 0);
 
         roundtrip_cmd<cluster::update_user_cmd>(
           tests::random_named_string<security::credential_user>(),
-          random_credential());
+          tests::random_credential());
 
         cluster::create_acls_cmd_data create_acls_data{};
         for (auto i = 0, mi = random_generators::get_int(1, 20); i < mi; ++i) {
-            create_acls_data.bindings.push_back(random_acl_binding());
+            create_acls_data.bindings.push_back(tests::random_acl_binding());
         }
 
         roundtrip_cmd<cluster::create_acls_cmd>(std::move(create_acls_data), 0);
 
         cluster::delete_acls_cmd_data delete_acl_data;
 
         for (auto i = 0, mi = random_generators::get_int(1, 20); i < mi; ++i) {
-            delete_acl_data.filters.push_back(random_acl_binding_filter());
+            delete_acl_data.filters.push_back(
+              tests::random_acl_binding_filter());
         }
 
         roundtrip_cmd<cluster::delete_acls_cmd>(std::move(delete_acl_data), 0);

src/v/cluster/types.h

@@ -1703,6 +1703,12 @@ struct create_acls_cmd_data
     operator==(const create_acls_cmd_data&, const create_acls_cmd_data&)
       = default;
 
+    friend std::ostream&
+    operator<<(std::ostream& o, const create_acls_cmd_data& r) {
+        fmt::print(o, "{{ bindings: {} }}", r.bindings);
+        return o;
+    }
+
     auto serde_fields() { return std::tie(bindings); }
 };
 
@@ -1721,6 +1727,12 @@ struct create_acls_request
     operator==(const create_acls_request&, const create_acls_request&)
       = default;
 
+    friend std::ostream&
+    operator<<(std::ostream& o, const create_acls_request& r) {
+        fmt::print(o, "{{ data: {}, timeout: {} }}", r.data, r.timeout.count());
+        return o;
+    }
+
     void serde_read(iobuf_parser& in, const serde::header& h) {
         using serde::read_nested;
         data = read_nested<create_acls_cmd_data>(in, h._bytes_left_limit);
@@ -1773,6 +1785,12 @@ struct delete_acls_result
     friend bool operator==(const delete_acls_result&, const delete_acls_result&)
       = default;
 
+    friend std::ostream&
+    operator<<(std::ostream& o, const delete_acls_result& r) {
+        fmt::print(o, "{{ error: {} bindings: {} }}", r.error, r.bindings);
+        return o;
+    }
+
     auto serde_fields() { return std::tie(error, bindings); }
 };
 
@@ -1813,6 +1831,12 @@ struct delete_acls_reply
     friend bool operator==(const delete_acls_reply&, const delete_acls_reply&)
       = default;
 
+    friend std::ostream&
+    operator<<(std::ostream& o, const delete_acls_reply& r) {
+        fmt::print(o, "{{ results: {} }}", r.results);
+        return o;
+    }
+
     auto serde_fields() { return std::tie(results); }
 };
 

src/v/compat/acls_compat.h

@@ -17,9 +17,25 @@
 
 namespace compat {
 
+GEN_COMPAT_CHECK(
+  cluster::create_acls_request,
+  {
+      json_write(data);
+      json_write(timeout);
+  },
+  {
+      json_read(data);
+      json_read(timeout);
+  });
+
 GEN_COMPAT_CHECK(
   cluster::create_acls_reply,
   { json_write(results); },
   { json_read(results); });
 
+GEN_COMPAT_CHECK(
+  cluster::delete_acls_reply,
+  { json_write(results); },
+  { json_read(results); });
+
 }; // namespace compat

src/v/compat/acls_generator.h

@@ -10,13 +10,28 @@
  */
 #pragma once
 
+#include "cluster/errc.h"
 #include "cluster/types.h"
 #include "compat/cluster_generator.h"
 #include "compat/generator.h"
 #include "test_utils/randoms.h"
 
 namespace compat {
 
+template<>
+struct instance_generator<cluster::create_acls_request> {
+    static cluster::create_acls_request random() {
+        cluster::create_acls_cmd_data data;
+        auto rand_bindings = tests::random_vector(
+          [] { return tests::random_acl_binding(); });
+        data.bindings.insert(
+          data.bindings.end(), rand_bindings.begin(), rand_bindings.end());
+        return {data, tests::random_duration<model::timeout_clock::duration>()};
+    }
+
+    static std::vector<cluster::create_acls_request> limits() { return {{}}; }
+};
+
 template<>
 struct instance_generator<cluster::create_acls_reply> {
     static cluster::create_acls_reply random() {
@@ -30,4 +45,22 @@ struct instance_generator<cluster::create_acls_reply> {
     static std::vector<cluster::create_acls_reply> limits() { return {{}}; }
 };
 
+template<>
+struct instance_generator<cluster::delete_acls_reply> {
+    static cluster::delete_acls_reply random() {
+        auto generator = []() {
+            auto errc = instance_generator<cluster::errc>::random();
+            auto acl_bindings = tests::random_vector(
+              []() { return tests::random_acl_binding(); });
+            return cluster::delete_acls_result{
+              .error = errc, .bindings = acl_bindings};
+        };
+        return {
+          .results = tests::random_vector(generator),
+        };
+    }
+
+    static std::vector<cluster::delete_acls_reply> limits() { return {{}}; }
+};
+
 }; // namespace compat