voltdb-client-rust 0.2.1

A socket client library for VoltDB server supporting both sync and async operations.
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

#![cfg(feature = "tokio")]

use testcontainers::core::WaitFor;
use testcontainers::runners::AsyncRunner;
use testcontainers::{GenericImage, ImageExt};

use voltdb_client_rust::*;

#[tokio::test]
async fn test_async_node() -> Result<(), VoltError> {
    let voltdb = GenericImage::new("basvanbeek/voltdb-community", "9.2.1")
        .with_wait_for(WaitFor::message_on_stdout(
            "Server completed initialization.",
        ))
        .with_env_var("HOST_COUNT", "1");
    let docker = voltdb.start().await.unwrap();
    let host_port = docker.get_host_port_ipv4(21211).await.unwrap();

    let opt = NodeOpt {
        ip_port: IpPort::new("localhost".to_string(), host_port),
        user: None,
        pass: None,
        connect_timeout: None,
        read_timeout: None,
    };

    let node = AsyncNode::new(opt).await?;

    let mut rx = node.list_procedures().await?;
    let mut table = async_block_for_result(&mut rx).await?;

    assert!(table.has_error().is_none());

    node.shutdown().await?;
    Ok(())
}

#[tokio::test]
async fn test_async_pool() -> Result<(), VoltError> {
    let voltdb = GenericImage::new("basvanbeek/voltdb-community", "9.2.1")
        .with_wait_for(WaitFor::message_on_stdout(
            "Server completed initialization.",
        ))
        .with_env_var("HOST_COUNT", "1");
    let docker = voltdb.start().await.unwrap();
    let host_port = docker.get_host_port_ipv4(21211).await.unwrap();

    let hosts = vec![IpPort::new("localhost".to_string(), host_port)];
    let pool = AsyncPool::new(Opts::new(hosts)).await?;

    let mut conn = pool.get_conn().await?;
    let mut table = conn.list_procedures().await?;
    assert!(table.has_error().is_none());

    Ok(())
}

#[tokio::test]
async fn test_async_pool_multiple_queries() -> Result<(), VoltError> {
    let voltdb = GenericImage::new("basvanbeek/voltdb-community", "9.2.1")
        .with_wait_for(WaitFor::message_on_stdout(
            "Server completed initialization.",
        ))
        .with_env_var("HOST_COUNT", "1");
    let docker = voltdb.start().await.unwrap();
    let host_port = docker.get_host_port_ipv4(21211).await.unwrap();

    let hosts = vec![IpPort::new("localhost".to_string(), host_port)];
    let pool = AsyncPool::new(Opts::new(hosts)).await?;

    // Test multiple queries using different connections from the pool
    for _ in 0..10 {
        let mut conn = pool.get_conn().await?;
        let mut table = conn.list_procedures().await?;
        assert!(table.has_error().is_none());
    }

    Ok(())
}