rsconstruct 0.9.85

Rust based fast build system
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
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::common::run_rsconstruct_with_env;
use std::fs;
use tempfile::TempDir;

/// Baseline: imports get derived to a sorted requirements.txt.
#[test]
fn requirements_derives_from_imports() {
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let project_path = temp_dir.path();

    fs::write(
        project_path.join("rsconstruct.toml"),
        "[processor.requirements]\nsrc_dirs = [\".\"]\n",
    )
    .unwrap();

    fs::write(
        project_path.join("app.py"),
        "import requests\nimport flask\n",
    )
    .unwrap();

    let output = run_rsconstruct_with_env(project_path, &["build"], &[("NO_COLOR", "1")]);
    assert!(
        output.status.success(),
        "Build should succeed: stdout={}, stderr={}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );

    let req = fs::read_to_string(project_path.join("requirements.txt")).unwrap();
    assert!(req.contains("flask"), "expected flask in output: {}", req);
    assert!(
        req.contains("requests"),
        "expected requests in output: {}",
        req
    );
}

/// `extra` adds distributions that no `import` references — the use case
/// is upstream packages that need a runtime dep at import time but fail
/// to declare it in their metadata (e.g. `manim_voiceover` needing
/// `setuptools` for `import pkg_resources`).
#[test]
fn requirements_extra_adds_undeclared_dep() {
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let project_path = temp_dir.path();

    fs::write(
        project_path.join("rsconstruct.toml"),
        "[processor.requirements]\n\
         src_dirs = [\".\"]\n\
         extra = [\"setuptools\"]\n",
    )
    .unwrap();

    // Note: no `import setuptools` anywhere — that's the whole point.
    fs::write(project_path.join("app.py"), "import flask\n").unwrap();

    let output = run_rsconstruct_with_env(project_path, &["build"], &[("NO_COLOR", "1")]);
    assert!(
        output.status.success(),
        "Build should succeed: stdout={}, stderr={}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );

    let req = fs::read_to_string(project_path.join("requirements.txt")).unwrap();
    assert!(
        req.contains("setuptools"),
        "extra=[setuptools] should appear in requirements.txt even though no import references it: {}",
        req
    );
    assert!(
        req.contains("flask"),
        "import-derived flask should still appear: {}",
        req
    );
}

/// `extra` should bypass `exclude` — exclude operates on import names of
/// scanned imports, while extras are distributions explicitly asserted by
/// the user. Listing both is a nonsense config; the user-asserted one wins.
#[test]
fn requirements_extra_bypasses_exclude() {
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let project_path = temp_dir.path();

    fs::write(
        project_path.join("rsconstruct.toml"),
        "[processor.requirements]\n\
         src_dirs = [\".\"]\n\
         exclude = [\"setuptools\"]\n\
         extra = [\"setuptools\"]\n",
    )
    .unwrap();

    fs::write(project_path.join("app.py"), "import flask\n").unwrap();

    let output = run_rsconstruct_with_env(project_path, &["build"], &[("NO_COLOR", "1")]);
    assert!(output.status.success());

    let req = fs::read_to_string(project_path.join("requirements.txt")).unwrap();
    assert!(
        req.contains("setuptools"),
        "extra should bypass exclude: {}",
        req
    );
}

/// Adding something to `extra` is a config change that should invalidate
/// the cache and trigger a rebuild — `extra` must be in checksum_fields.
#[test]
fn requirements_extra_change_triggers_rebuild() {
    let temp_dir = TempDir::new().expect("Failed to create temp dir");
    let project_path = temp_dir.path();

    fs::write(
        project_path.join("rsconstruct.toml"),
        "[processor.requirements]\nsrc_dirs = [\".\"]\n",
    )
    .unwrap();
    fs::write(project_path.join("app.py"), "import flask\n").unwrap();

    let out1 = run_rsconstruct_with_env(project_path, &["build"], &[("NO_COLOR", "1")]);
    assert!(out1.status.success());
    let req1 = fs::read_to_string(project_path.join("requirements.txt")).unwrap();
    assert!(
        !req1.contains("setuptools"),
        "round 1 should not have setuptools: {}",
        req1
    );

    // Now add extra — the config hash should change, forcing a rebuild.
    fs::write(
        project_path.join("rsconstruct.toml"),
        "[processor.requirements]\n\
         src_dirs = [\".\"]\n\
         extra = [\"setuptools\"]\n",
    )
    .unwrap();

    let out2 = run_rsconstruct_with_env(project_path, &["build"], &[("NO_COLOR", "1")]);
    assert!(out2.status.success());
    let req2 = fs::read_to_string(project_path.join("requirements.txt")).unwrap();
    assert!(
        req2.contains("setuptools"),
        "round 2 should pick up the new extra: {}",
        req2
    );
}