mod common;

use chrono::{SubsecRound, TimeDelta};
use gpodder::{AuthStore, Session};
use gpodder_sqlite::SqliteRepository;

#[test]
fn test_create_user() {
    let store = SqliteRepository::in_memory().unwrap();

    let user = store.get_user("test1");
    assert!(user.is_ok());
    assert_eq!(user.unwrap(), None);

    let new_user = store.insert_user("test1", "dummyhash");

    assert!(new_user.is_ok());

    let new_user = new_user.unwrap();
    assert_eq!(new_user.username, "test1");
    assert_eq!(new_user.password_hash, "dummyhash");

    let user = store.get_user("test1");

    assert!(user.is_ok());
    assert_eq!(user.unwrap(), Some(new_user));
}

#[test]
fn test_create_session() {
    let (store, users) = common::setup();

    let session = store.get_session(123).expect("operation shouldn't fail");
    assert_eq!(session, None);

    let new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    let session = store.get_session(123).expect("operation shouldn't fail");
    assert_eq!(session, Some(new_session));
}

#[test]
fn test_remove_session() {
    let (store, users) = common::setup();

    let new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    assert!(store
        .get_session(123)
        .expect("get session shouldn't fail")
        .is_some());

    store.remove_session(123).expect("remove shouldn't fail");

    assert!(store
        .get_session(123)
        .expect("get session shouldn't fail")
        .is_none());
}

#[test]
fn test_refresh_session() {
    let (store, users) = common::setup();

    let mut new_session = Session {
        id: 123,
        //
        last_seen: chrono::Utc::now().trunc_subsecs(0) - TimeDelta::seconds(10),
        user: users[0].clone(),
    };

    store
        .insert_session(&new_session)
        .expect("insert session shouldn't fail");

    store
        .refresh_session(&new_session, chrono::Utc::now().trunc_subsecs(0))
        .expect("refresh session shouldn't fail");

    new_session.last_seen = chrono::Utc::now().trunc_subsecs(0);

    assert_eq!(
        store.get_session(123).expect("get session shouldn't fail"),
        Some(new_session)
    );
}