alef 0.71.0

Opinionated polyglot binding generator for Rust libraries
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

//! Golden vectors pinning the stamp recipe to its recorded revision.
//!
//! Every `alef:hash:` value in every consumer repo is a function of the recipe in
//! [`super::compute_inputs_hash`] and [`super::compute_file_hash`]: the domain separators,
//! the field order, the `alef.toml` normalization, and
//! [`crate::core::template_versions::precommit::CODEGEN_FORMAT_VERSION`]. That constant is
//! the *recorded revision* of the recipe -- it is folded into `inputs_hash`, so bumping it
//! re-derives every stamp in the wild, and its doc carries the bump policy.
//!
//! What was missing was anything mechanical tying the recipe to the revision. A change to
//! the framing -- reordering two `update` calls, renaming a separator, adjusting the TOML
//! normalization -- silently invalidates every stamp ever written while every existing test
//! stays green, because they all compare the recipe against itself. The consumer then sees
//! files reported stale with no code change that explains it, which is exactly the
//! diagnosis that cost this investigation its first hours.
//!
//! These vectors are that tripwire. Editing the recipe fails them, and the only correct way
//! to make them pass is to recompute the vectors *and* bump `CODEGEN_FORMAT_VERSION` in the
//! same commit -- which is what makes the invalidation deliberate and dated rather than
//! silent. They are not a second implementation of the hash: a re-derivation would move in
//! lockstep with the code it is meant to pin. ~keep

use super::{compute_file_hash, compute_inputs_hash};
use crate::core::template_versions::precommit::CODEGEN_FORMAT_VERSION;

const FIXTURE_SOURCES_HASH: &str = "0000000000000000000000000000000000000000000000000000000000000000";
const FIXTURE_ALEF_TOML: &[u8] = b"[workspace]\nlanguages = [\"python\"]\n";
const FIXTURE_FILE_BODY: &str = "fn fixture() {}\n";

/// The revision the vectors below were computed under. Asserted separately so a bump without
/// recomputed vectors, and recomputed vectors without a bump, both fail loudly. ~keep
const PINNED_CODEGEN_FORMAT_VERSION: &str = "2";

const GOLDEN_INPUTS_HASH: &str = "2aa40c183b09b9c8cb986ff8120d0a3a665b5ed82962149f2abf8856866df57c";
const GOLDEN_FILE_HASH: &str = "59ce25fe68a99c6e95ef5ee2fc47f31be1303ba8a755531c4b905afa591bde8a";

#[test]
fn inputs_hash_recipe_matches_its_recorded_revision() {
    assert_eq!(
        CODEGEN_FORMAT_VERSION, PINNED_CODEGEN_FORMAT_VERSION,
        "CODEGEN_FORMAT_VERSION is the recorded revision of the stamp recipe; bumping it \
         re-derives every alef:hash: value in every consumer repo, so the golden vectors in \
         this file must be recomputed in the same commit"
    );
    assert_eq!(
        compute_inputs_hash(FIXTURE_SOURCES_HASH, FIXTURE_ALEF_TOML),
        GOLDEN_INPUTS_HASH,
        "the inputs-hash recipe changed without a CODEGEN_FORMAT_VERSION bump; every stamp \
         already written is now unverifiable and no regeneration explains why"
    );
}

#[test]
fn file_hash_recipe_matches_its_recorded_revision() {
    assert_eq!(
        compute_file_hash(GOLDEN_INPUTS_HASH, FIXTURE_FILE_BODY),
        GOLDEN_FILE_HASH,
        "the per-file stamp recipe changed without a CODEGEN_FORMAT_VERSION bump; every stamp \
         already written is now unverifiable and no regeneration explains why"
    );
}