yamldap 0.2.0

A lightweight LDAP server that serves directory data from YAML files
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
138
139
140
141
142
143

use std::io::Write;
use std::path::PathBuf;
use tempfile::NamedTempFile;
use tokio::io::AsyncReadExt;
use tokio::net::{TcpListener, TcpStream};
use yamldap::{Config, ResourceLimits, Server};

fn create_test_config(yaml_file: PathBuf) -> Config {
    Config::new(yaml_file)
        .with_bind_address("127.0.0.1:0".parse().unwrap())
        .with_anonymous_access(true)
}

fn create_yaml_file() -> NamedTempFile {
    let mut file = NamedTempFile::new().unwrap();
    writeln!(
        file,
        r#"directory:
  base_dn: dc=test,dc=com

entries:
  - dn: dc=test,dc=com
    objectClass: [top, domain]
    dc: test

  - dn: cn=admin,dc=test,dc=com
    objectClass: [top, person]
    cn: admin
    sn: Admin
    userPassword: secret
"#
    )
    .unwrap();
    file.flush().unwrap();
    file
}

#[tokio::test]
async fn server_starts_accepts_connections_and_shuts_down() {
    let yaml_file = create_yaml_file();
    let server = Server::new(create_test_config(yaml_file.path().to_path_buf()))
        .await
        .unwrap();
    let handle = server.start().await.unwrap();

    TcpStream::connect(handle.local_addr()).await.unwrap();
    handle.shutdown().await.unwrap();
}

#[tokio::test]
async fn server_owns_multiple_connection_tasks_during_shutdown() {
    let yaml_file = create_yaml_file();
    let server = Server::new(create_test_config(yaml_file.path().to_path_buf()))
        .await
        .unwrap();
    let handle = server.start().await.unwrap();

    let mut streams = Vec::new();
    for _ in 0..10 {
        streams.push(TcpStream::connect(handle.local_addr()).await.unwrap());
    }
    drop(streams);

    handle.shutdown().await.unwrap();
}

#[tokio::test]
async fn server_enforces_connection_limit_without_unbounded_tasks() {
    let yaml_file = create_yaml_file();
    let mut limits = ResourceLimits::default();
    limits.max_connections = 1;
    let server = Server::new(create_test_config(yaml_file.path().to_path_buf()))
        .await
        .unwrap()
        .with_resource_limits(limits)
        .unwrap();
    let handle = server.start().await.unwrap();

    let first = TcpStream::connect(handle.local_addr()).await.unwrap();
    let mut second = TcpStream::connect(handle.local_addr()).await.unwrap();
    let mut byte = [0_u8; 1];
    let closed = tokio::time::timeout(std::time::Duration::from_secs(1), second.read(&mut byte))
        .await
        .expect("excess connection was not handled")
        .unwrap();
    assert_eq!(closed, 0, "excess connection should be closed");
    drop(first);
    drop(second);

    handle.shutdown().await.unwrap();
}

#[tokio::test]
async fn server_reports_a_deterministic_bind_error() {
    let yaml_file = create_yaml_file();
    let occupied = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = occupied.local_addr().unwrap();
    let config = Config::new(yaml_file.path()).with_bind_address(address);
    let server = Server::new(config).await.unwrap();

    assert!(server.start().await.is_err());
}

#[tokio::test]
async fn server_rejects_a_missing_yaml_file() {
    let config = Config::new(PathBuf::from("/nonexistent/file.yaml"));
    assert!(Server::new(config).await.is_err());
}

#[tokio::test]
async fn server_starts_with_a_custom_schema() {
    let mut file = NamedTempFile::new().unwrap();
    writeln!(
        file,
        r#"directory:
  base_dn: dc=custom,dc=com

schema:
  object_classes:
    - name: customPerson
      attributes: [cn, email]
  custom_attributes:
    email:
      syntax: String
      single_value: true

entries:
  - dn: cn=test,dc=custom,dc=com
    objectClass: [customPerson]
    cn: test
    email: test@example.com
"#
    )
    .unwrap();
    file.flush().unwrap();

    let server = Server::new(create_test_config(file.path().to_path_buf()))
        .await
        .unwrap();
    let handle = server.start().await.unwrap();
    TcpStream::connect(handle.local_addr()).await.unwrap();
    handle.shutdown().await.unwrap();
}