pgdo-lib 0.5.6

The convenience of SQLite – but with PostgreSQL (Library package)
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

use pgdo::cluster::{config, Cluster, ClusterError};
use pgdo_test::for_all_runtimes;

type TestResult = Result<(), ClusterError>;

#[for_all_runtimes(min = "9.5")]
#[test]
fn cluster_parameter_set() -> TestResult {
    let data_dir = tempfile::tempdir()?;
    let cluster = Cluster::new(&data_dir, runtime)?;
    cluster.start(&[])?;

    let rt = tokio::runtime::Runtime::new()?;
    rt.block_on(async {
        let pool = cluster.pool(None)?;

        // By default, `trace_notify` is disabled.
        let parameter = config::Parameter::from("trace_notify");
        let value = parameter.get(&pool).await?;
        assert_eq!(value, Some(config::Value::Boolean(false)));

        // We'll enable it.
        parameter.set(&pool, true).await?;

        // We need to reload the configuration.
        config::reload(&pool).await?;

        // BUGBUG: We also need fresh connections, otherwise the test below is
        // flaky. It is non-deterministic whether the setting is picked up.
        // TODO: Maybe `RESET ALL` would work?
        let pool = cluster.pool(None)?;

        // Now `trace_notify` is enabled.
        let value = parameter.get(&pool).await?;
        assert_eq!(value, Some(config::Value::Boolean(true)));

        Ok::<(), ClusterError>(())
    })?;

    cluster.stop()?;
    Ok(())
}

#[for_all_runtimes(min = "9.5")]
#[test]
fn cluster_parameter_get() -> TestResult {
    let data_dir = tempfile::tempdir()?;
    let cluster = Cluster::new(&data_dir, runtime)?;
    cluster.start(&[])?;

    let rt = tokio::runtime::Runtime::new()?;
    let value = rt.block_on(async {
        let pool = cluster.pool(None)?;
        let value = config::Parameter::from("application_name").get(&pool).await;
        Ok::<_, ClusterError>(value?)
    })?;
    assert_eq!(value, Some(config::Value::String("pgdo".to_owned())));

    cluster.stop()?;
    Ok(())
}

#[for_all_runtimes(min = "9.5")]
#[test]
fn cluster_setting_list() -> TestResult {
    let data_dir = tempfile::tempdir()?;
    let cluster = Cluster::new(&data_dir, runtime)?;
    cluster.start(&[])?;

    let rt = tokio::runtime::Runtime::new()?;
    let settings = rt.block_on(async {
        let pool = cluster.pool(None)?;
        Ok::<_, ClusterError>(config::Setting::list(&pool).await?)
    })?;
    let mapping: std::collections::HashMap<config::Parameter, config::Value> = settings
        .iter()
        .map(|setting| (setting.into(), setting.try_into().unwrap()))
        .collect();

    for (parameter, value) in mapping {
        println!("{parameter}: {value}");
    }

    cluster.stop()?;
    Ok(())
}

#[for_all_runtimes(min = "9.5")]
#[test]
fn cluster_setting_get() -> TestResult {
    let data_dir = tempfile::tempdir()?;
    let cluster = Cluster::new(&data_dir, runtime)?;
    cluster.start(&[])?;

    let rt = tokio::runtime::Runtime::new()?;
    let parameter = config::Parameter::from("application_name");
    let application_name = rt
        .block_on(async {
            let pool = cluster.pool(None)?;
            Ok::<_, ClusterError>(config::Setting::get(&parameter, &pool).await?)
        })?
        .expect("missing application_name setting");

    assert_eq!(application_name.setting, "pgdo");
    assert_eq!(application_name.vartype, "string");

    cluster.stop()?;
    Ok(())
}