warg-cli 0.10.0

The warg registry command line interface.
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

//! Tests for the in-memory storage backend.

use super::{support::*, *};
use anyhow::Result;
use warg_client::api;

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_starts_with_initial_checkpoint() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_initial_checkpoint(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_publishes_a_component() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_component_publishing(&config).await?;

    // There should be two log entries in the registry
    let client = api::Client::new(config.home_url.as_ref().unwrap(), None)?;
    let ts_checkpoint = client.latest_checkpoint(None).await?;
    assert_eq!(
        ts_checkpoint.as_ref().checkpoint.log_length,
        2,
        "expected two log entries (initial + component)"
    );

    test_fetch_package_names(&config).await?;

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_yanks_a_package() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_package_yanking(&config).await?;

    // There should be three entries in the registry
    let client = api::Client::new(config.home_url.as_ref().unwrap(), None)?;
    let ts_checkpoint = client.latest_checkpoint(None).await?;
    assert_eq!(
        ts_checkpoint.as_ref().checkpoint.log_length,
        3,
        "expected three log entries (initial + release + yank)"
    );

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_publishes_a_wit_package() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_wit_publishing(&config).await?;

    // There should be two log entries in the registry
    let client = api::Client::new(config.home_url.as_ref().unwrap(), None)?;
    let ts_checkpoint = client.latest_checkpoint(None).await?;
    assert_eq!(
        ts_checkpoint.as_ref().checkpoint.log_length,
        2,
        "expected two log entries (initial + wit)"
    );

    Ok(())
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_rejects_non_wasm_content() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_wasm_content_policy(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_rejects_unauthorized_signing_key() -> Result<()> {
    let (_server, config) = spawn_server(
        &root().await?,
        None,
        None,
        Some(vec![(
            "test".to_string(),
            test_signing_key().public_key().fingerprint(),
        )]),
    )
    .await?;

    test_unauthorized_signing_key(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_rejects_unknown_signing_key() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_unknown_signing_key(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_rejects_invalid_signature() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_invalid_signature(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_formats_custom_content_urls() -> Result<()> {
    let (_server, config) = spawn_server(
        &root().await?,
        Some("https://example.com".parse().unwrap()),
        None,
        None,
    )
    .await?;
    test_custom_content_url(&config).await
}

#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
async fn it_get_ledger() -> Result<()> {
    let (_server, config) = spawn_server(&root().await?, None, None, None).await?;
    test_get_ledger(&config).await
}