4370280743

Build Type

push

github

Committed by GitHub

Commit Message

Bump async-trait from 0.1.65 to 0.1.66 (#1179)

Run Details

27808 of 38702 relevant lines covered (71.85%)

25323.55 hits per line

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

74.0

/dozer-api/src/api_helper.rs

use crate::auth::Access;
use crate::errors::{ApiError, AuthError};
use dozer_cache::cache::expression::QueryExpression;
use dozer_cache::cache::RecordWithId;
use dozer_cache::{AccessFilter, CacheReader};

pub fn get_record(
    cache_reader: &CacheReader,
    key: &[u8],
    access: Option<Access>,
) -> Result<RecordWithId, ApiError> {
    let access_filter = get_access_filter(access)?;
    let record = cache_reader
        .get(key, &access_filter)
        .map_err(ApiError::NotFound)?;
    Ok(record)
}

pub fn get_records_count(
    cache_reader: &CacheReader,
    exp: &mut QueryExpression,
    access: Option<Access>,
) -> Result<usize, ApiError> {
    let access_filter = get_access_filter(access)?;
    cache_reader
        .count(exp, access_filter)
        .map_err(ApiError::CountFailed)
}

/// Get multiple records
pub fn get_records(
    cache_reader: &CacheReader,
    exp: &mut QueryExpression,
    access: Option<Access>,
) -> Result<Vec<RecordWithId>, ApiError> {
    let access_filter = get_access_filter(access)?;
    cache_reader
        .query(exp, access_filter)
        .map_err(ApiError::QueryFailed)
}

fn get_access_filter(access: Option<Access>) -> Result<AccessFilter, ApiError> {
    match access {
        None | Some(Access::All) => Ok(AccessFilter {
            filter: None,
            fields: vec![],
        }),
        Some(Access::Custom(mut access_filters)) => {
            if let Some(access_filter) = access_filters.remove("get_records") {
                Ok(access_filter)
            } else {
                Err(ApiError::ApiAuthError(AuthError::InvalidToken))
            }
        }
    }
}

1	use crate::auth::Access;
2	use crate::errors::{ApiError, AuthError};
3	use dozer_cache::cache::expression::QueryExpression;
4	use dozer_cache::cache::RecordWithId;
5	use dozer_cache::{AccessFilter, CacheReader};
6
7	pub fn get_record(	1✔
8	cache_reader: &CacheReader,	1✔
9	key: &[u8],	1✔
10	access: Option<Access>,	1✔
11	) -> Result<RecordWithId, ApiError> {	1✔
12	let access_filter = get_access_filter(access)?;	1✔
13	let record = cache_reader	1✔
14	.get(key, &access_filter)	1✔
15	.map_err(ApiError::NotFound)?;	1✔
16	Ok(record)	1✔
17	}	1✔
18		×
19	pub fn get_records_count(	14✔
20	cache_reader: &CacheReader,	14✔
21	exp: &mut QueryExpression,	14✔
22	access: Option<Access>,	14✔
23	) -> Result<usize, ApiError> {	14✔
24	let access_filter = get_access_filter(access)?;	14✔
25	cache_reader	14✔
26	.count(exp, access_filter)	14✔
27	.map_err(ApiError::CountFailed)	14✔
28	}	14✔
29		×
30	/// Get multiple records	×
31	pub fn get_records(	22✔
32	cache_reader: &CacheReader,	22✔
33	exp: &mut QueryExpression,	22✔
34	access: Option<Access>,	22✔
35	) -> Result<Vec<RecordWithId>, ApiError> {	22✔
36	let access_filter = get_access_filter(access)?;	22✔
37	cache_reader	22✔
38	.query(exp, access_filter)	22✔
39	.map_err(ApiError::QueryFailed)	22✔
40	}	22✔
41		×
42	fn get_access_filter(access: Option<Access>) -> Result<AccessFilter, ApiError> {	×
43	match access {	3✔
44	None \| Some(Access::All) => Ok(AccessFilter {	37✔
45	filter: None,	37✔
46	fields: vec![],	37✔
47	}),	37✔
48	Some(Access::Custom(mut access_filters)) => {	×
49	if let Some(access_filter) = access_filters.remove("get_records") {	×
50	Ok(access_filter)	×
51	} else {	×
52	Err(ApiError::ApiAuthError(AuthError::InvalidToken))	×
53	}	×
54	}
55	}	×
56	}	37✔

getdozer / dozer / 4370280743

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