0
0
mirror of https://github.com/tursodatabase/libsql.git synced 2024-12-16 06:48:48 +00:00
2024-03-12 18:00:30 +00:00

434 lines
12 KiB
Rust

//! Tests for standalone primary configuration
#![allow(deprecated)]
use crate::common::net::{SimServer, TurmoilAcceptor};
use crate::common::{http::Client, snapshot_metrics};
use super::common;
use std::{sync::Arc, time::Duration};
use insta::assert_debug_snapshot;
use libsql::{params, Connection, Database, Value};
use tempfile::tempdir;
use tokio::sync::Notify;
use libsql_server::config::{AdminApiConfig, UserApiConfig};
use common::net::{init_tracing, TestServer, TurmoilConnector};
mod attach;
mod auth;
async fn make_standalone_server() -> Result<(), Box<dyn std::error::Error>> {
init_tracing();
let tmp = tempdir()?;
let server = TestServer {
path: tmp.path().to_owned().into(),
user_api_config: UserApiConfig {
hrana_ws_acceptor: None,
..Default::default()
},
admin_api_config: Some(AdminApiConfig {
acceptor: TurmoilAcceptor::bind(([0, 0, 0, 0], 9090)).await.unwrap(),
connector: TurmoilConnector,
disable_metrics: true,
}),
disable_namespaces: false,
..Default::default()
};
server.start_sim(8080).await?;
Ok(())
}
#[test]
fn basic_query() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("insert into test values (12)", ()).await?;
let mut rows = conn.query("select count(*) from test", ()).await?;
assert!(matches!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
libsql::Value::Integer(1)
));
Ok(())
});
sim.run().unwrap();
}
#[test]
fn basic_metrics() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("insert into test values (12)", ()).await?;
let mut rows = conn.query("select count(*) from test", ()).await?;
assert!(matches!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
libsql::Value::Integer(1)
));
tokio::time::sleep(Duration::from_secs(1)).await;
let snapshot = snapshot_metrics();
snapshot.assert_counter("libsql_server_libsql_execute_program", 3);
snapshot.assert_counter("libsql_server_user_http_response", 3);
for (key, (_, _, val)) in snapshot.snapshot() {
if key.kind() == metrics_util::MetricKind::Counter
&& key.key().name() == "libsql_client_version"
{
let label = key.key().labels().next().unwrap();
assert!(label.value().starts_with("libsql-remote-"));
assert_eq!(val, &metrics_util::debugging::DebugValue::Counter(3));
}
}
Ok(())
});
sim.run().unwrap();
}
#[test]
fn primary_serializability() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
let notify = Arc::new(Notify::new());
sim.client("writer", {
let notify = notify.clone();
async move {
let db =
Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("insert into test values (12)", ()).await?;
notify.notify_waiters();
Ok(())
}
});
sim.client("reader", {
async move {
let db =
Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
notify.notified().await;
let mut rows = conn.query("select count(*) from test", ()).await?;
assert!(matches!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(1)
));
Ok(())
}
});
sim.run().unwrap();
}
#[test]
fn basic_query_fail() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("create unique index test_index on test(x)", ())
.await?;
conn.execute("insert into test values (12)", ()).await?;
let e = conn
.execute("insert into test values (12)", ())
.await
.unwrap_err();
assert_debug_snapshot!(e);
Ok(())
});
sim.run().unwrap();
}
#[test]
fn begin_commit() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("begin;", ()).await?;
conn.execute("insert into test values (12);", ()).await?;
// we can read the inserted row
let mut rows = conn.query("select count(*) from test", ()).await?;
assert_eq!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(1)
);
conn.execute("commit;", ()).await?;
// after rollback row is no longer there
let mut rows = conn.query("select count(*) from test", ()).await?;
assert_eq!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(1)
);
Ok(())
});
sim.run().unwrap();
}
#[test]
fn begin_rollback() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("create table test (x)", ()).await?;
conn.execute("begin;", ()).await?;
conn.execute("insert into test values (12);", ()).await?;
// we can read the inserted row
let mut rows = conn.query("select count(*) from test", ()).await?;
assert_eq!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(1)
);
conn.execute("rollback;", ()).await?;
// after rollback row is no longer there
let mut rows = conn.query("select count(*) from test", ()).await?;
assert_eq!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(0)
);
Ok(())
});
sim.run().unwrap();
}
#[test]
fn is_autocommit() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
assert!(conn.is_autocommit());
conn.execute("create table test (x)", ()).await?;
conn.execute("begin;", ()).await?;
assert!(!conn.is_autocommit());
conn.execute("insert into test values (12);", ()).await?;
conn.execute("commit;", ()).await?;
assert!(conn.is_autocommit());
// make an explicit transaction
{
let tx = conn.transaction().await?;
assert!(!tx.is_autocommit());
assert!(conn.is_autocommit()); // connection is still autocommit
tx.execute("insert into test values (12);", ()).await?;
// transaction rolls back
}
assert!(conn.is_autocommit());
let mut rows = conn.query("select count(*) from test", ()).await?;
assert_eq!(
rows.next().await.unwrap().unwrap().get_value(0).unwrap(),
Value::Integer(1)
);
Ok(())
});
sim.run().unwrap();
}
#[test]
fn random_rowid() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute(
"CREATE TABLE shopping_list(item text, quantity int) RANDOM ROWID",
(),
)
.await?;
Ok(())
});
sim.run().unwrap();
}
#[test]
fn dirty_startup_dont_prevent_namespace_creation() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", || async {
init_tracing();
let tmp = tempdir()?;
let server = TestServer {
path: tmp.path().to_owned().into(),
user_api_config: UserApiConfig {
hrana_ws_acceptor: None,
..Default::default()
},
admin_api_config: Some(AdminApiConfig {
acceptor: TurmoilAcceptor::bind(([0, 0, 0, 0], 9090)).await.unwrap(),
connector: TurmoilConnector,
disable_metrics: true,
}),
disable_default_namespace: true,
disable_namespaces: false,
..Default::default()
};
tokio::fs::File::create(tmp.path().join(".sentinel"))
.await
.unwrap();
server.start_sim(8080).await?;
Ok(())
});
sim.client("test", async {
let client = Client::new();
let resp = client
.post(
"http://primary:9090/v1/namespaces/test/create",
serde_json::json!({}),
)
.await
.unwrap();
assert!(resp.status().is_success());
Ok(())
});
sim.run().unwrap();
}
#[test]
fn row_count() {
let mut sim = turmoil::Builder::new()
.simulation_duration(Duration::from_secs(1000))
.build();
sim.host("primary", make_standalone_server);
sim.client("test", async {
let db = Database::open_remote_with_connector("http://primary:8080", "", TurmoilConnector)?;
let conn = db.connect()?;
conn.execute("CREATE TABLE test(a int, b int);", ()).await?;
conn.execute("BEGIN;", ()).await?;
insert_rows(&conn, 0, 10).await?;
insert_rows_with_args(&conn, 10, 10).await?;
assert_rows_count(&conn, 20).await?;
Ok(())
});
sim.run().unwrap();
}
async fn insert_rows(conn: &Connection, start: u32, count: u32) -> libsql::Result<()> {
for i in start..(start + count) {
conn.execute(&format!("INSERT INTO test(a, b) VALUES({i},'{i}')"), ())
.await?;
}
Ok(())
}
async fn insert_rows_with_args(conn: &Connection, start: u32, count: u32) -> libsql::Result<()> {
for i in start..(start + count) {
let mut stmt = conn.prepare("INSERT INTO test(a, b) VALUES(?,?)").await?;
stmt.execute(params![i, i]).await?;
}
Ok(())
}
async fn assert_rows_count(conn: &Connection, expected: u32) -> libsql::Result<()> {
let mut q = conn.query("SELECT COUNT(*) FROM test", ()).await?;
let row = q.next().await?.unwrap();
let count: u32 = row.get(0)?;
assert_eq!(count, expected);
Ok(())
}