xberg-cli 1.2.8

Command-line interface for Xberg document intelligence
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

#[cfg(feature = "ocr-surface")]
use super::super::*;
#[cfg(feature = "ocr-surface")]
use super::default_overrides;
#[cfg(feature = "ocr-surface")]
use xberg::ExtractionConfig;

#[cfg(feature = "ocr-surface")]
#[test]
fn should_enable_ocr_when_cli_true_overrides_loaded_disable() {
    let mut config = ExtractionConfig {
        disable_ocr: true,
        ..ExtractionConfig::default()
    };
    let overrides = ExtractionOverrides {
        ocr: Some(true),
        ..default_overrides()
    };

    overrides.apply(&mut config);

    assert!(
        !config.disable_ocr,
        "explicit --ocr true should override loaded disable_ocr=true"
    );
    assert!(config.ocr.expect("--ocr true should configure OCR").enabled);
}

#[cfg(feature = "ocr-surface")]
#[test]
fn should_preserve_loaded_disable_ocr_when_ocr_flag_is_absent() {
    let mut config = ExtractionConfig {
        disable_ocr: true,
        ..ExtractionConfig::default()
    };

    default_overrides().apply(&mut config);

    assert!(config.disable_ocr, "an absent OCR flag should preserve loaded config");
}

#[cfg(feature = "ocr-surface")]
#[test]
fn should_clear_loaded_ocr_routing_when_cli_false_hard_disables_ocr() {
    let mut config = ExtractionConfig {
        force_ocr: true,
        ocr_strategy: xberg::OcrStrategy::ScannedPages { min_confidence: 0.8 },
        force_ocr_pages: Some(vec![2, 4]),
        ..ExtractionConfig::default()
    };
    let overrides = ExtractionOverrides {
        ocr: Some(false),
        ..default_overrides()
    };

    overrides.apply(&mut config);

    assert!(!config.force_ocr, "--ocr false should override loaded force_ocr=true");
    assert_eq!(config.ocr_strategy, xberg::OcrStrategy::Auto);
    assert!(
        config.force_ocr_pages.is_none(),
        "--ocr false should clear forced page selection"
    );
}

#[cfg(feature = "ocr-surface")]
#[test]
fn should_reject_ocr_false_with_force_ocr_true() {
    let overrides = ExtractionOverrides {
        ocr: Some(false),
        force_ocr: Some(true),
        ..default_overrides()
    };

    assert_eq!(
        overrides
            .validate()
            .expect_err("disabling and forcing OCR should conflict")
            .to_string(),
        "--ocr false cannot be combined with --force-ocr true"
    );
}

#[cfg(feature = "ocr-surface")]
#[test]
fn should_reject_ocr_false_with_scanned_pages() {
    let overrides = ExtractionOverrides {
        ocr: Some(false),
        ocr_scanned_pages: true,
        ..default_overrides()
    };

    assert_eq!(
        overrides
            .validate()
            .expect_err("disabling OCR and selecting scanned pages should conflict")
            .to_string(),
        "--ocr false cannot be combined with --ocr-scanned-pages"
    );
}

#[cfg(feature = "ocr-surface")]
#[test]
fn should_reject_contradictory_ocr_and_disable_ocr_values() {
    for (ocr, disable_ocr) in [(true, true), (false, false)] {
        let overrides = ExtractionOverrides {
            ocr: Some(ocr),
            disable_ocr: Some(disable_ocr),
            ..default_overrides()
        };

        assert_eq!(
            overrides
                .validate()
                .expect_err("contradictory OCR flags should be rejected")
                .to_string(),
            "--ocr and --disable-ocr specify contradictory values"
        );
    }
}

#[cfg(feature = "ocr-surface")]
#[test]
fn test_validate_invalid_ocr_backend() {
    let overrides = ExtractionOverrides {
        ocr_backend: Some("invalid-backend".to_string()),
        ..default_overrides()
    };
    let err = overrides.validate().unwrap_err();
    assert!(err.to_string().contains("Invalid OCR backend"));
}

#[cfg(feature = "ocr-surface")]
#[test]
fn test_validate_valid_ocr_backends() {
    for backend in &["tesseract", "paddle-ocr", "sceptre"] {
        let overrides = ExtractionOverrides {
            ocr_backend: Some(backend.to_string()),
            ..default_overrides()
        };
        assert!(overrides.validate().is_ok(), "Expected backend '{backend}' to be valid");
    }
}