wasmrs_frames/frames/
f_request_response.rs

1use bytes::Bytes;
2
3use super::{request_payload::RequestPayload, Error, FrameFlags, FrameHeader, FrameType, RSocketFrame};
4use crate::{Frame, RawPayload};
5
6#[cfg_attr(not(target = "wasm32-unknown-unknown"), derive(Debug))]
7#[must_use]
8#[derive(Clone)]
9pub struct RequestResponse(pub RequestPayload);
10
11impl RequestResponse {
12  pub(crate) fn from_payload(stream_id: u32, payload: RawPayload, flags: FrameFlags, initial_n: u32) -> Self {
13    Self(RequestPayload::from_payload(
14      stream_id,
15      payload,
16      Self::FRAME_TYPE,
17      flags,
18      initial_n,
19    ))
20  }
21}
22
23impl RSocketFrame<RequestResponse> for RequestResponse {
24  const FRAME_TYPE: FrameType = FrameType::RequestResponse;
25
26  fn stream_id(&self) -> u32 {
27    self.0.stream_id
28  }
29
30  fn decode_all(mut buffer: Bytes) -> Result<Self, Error> {
31    let header = FrameHeader::from_bytes(buffer.split_to(Frame::LEN_HEADER));
32    Self::decode_frame(&header, buffer)
33  }
34
35  fn decode_frame(header: &FrameHeader, buffer: Bytes) -> Result<Self, Error> {
36    Self::check_type(header)?;
37    Ok(Self(RequestPayload::decode(header, buffer)?))
38  }
39
40  fn encode(self) -> Bytes {
41    self.0.encode()
42  }
43
44  fn gen_header(&self) -> FrameHeader {
45    FrameHeader::new(self.0.stream_id, FrameType::RequestResponse, Frame::FLAG_METADATA)
46  }
47
48  fn get_flag(&self) -> FrameFlags {
49    self.0.get_flags()
50  }
51}
52
53impl From<RequestResponse> for RawPayload {
54  fn from(req: RequestResponse) -> Self {
55    req.0.into()
56  }
57}
58
59#[cfg(test)]
60mod test {
61  use anyhow::Result;
62
63  use super::*;
64
65  static BYTES: &[u8] = include_bytes!("../../testdata/frame.request_response.bin");
66
67  #[test]
68  fn test_decode() -> Result<()> {
69    println!("RAW: {:?}", BYTES);
70    let p = RequestResponse::decode_all(BYTES.into())?;
71    assert_eq!(p.0.stream_id, 1234);
72    assert_eq!(p.0.data, Bytes::from(b"hello".as_slice()));
73    Ok(())
74  }
75
76  #[test]
77  fn test_encode() -> Result<()> {
78    let payload = RequestPayload {
79      frame_type: FrameType::RequestResponse,
80      stream_id: 1234,
81      metadata: Bytes::from("hello"),
82      data: Bytes::from("hello"),
83      follows: true,
84      complete: true,
85      initial_n: 1,
86    };
87    let this = RequestResponse(payload);
88    let encoded = this.encode();
89    assert_eq!(encoded, Bytes::from(BYTES));
90    Ok(())
91  }
92}