appcore-contracts 1.0.0

Stable, implementation-independent manifests and distributed runtime contracts for AppCore.
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

// =============================================================================
//        #######
//     ###       ###     F: tests.rs
//    ##   ## ##   ##    P: AppCore-Runtime
//         ## ##
//                       C: 2026/07/22 15:41:18 by dnettoRaw
//    ##   ## ##   ##    U: 2026/07/24 11:51:10 by dnettoRaw
//      ###########      S: 1.0.1-rc.8
// =============================================================================
// appcore-norm: test

use super::*;
use crate::{CapabilityClass, CapabilityId, CapabilityMode, CapabilityVisibility};

fn manifest() -> ApplicationManifestV1 {
    ApplicationManifestV1::new(
        ApplicationId::new("example-app").unwrap(),
        "1.0.0",
        "Example App",
        "Example Vendor",
        ServiceId::new("example.service").unwrap(),
        RuntimeRequirements::new("0.6.1", "1").unwrap(),
    )
    .unwrap()
}

#[test]
fn application_manifest_round_trips_and_validates() {
    let manifest = manifest()
        .with_capability(
            CapabilityDeclaration::new(
                CapabilityId::new("document.extract").unwrap(),
                "1",
                CapabilityMode::Command,
                CapabilityVisibility::Cluster,
            )
            .unwrap(),
        )
        .unwrap();
    let encoded = serde_json::to_string(&manifest).unwrap();
    let decoded: ApplicationManifestV1 = serde_json::from_str(&encoded).unwrap();
    assert_eq!(decoded, manifest);
}

#[test]
fn application_manifest_matches_v1_fixture() {
    let expected: serde_json::Value =
        serde_json::from_str(include_str!("../fixtures/application-manifest-v1.json")).unwrap();
    assert_eq!(serde_json::to_value(manifest()).unwrap(), expected);
    let decoded: ApplicationManifestV1 = serde_json::from_value(expected).unwrap();
    assert_eq!(decoded, manifest());
}

#[test]
fn application_manifest_rejects_secrets_and_paths() {
    assert!(manifest().with_metadata("api_token", "raw").is_err());
    assert!(manifest().with_metadata("cache", "/var/app/cache").is_err());
    assert!(manifest()
        .with_metadata("control_endpoint", "https://runtime.example")
        .is_err());
}

#[test]
fn leadership_capability_requires_service_policy() {
    let capability = CapabilityDeclaration::new(
        CapabilityId::new("document.extract").unwrap(),
        "1",
        CapabilityMode::Command,
        CapabilityVisibility::Cluster,
    )
    .unwrap()
    .with_leadership(true);
    assert!(manifest().with_capability(capability).is_err());
}

#[test]
fn application_manifest_rejects_infrastructure_capabilities() {
    let capability = CapabilityDeclaration::new(
        CapabilityId::new("runtime.health").unwrap(),
        "1",
        CapabilityMode::Query,
        CapabilityVisibility::Local,
    )
    .unwrap()
    .with_class(CapabilityClass::Infrastructure);

    assert!(manifest().with_capability(capability).is_err());
}

#[test]
fn application_manifest_rejects_reserved_capability_namespaces() {
    for capability_id in [
        "appcore.health",
        "runtime.status",
        "infrastructure.storage",
        "Runtime.Status",
    ] {
        let capability = CapabilityDeclaration::new(
            CapabilityId::new(capability_id).unwrap(),
            "1",
            CapabilityMode::Query,
            CapabilityVisibility::Local,
        )
        .unwrap();

        assert!(manifest().with_capability(capability).is_err());
    }
}

#[test]
fn functional_class_keeps_the_v1_wire_shape() {
    let capability = CapabilityDeclaration::new(
        CapabilityId::new("document.extract").unwrap(),
        "1",
        CapabilityMode::Command,
        CapabilityVisibility::Cluster,
    )
    .unwrap();
    let encoded = serde_json::to_value(capability).unwrap();
    assert!(encoded.get("class").is_none());
}