microrm/microrm/tests/query_equiv.rs

use microrm::prelude::*;
use test_log::test;

mod common;

#[derive(Entity)]
struct SingleItem {
    #[key]
    s: String,
    v: Vec<u8>,
}

#[derive(Entity)]
struct DoubleItem {
    #[key]
    s: String,
    #[key]
    t: String,
    v: usize,
}

#[derive(Database)]
struct ItemDB {
    single_items: microrm::IDMap<SingleItem>,
    double_items: microrm::IDMap<DoubleItem>,
}

#[test]
fn single_item() {
    let db: ItemDB = common::open_test_db!();

    db.single_items
        .insert(SingleItem {
            s: "string 1".into(),
            v: vec![0u8, 1u8, 2u8],
        })
        .expect("couldn't insert test item");

    db.single_items
        .insert(SingleItem {
            s: "string 2".into(),
            v: vec![0u8, 1u8, 2u8],
        })
        .expect("couldn't insert test item");

    assert!(db
        .single_items
        .keyed("string 2")
        .get()
        .expect("couldn't query db")
        .is_some());
    assert!(db
        .single_items
        .keyed("string 3")
        .get()
        .expect("couldn't query db")
        .is_none());

    assert!(db
        .single_items
        .keyed(String::from("string 2"))
        .get()
        .expect("couldn't query db")
        .is_some());
    assert!(db
        .single_items
        .keyed(String::from("string 3"))
        .get()
        .expect("couldn't query db")
        .is_none());
}

#[test]
fn double_item() {
    let db: ItemDB = common::open_test_db!();

    db.double_items
        .insert(DoubleItem {
            s: "string 1".into(),
            t: "second string 1".into(),
            v: 42,
        })
        .expect("couldn't insert test item");

    db.double_items
        .insert(DoubleItem {
            s: "string 2".into(),
            t: "second string 2".into(),
            v: 6,
        })
        .expect("couldn't insert test item");

    assert!(db
        .double_items
        .keyed(("string 2", "second string 2"))
        .get()
        .expect("couldn't query db")
        .is_some());
    assert!(db
        .double_items
        .keyed(("string 3", "second string 3"))
        .get()
        .expect("couldn't query db")
        .is_none());

    assert!(db
        .double_items
        .keyed((String::from("string 2"), String::from("second string 2")))
        .get()
        .expect("couldn't query db")
        .is_some());
    assert!(db
        .double_items
        .keyed((String::from("string 3"), String::from("second string 3")))
        .get()
        .expect("couldn't query db")
        .is_none());
}

#[test]
fn with_test() {
    let db: ItemDB = common::open_test_db!();

    db.single_items
        .insert(SingleItem {
            s: "string 1".into(),
            v: vec![0u8, 1u8, 2u8],
        })
        .expect("couldn't insert test item");

    db.single_items
        .insert(SingleItem {
            s: "string 2".into(),
            v: vec![0u8, 1u8, 2u8],
        })
        .expect("couldn't insert test item");

    assert_eq!(
        db.single_items
            .with(SingleItem::V, [0u8].as_slice())
            .get()
            .expect("couldn't query db")
            .len(),
        0
    );
    assert_eq!(
        db.single_items
            .with(SingleItem::V, [0u8, 1, 2].as_slice())
            .get()
            .expect("couldn't query db")
            .len(),
        2
    );
}