4354627675

Build Type

push

github

Committed by GitHub

Commit Message

chore: Use `LmdbMap` and `LmdbMultimap` instead of raw database in cache (#1156)

Run Details

754 of 754 new or added lines in 15 files covered. (100.0%)

29895 of 39630 relevant lines covered (75.44%)

38604.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.31

/dozer-cache/src/cache/lmdb/tests/basic.rs

use crate::cache::{
    expression::{self, FilterExpression, QueryExpression, Skip},
    index,
    lmdb::cache::LmdbRwCache,
    test_utils::{self, query_from_filter},
    RoCache, RwCache,
};
use dozer_types::{
    serde_json::Value,
    types::{Field, Record, Schema},
};

use super::utils::create_cache;

fn _setup() -> (LmdbRwCache, Schema, &'static str) {
    let schema_name = "doc";
    let (cache, schema, _) = create_cache(schema_name, test_utils::schema_0);
    (cache, schema, schema_name)
}

fn _setup_empty_primary_index() -> (LmdbRwCache, Schema, &'static str) {
    let schema_name = "doc";
    let (cache, schema, _) = create_cache(schema_name, test_utils::schema_empty_primary_index);
    (cache, schema, schema_name)
}

fn query_and_test(
    cache: &dyn RwCache,
    inserted_record: &Record,
    schema_name: &str,
    exp: &QueryExpression,
) {
    let records = cache.query(schema_name, exp).unwrap().1;
    assert_eq!(records[0].record, inserted_record.clone(), "must be equal");
}

#[test]
fn get_schema() {
    let (cache, _, schema_name) = _setup();
    let schema = &cache.get_schema_and_indexes_by_name(schema_name).unwrap().0;

    let get_schema = cache.get_schema(schema.identifier.unwrap()).unwrap();
    assert_eq!(get_schema, schema, "must be equal");
}

#[test]
fn insert_get_and_delete_record() {
    let val = "bar".to_string();
    let (cache, schema, schema_name) = _setup();

    assert_eq!(
        cache
            .count(schema_name, &QueryExpression::with_no_limit())
            .unwrap(),
        0
    );

    let mut record = Record::new(schema.identifier, vec![Field::String(val.clone())], None);
    cache.insert(&mut record).unwrap();

    assert_eq!(
        cache
            .count(schema_name, &QueryExpression::with_no_limit())
            .unwrap(),
        1
    );

    let version = record.version.unwrap();

    let key = index::get_primary_key(&[0], &[Field::String(val)]);

    let get_record = cache.get(&key).unwrap().record;
    assert_eq!(get_record, record, "must be equal");

    assert_eq!(cache.delete(&key).unwrap(), version);
    assert_eq!(
        cache
            .count(schema_name, &QueryExpression::with_no_limit())
            .unwrap(),
        0
    );

    cache.get(&key).expect_err("Must not find a record");

    assert_eq!(
        cache
            .query(schema_name, &QueryExpression::default())
            .unwrap()
            .1,
        vec![]
    );
}

#[test]
fn insert_and_update_record() {
    let (cache, schema, _) = _setup();
    let mut foo = Record::new(
        schema.identifier,
        vec![Field::String("foo".to_string())],
        None,
    );
    let mut bar = Record::new(
        schema.identifier,
        vec![Field::String("bar".to_string())],
        None,
    );
    cache.insert(&mut foo).unwrap();
    let old_version = foo.version.unwrap();
    cache.insert(&mut bar).unwrap();

    let key = index::get_primary_key(&schema.primary_index, &foo.values);

    assert_eq!(cache.update(&key, &mut foo).unwrap(), old_version);
    assert_eq!(foo.version.unwrap(), old_version + 1);
}

fn insert_and_query_record_impl(cache: LmdbRwCache, schema: Schema, schema_name: &str) {
    let val = "bar".to_string();
    let mut record = Record::new(schema.identifier, vec![Field::String(val)], None);

    cache.insert(&mut record).unwrap();

    // Query with an expression
    let exp = query_from_filter(FilterExpression::Simple(
        "foo".to_string(),
        expression::Operator::EQ,
        Value::from("bar".to_string()),
    ));

    query_and_test(&cache, &record, schema_name, &exp);

    // Query without an expression
    query_and_test(
        &cache,
        &record,
        schema_name,
        &QueryExpression::new(None, vec![], Some(10), Skip::Skip(0)),
    );
}

#[test]
fn insert_and_query_record() {
    let (cache, schema, schema_name) = _setup();
    insert_and_query_record_impl(cache, schema, schema_name);
    let (cache, schema, schema_name) = _setup_empty_primary_index();
    insert_and_query_record_impl(cache, schema, schema_name);
}

1	use crate::cache::{
2	expression::{self, FilterExpression, QueryExpression, Skip},
3	index,
4	lmdb::cache::LmdbRwCache,
5	test_utils::{self, query_from_filter},
6	RoCache, RwCache,
7	};
8	use dozer_types::{
9	serde_json::Value,
10	types::{Field, Record, Schema},
11	};
12
13	use super::utils::create_cache;
14
15	fn _setup() -> (LmdbRwCache, Schema, &'static str) {	4✔
16	let schema_name = "doc";	4✔
17	let (cache, schema, _) = create_cache(schema_name, test_utils::schema_0);	4✔
18	(cache, schema, schema_name)	4✔
19	}	4✔
20
21	fn _setup_empty_primary_index() -> (LmdbRwCache, Schema, &'static str) {	1✔
22	let schema_name = "doc";	1✔
23	let (cache, schema, _) = create_cache(schema_name, test_utils::schema_empty_primary_index);	1✔
24	(cache, schema, schema_name)	1✔
25	}	1✔
26
27	fn query_and_test(	4✔
28	cache: &dyn RwCache,	4✔
29	inserted_record: &Record,	4✔
30	schema_name: &str,	4✔
31	exp: &QueryExpression,	4✔
32	) {	4✔
33	let records = cache.query(schema_name, exp).unwrap().1;	4✔
34	assert_eq!(records[0].record, inserted_record.clone(), "must be equal");	4✔
35	}	4✔
36
37	#[test]	1✔
38	fn get_schema() {	1✔
39	let (cache, _, schema_name) = _setup();	1✔
40	let schema = &cache.get_schema_and_indexes_by_name(schema_name).unwrap().0;	1✔
41		1✔
42	let get_schema = cache.get_schema(schema.identifier.unwrap()).unwrap();	1✔
43	assert_eq!(get_schema, schema, "must be equal");	1✔
44	}	1✔
45
46	#[test]	1✔
47	fn insert_get_and_delete_record() {	1✔
48	let val = "bar".to_string();	1✔
49	let (cache, schema, schema_name) = _setup();	1✔
50		1✔
51	assert_eq!(	1✔
52	cache	1✔
53	.count(schema_name, &QueryExpression::with_no_limit())	1✔
54	.unwrap(),	1✔
55	0	1✔
56	);	1✔
57		×
58	let mut record = Record::new(schema.identifier, vec![Field::String(val.clone())], None);	1✔
59	cache.insert(&mut record).unwrap();	1✔
60		1✔
61	assert_eq!(	1✔
62	cache	1✔
63	.count(schema_name, &QueryExpression::with_no_limit())	1✔
64	.unwrap(),	1✔
65	1	1✔
66	);	1✔
67		×
68	let version = record.version.unwrap();	1✔
69		1✔
70	let key = index::get_primary_key(&[0], &[Field::String(val)]);	1✔
71		1✔
72	let get_record = cache.get(&key).unwrap().record;	1✔
73	assert_eq!(get_record, record, "must be equal");	1✔
74		×
75	assert_eq!(cache.delete(&key).unwrap(), version);	1✔
76	assert_eq!(	1✔
77	cache	1✔
78	.count(schema_name, &QueryExpression::with_no_limit())	1✔
79	.unwrap(),	1✔
80	0	1✔
81	);	1✔
82		×
83	cache.get(&key).expect_err("Must not find a record");	1✔
84		1✔
85	assert_eq!(	1✔
86	cache	1✔
87	.query(schema_name, &QueryExpression::default())	1✔
88	.unwrap()	1✔
89	.1,	1✔
90	vec![]	1✔
91	);	1✔
92	}	1✔
93		×
94	#[test]	1✔
95	fn insert_and_update_record() {	1✔
96	let (cache, schema, _) = _setup();	1✔
97	let mut foo = Record::new(	1✔
98	schema.identifier,	1✔
99	vec![Field::String("foo".to_string())],	1✔
100	None,	1✔
101	);	1✔
102	let mut bar = Record::new(	1✔
103	schema.identifier,	1✔
104	vec![Field::String("bar".to_string())],	1✔
105	None,	1✔
106	);	1✔
107	cache.insert(&mut foo).unwrap();	1✔
108	let old_version = foo.version.unwrap();	1✔
109	cache.insert(&mut bar).unwrap();	1✔
110		1✔
111	let key = index::get_primary_key(&schema.primary_index, &foo.values);	1✔
112		1✔
113	assert_eq!(cache.update(&key, &mut foo).unwrap(), old_version);	1✔
114	assert_eq!(foo.version.unwrap(), old_version + 1);	1✔
115	}	1✔
116		×
117	fn insert_and_query_record_impl(cache: LmdbRwCache, schema: Schema, schema_name: &str) {	2✔
118	let val = "bar".to_string();	2✔
119	let mut record = Record::new(schema.identifier, vec![Field::String(val)], None);	2✔
120		2✔
121	cache.insert(&mut record).unwrap();	2✔
122		2✔
123	// Query with an expression	2✔
124	let exp = query_from_filter(FilterExpression::Simple(	2✔
125	"foo".to_string(),	2✔
126	expression::Operator::EQ,	2✔
127	Value::from("bar".to_string()),	2✔
128	));	2✔
129		2✔
130	query_and_test(&cache, &record, schema_name, &exp);	2✔
131		2✔
132	// Query without an expression	2✔
133	query_and_test(	2✔
134	&cache,	2✔
135	&record,	2✔
136	schema_name,	2✔
137	&QueryExpression::new(None, vec![], Some(10), Skip::Skip(0)),	2✔
138	);	2✔
139	}	2✔
140
141	#[test]	1✔
142	fn insert_and_query_record() {	1✔
143	let (cache, schema, schema_name) = _setup();	1✔
144	insert_and_query_record_impl(cache, schema, schema_name);	1✔
145	let (cache, schema, schema_name) = _setup_empty_primary_index();	1✔
146	insert_and_query_record_impl(cache, schema, schema_name);	1✔
147	}	1✔

getdozer / dozer / 4354627675

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous