ruslings project

rustlings/tests/fixture/failure/compFailure.rs

@@ -0,0 +1,3 @@
+fn main() {
+    let
+}

rustlings/tests/fixture/failure/compNoExercise.rs

@@ -0,0 +1,2 @@
+fn main() {
+}

rustlings/tests/fixture/failure/info.toml

@@ -0,0 +1,11 @@
+[[exercises]]
+name = "compFailure"
+path = "compFailure.rs"
+mode = "compile"
+hint = ""
+
+[[exercises]]
+name = "testFailure"
+path = "testFailure.rs"
+mode = "test"
+hint = "Hello!"

rustlings/tests/fixture/failure/testFailure.rs

@@ -0,0 +1,4 @@
+#[test]
+fn passing() {
+    asset!(true);
+}

rustlings/tests/fixture/failure/testNotPassed.rs

@@ -0,0 +1,4 @@
+#[test]
+fn not_passing() {
+    assert!(false);
+}

rustlings/tests/fixture/state/finished_exercise.rs

@@ -0,0 +1,5 @@
+// fake_exercise
+
+fn main() {
+
+}

rustlings/tests/fixture/state/info.toml

@@ -0,0 +1,18 @@
+[[exercises]]
+name = "pending_exercise"
+path = "pending_exercise.rs"
+mode = "compile"
+hint = """"""
+
+[[exercises]]
+name = "pending_test_exercise"
+path = "pending_test_exercise.rs"
+mode = "test"
+hint = """"""
+
+[[exercises]]
+name = "finished_exercise"
+path = "finished_exercise.rs"
+mode = "compile"
+hint = """"""
+

rustlings/tests/fixture/state/pending_exercise.rs

@@ -0,0 +1,7 @@
+// fake_exercise
+
+// I AM NOT DONE
+
+fn main() {
+
+}

rustlings/tests/fixture/state/pending_test_exercise.rs

@@ -0,0 +1,4 @@
+// I AM NOT DONE
+
+#[test]
+fn it_works() {}

rustlings/tests/fixture/success/compSuccess.rs

@@ -0,0 +1,2 @@
+fn main() {
+}

rustlings/tests/fixture/success/info.toml

@@ -0,0 +1,11 @@
+[[exercises]]
+name = "compSuccess"
+path = "compSuccess.rs"
+mode = "compile"
+hint = """"""
+
+[[exercises]]
+name = "testSuccess"
+path = "testSuccess.rs"
+mode = "test"
+hint = """"""

rustlings/tests/fixture/success/testSuccess.rs

@@ -0,0 +1,5 @@
+#[test]
+fn passing() {
+    println!("THIS TEST TOO SHALL PASS");
+    assert!(true);
+}

rustlings/tests/integration_tests.rs

