getdozer / dozer / 4392484403

#[test]

fn read_and_write() {

    let path = TempDir::new("dozer").unwrap();

    let path = (path.path().to_path_buf(), "cache".to_string());

    // write and read from cache from two different threads.

    let schema = test_utils::schema_1();

    let mut indexing_thread_pool = IndexingThreadPool::new(1);

    let cache_writer = LmdbRwCache::new(

        Some(&schema),

        &CacheCommonOptions {

            max_readers: 1,

            max_db_size: 100,

            path: Some(path.clone()),

            intersection_chunk_size: 1,

        },

        CacheWriteOptions {

            max_size: 1024 * 1024,

        },

        &mut indexing_thread_pool,

    )

    .unwrap();

    let items = vec![

        (1, Some("a".to_string()), Some(521)),

        (2, Some("a".to_string()), None),

        (3, None, Some(521)),

        (4, None, None),

    ];

    for val in items.clone() {

        lmdb_utils::insert_rec_1(&cache_writer, &schema.0, val.clone());

    }

    cache_writer.commit().unwrap();

    indexing_thread_pool.wait_until_catchup();

    let read_options = CacheCommonOptions {

        path: Some(path),

        ..Default::default()

    };

    let cache_reader = LmdbRoCache::new(&read_options).unwrap();

    for (a, b, c) in items {

        let rec = cache_reader.get(&Field::Int(a).encode()).unwrap();

        let values = vec![

            Field::Int(a),

            b.map_or(Field::Null, Field::String),

            c.map_or(Field::Null, Field::Int),

        ];

        assert_eq!(rec.record.values, values, "should be equal");

    let records = cache_reader

        .query(&QueryExpression {

            filter: Some(FilterExpression::Simple(

                "a".to_string(),

                Operator::EQ,

                Value::from(1),

            )),

            ..Default::default()

        })

        .unwrap();

    assert_eq!(records.len(), 1);

}