bambam 0.3.1

The Behavior and Advanced Mobility Big Access Model
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

use bambam::model::builders;
use clap::Parser;
use routee_compass::app::cli::cli_args::CliArgs;
use routee_compass::app::compass::CompassBuilderInventory;
inventory::submit! { builders::BUILDER_REGISTRATION }

fn main() {
    env_logger::init();

    log::debug!("cwd: {:?}", std::env::current_dir());
    let args = CliArgs::parse();
    // let args = CliArgs {
    //     config_file: String::from("test.toml"),
    //     query_file: String::from("test.json"),
    //     chunksize: None,
    //     newline_delimited: false,
    // };
    let builder = CompassBuilderInventory::new().expect("failed to load compass app builder");
    match routee_compass::app::cli::run::command_line_runner(&args, Some(builder), None) {
        Ok(_) => {}
        Err(e) => log::error!("{e}"),
    }
}

#[cfg(test)]
mod test {
    use routee_compass::app::{
        cli::cli_args::CliArgs,
        compass::{CompassApp, CompassAppError, CompassJsonExtensions},
    };
    use serde_json::Value;
    use std::{
        fs::File,
        io::BufReader,
        path::{Path, PathBuf},
    };

    #[test]
    fn test_e2e_denver() {
        let conf_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .parent()
            .expect("test invariant failed: repo 'rust/bambam' dir has no parent")
            .parent()
            .expect("test invariant failed: repo 'rust' dir has no parent")
            .join("configuration")
            .join("test_denver.toml");
        let query_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .parent()
            .expect("test invariant failed: repo 'rust/bambam' dir has no parent")
            .parent()
            .expect("test invariant failed: repo 'rust' dir has no parent")
            .join("query")
            .join("denver_extent.json");
        let conf_file = conf_path
            .to_str()
            .expect("test invariant failed: config file path cannot be a string");
        let query_file = query_path
            .to_str()
            .expect("test invariant failed: config file path cannot be a string");

        let args = CliArgs {
            config_file: conf_file.to_string(),
            query_file: query_file.to_string(),
            chunksize: None,
            newline_delimited: false,
            parallelism: None,
            output_directory: None,
        };
        let expected_grid_size = 48;

        match test_run_bambam(args) {
            Ok(rows) => {
                for (idx, row) in rows.iter().enumerate() {
                    if let Some(error) = row.get("error") {
                        panic!(
                            "row {idx} has error: {}",
                            serde_json::to_string_pretty(error).unwrap_or_default()
                        );
                    }
                }
                assert_eq!(rows.len(), expected_grid_size);
            }
            Err(e) => panic!("test failed: {e}"),
        }
    }

    /// runs bambam for test cases and expects a Vec<Value> result.
    /// <foot-shooting-clause>
    ///     this test runner is only here because there is no equivalent runner
    ///     in routee-compass. it also makes the assumption that the query dataset is
    ///     NOT newline-delimited.
    /// </foot-shooting-clause>
    fn test_run_bambam(args: CliArgs) -> Result<Vec<Value>, CompassAppError> {
        log::info!("starting app at {}", chrono::Local::now().to_rfc3339());
        let config_path = Path::new(&args.config_file);
        let app = CompassApp::try_from(config_path)?;
        let query_filename = &args.query_file;
        let query_file = File::open(query_filename).map_err(|e| {
            CompassAppError::BuildFailure(format!(
                "failure reading input query file '{query_filename}': {e}"
            ))
        })?;
        let reader = BufReader::new(query_file);
        let user_json: serde_json::Value = serde_json::from_reader(reader)?;
        let mut user_queries = user_json.get_queries()?;
        app.run(&mut user_queries, None)
    }
}