stream.read_u8 tests

crates/projection-irc/src/lib.rs

@@ -54,7 +54,7 @@ async fn handle_socket(
     socket_addr: &SocketAddr,
     players: PlayerRegistry,
     rooms: RoomRegistry,
-    termination: Deferred<()>,
+    termination: Deferred<()>, // TODO use it to stop the connection gracefully
     mut storage: Storage,
 ) -> Result<()> {
     log::info!("Received an IRC connection from {socket_addr}");

crates/projection-irc/tests/lib.rs

@@ -1,3 +1,4 @@
+use std::io::ErrorKind;
 use std::net::SocketAddr;
 use std::time::Duration;
 
@@ -220,6 +221,55 @@ async fn scenario_cap_short_negotiation() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn scenario_cap_sasl_fail() -> std::result::Result<()> {
+    let mut server = TestServer::start().await?;
+
+    // test scenario
+
+    server.storage.create_user("tester").await?;
+    server.storage.set_password("tester", "password").await?;
+
+    let mut stream = TcpStream::connect(server.server.addr).await?;
+    let mut s = TestScope::new(&mut stream);
+
+    s.send("CAP LS 302").await?;
+    s.send("NICK tester").await?;
+    s.send("USER UserName 0 * :Real Name").await?;
+    s.expect(":testserver CAP * LS :sasl=PLAIN").await?;
+    s.send("CAP REQ :sasl").await?;
+    s.expect(":testserver CAP tester ACK :sasl").await?;
+    s.send("AUTHENTICATE SHA256").await?;
+    s.expect(":testserver 904 tester :Unsupported mechanism").await?;
+    s.send("AUTHENTICATE PLAIN").await?;
+    s.expect(":testserver AUTHENTICATE +").await?;
+    s.send("AUTHENTICATE dGVzdGVyAHRlc3RlcgBwYXNzd29yZDE=").await?;
+    s.expect(":testserver 904 tester :Bad credentials").await?;
+    s.send("AUTHENTICATE dGVzdGVyAHRlc3RlcgBwYXNzd29yZA==").await?; // base64-encoded 'tester\x00tester\x00password'
+    s.expect(":testserver 900 tester tester tester :You are now logged in as tester").await?;
+    s.expect(":testserver 903 tester :SASL authentication successful").await?;
+
+    s.send("CAP END").await?;
+
+    s.expect(":testserver 001 tester :Welcome to Kek Server").await?;
+    s.expect(":testserver 002 tester :Welcome to Kek Server").await?;
+    s.expect(":testserver 003 tester :Welcome to Kek Server").await?;
+    s.expect(":testserver 004 tester testserver kek-0.1.alpha.3 r CFILPQbcefgijklmnopqrstvz").await?;
+    s.expect(":testserver 005 tester CHANTYPES=# :are supported by this server").await?;
+    s.expect_nothing().await?;
+    s.send("QUIT :Leaving").await?;
+    s.expect(":testserver ERROR :Leaving the server").await?;
+    s.expect_eof().await?;
+
+    stream.shutdown().await?;
+
+    // wrap up
+
+    server.server.terminate().await?;
+    Ok(())
+}
+
+
 #[tokio::test]
 async fn terminate_socket_scenario() -> Result<()> {
     let mut server = TestServer::start().await?;
@@ -240,9 +290,8 @@ async fn terminate_socket_scenario() -> Result<()> {
     s.send("AUTHENTICATE PLAIN").await?;
     s.expect(":testserver AUTHENTICATE +").await?;
 
-    stream.shutdown().await?;
     server.server.terminate().await?;
+    assert_eq!(stream.read_u8().await.unwrap_err().kind(), ErrorKind::UnexpectedEof);
 
-    assert!(TcpStream::connect(&address).await.is_err());
     Ok(())
 }

crates/projection-xmpp/src/lib.rs

@@ -162,7 +162,7 @@ async fn handle_socket(
     mut players: PlayerRegistry,
     rooms: RoomRegistry,
     mut storage: Storage,
-    termination: Deferred<()>,
+    termination: Deferred<()>, // TODO use it to stop the connection gracefully
 ) -> Result<()> {
     log::info!("Received an XMPP connection from {socket_addr}");
     let mut reader_buf = vec![];
@@ -215,7 +215,6 @@ async fn handle_socket(
         },
     }
 
-
     let a = xml_reader.into_inner().into_inner();
     let b = xml_writer.into_inner();
     a.unsplit(b).shutdown().await?;

crates/projection-xmpp/tests/lib.rs

@@ -1,3 +1,4 @@
+use std::io::ErrorKind;
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -7,7 +8,7 @@ use assert_matches::*;
 use prometheus::Registry as MetricsRegistry;
 use quick_xml::events::Event;
 use quick_xml::NsReader;
-use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
 use tokio::io::{ReadHalf as GenericReadHalf, WriteHalf as GenericWriteHalf};
 use tokio::net::tcp::{ReadHalf, WriteHalf};
 use tokio::net::TcpStream;
@@ -186,7 +187,6 @@ async fn scenario_basic() -> Result<()> {
     Ok(())
 }
 
-
 #[tokio::test]
 async fn terminate_socket() -> Result<()> {
     tracing_subscriber::fmt::init();
@@ -199,7 +199,7 @@ async fn terminate_socket() -> Result<()> {
     let mut storage = Storage::open(StorageConfig {
         db_path: ":memory:".into(),
     })
-        .await?;
+    .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();
@@ -233,21 +233,14 @@ async fn terminate_socket() -> Result<()> {
             .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");
 
-    let mut s = TestScopeTls::new(&mut stream, buffer);
-
-    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"));
-
-    stream.shutdown().await?;
     server.terminate().await?;
 
-    assert!(TcpStream::connect(&address).await.is_err());
+    assert_eq!(stream.read_u8().await.unwrap_err().kind(), ErrorKind::UnexpectedEof);
 
     Ok(())
 }