hf2q 0.1.7

Pure Rust CLI for converting HuggingFace models to hardware-optimized formats and serving them over an OpenAI-compatible API on Apple Silicon
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

use super::metadata::{lock_metadata_state, MetadataStateAuthorization};
use super::test_fixture::Fixture;
use super::{
    open_existing_installation_identity, ExplicitRootAuthorization, FirstActivationPreparation,
    LiveInstalledReleaseFloor,
};

fn authorization(fixture: &Fixture) -> MetadataStateAuthorization {
    let identity = open_existing_installation_identity(
        ExplicitRootAuthorization::new(&fixture.root).expect("explicit fixture root"),
    )
    .expect("open installation identity")
    .expect("installation identity exists");
    MetadataStateAuthorization::from_identity(identity)
}

#[test]
fn live_installed_release_floor_is_absent_then_exactly_bound_to_current() {
    let fixture = Fixture::new();
    let authorization = authorization(&fixture);
    let locked = lock_metadata_state(&authorization).expect("lock initial metadata state");
    assert!(matches!(
        locked
            .read_live_installed_release_floor()
            .expect("read absent floor"),
        LiveInstalledReleaseFloor::Absent
    ));
    drop(locked);

    let FirstActivationPreparation::Ready(prepared) =
        fixture.prepare().expect("prepare first activation")
    else {
        panic!("fresh fixture cannot already be activated")
    };
    prepared.commit().expect("commit first activation");

    let locked = lock_metadata_state(&authorization).expect("lock activated metadata state");
    let LiveInstalledReleaseFloor::Active(active) = locked
        .read_live_installed_release_floor()
        .expect("read active floor")
    else {
        panic!("committed current must establish a live floor")
    };
    assert_eq!(active.version().as_str(), "0.2.0");
    assert_eq!(active.target().as_str(), "aarch64-apple-darwin");
    assert_eq!(active.installation_sequence(), 1);
    assert_eq!(active.activation_sequence(), 1);
    assert_ne!(active.receipt_sha256(), [0; 32]);
}

#[test]
fn live_installed_release_floor_rejects_noncanonical_active_state() {
    enum Mutation {
        WrongCurrent,
        ExtraActivation,
        MutatedReceipt,
    }

    for mutation in [
        Mutation::WrongCurrent,
        Mutation::ExtraActivation,
        Mutation::MutatedReceipt,
    ] {
        let fixture = Fixture::new();
        let authorization = authorization(&fixture);
        let FirstActivationPreparation::Ready(prepared) =
            fixture.prepare().expect("prepare first activation")
        else {
            panic!("fresh fixture cannot already be activated")
        };
        prepared.commit().expect("commit first activation");

        match mutation {
            Mutation::WrongCurrent => {
                std::fs::remove_file(fixture.root.join("current")).expect("remove current link");
                std::os::unix::fs::symlink(
                    "activations/00000000000000000002",
                    fixture.root.join("current"),
                )
                .expect("replace current link");
            }
            Mutation::ExtraActivation => {
                std::fs::create_dir(fixture.root.join("activations/00000000000000000002"))
                    .expect("create extra activation");
            }
            Mutation::MutatedReceipt => {
                let receipt = fixture
                    .root
                    .join("activations/00000000000000000001/install-receipt.json");
                let mut bytes = std::fs::read(&receipt).expect("read receipt");
                bytes.push(b' ');
                std::fs::write(receipt, bytes).expect("mutate receipt");
            }
        }

        let locked = lock_metadata_state(&authorization).expect("lock mutated metadata state");
        assert!(locked.read_live_installed_release_floor().is_err());
    }
}