tests for cli api

Author: Heliozoa

tmc-client/src/tmc_client/api.rs

@@ -142,14 +142,8 @@ impl TmcClient {
         // todo use same code here and in json_res
         if !response.status().is_success() {
             let status = response.status();
-<<<<<<< HEAD
             if let Ok(err) = response.json::<ErrorResponse>() {
                 // failed and got an error json
-=======
-            let err: Result<ErrorResponse, _> = response.json();
-
-            if let Ok(err) = err {
->>>>>>> temp
                 let error = match (err.error, err.errors) {
                     (Some(err), Some(errs)) => format!("{}, {}", err, errs.join(",")),
                     (Some(err), None) => err,
@@ -163,18 +157,11 @@ impl TmcClient {
                     obsolete_client: err.obsolete_client,
                 })
             } else {
-<<<<<<< HEAD
                 // failed and failed to parse error json, return generic HTTP error
                 Err(ClientError::HttpError {
                     url,
                     status,
                     error: status.to_string(),
-=======
-                Err(ClientError::HttpError {
-                    url,
-                    status,
-                    error: "HTTP error".to_string(),
->>>>>>> temp
                     obsolete_client: false,
                 })
             }

tmc-langs-cli/src/main.rs

@@ -344,17 +344,19 @@ fn run_app(matches: ArgMatches, pretty: bool, warnings: &mut Vec<anyhow::Error>)
             let exercise_path = Path::new(exercise_path);
 
             let output_path = matches.value_of("output-path");
+
             let output_path = output_path.map(Path::new);
 
-            file_util::lock!(exercise_path);
+            let exercises = {
+                file_util::lock!(exercise_path);
 
-            let exercises =
                 task_executor::find_exercise_directories(exercise_path).with_context(|| {
                     format!(
                         "Failed to find exercise directories in {}",
                         exercise_path.display(),
                     )
-                })?;
+                })?
+            };
 
             if let Some(output_path) = output_path {
                 file_util::lock!(output_path);
@@ -478,16 +480,16 @@ fn run_app(matches: ArgMatches, pretty: bool, warnings: &mut Vec<anyhow::Error>)
             print_output(&output, pretty, &warnings)?
         }
         ("prepare-submission", Some(matches)) => {
+            let clone_path = matches.value_of("clone-path").unwrap();
+            let clone_path = Path::new(clone_path);
+
             let output_format = match matches.value_of("output-format") {
                 Some("tar") => OutputFormat::Tar,
                 Some("zip") => OutputFormat::Zip,
                 Some("zstd") => OutputFormat::TarZstd,
                 _ => unreachable!("validation error"),
             };
 
-            let clone_path = matches.value_of("clone-path").unwrap();
-            let clone_path = Path::new(clone_path);
-
             let output_path = matches.value_of("output-path").unwrap();
             let output_path = Path::new(output_path);
 
@@ -552,24 +554,26 @@ fn run_app(matches: ArgMatches, pretty: bool, warnings: &mut Vec<anyhow::Error>)
             print_output(&output, pretty, &warnings)?
         }
         ("refresh-course", Some(matches)) => {
-            let course_name = matches.value_of("course-name").unwrap();
             let cache_path = matches.value_of("cache-path").unwrap();
+            let cache_root = matches.value_of("cache-root").unwrap();
+            let chgrp_uid = matches.value_of("chgrp-uid");
+            let chmod_bits = matches.value_of("chmod-bits");
             let clone_path = matches.value_of("clone-path").unwrap();
-            let stub_path = matches.value_of("stub-path").unwrap();
-            let stub_zip_path = matches.value_of("stub-zip-path").unwrap();
-            let solution_path = matches.value_of("solution-path").unwrap();
-            let solution_zip_path = matches.value_of("solution-zip-path").unwrap();
+            let course_name = matches.value_of("course-name").unwrap();
+
             let exercise_args = matches.values_of("exercise");
-            let source_backend = matches.value_of("source-backend").unwrap();
-            let source_url = matches.value_of("source-url").unwrap();
             let git_branch = matches.value_of("git-branch").unwrap();
-            let no_directory_changes = matches.is_present("no-directory-changes");
             let no_background_operations = matches.is_present("no-background-operations");
-            let chmod_bits = matches.value_of("chmod-bits");
-            let chgrp_uid = matches.value_of("chgrp-uid");
-            let cache_root = matches.value_of("cache-root").unwrap();
+            let no_directory_changes = matches.is_present("no-directory-changes");
             let rails_root = matches.value_of("rails-root").unwrap();
 
+            let solution_path = matches.value_of("solution-path").unwrap();
+            let solution_zip_path = matches.value_of("solution-zip-path").unwrap();
+            let source_backend = matches.value_of("source-backend").unwrap();
+            let source_url = matches.value_of("source-url").unwrap();
+            let stub_path = matches.value_of("stub-path").unwrap();
+            let stub_zip_path = matches.value_of("stub-zip-path").unwrap();
+
             let mut exercises = vec![];
             if let Some(mut exercise_args) = exercise_args {
                 while let Some(exercise_name) = exercise_args.next() {

tmc-langs-cli/tests/base_integration.rs

@@ -1,28 +1,256 @@
 use std::env;
 use std::process::{Command, Output};
-use tempfile::tempdir;
+use tempfile::{tempdir, NamedTempFile};
 
 pub fn run_cmd(args: &[&str]) -> Output {
     let path = env::current_exe().unwrap().parent().unwrap().to_path_buf();
     let path = path.parent().unwrap().join("tmc-langs-cli");
     Command::new(path).args(args).output().unwrap()
 }
 
-fn test_dir(dir: &str) -> String {
-    format!("tests/data/{}", dir)
+pub fn run_assert_success(args: &[&str]) {
+    let out = run_cmd(args);
+    let stdout = String::from_utf8(out.stdout).unwrap();
+    let stderr = String::from_utf8(out.stderr).unwrap();
+    println!("stdout {}", stdout);
+    println!("stderr {}", stderr);
+    // if there's an issue with the argument parsing, stdout will be empty and not parse as json
+    let last_line = stdout.lines().last().unwrap();
+    let _json: serde_json::Value = serde_json::from_str(&last_line).unwrap();
+    assert!(stderr.is_empty());
+}
+
+#[test]
+fn sanity() {
+    let out = run_cmd(&["non-existent-command"]);
+    assert!(out.stdout.is_empty());
+    assert!(!out.stderr.is_empty());
+}
+
+#[test]
+fn checkstyle() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "checkstyle",
+        "--exercise-path",
+        path,
+        "--locale",
+        "fi",
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn clean() {
+    let temp = NamedTempFile::new().unwrap();
+    run_assert_success(&["clean", "--exercise-path", temp.path().to_str().unwrap()]);
 }
 
 #[test]
 fn compress_project() {
-    let temp = tempdir().unwrap();
-    let out = run_cmd(&[
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
         "compress-project",
         "--exercise-path",
-        &test_dir("project"),
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+// core is in a separate file
+
+#[test]
+fn disk_space() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&["disk-space", "--path", path]);
+}
+
+#[test]
+fn extract_project() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "extract-project",
+        "--archive-path",
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn fast_available_points() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&["fast-available-points", "--exercise-path", path]);
+}
+
+#[test]
+fn find_exercises() {
+    let temp = tempdir().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "find-exercises",
+        "--exercise-path",
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn get_exercise_packaging_configuration() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "get-exercise-packaging-configuration",
+        "--exercise-path",
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn list_local_course_exercises() {
+    run_assert_success(&[
+        "list-local-course-exercises",
+        "--client-name",
+        "client",
+        "--course-slug",
+        "slug",
+    ]);
+}
+
+#[test]
+fn prepare_solutions() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "prepare-solutions",
+        "--exercise-path",
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn prepare_stubs() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "prepare-stubs",
+        "--exercise-path",
+        path,
+        "--output-path",
+        path,
+    ]);
+}
+
+#[test]
+fn prepare_submission() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "prepare-submission",
+        "--clone-path",
+        path,
+        "--output-format",
+        "tar",
+        "--output-path",
+        path,
+        "--stub-zip-path",
+        path,
+        "--submission-path",
+        path,
+        "--tmc-param",
+        "a=b",
+        "--tmc-param",
+        "c=d",
+    ]);
+}
+
+#[test]
+fn refresh_course() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "refresh-course",
+        "--cache-path",
+        path,
+        "--cache-root",
+        path,
+        "--chgrp-uid",
+        "1234",
+        "--chmod-bits",
+        "1234",
+        "--clone-path",
+        path,
+        "--course-name",
+        "name",
+        "--exercise",
+        "name",
+        path,
+        "10,11,12",
+        "--exercise",
+        "second",
+        path,
+        "20,21,22",
+        "--git-branch",
+        "main",
+        "--no-background-operations",
+        "--no-directory-changes",
+        "--rails-root",
+        path,
+        "--solution-path",
+        path,
+        "--solution-zip-path",
+        path,
+        "--source-backend",
+        "git",
+        "--source-url",
+        "example.com",
+        "--stub-path",
+        path,
+        "--stub-zip-path",
+        path,
+    ]);
+}
+
+#[test]
+fn run_tests() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "run-tests",
+        "--checkstyle-output-path",
+        path,
+        "--exercise-path",
+        path,
+        "--locale",
+        "fi",
+        "--output-path",
+        path,
+    ]);
+}
+
+// settings in a separate file
+
+#[test]
+fn scan_exercise() {
+    let temp = NamedTempFile::new().unwrap();
+    let path = temp.path().to_str().unwrap();
+    run_assert_success(&[
+        "scan-exercise",
+        "--exercise-path",
+        path,
         "--output-path",
-        temp.path().join("zip.zip").to_str().unwrap(),
+        path,
     ]);
-    log::debug!("out:\n{}", String::from_utf8(out.stdout).unwrap());
-    log::debug!("err:\n{}", String::from_utf8(out.stderr).unwrap());
-    // TODO
 }