lazydns 0.3.20

A light and fast DNS server/forwarder implementation in Rust
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

//! Integration tests for the plugin builder system

use lazydns::config::types::PluginConfig;
use lazydns::plugin::factory;
use lazydns::plugin::factory::init;
use serde_yaml::{Mapping, Value};

#[test]
fn test_create_cache_plugin_from_builder() {
    init();

    let mut args = Mapping::new();
    args.insert(Value::String("size".into()), Value::Number(2048.into()));

    let config = PluginConfig {
        tag: Some("test_cache".to_string()),
        plugin_type: "cache".to_string(),
        args: Value::Mapping(args),
    };

    let builder_obj =
        factory::get_plugin_factory("cache").expect("cache builder should be registered");
    let plugin = builder_obj
        .create(&config)
        .expect("plugin creation should succeed");

    assert_eq!(plugin.name(), "cache");
}

#[test]
fn test_create_forward_plugin_from_builder() {
    init();

    let upstreams = vec![
        Value::String("8.8.8.8:53".to_string()),
        Value::String("8.8.4.4:53".to_string()),
    ];
    let mut args = Mapping::new();
    args.insert(
        Value::String("upstreams".into()),
        Value::Sequence(upstreams),
    );

    let config = PluginConfig {
        tag: Some("test_forward".to_string()),
        plugin_type: "forward".to_string(),
        args: Value::Mapping(args),
    };

    let builder_obj =
        factory::get_plugin_factory("forward").expect("forward builder should be registered");
    let plugin = builder_obj
        .create(&config)
        .expect("plugin creation should succeed");

    assert_eq!(plugin.name(), "forward");
}

#[test]
fn test_create_query_acl_plugin_from_builder() {
    init();

    let rule = {
        let mut rule = Mapping::new();
        rule.insert(
            Value::String("network".into()),
            Value::String("10.0.0.0/8".to_string()),
        );
        rule.insert(
            Value::String("action".into()),
            Value::String("allow".to_string()),
        );
        rule
    };

    let mut args = Mapping::new();
    args.insert(
        Value::String("rules".into()),
        Value::Sequence(vec![Value::Mapping(rule)]),
    );

    let config = PluginConfig {
        tag: Some("test_acl".to_string()),
        plugin_type: "query_acl".to_string(),
        args: Value::Mapping(args),
    };

    let builder_obj =
        factory::get_plugin_factory("query_acl").expect("query_acl builder should be registered");
    let plugin = builder_obj
        .create(&config)
        .expect("plugin creation should succeed");

    assert_eq!(plugin.name(), "query_acl");
}