5939715234

Committed 22 Aug 2023 01:47PM UTC coverage: 74.755% (-1.3%) from 76.052%

Build # 5939715234

Build Type

push

github

Committed by

web-flow

Commit Message

chore: Run e2e tests nightly (#1886)

* chore: Run e2e tests nightly

* chore: Run Dozer CI on default runners

Run Details

46459 of 62148 relevant lines covered (74.76%)

40132.91 hits per line

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

96.0

/dozer-api/src/auth/mod.rs

use std::collections::HashMap;

use dozer_cache::AccessFilter;
use dozer_types::serde;
use serde::{Deserialize, Serialize};
pub mod api;
pub mod authorizer;
pub use authorizer::Authorizer;
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
#[serde(crate = "self::serde")]
pub struct Claims {
    pub aud: String,
    pub sub: String,
    pub exp: usize,
    pub access: Access,
}
#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
#[serde(crate = "self::serde")]
// Access gets resolved in cache query, get and list functions
pub enum Access {
    /// Access to all indexes
    All,
    /// (endpoint_name, AccessFilter) Specific permissions to each of the indexes
    Custom(HashMap<String, AccessFilter>),
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use dozer_cache::AccessFilter;
    use dozer_types::serde_json::json;

    use super::Access;

    #[test]
    fn serialize_access() {
        let mut access_map = HashMap::new();
        access_map.insert(
            "films".to_string(),
            AccessFilter {
                filter: None,
                fields: vec![],
            },
        );
        let access = Access::Custom(access_map);
        let res = dozer_types::serde_json::to_string(&access);

        assert!(res.is_ok());

        let de_access = dozer_types::serde_json::from_value::<Access>(
            json!({"Custom":{"films":{"filter":null,"fields":[]}}}),
        );

        assert_eq!(de_access.unwrap(), access);

        let de_access = dozer_types::serde_json::from_value::<Access>(json!("All"));
        assert_eq!(de_access.unwrap(), Access::All);
    }
}

1	use std::collections::HashMap;
2
3	use dozer_cache::AccessFilter;
4	use dozer_types::serde;
5	use serde::{Deserialize, Serialize};
6	pub mod api;
7	pub mod authorizer;
8	pub use authorizer::Authorizer;
9	#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]	45✔
10	#[serde(crate = "self::serde")]
11	pub struct Claims {
12	pub aud: String,
13	pub sub: String,
14	pub exp: usize,
15	pub access: Access,
16	}
17	#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]	16✔
18	#[serde(crate = "self::serde")]
19	// Access gets resolved in cache query, get and list functions
20	pub enum Access {
21	/// Access to all indexes
22	All,
23	/// (endpoint_name, AccessFilter) Specific permissions to each of the indexes
24	Custom(HashMap<String, AccessFilter>),
25	}
26
27	#[cfg(test)]
28	mod tests {
29	use std::collections::HashMap;
30
31	use dozer_cache::AccessFilter;
32	use dozer_types::serde_json::json;
33
34	use super::Access;
35
36	#[test]	1✔
37	fn serialize_access() {	1✔
38	let mut access_map = HashMap::new();	1✔
39	access_map.insert(	1✔
40	"films".to_string(),	1✔
41	AccessFilter {	1✔
42	filter: None,	1✔
43	fields: vec![],	1✔
44	},	1✔
45	);	1✔
46	let access = Access::Custom(access_map);	1✔
47	let res = dozer_types::serde_json::to_string(&access);	1✔
48		1✔
49	assert!(res.is_ok());	1✔
50
51	let de_access = dozer_types::serde_json::from_value::<Access>(	1✔
52	json!({"Custom":{"films":{"filter":null,"fields":[]}}}),	1✔
53	);	1✔
54		1✔
55	assert_eq!(de_access.unwrap(), access);	1✔
56		×
57	let de_access = dozer_types::serde_json::from_value::<Access>(json!("All"));	1✔
58	assert_eq!(de_access.unwrap(), Access::All);	1✔
59	}	1✔
60	}

getdozer / dozer / 5939715234

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