Revert "test: Add test for repeated joining and leaving"

This partially reverts commit df4ee7db4c.
The changes to logging and ci-start.sh are kept.

testing/matrix-sdk-integration-testing/src/tests.rs

@@ -3,8 +3,8 @@ use std::{collections::HashMap, option_env};
 use anyhow::Result;
 use assign::assign;
 use matrix_sdk::{
-    config::RequestConfig,
     ruma::api::client::{account::register::v3::Request as RegistrationRequest, uiaa},
+    store::make_store_config,
     Client,
 };
 use once_cell::sync::Lazy;
@@ -30,14 +30,7 @@ pub fn test_server_conf() -> (String, String) {
     )
 }
 
-/// The StateStore to use.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Store {
-    Memory,
-    Sled,
-}
-
-pub async fn get_client_for_user(store: Store, username: String) -> Result<Client> {
+pub async fn get_client_for_user(username: String) -> Result<Client> {
     let mut users = USERS.lock().await;
     if let Some((client, _)) = users.get(&username) {
         return Ok(client.clone());
@@ -47,15 +40,12 @@ pub async fn get_client_for_user(store: Store, username: String) -> Result<Clien
 
     let tmp_dir = tempdir()?;
 
-    let mut builder = Client::builder()
+    let client = Client::builder()
         .user_agent("matrix-sdk-integation-tests")
+        .store_config(make_store_config(tmp_dir.path(), None)?)
         .homeserver_url(homeserver_url)
-        .request_config(RequestConfig::new().disable_retry());
-    builder = match store {
-        Store::Memory => builder,
-        Store::Sled => builder.sled_store(tmp_dir.path(), None)?,
-    };
-    let client = builder.build().await?;
+        .build()
+        .await?;
     // safe to assume we have not registered this user yet, but ignore if we did
 
     if let Err(resp) = client.register(RegistrationRequest::new()).await {
@@ -78,4 +68,3 @@ pub async fn get_client_for_user(store: Store, username: String) -> Result<Clien
 }
 
 mod invitations;
-mod repeated_join;

testing/matrix-sdk-integration-testing/src/tests/invitations.rs

@@ -6,12 +6,12 @@ use matrix_sdk::{
     room::Room, ruma::api::client::room::create_room::v3::Request as CreateRoomRequest,
 };
 
-use super::{get_client_for_user, Store};
+use super::get_client_for_user;
 
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn test_invitation_details() -> Result<()> {
-    let tamatoa = get_client_for_user(Store::Sled, "tamatoa".to_owned()).await?;
-    let sebastian = get_client_for_user(Store::Sled, "sebastian".to_owned()).await?;
+    let tamatoa = get_client_for_user("tamatoa".to_owned()).await?;
+    let sebastian = get_client_for_user("sebastian".to_owned()).await?;
 
     let invites = [sebastian.user_id().expect("sebastian has a userid!").to_owned()];
     // create a room and invite sebastian;

testing/matrix-sdk-integration-testing/src/tests/repeated_join.rs

@@ -1,144 +0,0 @@
-use std::time::Duration;
-
-use anyhow::Result;
-use assign::assign;
-use matrix_sdk::{
-    event_handler::Ctx,
-    room::Room,
-    ruma::{
-        api::client::room::create_room::v3::Request as CreateRoomRequest,
-        events::room::member::{MembershipState, StrippedRoomMemberEvent},
-    },
-    Client, RoomType,
-};
-use tokio::sync::mpsc;
-
-use super::{get_client_for_user, Store};
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-async fn test_repeated_join_leave() -> Result<()> {
-    let peter = get_client_for_user(Store::Memory, "peter".to_owned()).await?;
-    // FIXME: Run once with memory, once with sled
-    let karl = get_client_for_user(Store::Sled, "karl".to_owned()).await?;
-    let karl_id = karl.user_id().expect("karl has a userid!").to_owned();
-
-    // Create a room and invite karl.
-    let invites = [karl_id.clone()];
-    let request = assign!(CreateRoomRequest::new(), {
-        invite: &invites,
-        is_direct: true,
-    });
-
-    // Sync after 1 second to so that create_room receives the event it is waiting
-    // for.
-    let peter_clone = peter.clone();
-    tokio::spawn(async move {
-        tokio::time::sleep(Duration::from_secs(1)).await;
-        peter_clone.sync_once(Default::default()).await
-    });
-
-    let created_room = peter.create_room(request).await?;
-    let room_id = created_room.room_id();
-
-    // Sync karl once to ensure he got the invite.
-    karl.sync_once(Default::default()).await?;
-
-    // Continuously sync karl from now on.
-    let karl_clone = karl.clone();
-    let join_handle = tokio::spawn(async move {
-        karl_clone.sync(Default::default()).await;
-    });
-    let (invite_signal_sender, mut invite_signal) = mpsc::channel::<()>(1);
-    karl.add_event_handler_context(invite_signal_sender);
-    karl.add_event_handler(signal_on_invite);
-
-    for i in 0..3 {
-        println!("Iteration {i}");
-
-        // Test that karl has the expected state in its client.
-        assert!(karl.get_invited_room(room_id).is_some());
-        assert!(karl.get_joined_room(room_id).is_none());
-        assert!(karl.get_left_room(room_id).is_none());
-
-        let room = karl.get_room(room_id).expect("karl has the room");
-        let membership = room.get_member_no_sync(&karl_id).await?.expect("karl was invited");
-        assert_eq!(*membership.membership(), MembershipState::Invite);
-
-        // Join the room
-        println!("Joining..");
-        let room =
-            karl.get_invited_room(room_id).expect("karl has the room").accept_invitation().await?;
-        println!("Done");
-        let membership = room.get_member_no_sync(&karl_id).await?.expect("karl joined");
-        assert_eq!(*membership.membership(), MembershipState::Join);
-
-        assert!(karl.get_invited_room(room_id).is_none());
-        assert!(karl.get_joined_room(room_id).is_some());
-        assert!(karl.get_left_room(room_id).is_none());
-
-        // Leave the room
-        println!("Leaving..");
-        let room = room.leave().await?;
-        println!("Done");
-        let membership = room.get_member_no_sync(&karl_id).await?.expect("karl left");
-        assert_eq!(*membership.membership(), MembershipState::Leave);
-
-        assert!(karl.get_invited_room(room_id).is_none());
-        assert!(karl.get_joined_room(room_id).is_none());
-        assert!(karl.get_left_room(room_id).is_some());
-
-        // Invite karl again and wait for karl to receive the invite.
-        println!("Inviting..");
-        let room = peter.get_joined_room(room_id).expect("peter created the room!");
-        room.invite_user_by_id(&karl_id).await?;
-        println!("Waiting to receive invite..");
-        invite_signal.recv().await.expect("sender must be open");
-    }
-
-    // Stop the sync.
-    join_handle.abort();
-
-    // Now check the underlying state store that it also has the correct information
-    // (for when the client restarts).
-    let invited = karl.store().get_invited_user_ids(room_id).await?;
-    assert_eq!(invited.len(), 1);
-    assert_eq!(invited[0], karl_id);
-
-    let joined = karl.store().get_joined_user_ids(room_id).await?;
-    assert!(!joined.contains(&karl_id));
-
-    let event =
-        karl.store().get_member_event(room_id, &karl_id).await?.expect("member event should exist");
-    assert_eq!(*event.membership(), MembershipState::Invite);
-
-    // Yay, test succeeded
-    Ok(())
-}
-
-async fn signal_on_invite(
-    event: StrippedRoomMemberEvent,
-    room: Room,
-    client: Client,
-    sender: Ctx<mpsc::Sender<()>>,
-) {
-    let own_id = client.user_id().expect("client is logged in");
-    if event.sender == own_id {
-        return;
-    }
-
-    if room.room_type() != RoomType::Invited {
-        return;
-    }
-
-    if event.content.membership != MembershipState::Invite {
-        return;
-    }
-
-    let invited = &event.state_key;
-    if invited != own_id {
-        return;
-    }
-
-    // Send signal that we received an invite.
-    sender.send(()).await.expect("receiver must be open");
-}