macltok

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

mod support;

use std::{path::PathBuf, time::SystemTime};

use macltok::{

    EncryptedSessionStore, EngineConfig, Event, PasswordLogin, Session, SessionRecord,

    SessionStore, StoreConfig,

};

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

#[tokio::test]

async fn password_session_round_trips_and_discards_with_its_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 root = temporary_path();

    let store_path = root.join("store");

    let record_path = root.join("records").join("session");

    let sessions = || {

        EncryptedSessionStore::file(

            &record_path,

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

        )

    };

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

    let session = Session::login_password(

        PasswordLogin::new(server.uri(), "example", "wordpass")

            .with_device_display_name("macltok test"),

        &sessions(),

    )

    .await

    .unwrap();

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

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

    support::receive_until(&mut events, |event| {

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

    })

    .await;

    support::shut_down(&handle, &mut events, running).await;

    drop(handle);

    let wrong = EncryptedSessionStore::file(

        &record_path,

        StoreConfig::sqlite(&store_path, "someone else's passphrase"),

    );

    assert!(wrong.load().await.is_err());

    let sessions = sessions();

    let session = Session::restore(&sessions).await.unwrap().unwrap();

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

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

    support::receive_until(&mut events, |event| {

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

    })

    .await;

    support::shut_down(&handle, &mut events, running).await;

    drop(handle);

    sessions.discard().await.unwrap();

    assert!(!record_path.exists());

    assert!(!store_path.exists());

    assert!(Session::restore(&sessions).await.unwrap().is_none());

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

}

#[tokio::test]

async fn a_torn_or_failed_save_leaves_the_old_record() {

    let root = temporary_path();

    let record_path = root.join("session");

    let sessions = || {

        EncryptedSessionStore::file(

            &record_path,

            StoreConfig::sqlite(root.join("store"), "test store passphrase"),

        )

    };

    let temporary = root.join("session.tmp");

    sessions()

        .save(&record("https://old.example"))

        .await

        .unwrap();

    std::fs::write(&temporary, b"half a rec").unwrap();

    let loaded = sessions().load().await.unwrap().unwrap();

    assert_eq!(loaded.homeserver(), "https://old.example");

    std::fs::remove_file(&temporary).unwrap();

    std::fs::create_dir(&temporary).unwrap();

    assert!(

        sessions()

            .save(&record("https://new.example"))

            .await

            .is_err()

    );

    let loaded = sessions().load().await.unwrap().unwrap();

    assert_eq!(loaded.homeserver(), "https://old.example");

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

}

fn record(homeserver: &str) -> SessionRecord {

    serde_json::from_value(serde_json::json!({

        "homeserver": homeserver,

        "authentication": {

            "type": "matrix",

            "session": {

                "user_id": "@example:example.org",

                "device_id": "DEVICE",

                "access_token": "secret",

            },

        },

    }))

    .unwrap()

}

fn temporary_path() -> PathBuf {

    let nonce = SystemTime::now()

        .duration_since(SystemTime::UNIX_EPOCH)

        .unwrap()

        .as_nanos();

    PathBuf::from(env!("CARGO_TARGET_TMPDIR")).join(format!("macltok-account-{nonce}"))

}