autograde-rs 0.1.0

Run test cases vs. expected output
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#![allow(unused)]

use std::env::current_dir;
use std::fs::read_to_string;
use std::path::PathBuf;
use std::str::FromStr;

use anyhow::Context;
use clap::{Parser, Subcommand};
use log::{debug, info};
use miette::WrapErr;

use autograde_rs::build::make;
use autograde_rs::config::Config;
use autograde_rs::unit::TestUnits;

#[derive(Parser, Debug)]
struct Args {
    #[command(subcommand)]
    command: Command,
    #[arg(short, long)]
    project_path: Option<String>,
    // #[arg(short, long)]
    // tests_path: Option<String>,
}

#[derive(Subcommand, Debug)]
enum Command {
    /// Run the test case(s) for the current project
    Test {
        #[arg(short, long)]
        tests_path: Option<String>,
    },
    // Configure,
}

// tokio bug https://github.com/tokio-rs/tokio/pull/6874
#[allow(clippy::needless_return)]
#[tokio::main]
async fn main() -> miette::Result<()> {
    env_logger::init();

    match Args::parse().command {
        Command::Test { tests_path } => {
            let config = Config::read_or_create().unwrap();
            let config_test = config
                .test
                .clone()
                .context("Config file missing test section!")
                .unwrap();

            let tests_path = if let Some(u) = tests_path {
                u
            } else {
                config_test
                    .tests_path
                    .clone()
                    .context("Could not find test_path in config file!")
                    .unwrap()
            };

            let digital_path = config_test.digital_path();
            info!("Digital JAR path: {:?}", digital_path);

            // make().await?;

            // `foo-bar` project directory implies `bar` executable name
            let project_dir = current_dir().unwrap();
            let project_exec = project_dir
                .file_name()
                .unwrap()
                .to_str()
                .map(|s| s.split('-').next().unwrap_or(s))
                .expect("EXECUTABLE NAME");
            info!("project executable name: {}", project_exec);

            // TODO support tilde expansion
            // TODO search pwd/parents for tests dir
            let mut tests_path = PathBuf::from_str(&tests_path)
                .with_context(|| format!("Invalid path! {}", tests_path))
                .unwrap();
            tests_path.push(project_exec);
            tests_path.push(project_exec);
            tests_path.set_extension("toml");
            info!("test path: {:?}", tests_path);

            // TODO move to tests.rs
            let tests_file = read_to_string(&tests_path).unwrap();
            let mut tests: TestUnits = toml::from_str(&tests_file)
                .with_context(|| format!("Could not parse tests at {}!", tests_path.display()))
                .unwrap();

            tests.tests.iter_mut().for_each(|test| {
                match test.interpolate_config(&config, project_exec) {
                    Ok(_) => {
                        info!("Interpolation succeeded!");
                    }
                    Err(e) => {
                        panic!("Interpolation failed: {}", e);
                    }
                }
            });
            debug!(
                "parsed and interpolated test units:
                {:#?}",
                tests
            );

            // TODO auto pull
            let grade = tests.run().await?;
            info!("grade: {}", grade);
        }
    }

    Ok(())
}