ossctl-core 0.2.0

Core library for ossctl: contract normalizer, repo-fact detection, audit scoring, release engine, and the versioned protocol DTOs.
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
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
144
145
146
147
148
149

//! Journal-id derivation: backward-compatible single-target ids, per-target
//! disambiguation for multi-target ecosystems, and determinism.

use super::journal_target_ids;
use crate::contract::schema::{Adapter, Ecosystem, Registry};
use crate::protocol::plan::PlanTarget;

fn t(ecosystem: Ecosystem, package: &str, registry: Registry, adapter: Adapter) -> PlanTarget {
    PlanTarget {
        ecosystem,
        package: Some(package.to_string()),
        registry,
        adapter,
    }
}

#[test]
fn lone_target_per_ecosystem_keeps_the_bare_ecosystem_id() {
    // The historical shape: one target per ecosystem ⇒ the ecosystem wire string
    // is the id, unchanged from before this feature (no journal churn).
    let targets = vec![
        t(
            Ecosystem::Rust,
            "tool",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(Ecosystem::Node, "tool", Registry::Npm, Adapter::NpmPublish),
    ];
    assert_eq!(journal_target_ids(&targets), vec!["rust", "node"]);
}

#[test]
fn two_crates_in_one_ecosystem_disambiguate_by_package() {
    // The issue's canonical case: two crates.io crates in `rust`. Package alone is
    // enough to make them distinct.
    let targets = vec![
        t(
            Ecosystem::Rust,
            "ossctl-core",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
    ];
    assert_eq!(
        journal_target_ids(&targets),
        vec!["rust:ossctl-core", "rust:ossctl"]
    );
}

#[test]
fn same_package_different_channels_disambiguate_by_registry() {
    // `ossctl`'s real four-target contract: one crate published to crates.io, plus
    // the same crate as a gh-releases and a homebrew target — package collides, so
    // the id escalates to `package:registry`.
    let targets = vec![
        t(
            Ecosystem::Rust,
            "ossctl-core",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::GhReleases,
            Adapter::CargoDist,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::Homebrew,
            Adapter::HomebrewTap,
        ),
    ];
    assert_eq!(
        journal_target_ids(&targets),
        vec![
            "rust:ossctl-core:crates.io",
            "rust:ossctl:crates.io",
            "rust:ossctl:gh-releases",
            "rust:ossctl:homebrew",
        ]
    );
    // Every id is distinct — the property the coordinator's journal keying needs.
    let ids = journal_target_ids(&targets);
    let mut sorted = ids.clone();
    sorted.sort();
    sorted.dedup();
    assert_eq!(sorted.len(), ids.len(), "ids must be unique");
}

#[test]
fn identical_targets_collide_so_the_coordinator_can_reject_them() {
    // Two byte-identical targets cannot be told apart even at full qualification;
    // the derivation yields colliding ids on purpose so `validate_plan` refuses the
    // degenerate duplicate rather than silently keying them the same.
    let targets = vec![
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
    ];
    let ids = journal_target_ids(&targets);
    assert_eq!(
        ids[0], ids[1],
        "identical targets must produce a colliding id"
    );
}

#[test]
fn is_deterministic() {
    let targets = vec![
        t(
            Ecosystem::Rust,
            "ossctl-core",
            Registry::CratesIo,
            Adapter::CargoPublish,
        ),
        t(
            Ecosystem::Rust,
            "ossctl",
            Registry::Homebrew,
            Adapter::HomebrewTap,
        ),
        t(Ecosystem::Node, "tool", Registry::Npm, Adapter::NpmPublish),
    ];
    assert_eq!(journal_target_ids(&targets), journal_target_ids(&targets));
}