π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use std::{
fs,
future::Future,
path::{Path, PathBuf},
};
use uuid::Uuid;
use crate::{
TestResult,
net::{LOCAL_HOST, free_port},
object_store::ObjectStore,
postgres,
process::ChildProcess,
server,
};
pub struct Museum {
_server: ChildProcess,
_postgres: postgres::Postgres,
_object_store: ObjectStore,
temp_dir: TempDir,
endpoint: String,
}
impl Museum {
pub fn run(test: impl FnOnce(&Self) -> TestResult) -> TestResult {
Self::run_with_env(&[], test)
}
pub fn run_with_env(
env: &[(&str, &str)],
test: impl FnOnce(&Self) -> TestResult,
) -> TestResult {
let mut museum = Self::start(env)?;
match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| test(&museum))) {
Ok(Ok(())) => Ok(()),
Ok(Err(error)) => {
museum.temp_dir.retain();
Err(error)
}
Err(panic) => {
museum.temp_dir.retain();
std::panic::resume_unwind(panic);
}
}
}
pub fn run_async<F, Fut>(test: F) -> TestResult
where
F: FnOnce(String) -> Fut,
Fut: Future<Output = TestResult>,
{
Self::run(|museum| tokio::runtime::Runtime::new()?.block_on(test(museum.endpoint.clone())))
}
fn start(env: &[(&str, &str)]) -> TestResult<Self> {
let server_dir = server_dir()?;
let mut temp_dir = TempDir::new("ente-test")?;
let museum_port = free_port()?;
let endpoint = format!("http://{LOCAL_HOST}:{museum_port}");
let museum_config_file = temp_dir.path().join("museum.yaml");
let museum_bin = temp_dir.path().join("museum");
let result = (|| {
let object_store = ObjectStore::start()?;
server::write_config(&museum_config_file)?;
let postgres = postgres::start()?;
let server = server::start(
&server_dir,
env,
&museum_config_file,
museum_port,
&museum_bin,
&postgres,
&object_store.endpoint(),
)?;
Ok((postgres, object_store, server))
})();
let (postgres, object_store, server) = match result {
Ok(processes) => processes,
Err(error) => {
temp_dir.retain();
return Err(error);
}
};
Ok(Self {
_server: server,
_postgres: postgres,
_object_store: object_store,
temp_dir,
endpoint,
})
}
pub fn endpoint(&self) -> &str {
&self.endpoint
}
pub fn temp_dir(&self) -> &Path {
self.temp_dir.path()
}
pub fn object_store(&self) -> std::sync::Arc<crate::ObjectStoreControl> {
self._object_store.control.clone()
}
pub fn execute_sql(&self, sql: &str) -> TestResult {
self._postgres.execute_sql(sql)
}
}
fn server_dir() -> TestResult<PathBuf> {
let crate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
let repo_dir = crate_dir
.parent()
.and_then(Path::parent)
.and_then(Path::parent)
.ok_or("failed to resolve repository directory")?;
Ok(repo_dir.join("server"))
}
struct TempDir {
path: PathBuf,
retained: bool,
}
impl TempDir {
fn new(prefix: &str) -> TestResult<Self> {
let path = std::env::temp_dir().join(format!("{prefix}-{}", Uuid::new_v4()));
fs::create_dir_all(&path)?;
Ok(Self {
path,
retained: false,
})
}
fn path(&self) -> &Path {
&self.path
}
fn retain(&mut self) {
eprintln!(
"retaining integration test temp dir: {}",
self.path.display()
);
self.retained = true;
}
}
impl Drop for TempDir {
fn drop(&mut self) {
if !self.retained {
let _ = fs::remove_dir_all(&self.path);
}
}
}