syncular-testkit 0.1.0

Rust-first test fixtures, in-memory app server, and assertions for Syncular apps.
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
144
145
146
147
148
149
150

use syncular_runtime::app_schema::AppSchema;
use syncular_runtime::client::{SyncularClient, SyncularClientConfig};
use syncular_runtime::diesel_sqlite::DieselSqliteStore;
use syncular_runtime::error::Result;
use syncular_runtime::transport::SyncTransport;

use crate::app_server::AppTestServer;
use crate::temp::TempDbPath;
use crate::transport::TestTransport;

#[derive(Debug, Clone)]
pub struct AppFixtureOptions {
    pub db_prefix: String,
    pub base_url: String,
    pub client_id: String,
    pub actor_id: String,
    pub project_id: Option<String>,
}

impl Default for AppFixtureOptions {
    fn default() -> Self {
        Self {
            db_prefix: "syncular-app-test".to_string(),
            base_url: "http://syncular.test/sync".to_string(),
            client_id: "test-client".to_string(),
            actor_id: "user-rust".to_string(),
            project_id: Some("p0".to_string()),
        }
    }
}

pub struct AppFixture<T> {
    db: TempDbPath,
    pub client: SyncularClient<DieselSqliteStore, T>,
}

pub struct TestAppFixture {
    db: TempDbPath,
    pub client: SyncularClient<DieselSqliteStore, TestTransport>,
    pub transport: TestTransport,
}

pub struct InMemoryAppFixture<T> {
    pub client: SyncularClient<DieselSqliteStore, T>,
}

pub struct InMemoryTestAppFixture {
    pub client: SyncularClient<DieselSqliteStore, TestTransport>,
    pub transport: TestTransport,
}

impl<T> AppFixture<T> {
    pub fn db_path(&self) -> String {
        self.db.to_string_lossy()
    }
}

impl TestAppFixture {
    pub fn db_path(&self) -> String {
        self.db.to_string_lossy()
    }
}

pub fn open_app_client(app_schema: AppSchema) -> Result<TestAppFixture> {
    open_app_client_with_options(app_schema, AppFixtureOptions::default())
}

pub fn open_app_client_in_memory(app_schema: AppSchema) -> Result<InMemoryTestAppFixture> {
    let transport = TestTransport::new();
    let store = DieselSqliteStore::open_with_schema(":memory:", app_schema)?;
    let config = fixture_config(":memory:".to_string(), AppFixtureOptions::default());
    let client =
        SyncularClient::with_app_schema_parts(config, store, transport.clone(), app_schema);
    Ok(InMemoryTestAppFixture { client, transport })
}

pub fn open_app_client_with_options(
    app_schema: AppSchema,
    options: AppFixtureOptions,
) -> Result<TestAppFixture> {
    let transport = TestTransport::new();
    let db = TempDbPath::new(&options.db_prefix);
    let db_path = db.to_string_lossy();
    let store = DieselSqliteStore::open_with_schema(&db_path, app_schema)?;
    let config = fixture_config(db_path, options);
    let client =
        SyncularClient::with_app_schema_parts(config, store, transport.clone(), app_schema);
    Ok(TestAppFixture {
        db,
        client,
        transport,
    })
}

pub fn open_app_client_with_transport<T>(
    app_schema: AppSchema,
    transport: T,
    options: AppFixtureOptions,
) -> Result<AppFixture<T>>
where
    T: SyncTransport,
{
    let db = TempDbPath::new(&options.db_prefix);
    let db_path = db.to_string_lossy();
    let store = DieselSqliteStore::open_with_schema(&db_path, app_schema)?;
    let config = fixture_config(db_path, options);
    let client = SyncularClient::with_app_schema_parts(config, store, transport, app_schema);
    Ok(AppFixture { db, client })
}

pub fn open_app_client_with_server(
    app_schema: AppSchema,
    server: AppTestServer,
    options: AppFixtureOptions,
) -> Result<AppFixture<AppTestServer>> {
    open_app_client_with_transport(app_schema, server, options)
}

pub fn open_app_client_with_server_in_memory(
    app_schema: AppSchema,
    server: AppTestServer,
    options: AppFixtureOptions,
) -> Result<InMemoryAppFixture<AppTestServer>> {
    open_app_client_with_transport_in_memory(app_schema, server, options)
}

pub fn open_app_client_with_transport_in_memory<T>(
    app_schema: AppSchema,
    transport: T,
    options: AppFixtureOptions,
) -> Result<InMemoryAppFixture<T>>
where
    T: SyncTransport,
{
    let db_path = ":memory:".to_string();
    let store = DieselSqliteStore::open_with_schema(&db_path, app_schema)?;
    let config = fixture_config(db_path, options);
    let client = SyncularClient::with_app_schema_parts(config, store, transport, app_schema);
    Ok(InMemoryAppFixture { client })
}

fn fixture_config(db_path: String, options: AppFixtureOptions) -> SyncularClientConfig {
    SyncularClientConfig {
        db_path,
        base_url: options.base_url,
        client_id: options.client_id,
        actor_id: options.actor_id,
        project_id: options.project_id,
    }
}