Rewrote tests for repositories

backend/api/src/api/repository/data/search.rs

@@ -4,6 +4,7 @@ use utoipa::IntoParams;
 use validify::Validify;
 
 #[derive(Validify, Deserialize, IntoParams, Debug)]
+#[serde(rename_all = "camelCase")]
 pub struct SearchRepositoryParams {
  pub order_by: Option<String>,
  pub order: Option<Order>,

backend/tests/Cargo.toml

@@ -18,3 +18,5 @@ support.workspace = true
 tokio.workspace = true
 uuid.workspace = true
 chrono.workspace = true
+adtest.workspace = true
+lazy_static.workspace = true

backend/tests/src/cryptocurrencies/mod.rs

@@ -1,13 +1,13 @@
-use sea_orm::DatabaseConnection;
+// use sea_orm::DatabaseConnection;
 
-mod get;
-mod get_id;
-mod get_issues;
+// mod get;
+// mod get_id;
+// mod get_issues;
 
-mod helpers;
+// mod helpers;
 
-pub async fn test(sea_pool: &DatabaseConnection) {
- get::api_v1_crypto(sea_pool).await;
- get_id::api_v1_crypto_id(sea_pool).await;
- get_issues::api_v1_repository_id_issues(sea_pool).await;
-}
+// pub async fn test(sea_pool: &DatabaseConnection) {
+//  get::api_v1_crypto(sea_pool).await;
+//  get_id::api_v1_crypto_id(sea_pool).await;
+//  get_issues::api_v1_repository_id_issues(sea_pool).await;
+// }

backend/tests/src/e2e_api.rs

@@ -1,22 +1,19 @@
-use sea_orm::Database;
-use std::{sync::Arc, time::Duration};
+use sea_orm::DatabaseConnection;
+use std::{future::Future, sync::Arc, time::Duration};
 use tokio::time::sleep;
 
-use crate::cryptocurrencies;
-
-#[tokio::test]
-async fn e2e_api() {
- let db_url = config::get("DATABASE_URL").unwrap();
- let pool = Database::connect(db_url).await.unwrap();
- let sea_pool = Arc::new(pool.clone());
-
+pub async fn run_e2e_api_tests<F, T>(sea_pool: Arc<DatabaseConnection>, test_function: F)
+where
+ F: Fn() -> T,
+ T: Future<Output = ()>,
+{
  let routes = api::create_api(sea_pool);
 
  let handle = tokio::spawn(async move { routes.await });
 
  sleep(Duration::from_secs(1)).await;
 
- cryptocurrencies::test(&pool).await;
+ test_function().await;
 
  handle.abort();
 }

backend/tests/src/lib.rs

@@ -1,5 +1,8 @@
 pub mod cryptocurrencies;
-pub mod request;
-
 #[cfg(test)]
-mod e2e_api;
+pub mod repository;
+
+
+pub mod request;
+pub mod e2e_api;
+pub mod helpers;

backend/tests/src/repository/get_id.rs

@@ -0,0 +1,17 @@
+use reqwest::Method;
+use store::objects::RepositoryView;
+use uuid::Uuid;
+
+use crate::request::request;
+
+const ROUTE: &str = "/api/v1/repository/{id}";
+
+pub async fn get_id(id: Uuid) {
+ let url = ROUTE.replace("{id}", &id.to_string());
+
+ let repository: RepositoryView = request(url, Method::GET, (), ())
+ .await
+ .expect("Error getting repository");
+
+ assert_eq!(repository.name, "good-repo");
+}

backend/tests/src/repository/get_issues.rs

@@ -0,0 +1,30 @@
+use reqwest::Method;
+use support::pagination::PaginatedGithubIssue;
+use uuid::Uuid;
+
+use crate::request::request;
+
+const ROUTE: &str = "/api/v1/repository/{id}/issues";
+
+pub async fn get_issues(id: Uuid) {
+ let url = ROUTE.replace("{id}", id.to_string().as_str());
+
+ let issues: PaginatedGithubIssue = request(&url, Method::GET, (), ())
+ .await
+ .expect("Error getting issues");
+
+ assert_eq!(issues.total_items, 1);
+ assert_eq!(issues.data.len(), 1);
+
+ let issues: PaginatedGithubIssue = request(
+ url,
+ Method::GET,
+ [("closed", "true"), ("search", "Ricky")],
+ (),
+ )
+ .await
+ .expect("Error getting issues");
+
+ assert_eq!(issues.total_items, 0);
+ assert_eq!(issues.data.len(), 0);
+}

backend/tests/src/repository/mod.rs

@@ -0,0 +1,86 @@
+use std::sync::Arc;
+
+use lazy_static::lazy_static;
+use sea_orm::{sea_query::OnConflict, DatabaseConnection, EntityTrait, Set};
+use store::{github_projects, github_repositories, issues};
+use support::db_pool::create_db_pool;
+use uuid::Uuid;
+
+use crate::{e2e_api::run_e2e_api_tests, helpers::default_github_repo};
+
+mod get_id;
+mod get_issues;
+mod search;
+
+lazy_static! {
+ pub static ref GITHUB_UUID: Uuid = Uuid::new_v4();
+}
+
+#[adtest::adtest(
+ setup = async test_setup,
+ cleanup = async test_cleanup
+)]
+async fn repository_route() {
+ let (sea_pool, _) = _setup_;
+
+ run_e2e_api_tests(sea_pool, test_routes).await;
+}
+
+async fn test_setup() -> (Arc<DatabaseConnection>, github_projects::Model) {
+ let sea_pool = create_db_pool().await;
+ let github = github_projects::ActiveModel {
+ id: Set(*GITHUB_UUID),
+ name: Set("TestGit".to_owned()),
+ };
+
+ let github = github_projects::Entity::insert(github)
+ .on_conflict(
+ OnConflict::column(github_projects::Column::Name)
+ .do_nothing()
+ .to_owned(),
+ )
+ .exec_with_returning(sea_pool.as_ref())
+ .await
+ .expect("Error creating github project");
+
+ let github_repo = default_github_repo(github.id);
+
+ let repository = github_repositories::Entity::insert(github_repo)
+ .on_conflict(OnConflict::default().do_nothing().to_owned())
+ .exec_with_returning(sea_pool.as_ref())
+ .await
+ .expect("Error creating github repository");
+
+ let issues = issues::ActiveModel {
+ id: Default::default(),
+ repository: Set(repository.id),
+ issue: Set(420),
+ title: Set("Test issues".to_owned()),
+ description: Default::default(),
+ created_at: Set(repository.created_at),
+ closed: Set(false),
+ };
+
+ issues::Entity::insert(issues)
+ .on_conflict(OnConflict::default().do_nothing().to_owned())
+ .exec(sea_pool.as_ref())
+ .await
+ .expect("Error creating issues");
+
+ (sea_pool, github)
+}
+
+async fn test_cleanup() {
+ let sea_pool = create_db_pool().await;
+
+ github_projects::Entity::delete_by_id(*GITHUB_UUID)
+ .exec(sea_pool.as_ref())
+ .await
+ .expect("Error cleaning up");
+}
+
+async fn test_routes() {
+ let repository = search::search().await;
+ get_id::get_id(repository.id).await;
+ get_issues::get_issues(repository.id).await;
+}

