macltok

#![cfg(feature = "sqlite")]

use std::time::{Duration, SystemTime};

use macltok::{

    Command, EngineConfig, Event, LifecycleCommand, PasswordLogin, Session, SessionRecord,

    StoreConfig,

};

use matrix_sdk::{ruma::api::client::sync::sync_events::v5, test_utils::mocks::MatrixMockServer};

#[tokio::test]

async fn password_session_round_trips_through_an_encrypted_store() {

    let server = MatrixMockServer::new().await;

    server

        .mock_versions()

        .with_simplified_sliding_sync()

        .ok()

        .mount()

        .await;

    server.mock_login().ok().mount().await;

    server

        .mock_sliding_sync()

        .ok(v5::Response::new("1".to_owned()))

        .mount()

        .await;

    let store_path = temporary_store_path();

    std::fs::create_dir_all(&store_path).unwrap();

    let config = EngineConfig::default().with_initial_history_limit(0);

    let session = Session::login_password(

        PasswordLogin {

            homeserver: server.uri(),

            username: "example".into(),

            password: "wordpass".into(),

            device_display_name: Some("macltok test".into()),

            device_id: None,

        },

        StoreConfig::new(&store_path, "test store passphrase"),

    )

    .await

    .unwrap();

    let encoded = serde_json::to_vec(&session.record()).unwrap();

    let record: SessionRecord = serde_json::from_slice(&encoded).unwrap();

    assert_eq!(

        record.homeserver().trim_end_matches('/'),

        server.uri().trim_end_matches('/')

    );

    let (engine, handle, mut events) = session.build(config.clone()).await.unwrap();

    let running = tokio::spawn(engine.run());

    receive_authenticated(&mut events).await;

    handle

        .send(Command::Lifecycle(LifecycleCommand::Shutdown))

        .await

        .unwrap();

    running.await.unwrap().unwrap();

    let session = Session::restore(

        record,

        StoreConfig::new(&store_path, "test store passphrase"),

    )

    .await

    .unwrap();

    let (engine, handle, mut events) = session.build(config).await.unwrap();

    let running = tokio::spawn(engine.run());

    receive_authenticated(&mut events).await;

    handle

        .send(Command::Lifecycle(LifecycleCommand::Shutdown))

        .await

        .unwrap();

    running.await.unwrap().unwrap();

    std::fs::remove_dir_all(store_path).unwrap();

}

async fn receive_authenticated(events: &mut macltok::EventStream) {

    tokio::time::timeout(Duration::from_secs(2), async {

        while let Some(event) = events.recv().await {

            if matches!(event, Event::Authenticated { .. }) {

                return;

            }

        }

        panic!("event stream closed before authentication");

    })

    .await

    .expect("authentication event did not arrive");

}

fn temporary_store_path() -> std::path::PathBuf {

    let nonce = SystemTime::now()

        .duration_since(SystemTime::UNIX_EPOCH)

        .unwrap()

        .as_nanos();

    std::env::temp_dir().join(format!("macltok-account-{nonce}"))

}