login, logout, optional locale, progress format

Heliozoa · Heliozoa · commit d9f50ae73c1a · 2020-07-14T15:11:16.000+03:00
diff --git a/tmc-langs-cli/Cargo.toml b/tmc-langs-cli/Cargo.toml
@@ -14,12 +14,13 @@ walkdir = "2"
 serde_json = "1"
 env_logger = "0.7"
 log = "0.4"
-rpassword = { git = "https://github.com/conradkleinespel/rpassword", rev = "189c388" }  # fixes a windows test issue, use until version 5 is released
+rpassword = "4"
 url = "2"
 serde = "1"
 anyhow = "1"
 ansi_term = "0.12"
 quit = "1"
+dirs = "3"
 
 [dev-dependencies]
 tempfile = "3"
diff --git a/tmc-langs-cli/src/main.rs b/tmc-langs-cli/src/main.rs
@@ -6,10 +6,10 @@ use clap::{App, Arg, Error, ErrorKind, SubCommand};
 use serde::Serialize;
 use std::collections::HashMap;
 use std::env;
-use std::fs::File;
+use std::fs::{self, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
-use tmc_langs_core::{FeedbackAnswer, TmcCore};
+use tmc_langs_core::{FeedbackAnswer, TmcCore, Token};
 use tmc_langs_framework::io::submission_processing;
 use tmc_langs_util::{task_executor, Language};
 use url::Url;
@@ -159,12 +159,23 @@ fn run() -> Result<()> {
 
         .subcommand(SubCommand::with_name("core")
             .about("tmc-core commands. The program will ask for your TMC password through stdin.")
-            .arg(Arg::with_name("email")
-                .help("The email associated with your TMC account.")
-                .long("email")
+            .arg(Arg::with_name("clientName")
+                .help("Name used to differentiate between different TMC clients")
+                .long("clientName")
                 .required(true)
                 .takes_value(true))
 
+            .subcommand(SubCommand::with_name("login")
+                .about("Login and store OAuth2 token in config.")
+                .arg(Arg::with_name("email")
+                    .help("The email address of your TMC account")
+                    .long("email")
+                    .required(true)
+                    .takes_value(true)))
+
+            .subcommand(SubCommand::with_name("logout")
+                .about("Login and remove OAuth2 token from config."))
+
             .subcommand(SubCommand::with_name("get-organizations")
                 .about("Get organizations."))
 
@@ -261,7 +272,6 @@ fn run() -> Result<()> {
                 .arg(Arg::with_name("locale")
                     .help("Language as a three letter ISO 639-3 code, e.g. 'eng' or 'fin'.")                    
                     .long("locale")
-                    .required(true)
                     .takes_value(true)))
 
             .subcommand(SubCommand::with_name("get-exercise-updates")
@@ -518,14 +528,50 @@ fn run() -> Result<()> {
         // set progress report to print the updates to stdout as JSON
         core.set_progress_report(|update| println!("{}", serde_json::to_string(&update).unwrap()));
 
-        let email = matches.value_of("email").unwrap();
-        // TODO: "Please enter password" and quiet param
-        let password = rpassword::read_password().context("Failed to read password")?;
-
-        core.authenticate("vscode_plugin", email.to_string(), password)
-            .context("Failed to authenticate with TMC")?;
-
-        if let Some(_matches) = matches.subcommand_matches("get-organizations") {
+        // set token if a credentials.json is found for the client name
+        let client_name = matches.value_of("clientName").unwrap();
+        let tmc_dir = format!("tmc-{}", client_name);
+
+        let config_dir = match env::var("TMC_LANGS_CLI_CONFIG_DIR") {
+            Ok(v) => PathBuf::from(v),
+            Err(_) => dirs::config_dir().context("Failed to find config directory")?,
+        };
+        let credentials_path = config_dir.join(tmc_dir).join("credentials.json");
+        if let Ok(file) = File::open(&credentials_path) {
+            let token: Token = serde_json::from_reader(file).expect("malformed credentials.json");
+            core.set_token(token);
+        };
+
+        if let Some(matches) = matches.subcommand_matches("login") {
+            let email = matches.value_of("email").unwrap();
+            // TODO: "Please enter password" and quiet param
+            let password = rpassword::read_password().context("Failed to read password")?;
+            let token = core
+                .authenticate(client_name, email.to_string(), password)
+                .context("Failed to authenticate with TMC")?;
+            if let Some(p) = credentials_path.parent() {
+                fs::create_dir_all(p)
+                    .with_context(|| format!("Failed to create directory {}", p.display()))?;
+            }
+            let credentials_file = File::create(&credentials_path).with_context(|| {
+                format!("Failed to create file at {}", credentials_path.display())
+            })?;
+            serde_json::to_writer(credentials_file, &token).with_context(|| {
+                format!(
+                    "Failed to write credentials to {}",
+                    credentials_path.display()
+                )
+            })?;
+        } else if let Some(_matches) = matches.subcommand_matches("logout") {
+            if credentials_path.exists() {
+                fs::remove_file(&credentials_path).with_context(|| {
+                    format!(
+                        "Failed to remove credentials at {}",
+                        credentials_path.display()
+                    )
+                })?;
+            }
+        } else if let Some(_matches) = matches.subcommand_matches("get-organizations") {
             let orgs = core
                 .get_organizations()
                 .context("Failed to get organizations")?;
@@ -627,11 +673,15 @@ fn run() -> Result<()> {
             let submission_path = matches.value_of("submissionPath").unwrap();
             let submission_path = Path::new(submission_path);
 
-            let locale = matches.value_of("locale").unwrap();
-            let locale = into_locale(locale)?;
+            let optional_locale = matches.value_of("locale");
+            let optional_locale = if let Some(locale) = optional_locale {
+                Some(into_locale(locale)?)
+            } else {
+                None
+            };
 
             let new_submission = core
-                .submit(submission_url, submission_path, locale)
+                .submit(submission_url, submission_path, optional_locale)
                 .context("Failed to submit")?;
 
             print_result_as_json(&new_submission)?;
diff --git a/tmc-langs-cli/tests/core_mock.rs b/tmc-langs-cli/tests/core_mock.rs
@@ -1,49 +1,37 @@
-use mockito::{mock, Mock};
+use mockito::mock;
 use std::env;
-use std::io::Write;
 use std::process::Stdio;
 use std::process::{Command, Output};
 use tmc_langs_core::Organization;
 
-fn init() -> (Mock, Mock) {
+fn init() {
     if env::var("RUST_LOG").is_err() {
         env::set_var("RUST_LOG", "debug,hyper=warn,tokio_reactor=warn");
     }
     let _ = env_logger::builder().is_test(true).try_init();
     env::set_var("TMC_CORE_CLI_ROOT_URL", mockito::server_url());
-
-    let m1 = mock("GET", "/api/v8/application/vscode_plugin/credentials")
-        .with_body(
-            serde_json::json!({
-                "application_id": "id",
-                "secret": "secret",
-            })
-            .to_string(),
-        )
-        .create();
-    let m2 = mock("POST", "/oauth/token")
-        .with_body(
-            serde_json::json!({
-                "access_token": "token",
-                "token_type": "bearer",
-            })
-            .to_string(),
-        )
-        .create();
-    (m1, m2)
+    env::set_var("TMC_CORE_CLI_CONFIG_DIR", "./");
 }
 
 fn run_cmd(args: &[&str]) -> Output {
+    let temp = tempfile::tempdir().unwrap();
+    std::fs::create_dir_all(temp.path().join("client")).unwrap();
+    let f = std::fs::File::create(temp.path().join("client").join("credentials.json")).unwrap();
+    serde_json::to_writer(
+        f,
+        &serde_json::json! {
+            {"access_token":"accesstoken","token_type":"bearer","scope":"public"}
+        },
+    )
+    .unwrap();
     let path = env!("CARGO_BIN_EXE_tmc-langs-cli");
-    let mut child = Command::new(path)
+    let out = Command::new(path)
+        .current_dir(temp.path())
         .stdout(Stdio::piped())
         .stdin(Stdio::piped())
         .args(args)
-        .spawn()
+        .output()
         .unwrap();
-    let child_stdin = child.stdin.as_mut().unwrap();
-    child_stdin.write_all("password\n".as_bytes()).unwrap();
-    let out = child.wait_with_output().unwrap();
 
     log::debug!("stdout: {}", String::from_utf8_lossy(&out.stdout));
     log::debug!("stderr: {}", String::from_utf8_lossy(&out.stderr));
@@ -67,7 +55,7 @@ fn get_organizations() {
             .to_string(),
         )
         .create();
-    let out = run_cmd(&["core", "--email", "email", "get-organizations"]);
+    let out = run_cmd(&["core", "--clientName", "client", "get-organizations"]);
     assert!(out.status.success());
     let out = String::from_utf8(out.stdout).unwrap();
     let orgs: Vec<Organization> = serde_json::from_str(&out).unwrap();
diff --git a/tmc-langs-core/src/lib.rs b/tmc-langs-core/src/lib.rs
@@ -22,5 +22,5 @@ pub use response::{
     SubmissionFeedbackResponse, SubmissionFinished, SubmissionProcessingStatus, SubmissionStatus,
     User,
 };
-pub use tmc_core::TmcCore;
+pub use tmc_core::{TmcCore, Token};
 pub use tmc_langs_util::{Language, RunResult, Strategy, ValidationResult};
diff --git a/tmc-langs-core/src/tmc_core.rs b/tmc-langs-core/src/tmc_core.rs
@@ -23,9 +23,10 @@ pub type Token =
     oauth2::StandardTokenResponse<oauth2::EmptyExtraTokenFields, oauth2::basic::BasicTokenType>;
 
 #[derive(Debug, Serialize)]
-pub enum StatusUpdate {
-    Processing(&'static str, f64),
-    Finished,
+pub struct StatusUpdate {
+    finished: bool,
+    message: &'static str,
+    percent_done: f64,
 }
 
 /// A struct for interacting with the TestMyCode service, including authentication
@@ -92,23 +93,35 @@ impl TmcCore {
         Self::new(config_dir, root_url)
     }
 
+    pub fn set_token(&mut self, token: Token) {
+        self.token = Some(token);
+    }
+
     pub fn set_progress_report<F>(&mut self, progress_report: F)
     where
         F: Fn(StatusUpdate) + 'static,
     {
         self.progress_report = Some(Box::new(progress_report));
     }
 
-    pub fn report_progress(&self, msg: &'static str, progress: f64) {
-        self.progress_report
-            .as_ref()
-            .map(|f| f(StatusUpdate::Processing(msg, progress)));
+    pub fn report_progress(&self, message: &'static str, percent_done: f64) {
+        self.progress_report.as_ref().map(|f| {
+            f(StatusUpdate {
+                finished: false,
+                message,
+                percent_done,
+            })
+        });
     }
 
-    pub fn report_complete(&self) {
-        self.progress_report
-            .as_ref()
-            .map(|f| f(StatusUpdate::Finished));
+    pub fn report_complete(&self, message: &'static str) {
+        self.progress_report.as_ref().map(|f| {
+            f(StatusUpdate {
+                finished: true,
+                message,
+                percent_done: 1.0,
+            })
+        });
     }
 
     /// Attempts to log in with the given credentials, returns an error if an authentication token is already present.
@@ -131,7 +144,7 @@ impl TmcCore {
         client_name: &str,
         email: String,
         password: String,
-    ) -> Result<()> {
+    ) -> Result<Token> {
         if self.token.is_some() {
             return Err(CoreError::AlreadyAuthenticated);
         }
@@ -161,9 +174,9 @@ impl TmcCore {
                 &ResourceOwnerPassword::new(password),
             )
             .request(oauth2::reqwest::http_client)?;
-        self.token = Some(token);
+        self.token = Some(token.clone());
         log::debug!("authenticated");
-        Ok(())
+        Ok(token)
     }
 
     /// Fetches all organizations.
@@ -247,6 +260,9 @@ impl TmcCore {
     /// let courses = core.list_courses("hy").unwrap();
     /// ```
     pub fn list_courses(&self, organization_slug: &str) -> Result<Vec<Course>> {
+        if self.token.is_none() {
+            return Err(CoreError::AuthRequired);
+        }
         self.organization_courses(organization_slug)
     }
 
@@ -285,7 +301,7 @@ impl TmcCore {
         file.write_all(&compressed)
             .map_err(|e| CoreError::FileWrite(file.path().to_path_buf(), e))?;
 
-        self.post_submission_to_paste(submission_url, file.path(), paste_message, locale)
+        self.post_submission_to_paste(submission_url, file.path(), paste_message, Some(locale))
     }
 
     /// Checks the coding style for the project.
@@ -354,7 +370,7 @@ impl TmcCore {
         &self,
         submission_url: Url,
         submission_path: &Path,
-        locale: Language,
+        locale: Option<Language>,
     ) -> Result<NewSubmission> {
         // compress
         self.report_progress("Submitting exercise. Compressing submission...", 0.0);
@@ -367,7 +383,7 @@ impl TmcCore {
         self.report_progress("Wrote compressed data. Posting submission...", 0.75);
 
         let result = self.post_submission(submission_url, file.path(), locale);
-        self.report_complete();
+        self.report_complete("Submission finished!");
         result
     }
 
@@ -450,7 +466,12 @@ impl TmcCore {
         file.write_all(&compressed)
             .map_err(|e| CoreError::FileWrite(file.path().to_path_buf(), e))?;
 
-        self.post_submission_for_review(submission_url, file.path(), message_for_reviewer, locale)
+        self.post_submission_for_review(
+            submission_url,
+            file.path(),
+            message_for_reviewer,
+            Some(locale),
+        )
     }
 
     /// Downloads the model solution from the given url.
@@ -738,7 +759,7 @@ mod test {
             .submit(
                 submission_url,
                 Path::new("tests/data/exercise"),
-                Language::from_639_3("eng").unwrap(),
+                Some(Language::Eng),
             )
             .unwrap();
         assert_eq!(
@@ -1024,4 +1045,26 @@ mod test {
             SubmissionProcessingStatus::Processing(_) => panic!("wrong status"),
         }
     }
+
+    #[test]
+    fn status_serde() {
+        let p = StatusUpdate {
+            finished: false,
+            message: "submitting...",
+            percent_done: 0.5,
+        };
+        assert_eq!(
+            r#"{"finished":false,"message":"submitting...","percent_done":0.5}"#,
+            serde_json::to_string(&p).unwrap()
+        );
+        let f = StatusUpdate {
+            finished: true,
+            message: "done",
+            percent_done: 1.0,
+        };
+        assert_eq!(
+            r#"{"finished":true,"message":"done","percent_done":1.0}"#,
+            serde_json::to_string(&f).unwrap()
+        );
+    }
 }
diff --git a/tmc-langs-core/src/tmc_core/api.rs b/tmc-langs-core/src/tmc_core/api.rs
diff --git a/tmc-langs-core/tests/compare_server_results.rs b/tmc-langs-core/tests/compare_server_results.rs
