sloc-web 1.6.16

Axum web UI and REST API for interactive local SLOC analysis
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
139

// Tests for `sloc_web::bundle_run` — the shared entry point behind the CLI `bundle`
// command. Verifies the run directory + `result_<stem>.json` + `registry.json` are all
// created, and that the registry holds one entry whose `json_path` points at the written
// result file. This is the exact contract the local Compare / "Scan Delta" page relies on.

use chrono::Utc;
use sloc_config::AppConfig;
use sloc_core::{
    AnalysisRun, EnvironmentMetadata, ScanRegistry, SummaryTotals, ToolMetadata, read_json,
};

fn fixture_run(run_id: &str) -> AnalysisRun {
    AnalysisRun {
        tool: ToolMetadata {
            name: "oxide-sloc".into(),
            version: "test".into(),
            run_id: run_id.into(),
            timestamp_utc: Utc::now(),
        },
        environment: EnvironmentMetadata {
            operating_system: "linux".into(),
            architecture: "x86_64".into(),
            runtime_mode: "test".into(),
            initiator_username: "tester".into(),
            initiator_hostname: "ci".into(),
            ci_name: None,
        },
        effective_configuration: AppConfig::default(),
        input_roots: vec!["/tmp/myproject".into()],
        summary_totals: SummaryTotals {
            files_considered: 1,
            files_analyzed: 1,
            code_lines: 42,
            ..SummaryTotals::default()
        },
        totals_by_language: vec![],
        per_file_records: vec![],
        skipped_file_records: vec![],
        warnings: vec![],
        submodule_summaries: vec![],
        git_commit_short: Some("abc1234".into()),
        git_commit_long: Some("abc1234def5678".into()),
        git_branch: Some("main".into()),
        git_commit_author: Some("Tester".into()),
        git_tags: None,
        git_nearest_tag: None,
        git_commit_date: None,
        git_remote_url: None,
        style_summary: None,
        cocomo: None,
        uloc: 0,
        dryness_pct: None,
        duplicate_groups: vec![],
        duplicates_excluded: 0,
    }
}

#[test]
fn bundle_run_writes_layout_and_registers_entry() {
    let out_root = tempfile::tempdir().expect("tempdir");
    let run = fixture_run("run-1234");

    let run_dir = sloc_web::bundle_run(&run, out_root.path(), "run-1234", None)
        .expect("bundle_run should succeed");

    // The run directory follows the web convention: <project_label>_<run_id>.
    assert!(
        run_dir.is_dir(),
        "run dir must exist: {}",
        run_dir.display()
    );
    assert_eq!(
        run_dir.file_name().and_then(|s| s.to_str()),
        Some("myproject_run-1234"),
        "run dir name must be <project_label>_<run_id>"
    );

    // result_<stem>.json — stem is <label>_<git_commit_short>.
    let result_json = run_dir.join("json").join("result_myproject_abc1234.json");
    assert!(
        result_json.is_file(),
        "result JSON must exist at {}",
        result_json.display()
    );
    // It must round-trip as a valid AnalysisRun.
    let reloaded = read_json(&result_json).expect("result JSON must be a valid AnalysisRun");
    assert_eq!(reloaded.tool.run_id, "run-1234");

    // HTML report present too.
    assert!(
        run_dir
            .join("html")
            .join("report_myproject_abc1234.html")
            .is_file(),
        "HTML report must exist"
    );

    // registry.json created at the output root with exactly one entry pointing at the JSON.
    let registry_path = out_root.path().join("registry.json");
    assert!(registry_path.is_file(), "registry.json must exist");
    let registry = ScanRegistry::load(&registry_path);
    assert_eq!(registry.entries.len(), 1, "registry must hold one entry");
    let entry = &registry.entries[0];
    assert_eq!(entry.run_id, "run-1234");
    assert_eq!(entry.project_label, "myproject");
    assert_eq!(
        entry.json_path.as_deref(),
        Some(result_json.as_path()),
        "registry json_path must point at the written result file"
    );
    assert_eq!(entry.git_commit.as_deref(), Some("abc1234"));
    assert_eq!(entry.git_branch.as_deref(), Some("main"));
}

#[test]
fn bundle_run_label_override_and_generated_run_id() {
    let out_root = tempfile::tempdir().expect("tempdir");
    // No git commit -> file stem is just the label; explicit label overrides derivation.
    let mut run = fixture_run("");
    run.git_commit_short = None;

    let run_dir = sloc_web::bundle_run(&run, out_root.path(), "explicit-id", Some("My Service"))
        .expect("bundle_run should succeed");

    assert_eq!(
        run_dir.file_name().and_then(|s| s.to_str()),
        Some("my-service_explicit-id"),
        "label is sanitized and joined with the run id"
    );
    let result_json = run_dir.join("json").join("result_my-service.json");
    assert!(
        result_json.is_file(),
        "result JSON stem must be the sanitized label when no commit is known"
    );

    let registry = ScanRegistry::load(&out_root.path().join("registry.json"));
    assert_eq!(registry.entries.len(), 1);
    assert_eq!(registry.entries[0].run_id, "explicit-id");
}