4116183752

Build Type

push

github

Committed by GitHub

Commit Message

refactor: Make `LmdbRoCache` and `LmdbRwCache` `Send` and `Sync` (#821)

Run Details

790 of 790 new or added lines in 44 files covered. (100.0%)

23005 of 33842 relevant lines covered (67.98%)

56312.85 hits per line

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

92.0

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

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

use super::super::cache::LmdbRwCache;

fn _setup() -> (LmdbRwCache, Schema, Vec<IndexDefinition>) {
    let (schema, secondary_indexes) = test_utils::schema_0();
    let cache = LmdbRwCache::new(Default::default(), Default::default()).unwrap();
    (cache, schema, secondary_indexes)
}

fn _setup_empty_primary_index() -> (LmdbRwCache, Schema, Vec<IndexDefinition>) {
    let (schema, secondary_indexes) = test_utils::schema_empty_primary_index();
    let cache = LmdbRwCache::new(Default::default(), Default::default()).unwrap();
    (cache, schema, secondary_indexes)
}

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

#[test]
fn insert_and_get_schema() {
    let (cache, schema, secondary_indexes) = _setup();
    cache
        .insert_schema("test", &schema, &secondary_indexes)
        .unwrap();
    let schema = cache.get_schema_and_indexes_by_name("test").unwrap().0;

    let get_schema = cache
        .get_schema(&schema.identifier.to_owned().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, secondary_indexes) = _setup();
    let record = Record::new(schema.identifier, vec![Field::String(val.clone())], None);
    cache
        .insert_schema("docs", &schema, &secondary_indexes)
        .unwrap();
    cache.insert(&record).unwrap();

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

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

    cache.delete(&key).unwrap();

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

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

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

    cache.update(&key, &foo).unwrap();
}

fn insert_and_query_record_impl(
    cache: LmdbRwCache,
    schema: Schema,
    secondary_indexes: Vec<IndexDefinition>,
) {
    let val = "bar".to_string();
    let record = Record::new(schema.identifier, vec![Field::String(val)], None);

    cache
        .insert_schema("docs", &schema, &secondary_indexes)
        .unwrap();
    cache.insert(&record).unwrap();

    // Query with an expression
    let exp = QueryExpression::new(
        Some(FilterExpression::Simple(
            "foo".to_string(),
            expression::Operator::EQ,
            Value::from("bar".to_string()),
        )),
        vec![],
        Some(10),
        0,
    );

    query_and_test(&cache, &record, "docs", &exp);

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

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

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

getdozer / dozer / 4116183752

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