MeiliSearch/meilisearch-http/tests/common/server.rs

165 lines
4.7 KiB
Rust
Raw Normal View History

2021-12-15 10:30:00 +01:00
#![allow(dead_code)]
use clap::Parser;
2021-03-24 11:03:01 +01:00
use std::path::Path;
2021-03-10 14:43:10 +01:00
use actix_web::http::StatusCode;
2021-02-18 19:50:52 +01:00
use byte_unit::{Byte, ByteUnit};
use meilisearch_auth::AuthController;
2021-09-28 18:10:09 +02:00
use meilisearch_http::setup_meilisearch;
use meilisearch_lib::options::{IndexerOpts, MaxMemory};
use once_cell::sync::Lazy;
2021-02-19 19:14:25 +01:00
use serde_json::Value;
2021-09-28 18:10:09 +02:00
use tempfile::TempDir;
2021-02-18 19:50:52 +01:00
2021-09-28 18:10:09 +02:00
use meilisearch_http::option::Opt;
2021-02-18 19:50:52 +01:00
use super::index::Index;
use super::service::Service;
pub struct Server {
2021-02-24 09:30:51 +01:00
pub service: Service,
2021-03-24 11:03:01 +01:00
// hold ownership to the tempdir while we use the server instance.
2021-09-28 18:10:09 +02:00
_dir: Option<TempDir>,
2021-02-18 19:50:52 +01:00
}
pub static TEST_TEMP_DIR: Lazy<TempDir> = Lazy::new(|| TempDir::new().unwrap());
2021-09-28 18:10:09 +02:00
2021-02-18 19:50:52 +01:00
impl Server {
pub async fn new() -> Self {
2021-09-28 18:10:09 +02:00
let dir = TempDir::new().unwrap();
if cfg!(windows) {
std::env::set_var("TMP", TEST_TEMP_DIR.path());
} else {
std::env::set_var("TMPDIR", TEST_TEMP_DIR.path());
}
2021-02-18 19:50:52 +01:00
2021-09-28 18:10:09 +02:00
let options = default_settings(dir.path());
2021-02-18 19:50:52 +01:00
2021-09-28 18:10:09 +02:00
let meilisearch = setup_meilisearch(&options).unwrap();
let auth = AuthController::new(&options.db_path, &options.master_key).unwrap();
2021-09-28 22:22:59 +02:00
let service = Service {
meilisearch,
auth,
2021-09-28 22:22:59 +02:00
options,
api_key: None,
2021-09-28 22:22:59 +02:00
};
2021-02-18 19:50:52 +01:00
2021-03-24 11:29:11 +01:00
Server {
service,
_dir: Some(dir),
}
2021-03-24 11:03:01 +01:00
}
pub async fn new_auth() -> Self {
let dir = TempDir::new().unwrap();
if cfg!(windows) {
std::env::set_var("TMP", TEST_TEMP_DIR.path());
} else {
std::env::set_var("TMPDIR", TEST_TEMP_DIR.path());
}
let mut options = default_settings(dir.path());
options.master_key = Some("MASTER_KEY".to_string());
let meilisearch = setup_meilisearch(&options).unwrap();
let auth = AuthController::new(&options.db_path, &options.master_key).unwrap();
let service = Service {
meilisearch,
auth,
options,
api_key: None,
};
Server {
service,
_dir: Some(dir),
}
}
2022-04-28 10:48:57 +02:00
pub async fn new_with_options(options: Opt) -> Result<Self, anyhow::Error> {
let meilisearch = setup_meilisearch(&options)?;
let auth = AuthController::new(&options.db_path, &options.master_key)?;
2021-09-28 22:22:59 +02:00
let service = Service {
meilisearch,
auth,
2021-09-28 22:22:59 +02:00
options,
api_key: None,
2021-09-28 22:22:59 +02:00
};
2021-03-24 11:03:01 +01:00
2022-04-28 10:48:57 +02:00
Ok(Server {
2021-03-24 11:29:11 +01:00
service,
_dir: None,
2022-04-28 10:48:57 +02:00
})
2021-02-18 19:50:52 +01:00
}
/// Returns a view to an index. There is no guarantee that the index exists.
2021-05-31 16:03:39 +02:00
pub fn index(&self, uid: impl AsRef<str>) -> Index<'_> {
2021-02-18 19:50:52 +01:00
Index {
2021-11-03 14:25:49 +01:00
uid: uid.as_ref().to_string(),
2021-02-18 19:50:52 +01:00
service: &self.service,
}
}
pub async fn list_indexes(
&self,
offset: Option<usize>,
limit: Option<usize>,
) -> (Value, StatusCode) {
let (offset, limit) = (
offset.map(|offset| format!("offset={offset}")),
limit.map(|limit| format!("limit={limit}")),
);
let query_parameter = offset
.as_ref()
.zip(limit.as_ref())
.map(|(offset, limit)| format!("{offset}&{limit}"))
.or_else(|| offset.xor(limit));
if let Some(query_parameter) = query_parameter {
self.service
.get(format!("/indexes?{query_parameter}"))
.await
} else {
self.service.get("/indexes").await
}
2021-02-19 19:14:25 +01:00
}
2021-03-15 19:08:19 +01:00
pub async fn version(&self) -> (Value, StatusCode) {
self.service.get("/version").await
}
2021-04-01 20:54:37 +02:00
pub async fn stats(&self) -> (Value, StatusCode) {
self.service.get("/stats").await
}
pub async fn tasks(&self) -> (Value, StatusCode) {
self.service.get("/tasks").await
}
2021-12-15 10:30:00 +01:00
pub async fn get_dump_status(&self, uid: &str) -> (Value, StatusCode) {
self.service.get(format!("/dumps/{}/status", uid)).await
}
2021-02-18 19:50:52 +01:00
}
2021-03-24 11:03:01 +01:00
pub fn default_settings(dir: impl AsRef<Path>) -> Opt {
Opt {
db_path: dir.as_ref().join("db"),
dumps_dir: dir.as_ref().join("dump"),
env: "development".to_owned(),
2021-06-16 17:12:49 +02:00
#[cfg(all(not(debug_assertions), feature = "analytics"))]
2022-01-12 15:57:31 +01:00
no_analytics: true,
max_index_size: Byte::from_unit(100.0, ByteUnit::MiB).unwrap(),
max_task_db_size: Byte::from_unit(1.0, ByteUnit::GiB).unwrap(),
2021-03-24 11:03:01 +01:00
http_payload_size_limit: Byte::from_unit(10.0, ByteUnit::MiB).unwrap(),
snapshot_dir: ".".into(),
indexer_options: IndexerOpts {
// memory has to be unlimited because several meilisearch are running in test context.
max_indexing_memory: MaxMemory::unlimited(),
..Parser::parse_from(None as Option<&str>)
},
..Parser::parse_from(None as Option<&str>)
2021-03-24 11:03:01 +01:00
}
}