attempt to write tests

crates/projection-xmpp/src/lib.rs

@@ -187,18 +187,32 @@ async fn handle_socket(
     let mut xml_reader = NsReader::from_reader(BufReader::new(a));
     let mut xml_writer = Writer::new(b);
 
-    let authenticated = socket_auth(&mut xml_reader, &mut xml_writer, &mut reader_buf, &mut storage).await?;
+    pin!(termination);
-    log::debug!("User authenticated");
+    select! {
-    let mut connection = players.connect_to_player(authenticated.player_id.clone()).await;
+        biased;
-    socket_final(
+        _ = &mut termination => return Ok(()),
-        &mut xml_reader,
+        authenticated = socket_auth(&mut xml_reader, &mut xml_writer, &mut reader_buf, &mut storage) => {
-        &mut xml_writer,
+            match authenticated {
-        &mut reader_buf,
+                Ok(authenticated) => {
-        &authenticated,
+                    log::debug!("User authenticated");
-        &mut connection,
+                    let mut connection = players.connect_to_player(authenticated.player_id.clone()).await;
-        &rooms,
+                    socket_final(
-    )
+                        &mut xml_reader,
-    .await?;
+                        &mut xml_writer,
+                        &mut reader_buf,
+                        &authenticated,
+                        &mut connection,
+                        &rooms,
+                    )
+                    .await?;
+                },
+                Err(err) => {
+                    log::error!("Authentication error: {:?}", err);
+                }
+            }
+        },
+    }
+
 
     let a = xml_reader.into_inner().into_inner();
     let b = xml_writer.into_inner();

crates/projection-xmpp/tests/lib.rs

@@ -184,3 +184,75 @@ async fn scenario_basic() -> Result<()> {
     server.terminate().await?;
     Ok(())
 }
+
+
+#[tokio::test]
+async fn terminate_socket() -> Result<()> {
+    tracing_subscriber::fmt::init();
+    let config = ServerConfig {
+        listen_on: "127.0.0.1:0".parse().unwrap(),
+        cert: "tests/certs/xmpp.pem".parse().unwrap(),
+        key: "tests/certs/xmpp.key".parse().unwrap(),
+    };
+    let mut metrics = MetricsRegistry::new();
+    let mut storage = Storage::open(StorageConfig {
+        db_path: ":memory:".into(),
+    })
+        .await?;
+    let rooms = RoomRegistry::new(&mut metrics, storage.clone()).unwrap();
+    let players = PlayerRegistry::empty(rooms.clone(), &mut metrics).unwrap();
+    let server = launch(config, players, rooms, metrics, storage.clone()).await.unwrap();
+
+    // test scenario
+
+    storage.create_user("tester").await?;
+    storage.set_password("tester", "password").await?;
+
+    let mut stream = TcpStream::connect(server.addr).await?;
+    let mut s = TestScope::new(&mut stream);
+    tracing::info!("TCP connection established");
+
+    s.send(r#"<?xml version="1.0"?>"#).await?;
+    s.send(r#"<stream:stream xmlns:stream="http://etherx.jabber.org/streams" to="127.0.0.1" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns="jabber:client" version="1.0">"#).await?;
+    assert_matches!(s.next_xml_event().await?, Event::Decl(_) => {});
+    assert_matches!(s.next_xml_event().await?, Event::Start(b) => assert_eq!(b.local_name().into_inner(), b"stream"));
+    assert_matches!(s.next_xml_event().await?, Event::Start(b) => assert_eq!(b.local_name().into_inner(), b"features"));
+    assert_matches!(s.next_xml_event().await?, Event::Start(b) => assert_eq!(b.local_name().into_inner(), b"starttls"));
+    assert_matches!(s.next_xml_event().await?, Event::Empty(b) => assert_eq!(b.local_name().into_inner(), b"required"));
+    assert_matches!(s.next_xml_event().await?, Event::End(b) => assert_eq!(b.local_name().into_inner(), b"starttls"));
+    assert_matches!(s.next_xml_event().await?, Event::End(b) => assert_eq!(b.local_name().into_inner(), b"features"));
+    s.send(r#"<starttls/>"#).await?;
+    assert_matches!(s.next_xml_event().await?, Event::Empty(b) => assert_eq!(b.local_name().into_inner(), b"proceed"));
+    let buffer = s.buffer;
+    tracing::info!("TLS feature negotiation complete");
+
+    let connector = TlsConnector::from(Arc::new(
+        ClientConfig::builder()
+            .with_safe_defaults()
+            .with_custom_certificate_verifier(Arc::new(IgnoreCertVerification))
+            .with_no_client_auth(),
+    ));
+    tracing::info!("Initiating TLS connection...");
+    let mut stream = connector.connect(ServerName::IpAddress(server.addr.ip()), stream).await?;
+    tracing::info!("TLS connection established");
+
+    server.terminate().await?;
+
+    let mut s = TestScopeTls::new(&mut stream, buffer);
+
+    println!("--------------------------------");
+    let res = s.send(r#"<?xml version="1.0"?>"#).await;
+    println!();
+    assert!(res.is_ok());
+
+    // s.send(r#"<stream:stream xmlns:stream="http://etherx.jabber.org/streams" to="127.0.0.1" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" xmlns="jabber:client" version="1.0">"#).await?;
+    // assert_matches!(s.next_xml_event().await?, Event::Decl(_) => {});
+    // assert_matches!(s.next_xml_event().await?, Event::Start(b) => assert_eq!(b.local_name().into_inner(), b"stream"));
+
+    // stream.shutdown().await?;
+
+    // wrap up
+
+    // server.terminate().await?;
+    Ok(())
+}