rimrs 0.1.4

RimWorld mod manager
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

use rimrs::{validate, Dependency, ModList, ModMetaData, ModsConfig, RimPyConfig};
use std::{
    collections::{HashMap, HashSet},
    sync::{Arc, Mutex},
};

fn generate_mod_meta_data() -> Arc<Mutex<HashMap<String, ModMetaData>>> {
    let mut mmd = HashMap::new();

    mmd.insert(
        String::from("a"),
        ModMetaData {
            loadBefore: Some(HashSet::from_iter(vec![String::from("c")])),
            ..Default::default()
        },
    );
    mmd.insert(
        String::from("b"),
        ModMetaData {
            modDependencies: Some(HashSet::from_iter(vec![Dependency {
                packageId: Some(String::from("a")),
                ..Default::default()
            }])),
            ..Default::default()
        },
    );
    mmd.insert(String::from("c"), ModMetaData::default());
    mmd.insert(
        String::from("d"),
        ModMetaData {
            loadAfter: Some(HashSet::from_iter(vec![String::from("c")])),
            ..Default::default()
        },
    );
    mmd.insert(
        String::from("e"),
        ModMetaData {
            incompatibleWith: Some(HashSet::from_iter(vec![String::from("b")])),
            ..Default::default()
        },
    );

    Arc::new(Mutex::new(mmd))
}

macro_rules! validate {
    ($x:expr) => {{
        let mmd = generate_mod_meta_data();
        validate(&mmd, $x)
    }};
}

#[test]
fn empty() {
    let res = validate!(&[]);
    assert!(res.is_ok());
}

#[test]
fn no_mod_metadata() {
    let res = validate!(&[String::from("z")]);
    assert!(res.is_warn());
    assert_eq!(
        res.warnings().unwrap(),
        &vec![String::from("Couldn't find metadata for z")]
    );
}

#[test]
fn all_in_order() {
    let res = validate!(&[
        String::from("a"),
        String::from("b"),
        String::from("c"),
        String::from("d")
    ]);
    assert!(res.is_ok());
}

#[test]
fn hard_dependency_missing() {
    let res = validate!(&[String::from("b"), String::from("c")]);
    assert!(res.is_err());
    assert_eq!(res.errors().unwrap(), &vec![String::from("b requires a")]);
}

#[test]
fn load_after_wrong_order() {
    let res = validate!(&[String::from("d"), String::from("c")]);
    assert!(res.is_warn());
    assert_eq!(
        res.warnings().unwrap(),
        &vec![String::from("d should be loaded after c")]
    );
}

#[test]
fn load_before_wrong_order() {
    let res = validate!(&[String::from("c"), String::from("a")]);
    assert!(res.is_warn());
    assert_eq!(
        res.warnings().unwrap(),
        &vec![String::from("a should be loaded before c")]
    );
}

#[test]
fn incompatible() {
    let res = validate!(&[String::from("e"), String::from("b")]);
    assert!(res.is_err());
    assert_eq!(
        res.errors().unwrap(),
        &vec![
            String::from("b requires a"),
            String::from("e is incompatible with b")
        ]
    );
}

/// Reads mod list from disk then validates it.
///
/// `cargo test full_test --test mod_list_validation -- --ignored --nocapture`
#[test]
#[ignore]
fn full_test() {
    let rimpy_config = RimPyConfig::from_file().unwrap();
    let mod_list = ModList::try_from(&rimpy_config).unwrap();
    let mmd = &mod_list.mods;

    let mut mods_config_path = rimpy_config.folders.config_folder.unwrap();
    mods_config_path.push("ModsConfig.xml");
    let mods_config = ModsConfig::try_from(mods_config_path.as_path()).unwrap();
    let active_mods = &mods_config.activeMods;

    let res = validate(mmd, active_mods);

    println!("res: {res:?}");
}