format & fix & tests

role-manager/src/cli.rs

@@ -318,6 +318,12 @@ pub fn parse_args(manager: &mut RoleContext) -> Result<bool, Box<dyn Error>> {
                     let role = manager.get_role().unwrap();
                     println!("{}", role.as_ref().borrow().get_description());
                 }
+            } else {
+                let roles = manager.roles.as_ref().borrow();
+                for role in roles.roles.iter().cloned() {
+                    println!("=============\nRole {}", role.as_ref().borrow().name);
+                    println!("{}", role.as_ref().borrow().get_description());
+                }
             }
             Ok(true)
         }

role-manager/src/config/structs.rs

@@ -246,7 +246,7 @@ impl<'a> Role<'a> {
             self.tasks
                 .iter()
                 .cloned()
-                .map(|x| x.as_ref().borrow().commands.join("\n"))
+                .map(|x| x.as_ref().borrow().id.to_string())
                 .collect::<Vec<String>>()
                 .join("\n")
         ));
@@ -349,3 +349,62 @@ pub trait Save {
         element: Option<&Element>,
     ) -> Result<bool, Box<dyn Error>>;
 }
+
+#[cfg(test)]
+mod tests {
+    use std::borrow::BorrowMut;
+
+    use crate::options::Level;
+
+    use super::*;
+
+    #[test]
+    fn test_get_empty_description() {
+        let role = Role::new("test_role".to_string(), None);
+        assert_eq!(
+            role.as_ref().borrow().get_description(),
+            "Users:\n()\nGroups:\n()\nTasks:\n\n"
+        );
+        let task = Task::new(IdTask::Number(0), Rc::downgrade(&role));
+        assert_eq!(task.as_ref().borrow().get_description(), "Commands:\n\n");
+    }
+
+    #[test]
+    fn test_get_description() {
+        let role = Role::new("test_role".to_string(), None);
+        let task = Task::new(IdTask::Number(0), Rc::downgrade(&role));
+        task.as_ref().borrow_mut().commands.push("ls".to_string());
+        task.as_ref()
+            .borrow_mut()
+            .commands
+            .push("another".to_string());
+        task.as_ref().borrow_mut().purpose = Some("thepurpose".to_string());
+        task.as_ref().borrow_mut().setuid = Some("thesetuid".to_string());
+        task.as_ref().borrow_mut().setgid =
+            Some(vec!["thesetgid".to_string(), "thesecondsetgid".to_string()].into());
+        task.as_ref().borrow_mut().capabilities = Some(Caps::V2(3));
+        let mut opt = Opt::new(Level::Task);
+        opt.path = Some("thepath".to_string());
+        opt.bounding = Some(false);
+        opt.no_root = Some(true);
+        opt.wildcard_denied = Some("thewildcard-denied".to_string());
+        opt.env_checklist = Some("thechecklist".to_string());
+        opt.env_whitelist = Some("thewhitelist".to_string());
+        task.as_ref().borrow_mut().options = Some(Rc::new(RefCell::new(opt)));
+        let desc = task.as_ref().borrow().get_description();
+        println!("{}", desc);
+        assert!(desc.contains("ls\nanother\n"));
+        assert!(desc.contains("thepurpose"));
+        assert!(desc.contains("thesetuid"));
+        assert!(desc.contains("thesetgid"));
+        assert!(desc.contains("thesecondsetgid"));
+        assert!(desc.contains(&Caps::V2(3).to_string()));
+        assert!(desc.contains("Options"));
+        assert!(desc.contains("thepath"));
+        assert!(desc.contains("thewildcard-denied"));
+        assert!(desc.contains("thechecklist"));
+        assert!(desc.contains("thewhitelist"));
+        assert!(desc.contains("No root: true"));
+        assert!(desc.contains("Bounding: false"));
+    }
+}

role-manager/src/main.rs

