kafrust_protocol/api/
describe_user_scram_credentials.rs

1use crate::codec::{Decoder, Encoder};
2use crate::error::Result;
3use crate::header::RequestHeader;
4
5pub const API_KEY: i16 = 50;
6
7#[derive(Debug, Clone, PartialEq, Eq)]
8pub struct DescribeUserScramCredentialsRequestV0 {
9    pub correlation_id: i32,
10    pub client_id: Option<String>,
11    pub users: Option<Vec<String>>,
12}
13
14impl DescribeUserScramCredentialsRequestV0 {
15    pub fn encode(&self) -> Result<Vec<u8>> {
16        let mut encoder = Encoder::new();
17        RequestHeader {
18            api_key: API_KEY,
19            api_version: 0,
20            correlation_id: self.correlation_id,
21            client_id: self.client_id.clone(),
22        }
23        .encode_v2(&mut encoder)?;
24        encoder.write_compact_array(self.users.as_deref(), |encoder, user| {
25            encoder.write_compact_string(user)?;
26            encoder.write_empty_tagged_fields();
27            Ok(())
28        })?;
29        encoder.write_empty_tagged_fields();
30        Ok(encoder.into_bytes())
31    }
32}
33
34#[derive(Debug, Clone, PartialEq, Eq)]
35pub struct DescribeUserScramCredentialsResponseV0 {
36    pub throttle_time_ms: i32,
37    pub error_code: i16,
38    pub error_message: Option<String>,
39    pub results: Vec<DescribeUserScramCredentialsResultV0>,
40}
41
42impl DescribeUserScramCredentialsResponseV0 {
43    pub fn decode_body(decoder: &mut Decoder<'_>) -> Result<Self> {
44        let throttle_time_ms = decoder.read_i32()?;
45        let error_code = decoder.read_i16()?;
46        let error_message = decoder.read_compact_nullable_string()?;
47        let results = decoder
48            .read_compact_array(
49                "describe user SCRAM credential results",
50                DescribeUserScramCredentialsResultV0::decode,
51            )?
52            .unwrap_or_default();
53        decoder.read_tagged_fields()?;
54        Ok(Self {
55            throttle_time_ms,
56            error_code,
57            error_message,
58            results,
59        })
60    }
61}
62
63#[derive(Debug, Clone, PartialEq, Eq)]
64pub struct DescribeUserScramCredentialsResultV0 {
65    pub user: String,
66    pub error_code: i16,
67    pub error_message: Option<String>,
68    pub credential_infos: Vec<ScramCredentialInfoV0>,
69}
70
71impl DescribeUserScramCredentialsResultV0 {
72    fn decode(decoder: &mut Decoder<'_>) -> Result<Self> {
73        let user = decoder.read_compact_string()?;
74        let error_code = decoder.read_i16()?;
75        let error_message = decoder.read_compact_nullable_string()?;
76        let credential_infos = decoder
77            .read_compact_array(
78                "described SCRAM credential infos",
79                ScramCredentialInfoV0::decode,
80            )?
81            .unwrap_or_default();
82        decoder.read_tagged_fields()?;
83        Ok(Self {
84            user,
85            error_code,
86            error_message,
87            credential_infos,
88        })
89    }
90}
91
92#[derive(Debug, Clone, PartialEq, Eq)]
93pub struct ScramCredentialInfoV0 {
94    pub mechanism: i8,
95    pub iterations: i32,
96}
97
98impl ScramCredentialInfoV0 {
99    fn decode(decoder: &mut Decoder<'_>) -> Result<Self> {
100        let mechanism = decoder.read_i8()?;
101        let iterations = decoder.read_i32()?;
102        decoder.read_tagged_fields()?;
103        Ok(Self {
104            mechanism,
105            iterations,
106        })
107    }
108}
109
110#[cfg(test)]
111#[allow(clippy::unwrap_used)]
112mod tests {
113    use super::{
114        DescribeUserScramCredentialsRequestV0, DescribeUserScramCredentialsResponseV0, API_KEY,
115    };
116    use crate::codec::{Decoder, Encoder};
117
118    #[test]
119    fn encodes_describe_all_user_scram_credentials_v0_request() {
120        let request = DescribeUserScramCredentialsRequestV0 {
121            correlation_id: 23,
122            client_id: Some("kafrust".to_owned()),
123            users: None,
124        };
125
126        let bytes = request.encode().unwrap();
127        assert_eq!(&bytes[0..4], &[0, API_KEY as u8, 0, 0]);
128        assert_eq!(&bytes[4..8], &[0, 0, 0, 23]);
129        assert_eq!(&bytes[bytes.len() - 2..], &[0, 0]);
130    }
131
132    #[test]
133    fn decodes_describe_user_scram_credentials_v0_response() {
134        let mut bytes = Encoder::new();
135        bytes.write_i32(9);
136        bytes.write_i16(0);
137        bytes.write_compact_nullable_string(None).unwrap();
138        bytes.write_unsigned_varint(2); // one result
139        bytes.write_compact_string("alice").unwrap();
140        bytes.write_i16(0);
141        bytes.write_compact_nullable_string(None).unwrap();
142        bytes.write_unsigned_varint(3); // two credential infos
143        bytes.write_i8(1);
144        bytes.write_i32(4096);
145        bytes.write_empty_tagged_fields();
146        bytes.write_i8(2);
147        bytes.write_i32(8192);
148        bytes.write_empty_tagged_fields();
149        bytes.write_empty_tagged_fields();
150        bytes.write_empty_tagged_fields();
151        let bytes = bytes.into_bytes();
152        let mut decoder = Decoder::new(&bytes);
153
154        let response = DescribeUserScramCredentialsResponseV0::decode_body(&mut decoder).unwrap();
155
156        assert_eq!(response.throttle_time_ms, 9);
157        assert_eq!(response.results[0].user, "alice");
158        assert_eq!(response.results[0].credential_infos[0].mechanism, 1);
159        assert_eq!(response.results[0].credential_infos[1].iterations, 8192);
160        assert!(decoder.is_empty());
161    }
162}
kafrust_protocol/api/describe_user_scram_credentials.rs

kafrust_protocol/api/
describe_user_scram_credentials.rs
