9d0e762f36
* permissions tests * finished permissions; organization tests * clippy, fmt * post-merge fixes * teams changes * refactored to use new api * fmt, clippy * sqlx prepare * revs * revs * re-tested * re-added name * reverted to matrix
114 lines
3.1 KiB
Rust
114 lines
3.1 KiB
Rust
#![allow(dead_code)]
|
|
|
|
use std::{rc::Rc, sync::Arc};
|
|
|
|
use super::{
|
|
api_v2::ApiV2,
|
|
asserts::assert_status,
|
|
database::{TemporaryDatabase, FRIEND_USER_ID, USER_USER_PAT},
|
|
dummy_data,
|
|
};
|
|
use crate::common::setup;
|
|
use actix_http::StatusCode;
|
|
use actix_web::{dev::ServiceResponse, test, App};
|
|
use futures::Future;
|
|
|
|
pub async fn with_test_environment<Fut>(f: impl FnOnce(TestEnvironment) -> Fut)
|
|
where
|
|
Fut: Future<Output = ()>,
|
|
{
|
|
let test_env = TestEnvironment::build(None).await;
|
|
let db = test_env.db.clone();
|
|
|
|
f(test_env).await;
|
|
|
|
db.cleanup().await;
|
|
}
|
|
|
|
// A complete test environment, with a test actix app and a database.
|
|
// Must be called in an #[actix_rt::test] context. It also simulates a
|
|
// temporary sqlx db like #[sqlx::test] would.
|
|
// Use .call(req) on it directly to make a test call as if test::call_service(req) were being used.
|
|
#[derive(Clone)]
|
|
pub struct TestEnvironment {
|
|
test_app: Rc<dyn LocalService>, // Rc as it's not Send
|
|
pub db: TemporaryDatabase,
|
|
pub v2: ApiV2,
|
|
|
|
pub dummy: Option<Arc<dummy_data::DummyData>>,
|
|
}
|
|
|
|
impl TestEnvironment {
|
|
pub async fn build(max_connections: Option<u32>) -> Self {
|
|
let db = TemporaryDatabase::create(max_connections).await;
|
|
let mut test_env = Self::build_with_db(db).await;
|
|
|
|
let dummy = dummy_data::get_dummy_data(&test_env).await;
|
|
test_env.dummy = Some(Arc::new(dummy));
|
|
test_env
|
|
}
|
|
|
|
pub async fn build_with_db(db: TemporaryDatabase) -> Self {
|
|
let labrinth_config = setup(&db).await;
|
|
let app = App::new().configure(|cfg| labrinth::app_config(cfg, labrinth_config.clone()));
|
|
let test_app: Rc<dyn LocalService> = Rc::new(test::init_service(app).await);
|
|
Self {
|
|
v2: ApiV2 {
|
|
test_app: test_app.clone(),
|
|
},
|
|
test_app,
|
|
db,
|
|
dummy: None,
|
|
}
|
|
}
|
|
|
|
pub async fn cleanup(self) {
|
|
self.db.cleanup().await;
|
|
}
|
|
|
|
pub async fn call(&self, req: actix_http::Request) -> ServiceResponse {
|
|
self.test_app.call(req).await.unwrap()
|
|
}
|
|
|
|
pub async fn generate_friend_user_notification(&self) {
|
|
let resp = self
|
|
.v2
|
|
.add_user_to_team(
|
|
&self.dummy.as_ref().unwrap().project_alpha.team_id,
|
|
FRIEND_USER_ID,
|
|
None,
|
|
None,
|
|
USER_USER_PAT,
|
|
)
|
|
.await;
|
|
assert_status(resp, StatusCode::NO_CONTENT);
|
|
}
|
|
}
|
|
|
|
pub trait LocalService {
|
|
fn call(
|
|
&self,
|
|
req: actix_http::Request,
|
|
) -> std::pin::Pin<
|
|
Box<dyn std::future::Future<Output = Result<ServiceResponse, actix_web::Error>>>,
|
|
>;
|
|
}
|
|
impl<S> LocalService for S
|
|
where
|
|
S: actix_web::dev::Service<
|
|
actix_http::Request,
|
|
Response = ServiceResponse,
|
|
Error = actix_web::Error,
|
|
>,
|
|
S::Future: 'static,
|
|
{
|
|
fn call(
|
|
&self,
|
|
req: actix_http::Request,
|
|
) -> std::pin::Pin<
|
|
Box<dyn std::future::Future<Output = Result<ServiceResponse, actix_web::Error>>>,
|
|
> {
|
|
Box::pin(self.call(req))
|
|
}
|
|
}
|