@@ -29,9 +29,16 @@ pub struct RoleManagerApp {
 fn main() {
     let roles = config::load::load_roles(FILENAME).expect("Failed to load roles");
     let mut rc_role_manager = RoleContext::new(roles);
-    if let Err(err) = parse_args(&mut rc_role_manager) {
-        eprintln!("{}", err);
-        std::process::exit(1);
+    match parse_args(&mut rc_role_manager) {
+        Ok(value) => {
+            if value {
+                std::process::exit(0);
+            }
+        }
+        Err(err) => {
+            eprintln!("{}", err);
+            std::process::exit(1);
+        }
     }
     // a builder for `FmtSubscriber`.
     let subscriber = FmtSubscriber::builder()

role-manager/src/state.rs

@@ -117,12 +117,15 @@ pub fn execute(s: &mut Cursive, exec_type: ExecuteType) {
         ));
         style.effects.insert(Effect::Bold);
         s.add_layer(
-            Dialog::around(TextView::new(err.to_string()).style(style)).button("Understood", move |s| {
-                s.pop_layer();
-                if exiting {
-                    s.quit();
-                }
-            }),
+            Dialog::around(TextView::new(err.to_string()).style(style)).button(
+                "Understood",
+                move |s| {
+                    s.pop_layer();
+                    if exiting {
+                        s.quit();
+                    }
+                },
+            ),
         );
     } else if exiting {
         s.quit();
@@ -141,7 +144,7 @@ mod tests {
     use super::*;
 
     trait Downcast {
-        unsafe fn downcast<T>(&self) -> &T ;
+        unsafe fn downcast<T>(&self) -> &T;
     }
 
     impl Downcast for dyn State {
@@ -151,42 +154,40 @@ mod tests {
     }
 
     #[derive(Debug)]
-    struct TestState{
-        pub i : usize,
-        pub j : char,
+    struct TestState {
+        pub i: usize,
+        pub j: char,
     }
 
     impl TestState {
-        pub fn new(i : usize, j : char) -> Self {
+        pub fn new(i: usize, j: char) -> Self {
             Self { i, j }
         }
     }
 
     impl State for TestState {
-        fn create(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State>{
+        fn create(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'c'))
         }
-        fn delete(self: Box<Self>, _: &mut RoleContext, _: usize) -> Box<dyn State>{
+        fn delete(self: Box<Self>, _: &mut RoleContext, _: usize) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'd'))
         }
-        fn submit(self: Box<Self>, _: &mut RoleContext, _: usize) -> Box<dyn State>{
+        fn submit(self: Box<Self>, _: &mut RoleContext, _: usize) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 's'))
         }
-        fn cancel(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State>{
+        fn cancel(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'l'))
         }
-        fn confirm(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State>{
+        fn confirm(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'm'))
         }
-        fn config(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State>{
+        fn config(self: Box<Self>, _: &mut RoleContext) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'g'))
         }
-        fn input(self: Box<Self>, _: &mut RoleContext, _: Input) -> Box<dyn State>{
+        fn input(self: Box<Self>, _: &mut RoleContext, _: Input) -> Box<dyn State> {
             Box::new(Self::new(self.i + 1, 'i'))
         }
-        fn render(&self, _: &mut RoleContext, _: &mut Cursive){
-
-        }
+        fn render(&self, _: &mut RoleContext, _: &mut Cursive) {}
     }
 
     #[test]
@@ -196,21 +197,21 @@ mod tests {
         let state = Box::new(TestState::new(0, 'a'));
         s.set_user_data(RoleManagerApp { manager, state });
         execute(&mut s, ExecuteType::Exit);
-        let app : RoleManagerApp = s.take_user_data().unwrap();
+        let app: RoleManagerApp = s.take_user_data().unwrap();
         assert!(app.manager.is_exiting());
     }
 
-    fn test_dyn_state(state : &Box<dyn State>, i : usize, j : char) {
+    fn test_dyn_state(state: &Box<dyn State>, i: usize, j: char) {
         unsafe {
             let state = state.downcast::<TestState>();
             assert_eq!(state.i, i);
             assert_eq!(state.j, j);
         }
     }
 
-    fn execute_and_test(s : &mut Cursive, exec_type : ExecuteType, i : usize, j : char) {
+    fn execute_and_test(s: &mut Cursive, exec_type: ExecuteType, i: usize, j: char) {
         execute(s, exec_type);
-        let RoleManagerApp{state, manager} = s.take_user_data().unwrap();
+        let RoleManagerApp { state, manager } = s.take_user_data().unwrap();
         test_dyn_state(&state, i, j);
         s.set_user_data(RoleManagerApp { manager, state });
     }
@@ -226,7 +227,12 @@ mod tests {
         execute_and_test(&mut s, ExecuteType::Config, 3, 'g');
         execute_and_test(&mut s, ExecuteType::Create, 4, 'c');
         execute_and_test(&mut s, ExecuteType::Delete(0), 5, 'd');
-        execute_and_test(&mut s, ExecuteType::Input(Input::String("test".to_string())), 6, 'i');
+        execute_and_test(
+            &mut s,
+            ExecuteType::Input(Input::String("test".to_string())),
+            6,
+            'i',
+        );
         execute_and_test(&mut s, ExecuteType::Submit(0), 7, 's');
     }
-}
+}

role-manager/src/state/task.rs

@@ -258,12 +258,10 @@ impl State for EditTaskState {
     }
     fn render(&self, manager: &mut RoleContext, cursive: &mut Cursive) {
         let mut title = "".to_owned();
-        let task = manager
-            .get_task()
-            .map(|o| {
-                title = format!("Edit {}", o.as_ref().borrow().id.to_string());
-                o
-            });
+        let task = manager.get_task().map(|o| {
+            title = format!("Edit {}", o.as_ref().borrow().id.to_string());
+            o
+        });
         let mut select = SelectView::new().on_submit(|s, item| {
             execute(s, ExecuteType::Submit(*item));
         });