bibsync 0.3.3

A Rust package to automatically resolve, synchronize, and validate LaTeX citations across BibTeX databases
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

//! Integration tests for the command-line interface.

use assert_cmd::Command;
use predicates::prelude::predicate;
use tempfile::tempdir;

#[test]
fn cli_requires_input_files() {
    let mut command = Command::cargo_bin("bibsync").expect("binary exists");

    command
        .assert()
        .failure()
        .stderr(predicate::str::contains("at least one TeX file"));
}

#[test]
fn cli_prints_pre_commit_hook_manifest() {
    let mut command = Command::cargo_bin("bibsync").expect("binary exists");

    command
        .arg("--print-pre-commit-hook")
        .assert()
        .success()
        .stdout(predicate::str::contains("id: bibsync"))
        .stdout(predicate::str::contains("entry: bibsync"));
}

#[test]
fn cli_defaults_to_check_mode() {
    let dir = tempdir().expect("tempdir");
    let tex = dir.path().join("main.tex");
    let bib = dir.path().join("refs.bib");
    std::fs::write(&tex, "\\cite{NotAnIdentifier}\n\\bibliography{refs}").expect("write tex");
    std::fs::write(&bib, "").expect("write bib");

    let mut command = Command::cargo_bin("bibsync").expect("binary exists");
    command
        .arg("--provider")
        .arg("inspire")
        .arg("--output")
        .arg(&bib)
        .arg(&tex)
        .assert()
        .failure()
        .stdout(predicate::str::contains("unresolved:"))
        .stdout(predicate::str::contains(
            "NotAnIdentifier: unsupported identifier format",
        ));
}

#[test]
fn cli_reports_missing_ignore_file() {
    let dir = tempdir().expect("tempdir");
    let tex = dir.path().join("main.tex");
    let bib = dir.path().join("refs.bib");
    let ignore = dir.path().join(".bibsyncignore");
    std::fs::write(&tex, "\\cite{NotAnIdentifier}").expect("write tex");

    let mut command = Command::cargo_bin("bibsync").expect("binary exists");
    command
        .arg("--output")
        .arg(&bib)
        .arg("--ignore-file")
        .arg(&ignore)
        .arg(&tex)
        .assert()
        .failure()
        .stderr(predicate::str::contains("ignore file not found"))
        .stderr(predicate::str::contains(ignore.display().to_string()));
}

#[test]
fn cli_reports_malformed_bibtex() {
    let dir = tempdir().expect("tempdir");
    let bib = dir.path().join("refs.bib");
    std::fs::write(&bib, "@article{broken,\n  title = {Missing close}\n")
        .expect("write malformed bib");

    let mut command = Command::cargo_bin("bibsync").expect("binary exists");
    command
        .arg(&bib)
        .assert()
        .failure()
        .stderr(predicate::str::contains("invalid BibTeX"))
        .stderr(predicate::str::contains("missing a closing"));
}

#[test]
fn cli_rejects_check_with_fix() {
    let mut command = Command::cargo_bin("bibsync").expect("binary exists");

    command
        .arg("--check")
        .arg("--fix")
        .arg("example.tex")
        .assert()
        .failure()
        .stderr(predicate::str::contains("cannot be used with"));
}

#[test]
fn cli_exposes_cache_flags() {
    let mut command = Command::cargo_bin("bibsync").expect("binary exists");

    command
        .arg("--help")
        .assert()
        .success()
        .stdout(predicate::str::contains("--cache"))
        .stdout(predicate::str::contains("--refresh-cache"))
        .stdout(predicate::str::contains("--cache-dir"));
}