fix: transport context polling order (#456)

This PR provides a fix for the strange order identified in
#455 and updates the
`transport_events` test to validate the new behaviour.

As explained in #455,
polling order is now sanitized and resumes wherever it left off in a
previous call to `poll_next`.

resolves #455

Author: iTranscend

src/transport/manager/mod.rs

@@ -174,9 +174,9 @@ impl Stream for TransportContext {
         }
 
         let len = self.transports.len();
-        self.index = (self.index + 1) % len;
-        for index in 0..len {
-            let current = (self.index + index) % len;
+        for _ in 0..len {
+            let current = self.index;
+            self.index = (current + 1) % len;
             let (key, stream) = self.transports.get_index_mut(current).expect("transport to exist");
             match stream.poll_next_unpin(cx) {
                 Poll::Pending => {}
@@ -1506,6 +1506,7 @@ mod tests {
 
     #[tokio::test]
     #[cfg(feature = "websocket")]
+    #[cfg(feature = "quic")]
     async fn transport_events() {
         let mut transports = TransportContext::new();
 
@@ -1517,23 +1518,27 @@ mod tests {
         let transport = MockTransport::new(rx);
         transports.register_transport(SupportedTransport::WebSocket, Box::new(transport));
 
+        let (tx_quic, rx) = tokio::sync::mpsc::channel(8);
+        let transport = MockTransport::new(rx);
+        transports.register_transport(SupportedTransport::Quic, Box::new(transport));
+
         assert_eq!(transports.index, 0);
-        assert_eq!(transports.transports.len(), 2);
+        assert_eq!(transports.transports.len(), 3);
         // No items.
         futures::future::poll_fn(|cx| match transports.poll_next_unpin(cx) {
             std::task::Poll::Ready(_) => panic!("didn't expect event from `TransportService`"),
             std::task::Poll::Pending => std::task::Poll::Ready(()),
         })
         .await;
-        assert_eq!(transports.index, 1);
+        assert_eq!(transports.index, 0);
 
         // Websocket events.
         tx_ws
             .send(TransportEvent::PendingInboundConnection {
                 connection_id: ConnectionId::from(1),
             })
             .await
-            .expect("chanel to be open");
+            .expect("channel to be open");
 
         let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
             .await
@@ -1543,15 +1548,15 @@ mod tests {
             event.1,
             TransportEvent::PendingInboundConnection { .. }
         ));
-        assert_eq!(transports.index, 0);
+        assert_eq!(transports.index, 2);
 
         // TCP events.
         tx_tcp
             .send(TransportEvent::PendingInboundConnection {
                 connection_id: ConnectionId::from(2),
             })
             .await
-            .expect("chanel to be open");
+            .expect("channel to be open");
 
         let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
             .await
@@ -1563,19 +1568,43 @@ mod tests {
         ));
         assert_eq!(transports.index, 1);
 
-        // Both transports produce events.
-        tx_ws
+        // QUIC events
+        tx_quic
             .send(TransportEvent::PendingInboundConnection {
                 connection_id: ConnectionId::from(3),
             })
             .await
-            .expect("chanel to be open");
-        tx_tcp
+            .expect("channel to be open");
+
+        let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
+            .await
+            .expect("expected event");
+        assert_eq!(event.0, SupportedTransport::Quic);
+        assert!(std::matches!(
+            event.1,
+            TransportEvent::PendingInboundConnection { .. }
+        ));
+        assert_eq!(transports.index, 0);
+
+        // All three transports produce events.
+        tx_ws
             .send(TransportEvent::PendingInboundConnection {
                 connection_id: ConnectionId::from(4),
             })
             .await
-            .expect("chanel to be open");
+            .expect("channel to be open");
+        tx_tcp
+            .send(TransportEvent::PendingInboundConnection {
+                connection_id: ConnectionId::from(5),
+            })
+            .await
+            .expect("channel to be open");
+        tx_quic
+            .send(TransportEvent::PendingInboundConnection {
+                connection_id: ConnectionId::from(6),
+            })
+            .await
+            .expect("channel to be open");
 
         let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
             .await
@@ -1585,7 +1614,7 @@ mod tests {
             event.1,
             TransportEvent::PendingInboundConnection { .. }
         ));
-        assert_eq!(transports.index, 0);
+        assert_eq!(transports.index, 1);
 
         let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
             .await
@@ -1595,7 +1624,17 @@ mod tests {
             event.1,
             TransportEvent::PendingInboundConnection { .. }
         ));
-        assert_eq!(transports.index, 1);
+        assert_eq!(transports.index, 2);
+
+        let event = futures::future::poll_fn(|cx| transports.poll_next_unpin(cx))
+            .await
+            .expect("expected event");
+        assert_eq!(event.0, SupportedTransport::Quic);
+        assert!(std::matches!(
+            event.1,
+            TransportEvent::PendingInboundConnection { .. }
+        ));
+        assert_eq!(transports.index, 0);
     }
 
     #[test]