dwn 0.4.0

Rust implementation of a Decentralized Web Node.
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

use dwn_core::message::{
    descriptor::RecordsWriteBuilder,
    mime::{APPLICATION_JSON, TEXT_PLAIN},
};
use serde_json::json;
use tracing_test::traced_test;

use crate::utils::{init_dwn, serve_string};

use super::{expect_fail, expect_success};

#[tokio::test]
#[traced_test]
async fn test_schema_success() {
    let (actor, _, mut dwn) = init_dwn();

    let schema = json!({ "maxLength": 5 });
    let data = json!("foo");
    assert!(jsonschema::is_valid(&schema, &data));

    let schema_url = serve_string(schema.to_string()).await;

    let mut msg = RecordsWriteBuilder {
        data_format: Some(APPLICATION_JSON),
        data: Some(data.to_string().into_bytes()),
        schema: Some(schema_url),
        ..Default::default()
    }
    .build()
    .unwrap();
    actor.authorize(&mut msg).unwrap();

    expect_success(&actor.did, &mut dwn, msg).await;
}

#[tokio::test]
#[traced_test]
async fn test_schema_fail() {
    let (actor, _, mut dwn) = init_dwn();

    let schema = json!({ "maxLength": 2 });
    let data = json!("foo");
    assert!(!jsonschema::is_valid(&schema, &data));

    let schema_url = serve_string(schema.to_string()).await;

    let mut msg = RecordsWriteBuilder {
        data_format: Some(APPLICATION_JSON),
        data: Some(data.to_string().into_bytes()),
        schema: Some(schema_url),
        ..Default::default()
    }
    .build()
    .unwrap();
    actor.authorize(&mut msg).unwrap();

    expect_fail(&actor.did, &mut dwn, msg).await;
}

#[tokio::test]
#[traced_test]
async fn test_invalid_schema() {
    let (actor, _, mut dwn) = init_dwn();

    let schema = "not a valid schema";
    let data = json!("foo");

    let schema_url = serve_string(schema.to_string()).await;

    let mut msg = RecordsWriteBuilder {
        data_format: Some(APPLICATION_JSON),
        data: Some(data.to_string().into_bytes()),
        schema: Some(schema_url),
        ..Default::default()
    }
    .build()
    .unwrap();
    actor.authorize(&mut msg).unwrap();

    expect_fail(&actor.did, &mut dwn, msg).await;
}

#[tokio::test]
#[traced_test]
async fn test_invalid_schema_url() {
    let (actor, _, mut dwn) = init_dwn();

    let data = json!("foo");
    let schema_url = "not a url".to_string();

    let mut msg = RecordsWriteBuilder {
        data_format: Some(APPLICATION_JSON),
        data: Some(data.to_string().into_bytes()),
        schema: Some(schema_url),
        ..Default::default()
    }
    .build()
    .unwrap();
    actor.authorize(&mut msg).unwrap();

    expect_fail(&actor.did, &mut dwn, msg).await;
}

#[tokio::test]
#[traced_test]
async fn test_schema_requires_data_format_json() {
    let (actor, _, mut dwn) = init_dwn();

    let schema = json!({ "maxLength": 5 });
    let data = json!("foo");
    assert!(jsonschema::is_valid(&schema, &data));

    let schema_url = serve_string(schema.to_string()).await;

    let mut msg = RecordsWriteBuilder {
        data_format: Some(TEXT_PLAIN),
        data: Some(data.to_string().into_bytes()),
        schema: Some(schema_url),
        ..Default::default()
    }
    .build()
    .unwrap();
    actor.authorize(&mut msg).unwrap();

    expect_fail(&actor.did, &mut dwn, msg).await;
}