pray-core 1.6.0

Core library for Prayfile, the package manager for the language placed before inference
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

use jsonschema::Validator;
use pray_core::lockfile::read_lockfile;
use pray_core::manifest::parse_manifest;
use pray_core::package_spec::parse_package_spec;
use pray_core::registry::{RegistryIndex, RegistryPackageMetadata, RegistryPackageVersion};
use std::fs;
use std::path::{Path, PathBuf};

fn workspace_root() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..")
}

fn schema_path(name: &str) -> PathBuf {
    workspace_root().join("schema").join(name)
}

fn load_validator(schema_name: &str) -> Validator {
    let path = schema_path(schema_name);
    let schema_text = fs::read_to_string(&path).unwrap_or_else(|error| {
        panic!("read schema {}: {error}", path.display());
    });
    let schema_json: serde_json::Value =
        serde_json::from_str(&schema_text).expect("parse schema json");
    Validator::new(&schema_json).expect("compile schema")
}

fn assert_valid(validator: &Validator, value: &serde_json::Value, label: &str) {
    let errors: Vec<String> = validator
        .iter_errors(value)
        .map(|error| error.to_string())
        .collect();
    assert!(
        errors.is_empty(),
        "schema validation failed for {label}: {errors:?}"
    );
}

fn lockfile_to_json(path: &Path) -> serde_json::Value {
    let lockfile = read_lockfile(path).expect("read lockfile");
    serde_json::to_value(lockfile).expect("serialize lockfile to json")
}

#[test]
fn example_lockfiles_validate_against_lockfile_schema() {
    let validator = load_validator("lockfile.schema.json");
    for relative_path in [
        "examples/simple-project/Prayfile.lock",
        "examples/team-workflow/Prayfile.lock",
        "examples/customized-render/Prayfile.lock",
        "Prayfile.lock",
    ] {
        let path = workspace_root().join(relative_path);
        if !path.exists() {
            continue;
        }
        let value = lockfile_to_json(&path);
        assert_valid(&validator, &value, relative_path);
    }
}

#[test]
fn parsed_example_manifests_validate_against_manifest_schema() {
    let validator = load_validator("manifest.schema.json");
    for relative_path in [
        "examples/simple-project/Prayfile",
        "examples/team-workflow/Prayfile",
        "examples/customized-render/Prayfile",
        "Prayfile",
    ] {
        let path = workspace_root().join(relative_path);
        if !path.exists() {
            continue;
        }
        let manifest_text = fs::read_to_string(&path).expect("read prayfile");
        let manifest = parse_manifest(&manifest_text).expect("parse prayfile");
        let value = serde_json::to_value(manifest.canonicalized()).expect("serialize manifest");
        assert_valid(&validator, &value, relative_path);
    }
}

#[test]
fn parsed_example_package_spec_validates_against_package_schema() {
    let validator = load_validator("package.schema.json");
    let path = workspace_root().join("examples/simple-project/packages/base/sample-base.prayspec");
    let package_text = fs::read_to_string(&path).expect("read prayspec");
    let package_spec = parse_package_spec(&package_text).expect("parse prayspec");
    let value = serde_json::to_value(package_spec.canonicalized()).expect("serialize package spec");
    assert_valid(&validator, &value, path.to_str().expect("utf-8 path"));
}

#[test]
fn registry_metadata_validates_against_registry_schema() {
    let validator = load_validator("registry.schema.json");
    let metadata = RegistryPackageMetadata {
        name: "sample/base".to_string(),
        versions: vec![RegistryPackageVersion {
            version: "1.0.0".to_string(),
            artifact: "v1/artifacts/sample/base/1.0.0/package.praypkg".to_string(),
            artifact_hash: Some(
                "sha256:0000000000000000000000000000000000000000000000000000000000000000"
                    .to_string(),
            ),
            tree_hash: Some(
                "sha256:1111111111111111111111111111111111111111111111111111111111111111"
                    .to_string(),
            ),
            yanked: false,
            targets: vec!["tool_a".to_string()],
            exports: vec!["testing-basics".to_string()],
            signer: None,
            signer_fingerprint: None,
            signer_public_key: None,
            published_at: None,
            signature: None,
            derived_metadata: None,
        }],
    };
    let value = serde_json::to_value(metadata).expect("serialize registry metadata");
    assert_valid(&validator, &value, "registry package metadata");

    let index = RegistryIndex {
        spec: "pray-registry-v1".to_string(),
        packages: vec!["sample/base".to_string()],
    };
    let index_value = serde_json::to_value(index).expect("serialize registry index");
    assert!(
        !validator.is_valid(&index_value),
        "registry package schema should not accept registry index documents"
    );
}