backend/tests/src/repository/search.rs

@@ -0,0 +1,35 @@
+use reqwest::Method;
+use store::objects::SearchRepository;
+use support::pagination::PaginatedRepositories;
+
+use crate::request::request;
+
+const ROUTE: &str = "/api/v1/repository/search";
+
+pub async fn search() -> SearchRepository {
+ let mut repositories: PaginatedRepositories = request(ROUTE, Method::GET, (), ())
+ .await
+ .expect("Error searching repositories");
+
+ let response: PaginatedRepositories = request(
+ ROUTE,
+ Method::GET,
+ [
+ ("language", "DREAM"),
+ ("repository", "github.com"),
+ ("projectId", "38ecb0bd-7bfe-4919-a6dd-15c948f0ac1f"),
+ ("project", "lol"),
+ ("fork", "true"),
+ ("archived", "true")
+ ],
+ (),
+ )
+ .await
+ .expect("Error searching repositories");
+
+ assert!(response.data.is_empty());
+ assert_eq!(response.last_page, 0);
+ assert_eq!(response.total_items, 0);
+
+ repositories.data.pop().unwrap()
+}

backend/tests/src/request.rs

@@ -2,15 +2,22 @@ use error::{Error, Result};
 use reqwest::{Client, Method};
 use serde::{de::DeserializeOwned, Serialize};
 
-pub async fn request<U, B, R>(url: U, method: Method, body: B) -> Result<R>
+pub async fn request<U, P, B, R>(url: U, method: Method, query: P, body: B) -> Result<R>
 where
  U: Into<String>,
  B: Serialize,
+ P: Serialize,
  R: DeserializeOwned + 'static,
 {
  let client = Client::default();
  let url = format!("http://localhost:1111{}", url.into());
- let request = client.request(method, url).json(&body).send().await?;
+ let request = client
+ .request(method, url)
+ .query(&query)
+ .json(&body)
+ .send()
+ .await?;
+
  let response_body = request.text().await?;
  serde_json::from_str(&response_body).map_err(Error::from)
 }