xvc 0.7.0

An MLOps tool to manage data files and pipelines on top of Git
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

mod common;

use crate::common::{run_in_temp_dir, test_logging};
use std::collections::HashMap;
use std::fs;
use xvc_core::configuration::{
    blank_optional_config, default_config, initial_xvc_configuration_file, merge_configs,
    OptionalCoreConfig, OptionalGitConfig, XvcConfiguration, XvcOptionalConfiguration,
};

use xvc_core::XvcConfigResult as Result;

#[test]
fn test_default_config() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let config = default_config();
    assert_eq!(config.core.verbosity, "error");
    assert_eq!(config.git.use_git, true);
    assert_eq!(config.cache.algorithm, "blake3");
    assert_eq!(config.file.recheck.method, "copy");
    Ok(())
}

#[test]
fn test_blank_optional_config() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let opt_config = blank_optional_config();
    assert!(opt_config.core.is_none());
    assert!(opt_config.git.is_none());
    assert!(opt_config.cache.is_none());
    assert!(opt_config.file.is_none());
    assert!(opt_config.pipeline.is_none());
    assert!(opt_config.check_ignore.is_none());
    Ok(())
}

#[test]
fn test_merge_configs() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let base_config = default_config();
    let mut opt_config = blank_optional_config();
    opt_config.core = Some(OptionalCoreConfig {
        verbosity: Some("debug".to_string()),
        ..Default::default()
    });
    opt_config.git = Some(OptionalGitConfig {
        use_git: Some(false),
        ..Default::default()
    });

    let merged_config = merge_configs(&base_config, &opt_config);

    assert_eq!(merged_config.core.verbosity, "debug");
    assert_eq!(merged_config.git.use_git, false);
    // Unchanged value
    assert_eq!(merged_config.cache.algorithm, base_config.cache.algorithm);
    Ok(())
}

#[test]
fn test_from_hash_map() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let mut values = HashMap::new();
    values.insert("CORE.VERBOSITY".to_string(), "info".to_string());
    values.insert("GIT.USE_GIT".to_string(), "false".to_string());
    values.insert("CACHE.ALGORITHM".to_string(), "sha2".to_string());
    values.insert("UNKNOWN.KEY".to_string(), "some_value".to_string());

    let opt_config = XvcOptionalConfiguration::from_hash_map("", &values);

    assert_eq!(
        opt_config.core.unwrap().verbosity.unwrap(),
        "info".to_string()
    );
    assert_eq!(opt_config.git.unwrap().use_git.unwrap(), false);
    assert_eq!(
        opt_config.cache.unwrap().algorithm.unwrap(),
        "sha2".to_string()
    );

    Ok(())
}

#[test]
fn test_config_from_file() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let temp_dir = run_in_temp_dir();
    let config_path = temp_dir.join("test.toml");

    let toml_content = r#"

[core]
verbosity = "debug"

[git]
use_git = false
"#;

    fs::write(&config_path, toml_content)?;

    let opt_config = XvcOptionalConfiguration::from_file(&config_path)?;
    assert_eq!(
        opt_config.core.unwrap().verbosity.unwrap(),
        "debug".to_string()
    );
    assert_eq!(opt_config.git.unwrap().use_git.unwrap(), false);

    // Test full configuration loading
    let full_toml_content = toml::to_string(&default_config()).unwrap();
    let full_config_path = temp_dir.join("full.toml");
    fs::write(&full_config_path, full_toml_content)?;

    let full_config = XvcConfiguration::from_file(&full_config_path)?;
    assert_eq!(full_config.core.verbosity, "error");

    fs::remove_dir_all(temp_dir)?;
    Ok(())
}

#[test]
fn test_initial_xvc_config() -> Result<()> {
    test_logging(log::LevelFilter::Trace);
    let base_config = default_config();
    let mut user_options = blank_optional_config();
    user_options.core = Some(OptionalCoreConfig {
        verbosity: Some("info".to_string()),
        ..Default::default()
    });

    let config = merge_configs(&base_config, &user_options);

    let config_str = initial_xvc_configuration_file(&config)?;

    assert!(config_str.contains("verbosity = \"info\""));
    assert!(config_str.contains("use_git = true")); // from default

    Ok(())
}