pray-core 1.13.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
131
132
133
134
135
136
137

use super::{
    build_lockfile, lockfiles_equivalent, normalize_lockfile_artifact, relative_lockfile_path,
    LockSource, LockedPackage, Lockfile,
};
use std::collections::BTreeMap;
use std::path::Path;

#[test]
fn build_lockfile_records_git_source_revision() {
    let mut source_revisions = BTreeMap::new();
    source_revisions.insert(
        "dist".to_string(),
        "abc123def4567890abc123def4567890abc123de".to_string(),
    );
    let lockfile = build_lockfile(
        "sha256:manifest".to_string(),
        None,
        Path::new("."),
        &[crate::manifest::ManifestSource {
            name: "dist".to_string(),
            kind: "git".to_string(),
            url: "git+https://example.com/dist.git".to_string(),
            subdir: None,
            rev: None,
            tag: None,
        }],
        &[],
        &[],
        &[],
        &source_revisions,
        &BTreeMap::new(),
    );
    assert_eq!(
        lockfile.source,
        vec![LockSource {
            name: "dist".to_string(),
            kind: "git".to_string(),
            url: "git+https://example.com/dist.git".to_string(),
            revision: Some("abc123def4567890abc123def4567890abc123de".to_string()),
            host_key_fingerprint: None,
        }]
    );
    let serialized = lockfile.serialized().expect("serialize lockfile");
    assert!(serialized.contains("revision ="));
}

#[test]
fn build_lockfile_records_package_upstream() {
    let lockfile = Lockfile {
        package: vec![LockedPackage {
            name: "fork/base".to_string(),
            version: "1.0.0".to_string(),
            source: None,
            path: "./packages/base".to_string(),
            tree_hash: "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                .to_string(),
            artifact_hash:
                "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
                    .to_string(),
            artifact: "path:./packages/base".to_string(),
            exports: Vec::new(),
            dependencies: Vec::new(),
            signer_fingerprint: None,
            upstream: Some(crate::package_upstream::LockedUpstream {
                name: "sample/base".to_string(),
                version: "1.4.3".to_string(),
                source: Some("sample".to_string()),
                tree_hash:
                    "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
                        .to_string(),
                artifact_hash:
                    "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
                        .to_string(),
            }),
        }],
        ..Lockfile::default()
    };
    let serialized = lockfile.serialized().expect("serialize lockfile");
    assert!(serialized.contains("sample/base"));
    assert!(serialized.contains("1.4.3"));
}

#[test]
fn lockfiles_equivalent_ignores_field_order() {
    let left = Lockfile {
        manifest_hash: "sha256:manifest".to_string(),
        package: vec![LockedPackage {
            name: "alpha".to_string(),
            version: "1.0.0".to_string(),
            source: None,
            path: "packages/alpha".to_string(),
            tree_hash: "sha256:tree".to_string(),
            artifact_hash: "sha256:artifact".to_string(),
            artifact: "alpha-1.0.0.praypkg".to_string(),
            exports: vec!["SKILL.md".to_string()],
            dependencies: Vec::new(),
            signer_fingerprint: None,
            upstream: None,
        }],
        ..Lockfile::default()
    };
    let mut right = left.clone();
    right.package.reverse();
    assert!(lockfiles_equivalent(&left.canonicalized(), &right));
}

#[test]
fn relative_lockfile_path_strips_absolute_project_prefix() {
    let project_root = Path::new("/tmp/project");
    let package_root = Path::new("/tmp/project/./packages/base");
    assert_eq!(
        relative_lockfile_path(project_root, package_root),
        "./packages/base"
    );
}

#[test]
fn normalize_lockfile_artifact_relativizes_path_artifacts() {
    let project_root = Path::new("/tmp/project");
    let package_root = Path::new("/tmp/project/packages/base");
    assert_eq!(
        normalize_lockfile_artifact(
            project_root,
            "path:/tmp/project/./packages/base",
            package_root,
        ),
        "path:./packages/base"
    );
    assert_eq!(
        normalize_lockfile_artifact(
            project_root,
            "v1/artifacts/sample/base/1.0.0/package.praypkg",
            package_root,
        ),
        "v1/artifacts/sample/base/1.0.0/package.praypkg"
    );
}