list-permissions command (#34)

Author: bookdude13

README.md

@@ -9,9 +9,8 @@ Command line interface to manipulate ProtonLights projects.
 - `new-sequence <admin-key> <name> <music-file>`: Init a sequence
 - `remove-sequence <admin-key> <name>`: Removes a sequence and deletes its files
 - `id-user <private-key>`: Identify user by ssh key (public key in repo)
-- `list-permissions`: Get list of all available permissions
+- `list-permissions <private-key>`: Get list of user's permissions
 - `set-permission <admin-key> (add | remove) <name> <permission> [<target>]`: Change user permissions
-- `list-editable [TODO]`: Get list of editable files for a given user
 - `resection-sequence [TODO]`: (Re-)Section a sequence
   - On init, section as section1.
     - Number each section, and don't delete.

src/main.rs

@@ -5,6 +5,7 @@ extern crate docopt;
 
 use std::env;
 use std::path::Path;
+use rustc_serialize::json;
 use docopt::Docopt;
 
 use proton_cli::error::Error;
@@ -22,7 +23,7 @@ Usage:
   ./proton new-sequence <admin-key> <name> <music-file>
   ./proton remove-sequence <admin-key> <name>
   ./proton id-user <private-key>
-  ./proton list-permissions
+  ./proton list-permissions <private-key>
   ./proton set-permission <admin-key> (add | remove) <name> <permission> [<target>]
   ./proton (-h | --help)
 
@@ -118,10 +119,10 @@ fn run_remove_sequence(args: Args) -> Result<(), Error> {
 	proton_cli::remove_sequence(&admin_key_path, &name)
 }
 
-#[allow(unused_variables)]
 fn run_list_permissions(args: Args) -> Result<(), Error> {
-	let permissions = proton_cli::get_permissions();
-	Ok(println!("{}", permissions.join("\n")))
+	let private_key = args.arg_private_key;
+	proton_cli::get_permissions(&private_key.unwrap())
+		.map(|p| println!("{}", json::as_pretty_json(&p)))
 }
 
 fn run_set_permission(args: Args) -> Result<(), Error> {

src/permissions.rs

@@ -6,16 +6,9 @@ use git2::Signature;
 use error::Error;
 use project_types::{User, Permission, PermissionEnum};
 use utils;
+use user;
 
 
-pub fn get_permissions() -> Vec<&'static str> {
-    vec![
-        "Administrate",
-        "EditSeq",
-        "EditSeqSec"
-    ]
-}
-
 pub fn set_permission(
     auth_user: &User,
     add: bool,
@@ -56,6 +49,9 @@ pub fn set_permission(
         auth_user.name, change_type, perm, target_username);
 
     utils::commit_all(None::<&Path>, &signature, &msg)
-
 }
 
+pub fn get_permissions<P: AsRef<Path>> (user_key_path: P
+) -> Result<Vec<Permission>, Error> {
+    user::id_user(&user_key_path).map(|user| user.permissions)
+}

src/project_types/permissions.rs

@@ -56,6 +56,7 @@ impl Permission {
                     let target_str = target.to_owned().unwrap();
                     let targets: Vec<&str> = target_str.split(",").collect();
                     if targets.len() != 2 {
+                        println!("EditSeqSec target must be of the form \"name,section\"");
                         false
                     } else {
                         let seq_name = targets[0];
@@ -67,9 +68,16 @@ impl Permission {
                         let project = try!(utils::read_protonfile(None::<&Path>));
                         match project.find_sequence_by_name(&seq_name) {
                             Some(seq) => {
-                                section_num > 0 && section_num <= seq.num_sections
+                                let in_range = section_num > 0 && section_num <= seq.num_sections;
+                                if !in_range {
+                                    println!("EditSeqSec target must be of the form \"name,section\"");
+                                }
+                                in_range
+                            },
+                            None => {
+                                println!("EditSeqSec target must be of the form \"name,section\"");
+                                false
                             },
-                            None => false,
                         }
 
                     }
@@ -83,5 +91,4 @@ impl Permission {
             Err(Error::InvalidPermissionTarget)
         }
     }
-
 }

src/sequence.rs

@@ -181,4 +181,3 @@ fn get_music_duration_sec<P: AsRef<Path>>(path: P) -> Result<u32, Error> {
     let duration = duration_time.as_seconds() as u32;
     Ok(duration)
 }
-

src/user.rs

@@ -108,6 +108,3 @@ pub fn id_user<P: AsRef<Path>>(private_key_path: P) -> Result<User, Error> {
 
     Err(Error::UserNotFound)
 }
-
-
-

tests/common/setup.rs

@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
 use self::tempdir::TempDir;
 
 use proton_cli;
+use proton_cli::project_types::PermissionEnum;
 
 use super::rsa_keys::{self, TestKey};
 
@@ -75,3 +76,29 @@ pub fn try_make_sequence(admin_key_path: &Path, name: &str, music_file: &str) {
     seq_dir_path.push(&seq.music_file_name);
     assert!(seq_dir_path.exists());
 }
+
+/// Tries to modify a user's permission
+/// Panics on error
+///
+/// Impure.
+pub fn try_set_permission<P: AsRef<Path>>(
+    root_path: &Path,
+    auth_private_key_path: P,
+    add: bool,
+    target_username: &str,
+    permission: PermissionEnum,
+    target: Option<String>,
+) {
+    let auth_user = proton_cli::id_user(&auth_private_key_path)
+        .expect("Auth user not found");
+
+    proton_cli::set_permission(
+        &auth_user,
+        add,
+        &target_username,
+        permission.to_owned(),
+        target.to_owned()
+    ).expect("Error setting permission");
+
+    super::assert_repo_no_modified_files(&root_path);
+}

tests/get_permissions.rs

@@ -0,0 +1,169 @@
+extern crate proton_cli;
+
+mod common;
+
+use std::path::Path;
+
+use common::setup;
+use common::rsa_keys::TestKey;
+use proton_cli::project_types::PermissionEnum;
+
+
+#[test]
+fn works_with_valid_key_no_permissions() {
+    let root = setup::setup_init_cd();
+    let root_key_path = common::make_key_file(&root.path(), "root.pem", TestKey::RootKeyPem);
+    let user_key_path = common::make_key_file(&root.path(), "a.pem", TestKey::GoodKeyPem);
+    let name = "UserA";
+
+    setup::try_new_user(
+        &root_key_path.as_path(),
+        root.path(),
+        &name,
+        "a.pub",
+        TestKey::GoodKeyPub);
+
+    let permissions = proton_cli::get_permissions(&user_key_path)
+        .expect("Error getting permissions");
+
+    assert_eq!(permissions.len(), 0);
+}
+
+#[test]
+fn works_with_valid_key_one_permission() {
+    let root = setup::setup_init_cd();
+    let root_key_path = common::make_key_file(&root.path(), "root.pem", TestKey::RootKeyPem);
+    let user_key_path = common::make_key_file(&root.path(), "a.pem", TestKey::GoodKeyPem);
+    let name = "UserA";
+
+    setup::try_new_user(
+        &root_key_path.as_path(),
+        root.path(),
+        &name,
+        "a.pub",
+        TestKey::GoodKeyPub);
+
+    setup::try_make_sequence(
+        &root_key_path.as_path(),
+        "asdf",
+        "Dissonance.ogg"
+    );
+
+    setup::try_set_permission(
+        &root.path(),
+        &root_key_path,
+        true,
+        &name,
+        PermissionEnum::EditSeq,
+        Some("asdf".to_owned()));
+    
+    let permissions = proton_cli::get_permissions(&user_key_path)
+        .expect("Error getting permissions");
+
+    assert_eq!(permissions.len(), 1);
+    assert_eq!(&permissions[0].which, &PermissionEnum::EditSeq);
+    assert!(&permissions[0].target.is_some());
+    assert_eq!(permissions[0].target, Some("asdf".to_owned()));
+}
+
+#[test]
+fn works_with_valid_key_all_permissions() {
+    let root = setup::setup_init_cd();
+    let root_key_path = common::make_key_file(&root.path(), "root.pem", TestKey::RootKeyPem);
+    let user_key_path = common::make_key_file(&root.path(), "a.pem", TestKey::GoodKeyPem);
+    let name = "UserA";
+
+    setup::try_new_user(
+        &root_key_path.as_path(),
+        root.path(),
+        &name,
+        "a.pub",
+        TestKey::GoodKeyPub);
+
+    setup::try_make_sequence(
+        &root_key_path.as_path(),
+        "asdf",
+        "Dissonance.ogg"
+    );
+
+    setup::try_make_sequence(
+        &root_key_path.as_path(),
+        "ghjk",
+        "GlorytotheBells.ogg"
+    );
+
+    setup::try_set_permission(
+        &root.path(),
+        &root_key_path,
+        true,
+        &name,
+        PermissionEnum::Administrate,
+        None::<String>);
+
+    setup::try_set_permission(
+        &root.path(),
+        &root_key_path,
+        true,
+        &name,
+        PermissionEnum::EditSeq,
+        Some("asdf".to_owned()));
+
+    setup::try_set_permission(
+        &root.path(),
+        &root_key_path,
+        true,
+        &name,
+        PermissionEnum::EditSeqSec,
+        Some("ghjk,1".to_owned()));
+
+    let permissions = proton_cli::get_permissions(&user_key_path)
+        .expect("Error getting permissions");
+
+    assert_eq!(permissions.len(), 3);
+    assert_eq!(&permissions[0].which, &PermissionEnum::Administrate);
+    assert!(&permissions[0].target.is_none());
+    assert_eq!(&permissions[1].which, &PermissionEnum::EditSeq);
+    assert!(&permissions[1].target.is_some());
+    assert_eq!(permissions[1].target, Some("asdf".to_owned()));
+    assert_eq!(&permissions[2].which, &PermissionEnum::EditSeqSec);
+    assert!(&permissions[2].target.is_some());
+    assert_eq!(permissions[2].target, Some("ghjk,1".to_owned()));
+}
+
+#[test]
+#[should_panic(expected = "Error getting permissions: Io")]
+fn fails_with_invalid_key_path() {
+    let root = setup::setup_init_cd();
+    let root_key_path = common::make_key_file(&root.path(), "root.pem", TestKey::RootKeyPem);
+    let user_key_path = Path::new("invalid");
+    let name = "UserA";
+
+    setup::try_new_user(
+        &root_key_path.as_path(),
+        root.path(),
+        &name,
+        "a.pub",
+        TestKey::GoodKeyPub);
+
+    let _ = proton_cli::get_permissions(&user_key_path)
+        .expect("Error getting permissions");
+}
+
+#[test]
+#[should_panic(expected = "Error getting permissions: Ssl")]
+fn fails_with_invalid_key() {
+    let root = setup::setup_init_cd();
+    let root_key_path = common::make_key_file(&root.path(), "root.pem", TestKey::RootKeyPem);
+    let user_key_path = common::make_key_file(&root.path(), "a.pub", TestKey::GoodKeyPub);
+    let name = "UserA";
+
+    setup::try_new_user(
+        &root_key_path.as_path(),
+        root.path(),
+        &name,
+        "aa.pub",
+        TestKey::GoodKeyPub);
+
+    let _ = proton_cli::get_permissions(&user_key_path)
+        .expect("Error getting permissions");
+}