@@ -0,0 +1,269 @@
+use assert_cmd::prelude::*;
+use glob::glob;
+use predicates::boolean::PredicateBooleanExt;
+use std::fs::File;
+use std::io::Read;
+use std::process::Command;
+
+#[test]
+fn runs_without_arguments() {
+    let mut cmd = Command::cargo_bin("rustlings").unwrap();
+    cmd.assert().success();
+}
+
+#[test]
+fn fails_when_in_wrong_dir() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .current_dir("tests/")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn verify_all_success() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .arg("verify")
+        .current_dir("tests/fixture/success")
+        .assert()
+        .success();
+}
+
+#[test]
+fn verify_fails_if_some_fails() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .arg("verify")
+        .current_dir("tests/fixture/failure")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn run_single_compile_success() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "compSuccess"])
+        .current_dir("tests/fixture/success/")
+        .assert()
+        .success();
+}
+
+#[test]
+fn run_single_compile_failure() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "compFailure"])
+        .current_dir("tests/fixture/failure/")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn run_single_test_success() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "testSuccess"])
+        .current_dir("tests/fixture/success/")
+        .assert()
+        .success();
+}
+
+#[test]
+fn run_single_test_failure() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "testFailure"])
+        .current_dir("tests/fixture/failure/")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn run_single_test_not_passed() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "testNotPassed.rs"])
+        .current_dir("tests/fixture/failure/")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn run_single_test_no_filename() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .arg("run")
+        .current_dir("tests/fixture/")
+        .assert()
+        .code(2)
+        .stderr(predicates::str::contains(
+            "required arguments were not provided",
+        ));
+}
+
+#[test]
+fn run_single_test_no_exercise() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "compNoExercise.rs"])
+        .current_dir("tests/fixture/failure")
+        .assert()
+        .code(1);
+}
+
+#[test]
+fn reset_single_exercise() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["reset", "intro1"])
+        .assert()
+        .code(0);
+}
+
+#[test]
+fn reset_no_exercise() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .arg("reset")
+        .assert()
+        .code(2)
+        .stderr(predicates::str::contains(
+            "required arguments were not provided",
+        ));
+}
+
+#[test]
+fn get_hint_for_single_test() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["hint", "testFailure"])
+        .current_dir("tests/fixture/failure")
+        .assert()
+        .code(0)
+        .stdout("Hello!\n");
+}
+
+#[test]
+fn all_exercises_require_confirmation() {
+    for exercise in glob("exercises/**/*.rs").unwrap() {
+        let path = exercise.unwrap();
+        if path.file_name().unwrap() == "mod.rs" {
+            continue;
+        }
+        let source = {
+            let mut file = File::open(&path).unwrap();
+            let mut s = String::new();
+            file.read_to_string(&mut s).unwrap();
+            s
+        };
+        source
+            .matches("// I AM NOT DONE")
+            .next()
+            .unwrap_or_else(|| {
+                panic!(
+                    "There should be an `I AM NOT DONE` annotation in {:?}",
+                    path
+                )
+            });
+    }
+}
+
+#[test]
+fn run_compile_exercise_does_not_prompt() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "pending_exercise"])
+        .current_dir("tests/fixture/state")
+        .assert()
+        .code(0)
+        .stdout(predicates::str::contains("I AM NOT DONE").not());
+}
+
+#[test]
+fn run_test_exercise_does_not_prompt() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "pending_test_exercise"])
+        .current_dir("tests/fixture/state")
+        .assert()
+        .code(0)
+        .stdout(predicates::str::contains("I AM NOT DONE").not());
+}
+
+#[test]
+fn run_single_test_success_with_output() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["--nocapture", "run", "testSuccess"])
+        .current_dir("tests/fixture/success/")
+        .assert()
+        .code(0)
+        .stdout(predicates::str::contains("THIS TEST TOO SHALL PASS"));
+}
+
+#[test]
+fn run_single_test_success_without_output() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["run", "testSuccess"])
+        .current_dir("tests/fixture/success/")
+        .assert()
+        .code(0)
+        .stdout(predicates::str::contains("THIS TEST TOO SHALL PASS").not());
+}
+
+#[test]
+fn run_rustlings_list() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["list"])
+        .current_dir("tests/fixture/success")
+        .assert()
+        .success();
+}
+
+#[test]
+fn run_rustlings_list_no_pending() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["list"])
+        .current_dir("tests/fixture/success")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains("Pending").not());
+}
+
+#[test]
+fn run_rustlings_list_both_done_and_pending() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["list"])
+        .current_dir("tests/fixture/state")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains("Done").and(predicates::str::contains("Pending")));
+}
+
+#[test]
+fn run_rustlings_list_without_pending() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["list", "--solved"])
+        .current_dir("tests/fixture/state")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains("Pending").not());
+}
+
+#[test]
+fn run_rustlings_list_without_done() {
+    Command::cargo_bin("rustlings")
+        .unwrap()
+        .args(["list", "--unsolved"])
+        .current_dir("tests/fixture/state")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains("Done").not());
+}