tests: datagrams should only be sent if both local and peer have sent SETTINGS_H3_DATAGRAM

Author: JPDye

h3-datagram/src/datagram_handler.rs

@@ -137,3 +137,67 @@ impl Display for SendDatagramError {
 }
 
 impl Error for SendDatagramError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::datagram::EncodedDatagram;
+    use h3::proto::frame;
+
+    use bytes::Bytes;
+
+    mod sender {
+        use super::*;
+
+        pub fn create(shared: Arc<SharedState>) -> DatagramSender<CountingSender, Bytes> {
+            DatagramSender {
+                handler: CountingSender::default(),
+                _marker: PhantomData,
+                shared_state: shared,
+                stream_id: StreamId::try_from(0u64).unwrap(),
+            }
+        }
+
+        #[derive(Default)]
+        pub struct CountingSender {
+            pub calls: usize,
+        }
+
+        impl SendDatagram<Bytes> for CountingSender {
+            fn send_datagram<T: Into<EncodedDatagram<Bytes>>>(
+                &mut self,
+                _data: T,
+            ) -> Result<(), SendDatagramErrorIncoming> {
+                self.calls += 1;
+                Ok(())
+            }
+        }
+    }
+
+    #[test]
+    fn refuses_send_when_datagrams_not_negotiated() {
+        let mut s = sender::create(Arc::new(SharedState::default()));
+        let res = s.send_datagram(Bytes::from_static(b"hi"));
+
+        assert!(res.is_err());
+        assert!(matches!(res.unwrap_err(), SendDatagramError::NotAvailable));
+        assert_eq!(s.handler.calls, 0);
+    }
+
+    #[test]
+    fn sends_when_datagrams_negotiated() {
+        let mut s = {
+            let mut settings = frame::Settings::default();
+            settings.insert(frame::SettingId::H3_DATAGRAM, 1).unwrap();
+
+            let shared_settings = Arc::new(SharedState::default());
+            shared_settings.set_settings((&settings).into());
+
+            sender::create(shared_settings)
+        };
+
+        s.send_datagram(Bytes::from_static(b"hi")).unwrap();
+        assert_eq!(s.handler.calls, 1, "should delegate to the QUIC backend");
+    }
+}