flpdf-cli 0.8.0

Command-line tools for flpdf, mirroring qpdf inspection and rewrite subcommands.
//! Integration test: qpdf --json=2 vs flpdf --json=2 schema-diff over a curated
//! fixture corpus.

// The shared compatibility helpers are intentionally broader than this test;
// individual integration binaries consume different subsets of them.
#[allow(dead_code, unused_imports)]
mod support;

use std::path::{Path, PathBuf};

use support::json_diff::{
    compute_matrix, run_flpdf_json, run_qpdf_json, Allowlist, FixtureResult, Report,
};

struct FixtureSpec {
    label: &'static str,
    relative_path: &'static str,
    password: Option<&'static str>,
    compared_top_level_key: Option<&'static str>,
}

fn project_top_level_key(value: serde_json::Value, key: Option<&str>) -> serde_json::Value {
    let Some(key) = key else {
        return value;
    };
    let mut projected = serde_json::Map::new();
    if let serde_json::Value::Object(mut object) = value {
        if let Some(section) = object.remove(key) {
            projected.insert(key.to_string(), section);
        }
    }
    serde_json::Value::Object(projected)
}

const CORPUS: &[FixtureSpec] = &[
    FixtureSpec {
        label: "json-diff/direct-outlines.pdf",
        relative_path: "json-diff/direct-outlines.pdf",
        password: None,
        compared_top_level_key: Some("outlines"),
    },
    FixtureSpec {
        label: "minimal.pdf",
        relative_path: "minimal.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/one-page.pdf",
        relative_path: "compat/one-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/two-page.pdf",
        relative_path: "compat/two-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/three-page.pdf",
        relative_path: "compat/three-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/linearized-one-page.pdf",
        relative_path: "compat/linearized-one-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/attachment-two-page.pdf",
        relative_path: "compat/attachment-two-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/multi-contents-one-page.pdf",
        relative_path: "compat/multi-contents-one-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "compat/unref-resources-one-page.pdf",
        relative_path: "compat/unref-resources-one-page.pdf",
        password: None,
        compared_top_level_key: None,
    },
    // qdf-fix/qdf-golden/qdf-roundtrip: QDF-form PDFs (qpdf's debug output
    // format, re-parsed as PDFs). Cover diverse content trees and xref shapes.
    FixtureSpec {
        label: "qdf-fix/one-page-clean.qdf",
        relative_path: "qdf-fix/one-page-clean.qdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "qdf-golden/minimal.qdf",
        relative_path: "qdf-golden/minimal.qdf",
        password: None,
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "qdf-roundtrip/three-page-clean.qdf",
        relative_path: "qdf-roundtrip/three-page-clean.qdf",
        password: None,
        compared_top_level_key: None,
    },
    // SKIP: qdf-roundtrip/three-page-edited-payload.qdf — intentionally damaged
    // (qpdf reconstructs xref with warnings, flpdf rejects with "parse error
    // at byte 3: expected integer"). Schema-diff is not the right test
    // surface for repair-path divergence.
    // SKIP: qdf-fix/corrupt-*.qdf — all intentionally corrupted variants used
    // by the qdf-fix repair test; same reason as above.
    // Encrypted: AES-128 (V=4 R=4) and AES-256 (V=5 R=6). RC4 fixtures
    // require flpdf's --allow-weak-crypto flag, which the support module's
    // run_flpdf_json helper does not currently pass, so they are excluded.
    FixtureSpec {
        label: "encrypted/v4-aes-128-r4.pdf",
        relative_path: "encrypted/v4-aes-128-r4.pdf",
        password: Some("user-v4-aes"),
        compared_top_level_key: None,
    },
    FixtureSpec {
        label: "encrypted/v5-aes-256-r6.pdf",
        relative_path: "encrypted/v5-aes-256-r6.pdf",
        password: Some("user-v5-r6"),
        compared_top_level_key: None,
    },
];

fn workspace_fixtures_root() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures")
}

fn allowlist_path() -> PathBuf {
    workspace_fixtures_root().join("json-diff/allowed-divergences.json")
}

fn report_dir() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/json-diff")
}

#[test]
fn project_top_level_key_limits_a_fixture_to_its_oracle_section() {
    let full = serde_json::json!({
        "outlines": [{"title": "Chapter"}],
        "pagelabels": [{"index": 0}],
        "pages": [{"object": "3 0 R"}],
    });

    assert_eq!(
        project_top_level_key(full.clone(), Some("outlines")),
        serde_json::json!({"outlines": [{"title": "Chapter"}]})
    );
    assert_eq!(project_top_level_key(full.clone(), None), full);
}

#[test]
fn json_schema_diff_corpus() {
    if !support::is_qpdf_available() {
        eprintln!("skipping json_schema_diff_corpus: qpdf not on PATH");
        return;
    }

    let root = workspace_fixtures_root();
    let mut allowlist = Allowlist::from_path(&allowlist_path()).expect("allowlist load");

    let mut fixtures = Vec::new();
    for spec in CORPUS {
        let path = root.join(spec.relative_path);
        let qpdf_out = run_qpdf_json(&path, spec.password);
        let flpdf_out = run_flpdf_json(&path, spec.password);

        let (cells, qpdf_error, flpdf_error) = match (qpdf_out, flpdf_out) {
            (Ok(qv), Ok(fv)) => {
                let qv = project_top_level_key(qv, spec.compared_top_level_key);
                let fv = project_top_level_key(fv, spec.compared_top_level_key);
                (
                    compute_matrix(spec.label, &qv, &fv, &mut allowlist),
                    None,
                    None,
                )
            }
            (Err(qe), Ok(_)) => (vec![], Some(qe), None),
            (Ok(_), Err(fe)) => (vec![], None, Some(fe)),
            (Err(qe), Err(fe)) => (vec![], Some(qe), Some(fe)),
        };

        fixtures.push(FixtureResult {
            fixture: spec.label.to_string(),
            cells,
            qpdf_error,
            flpdf_error,
        });
    }

    let stale = allowlist
        .stale_entries()
        .into_iter()
        .cloned()
        .collect::<Vec<_>>();
    let report = Report {
        fixtures,
        stale_allowlist: stale,
    };

    let out_dir = report_dir();
    std::fs::create_dir_all(&out_dir).expect("create target/json-diff");
    std::fs::write(out_dir.join("report.md"), report.to_markdown())
        .expect("write target/json-diff/report.md");
    std::fs::write(out_dir.join("report.json"), report.to_json())
        .expect("write target/json-diff/report.json");

    let invocation_errors: Vec<String> = report
        .fixtures
        .iter()
        .flat_map(|f| {
            let mut v = vec![];
            if let Some(e) = &f.qpdf_error {
                v.push(format!("{}: qpdf: {e}", f.fixture));
            }
            if let Some(e) = &f.flpdf_error {
                v.push(format!("{}: flpdf: {e}", f.fixture));
            }
            v
        })
        .collect();
    assert!(
        invocation_errors.is_empty(),
        "tool errors:\n{}",
        invocation_errors.join("\n")
    );

    let unknown = report.unknown_divergences();
    assert!(
        unknown.is_empty(),
        "unknown divergences ({}):\n{}\n\nFull report at {}",
        unknown.len(),
        report.unknown_summary(),
        report_dir().join("report.md").display(),
    );

    assert!(
        report.stale_allowlist.is_empty(),
        "stale allowlist entries:\n{}",
        report.stale_summary(),
    );
}