headgate-testkit 0.1.4

A policy-aware distributed job queue with PostgreSQL, MySQL, and Redis backends.
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

use headgate_testkit::PostgresTestDatabase;

async fn connect(
    config: tokio_postgres::Config,
) -> (
    tokio_postgres::Client,
    tokio::task::JoinHandle<Result<(), tokio_postgres::Error>>,
) {
    let (client, connection) = config
        .connect(tokio_postgres::NoTls)
        .await
        .expect("connect isolated schema");
    (client, tokio::spawn(connection))
}

#[tokio::test]
async fn postgres_test_databases_migrate_isolate_parallel_tests_and_cleanup() {
    let Ok(conninfo) = std::env::var("HG_TEST_PG") else {
        eprintln!("HG_TEST_PG not set; skipping Postgres test-database helper");
        return;
    };
    let (left, right) = tokio::join!(
        PostgresTestDatabase::create(&conninfo),
        PostgresTestDatabase::create(&conninfo)
    );
    let left = left.expect("left database");
    let right = right.expect("right database");
    assert_ne!(left.schema(), right.schema());

    let (left_client, left_task) = connect(left.config()).await;
    let (right_client, right_task) = connect(right.config()).await;
    let left_installed: bool = left_client
        .query_one("SELECT to_regclass('headgate_job') IS NOT NULL", &[])
        .await
        .unwrap()
        .get(0);
    let right_installed: bool = right_client
        .query_one("SELECT to_regclass('headgate_job') IS NOT NULL", &[])
        .await
        .unwrap()
        .get(0);
    assert!(
        left_installed && right_installed,
        "both schemas are migrated"
    );
    left_client
        .execute(
            "INSERT INTO headgate_queue_state(queue) VALUES ('only-left')",
            &[],
        )
        .await
        .unwrap();
    let right_count: i64 = right_client
        .query_one(
            "SELECT count(*) FROM headgate_queue_state WHERE queue = 'only-left'",
            &[],
        )
        .await
        .unwrap()
        .get(0);
    assert_eq!(right_count, 0, "parallel schemas cannot see each other");

    drop(left_client);
    let _ = left_task.await;
    left.cleanup().await.expect("cleanup left");
    let still_live: bool = right_client
        .query_one("SELECT to_regclass('headgate_job') IS NOT NULL", &[])
        .await
        .unwrap()
        .get(0);
    assert!(still_live, "cleaning one test must not drop its sibling");
    drop(right_client);
    let _ = right_task.await;
    right.cleanup().await.expect("cleanup right");
}