521 lines
16 KiB
Rust
521 lines
16 KiB
Rust
use std::future::Future;
|
|
use std::panic::{AssertUnwindSafe, catch_unwind, resume_unwind};
|
|
use std::path::Path;
|
|
use std::sync::atomic::{AtomicU64, Ordering};
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|
|
|
use dever_runtime::config::{Database as DatabaseSetting, PostgresTls, Settings};
|
|
use dever_runtime::orm::Value;
|
|
use dever_runtime::postgres::{ConnectionOptions, Database};
|
|
|
|
const POSTGRES_TEST_CONNECTION: &str = "postgres_test";
|
|
const MAX_PAGE_SIZE: usize = 100;
|
|
|
|
static NEXT_SCHEMA: AtomicU64 = AtomicU64::new(0);
|
|
|
|
pub struct IsolatedDatabase {
|
|
document: serde_json::Value,
|
|
url: String,
|
|
tls: PostgresTls,
|
|
}
|
|
|
|
impl IsolatedDatabase {
|
|
pub fn url(&self) -> &str {
|
|
&self.url
|
|
}
|
|
|
|
pub fn tls(&self) -> PostgresTls {
|
|
self.tls
|
|
}
|
|
|
|
pub fn open(
|
|
&self,
|
|
max_connections: usize,
|
|
wait_timeout: Duration,
|
|
io_timeout: Duration,
|
|
) -> Database {
|
|
open_database(
|
|
&self.url,
|
|
self.tls,
|
|
max_connections,
|
|
wait_timeout,
|
|
io_timeout,
|
|
)
|
|
}
|
|
|
|
pub fn settings_json(&self) -> String {
|
|
let mut connection = self.document["database"][POSTGRES_TEST_CONNECTION].clone();
|
|
connection["url"] = serde_json::Value::String(self.url.clone());
|
|
let mut document = serde_json::Map::new();
|
|
for name in ["http", "log"] {
|
|
if let Some(value) = self.document.get(name) {
|
|
document.insert(name.to_owned(), value.clone());
|
|
}
|
|
}
|
|
if let Some(value) = self.document.get("tenant") {
|
|
let mut tenant = value.clone();
|
|
tenant["database"] = serde_json::Value::String("default".into());
|
|
document.insert("tenant".into(), tenant);
|
|
}
|
|
document.insert(
|
|
"database".into(),
|
|
serde_json::json!({"default": connection}),
|
|
);
|
|
serde_json::to_string_pretty(&document).unwrap() + "\n"
|
|
}
|
|
}
|
|
|
|
pub struct IsolatedTenantDatabases {
|
|
database_setting: serde_json::Value,
|
|
}
|
|
|
|
impl IsolatedTenantDatabases {
|
|
pub fn database_setting(&self) -> serde_json::Value {
|
|
self.database_setting.clone()
|
|
}
|
|
}
|
|
|
|
pub fn run_in_isolated_databases<F, T>(case_name: &str, test: F) -> T
|
|
where
|
|
F: FnOnce(IsolatedTenantDatabases) -> Result<T, String>,
|
|
{
|
|
let setting = load_setting(case_name);
|
|
let suffix = unique_namespace();
|
|
let control_case = format!("{case_name}_{suffix}");
|
|
let template = setting.document["database"][POSTGRES_TEST_CONNECTION]["url"]
|
|
.as_str()
|
|
.unwrap();
|
|
let control_url = case_url(template, &control_case);
|
|
let control_name = database_name(&control_url);
|
|
let tenant_prefix = format!("dever_t_{suffix}");
|
|
assert!(control_name.len() <= 63 && valid_case_name(&control_name));
|
|
assert!(tenant_prefix.len() <= 43 && valid_case_name(&tenant_prefix));
|
|
|
|
let mut cleanup_required = false;
|
|
let setup = catch_unwind(AssertUnwindSafe(|| {
|
|
dever_runtime::task::run_entry(async {
|
|
let administrator = open_database(
|
|
&setting.url,
|
|
setting.tls,
|
|
1,
|
|
Duration::from_secs(1),
|
|
Duration::from_secs(5),
|
|
);
|
|
let result = async {
|
|
let existing = database_names(&administrator).await?;
|
|
if existing.iter().any(|name| {
|
|
name == &control_name || name.starts_with(&format!("{tenant_prefix}_"))
|
|
}) {
|
|
return Err("isolated PostgreSQL database names already exist".into());
|
|
}
|
|
cleanup_required = true;
|
|
administrator
|
|
.query_owned(format!("CREATE DATABASE \"{control_name}\""), vec![])
|
|
.await
|
|
.map_err(|error| error.to_string())?;
|
|
Ok(())
|
|
}
|
|
.await;
|
|
let close = administrator
|
|
.close()
|
|
.await
|
|
.map_err(|error| error.to_string());
|
|
result.and(close)
|
|
})
|
|
}));
|
|
|
|
let mut database_setting = setting.document["database"][POSTGRES_TEST_CONNECTION].clone();
|
|
database_setting["url"] = serde_json::Value::String(control_url);
|
|
database_setting["tenant_database_prefix"] = serde_json::Value::String(tenant_prefix.clone());
|
|
let result = match setup {
|
|
Ok(Ok(())) => catch_unwind(AssertUnwindSafe(|| {
|
|
test(IsolatedTenantDatabases { database_setting })
|
|
})),
|
|
Ok(Err(error)) => Ok(Err(error)),
|
|
Err(panic) => Err(panic),
|
|
};
|
|
let cleanup = cleanup_required.then(|| {
|
|
catch_unwind(AssertUnwindSafe(|| {
|
|
dever_runtime::task::run_entry(cleanup_databases(
|
|
&setting.url,
|
|
setting.tls,
|
|
&control_name,
|
|
&tenant_prefix,
|
|
))
|
|
}))
|
|
});
|
|
let cleanup_error = match cleanup {
|
|
None | Some(Ok(Ok(()))) => None,
|
|
Some(Ok(Err(error))) => Some(error),
|
|
Some(Err(_)) => Some("PostgreSQL database cleanup panicked".into()),
|
|
};
|
|
match result {
|
|
Ok(Ok(value)) => {
|
|
if let Some(error) = cleanup_error {
|
|
panic!("PostgreSQL database cleanup failed: {error}");
|
|
}
|
|
value
|
|
}
|
|
Ok(Err(error)) => match cleanup_error {
|
|
Some(cleanup_error) => {
|
|
panic!("{error}; PostgreSQL database cleanup failed: {cleanup_error}")
|
|
}
|
|
None => panic!("{error}"),
|
|
},
|
|
Err(panic) => {
|
|
if let Some(error) = cleanup_error {
|
|
eprintln!("PostgreSQL database cleanup failed after panic: {error}");
|
|
}
|
|
resume_unwind(panic);
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn database_names(administrator: &Database) -> Result<Vec<String>, String> {
|
|
let rows = administrator
|
|
.query("SELECT datname::text FROM pg_database", vec![])
|
|
.await
|
|
.map_err(|error| error.to_string())?;
|
|
rows.into_iter()
|
|
.map(|row| match row.get(0).map_err(|error| error.to_string())? {
|
|
Value::Text(name) => Ok(name.clone()),
|
|
_ => Err("PostgreSQL database name was not Text".into()),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
async fn cleanup_databases(
|
|
administrator_url: &str,
|
|
tls: PostgresTls,
|
|
control_name: &str,
|
|
tenant_prefix: &str,
|
|
) -> Result<(), String> {
|
|
let administrator = open_database(
|
|
administrator_url,
|
|
tls,
|
|
1,
|
|
Duration::from_secs(1),
|
|
Duration::from_secs(5),
|
|
);
|
|
let result = async {
|
|
let mut failures = Vec::new();
|
|
match database_names(&administrator).await {
|
|
Ok(names) => {
|
|
for name in owned_tenant_database_names(names, tenant_prefix) {
|
|
if let Err(error) = administrator
|
|
.query_owned(format!("DROP DATABASE \"{name}\""), vec![])
|
|
.await
|
|
{
|
|
failures.push(format!("cannot drop owned tenant database {name}: {error}"));
|
|
}
|
|
}
|
|
}
|
|
Err(error) => failures.push(format!("cannot list owned tenant databases: {error}")),
|
|
}
|
|
if let Err(error) = administrator
|
|
.query_owned(
|
|
format!("DROP DATABASE IF EXISTS \"{control_name}\""),
|
|
vec![],
|
|
)
|
|
.await
|
|
{
|
|
failures.push(format!(
|
|
"cannot drop owned control database {control_name}: {error}"
|
|
));
|
|
}
|
|
if failures.is_empty() {
|
|
Ok(())
|
|
} else {
|
|
Err(failures.join("; "))
|
|
}
|
|
}
|
|
.await;
|
|
let close = administrator
|
|
.close()
|
|
.await
|
|
.map_err(|error| error.to_string());
|
|
result.and(close)
|
|
}
|
|
|
|
fn owned_tenant_database_names(names: Vec<String>, prefix: &str) -> Vec<String> {
|
|
let marker = format!("{prefix}_");
|
|
names
|
|
.into_iter()
|
|
.filter(|name| {
|
|
name.strip_prefix(&marker)
|
|
.and_then(|id| {
|
|
id.parse::<u64>()
|
|
.ok()
|
|
.filter(|value| *value > 0)
|
|
.map(|value| value.to_string() == id)
|
|
})
|
|
.unwrap_or(false)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn run_in_isolated_schema<F, Fut>(case_name: &str, test: F)
|
|
where
|
|
F: FnOnce(IsolatedDatabase) -> Fut,
|
|
Fut: Future<Output = Result<(), String>>,
|
|
{
|
|
let setting = load_setting(case_name);
|
|
let schema = unique_schema();
|
|
let cleanup_url = setting.url.clone();
|
|
let cleanup_schema = schema.clone();
|
|
let tls = setting.tls;
|
|
let result = catch_unwind(AssertUnwindSafe(|| {
|
|
dever_runtime::task::run_entry(async move {
|
|
let administrator = open_database(
|
|
&setting.url,
|
|
tls,
|
|
2,
|
|
Duration::from_secs(1),
|
|
Duration::from_secs(5),
|
|
);
|
|
administrator
|
|
.query_owned(format!("CREATE SCHEMA \"{schema}\""), vec![])
|
|
.await
|
|
.map_err(|error| error.to_string())?;
|
|
administrator
|
|
.close()
|
|
.await
|
|
.map_err(|error| error.to_string())?;
|
|
test(IsolatedDatabase {
|
|
document: setting.document,
|
|
url: scoped_url(&setting.url, &schema),
|
|
tls,
|
|
})
|
|
.await
|
|
})
|
|
}));
|
|
let cleanup = catch_unwind(AssertUnwindSafe(|| {
|
|
dever_runtime::task::run_entry(async move {
|
|
let administrator = open_database(
|
|
&cleanup_url,
|
|
tls,
|
|
1,
|
|
Duration::from_secs(1),
|
|
Duration::from_secs(5),
|
|
);
|
|
let drop_result = administrator
|
|
.query_owned(
|
|
format!("DROP SCHEMA IF EXISTS \"{cleanup_schema}\" CASCADE"),
|
|
vec![],
|
|
)
|
|
.await;
|
|
let close_result = administrator.close().await;
|
|
drop_result.map_err(|error| error.to_string())?;
|
|
close_result.map_err(|error| error.to_string())?;
|
|
Ok(())
|
|
})
|
|
}));
|
|
match result {
|
|
Ok(result) => {
|
|
cleanup.unwrap().unwrap();
|
|
result.unwrap();
|
|
}
|
|
Err(panic) => {
|
|
let _ = cleanup;
|
|
resume_unwind(panic);
|
|
}
|
|
}
|
|
}
|
|
|
|
struct PostgresTestSetting {
|
|
document: serde_json::Value,
|
|
url: String,
|
|
tls: PostgresTls,
|
|
}
|
|
|
|
fn load_setting(case_name: &str) -> PostgresTestSetting {
|
|
assert!(
|
|
valid_case_name(case_name),
|
|
"PostgreSQL acceptance case names must use lower_snake_case"
|
|
);
|
|
let workspace = Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
|
|
let settings = Settings::load_project(&workspace).unwrap_or_else(|error| {
|
|
panic!(
|
|
"PostgreSQL acceptance requires '{}': {error}",
|
|
workspace.join("config/setting.json").display()
|
|
)
|
|
});
|
|
let (url, tls) = match settings.database(POSTGRES_TEST_CONNECTION) {
|
|
Some(DatabaseSetting::Postgres { url, tls, .. }) => (case_url(url, case_name), *tls),
|
|
Some(DatabaseSetting::Sqlite { .. }) => {
|
|
panic!("database.{POSTGRES_TEST_CONNECTION} must use type 'postgres'")
|
|
}
|
|
None => panic!("database.{POSTGRES_TEST_CONNECTION} is required"),
|
|
};
|
|
let document = serde_json::from_str(
|
|
&std::fs::read_to_string(workspace.join("config/setting.json")).unwrap(),
|
|
)
|
|
.unwrap();
|
|
PostgresTestSetting { document, url, tls }
|
|
}
|
|
|
|
fn case_url(template: &str, case_name: &str) -> String {
|
|
let (url, query) = template
|
|
.split_once('?')
|
|
.map_or((template, ""), |(url, query)| (url, query));
|
|
let database = url.rsplit_once('/').map_or("", |(_, database)| database);
|
|
assert!(
|
|
matches!(
|
|
template.split_once("://"),
|
|
Some(("postgres" | "postgresql", _))
|
|
) && template.matches("{case}").count() == 1
|
|
&& database.matches("{case}").count() == 1
|
|
&& !query_overrides_database(query),
|
|
concat!(
|
|
"config/setting.json database.postgres_test.url must contain exactly one ",
|
|
"{{case}} placeholder in its database name and must not override it with dbname"
|
|
)
|
|
);
|
|
template.replace("{case}", case_name)
|
|
}
|
|
|
|
fn query_overrides_database(query: &str) -> bool {
|
|
query.split('&').any(|parameter| {
|
|
let key = parameter.split_once('=').map_or(parameter, |(key, _)| key);
|
|
percent_decode(key).as_deref() == Some(b"dbname")
|
|
})
|
|
}
|
|
|
|
fn percent_decode(value: &str) -> Option<Vec<u8>> {
|
|
let bytes = value.as_bytes();
|
|
let mut decoded = Vec::with_capacity(bytes.len());
|
|
let mut index = 0;
|
|
while index < bytes.len() {
|
|
if bytes[index] != b'%' {
|
|
decoded.push(bytes[index]);
|
|
index += 1;
|
|
continue;
|
|
}
|
|
let high = hex_digit(*bytes.get(index + 1)?)?;
|
|
let low = hex_digit(*bytes.get(index + 2)?)?;
|
|
decoded.push(high * 16 + low);
|
|
index += 3;
|
|
}
|
|
Some(decoded)
|
|
}
|
|
|
|
fn hex_digit(byte: u8) -> Option<u8> {
|
|
match byte {
|
|
b'0'..=b'9' => Some(byte - b'0'),
|
|
b'a'..=b'f' => Some(byte - b'a' + 10),
|
|
b'A'..=b'F' => Some(byte - b'A' + 10),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn valid_case_name(case_name: &str) -> bool {
|
|
!case_name.is_empty()
|
|
&& case_name.starts_with(|character: char| character.is_ascii_lowercase())
|
|
&& case_name.split('_').all(|part| {
|
|
!part.is_empty()
|
|
&& part
|
|
.chars()
|
|
.all(|character| character.is_ascii_lowercase() || character.is_ascii_digit())
|
|
})
|
|
}
|
|
|
|
fn unique_schema() -> String {
|
|
let nanos = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos();
|
|
format!(
|
|
"dever_t_{:x}_{:x}_{:x}",
|
|
std::process::id(),
|
|
nanos,
|
|
NEXT_SCHEMA.fetch_add(1, Ordering::Relaxed)
|
|
)
|
|
}
|
|
|
|
fn unique_namespace() -> String {
|
|
let nanos = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_nanos();
|
|
format!(
|
|
"{:x}_{:x}_{:x}",
|
|
std::process::id(),
|
|
nanos,
|
|
NEXT_SCHEMA.fetch_add(1, Ordering::Relaxed)
|
|
)
|
|
}
|
|
|
|
fn database_name(url: &str) -> String {
|
|
let path = url.split_once('?').map_or(url, |(path, _)| path);
|
|
path.rsplit_once('/').unwrap().1.to_owned()
|
|
}
|
|
|
|
fn scoped_url(url: &str, schema: &str) -> String {
|
|
let separator = if url.contains('?') { '&' } else { '?' };
|
|
format!("{url}{separator}options=-csearch_path%3D{schema}")
|
|
}
|
|
|
|
pub(crate) fn open_database(
|
|
url: &str,
|
|
tls: PostgresTls,
|
|
max_connections: usize,
|
|
wait_timeout: Duration,
|
|
io_timeout: Duration,
|
|
) -> Database {
|
|
Database::open(ConnectionOptions {
|
|
url,
|
|
database_name: None,
|
|
tls,
|
|
min_connections: 0,
|
|
max_connections,
|
|
max_page_size: MAX_PAGE_SIZE,
|
|
wait_timeout,
|
|
io_timeout,
|
|
})
|
|
.unwrap()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{case_url, owned_tenant_database_names};
|
|
|
|
#[test]
|
|
fn case_placeholder_must_select_the_effective_database() {
|
|
assert_eq!(
|
|
case_url(
|
|
"postgresql://dever@localhost/dever_{case}?sslmode=disable",
|
|
"authorization_postgres",
|
|
),
|
|
"postgresql://dever@localhost/dever_authorization_postgres?sslmode=disable"
|
|
);
|
|
for url in [
|
|
"postgresql://dever@localhost/dever_{case}?dbname=production",
|
|
"postgresql://dever@localhost/dever_{case}?%64bname=production",
|
|
"postgresql://dever@localhost/dever?application_name={case}",
|
|
] {
|
|
assert!(
|
|
std::panic::catch_unwind(|| case_url(url, "postgres_orm")).is_err(),
|
|
"URL must be rejected: {url}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn cleanup_only_selects_this_run_and_canonical_positive_tenant_ids() {
|
|
let names = [
|
|
"dever_t_run_1",
|
|
"dever_t_run_2",
|
|
"dever_t_run_0",
|
|
"dever_t_run_01",
|
|
"dever_t_run_-1",
|
|
"dever_t_run_1_extra",
|
|
"dever_t_run2_1",
|
|
"dever_t_run",
|
|
];
|
|
assert_eq!(
|
|
owned_tenant_database_names(names.map(str::to_owned).to_vec(), "dever_t_run"),
|
|
["dever_t_run_1", "dever_t_run_2"],
|
|
);
|
|
}
|
|
}
|