dan/Portfolio
1
0
Fork 0
mirror of https://github.com/danbulant/Portfolio synced 2026-05-24 12:35:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #44 from EETagent/portfolio_fixes

Browse source 
Portfolio fixes
This commit is contained in:
Vojtěch Jungmann 2022-11-16 21:41:22 +01:00 committed by GitHub
commit 4ef80e88d3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 543 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
Cargo.lock generated
View file

@ -2025,6 +2025,7 @@ dependencies = [
"sea-orm",
"secrecy",
"serde",
"serial_test",
"thiserror",
"tokio",
]
@ -2708,6 +2709,32 @@ dependencies = [
"serde",
]
[[package]]
name = "serial_test"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92761393ee4dc3ff8f4af487bd58f4307c9329bbedea02cac0089ad9c411e153"
dependencies = [
"dashmap",
"futures",
"lazy_static",
"log",
"parking_lot 0.12.1",
"serial_test_derive",
]
[[package]]
name = "serial_test_derive"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b6f5d1c3087fb119617cff2966fe3808a80e5eb59a8c1601d5994d66f4346a5"
dependencies = [
"proc-macro-error",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "sha1"
version = "0.10.5"

17
api/src/lib.rs
View file

@ -41,11 +41,24 @@ async fn start() -> Result<(), rocket::Error> {
routes![
routes::candidate::login,
routes::candidate::whoami,
routes::candidate::fill_details,
routes::candidate::get_details,
routes::candidate::upload_cover_letter,
],
)
.mount(
"/candidate/add",
routes![
routes::candidate::add_details,
routes::candidate::upload_portfolio_letter,
routes::candidate::upload_portfolio_zip,
routes::candidate::upload_cover_letter,
],
)
.mount(
"/candidate/portfolio",
routes![
routes::candidate::submit_portfolio,
routes::candidate::is_portfolio_prepared,
routes::candidate::is_portfolio_submitted,
],
)
.mount(

123
api/src/routes/candidate.rs
View file

@ -2,7 +2,7 @@ use std::net::SocketAddr;
use portfolio_core::candidate_details::ApplicationDetails;
use portfolio_core::services::application_service::ApplicationService;
use portfolio_core::services::candidate_service::{CandidateService};
use portfolio_core::services::candidate_service::CandidateService;
use requests::LoginRequest;
use rocket::http::{Cookie, CookieJar, Status};
use rocket::response::status::Custom;
@ -59,7 +59,7 @@ pub async fn whoami(session: CandidateAuth) -> Result<String, Custom<String>> {
}
#[post("/details", data = "<details>")]
pub async fn fill_details(
pub async fn add_details(
conn: Connection<'_, Db>,
details: Json<ApplicationDetails>,
session: CandidateAuth,
@ -68,7 +68,8 @@ pub async fn fill_details(
let form = details.into_inner();
let candidate: entity::candidate::Model = session.into(); // TODO: don't return candidate from session
let candidate_parent = ApplicationService::add_all_details(db, candidate.application, form).await;
let candidate_parent =
ApplicationService::add_all_details(db, candidate.application, form).await;
if candidate_parent.is_err() {
// TODO cleanup
@ -95,18 +96,24 @@ pub async fn get_details(
// let handle = tokio::spawn(async move {
let details = ApplicationService::decrypt_all_details(db, candidate.application, password)
.await
.map_err(|e| Custom(Status::from_code(e.code()).unwrap_or_default(), e.to_string()));
.map_err(|e| {
Custom(
Status::from_code(e.code()).unwrap_or_default(),
e.to_string(),
)
});
details.map(|d| Json(d))
}
#[post("/coverletter", data = "<letter>")]
#[post("/cover_letter", data = "<letter>")]
pub async fn upload_cover_letter(
session: CandidateAuth,
letter: Letter,
) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let candidate = CandidateService::add_cover_letter(candidate.application, letter.into()).await;
let candidate =
CandidateService::add_cover_letter_to_cache(candidate.application, letter.into()).await;
if candidate.is_err() {
// TODO cleanup
@ -120,7 +127,17 @@ pub async fn upload_cover_letter(
Ok("Letter added".to_string())
}
#[post("/portfolioletter", data = "<letter>")]
// TODO: JSON
#[get["/is_cover_letter"]]
pub async fn is_cover_letter(session: CandidateAuth) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let exists = CandidateService::is_cover_letter(candidate.application).await;
Ok(exists.to_string())
}
#[post("/portfolio_letter", data = "<letter>")]
pub async fn upload_portfolio_letter(
session: CandidateAuth,
letter: Letter,
@ -128,7 +145,7 @@ pub async fn upload_portfolio_letter(
let candidate: entity::candidate::Model = session.into();
let candidate =
CandidateService::add_portfolio_letter(candidate.application, letter.into()).await;
CandidateService::add_portfolio_letter_to_cache(candidate.application, letter.into()).await;
if candidate.is_err() {
// TODO cleanup
@ -142,7 +159,17 @@ pub async fn upload_portfolio_letter(
Ok("Letter added".to_string())
}
#[post("/portfolio", data = "<portfolio>")]
// TODO: JSON
#[get["/is_portfolio_letter"]]
pub async fn is_portfolio_letter(session: CandidateAuth) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let exists = CandidateService::is_portfolio_letter(candidate.application).await;
Ok(exists.to_string())
}
#[post("/portfolio_zip", data = "<portfolio>")]
pub async fn upload_portfolio_zip(
session: CandidateAuth,
portfolio: Portfolio,
@ -150,7 +177,7 @@ pub async fn upload_portfolio_zip(
let candidate: entity::candidate::Model = session.into();
let candidate =
CandidateService::add_portfolio_zip(candidate.application, portfolio.into()).await;
CandidateService::add_portfolio_zip_to_cache(candidate.application, portfolio.into()).await;
if candidate.is_err() {
// TODO cleanup
@ -161,5 +188,79 @@ pub async fn upload_portfolio_zip(
));
}
Ok("Letter added".to_string())
Ok("Portfolio added".to_string())
}
// TODO: JSON
#[get["/is_portfolio_zip"]]
pub async fn is_portfolio_zip(session: CandidateAuth) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let exists = CandidateService::is_portfolio_zip(candidate.application).await;
Ok(exists.to_string())
}
#[post("/submit")]
pub async fn submit_portfolio(
conn: Connection<'_, Db>,
session: CandidateAuth,
) -> Result<String, Custom<String>> {
let db = conn.into_inner();
let candidate: entity::candidate::Model = session.into();
let submit = CandidateService::add_portfolio(candidate.application, &db).await;
if submit.is_err() {
let e = submit.err().unwrap();
// Delete on critical error
// TODO: Více kontrol?
if e.code() == 500 {
// Cleanup
CandidateService::delete_portfolio(candidate.application)
.await
.unwrap();
}
return Err(Custom(
Status::from_code(e.code()).unwrap_or_default(),
e.to_string(),
));
}
Ok("Portfolio submitted".to_string())
}
#[get("/is_prepared")]
pub async fn is_portfolio_prepared(session: CandidateAuth) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let is_ok = CandidateService::is_portfolio_prepared(candidate.application).await;
if !is_ok {
// TODO: Correct error
return Err(Custom(
Status::from_code(404).unwrap_or_default(),
"Portfolio not prepared".to_string(),
));
}
Ok("Portfolio ok".to_string())
}
#[get("/is_submitted")]
pub async fn is_portfolio_submitted(session: CandidateAuth) -> Result<String, Custom<String>> {
let candidate: entity::candidate::Model = session.into();
let is_ok = CandidateService::is_portfolio_submitted(candidate.application).await;
if !is_ok {
// TODO: Correct error
return Err(Custom(
Status::from_code(404).unwrap_or_default(),
"Portfolio not submitted".to_string(),
));
}
Ok("Portfolio ok".to_string())
}

3
core/Cargo.toml
View file

@ -47,4 +47,5 @@ features = [
[dev-dependencies]
tokio = { version = "^1.21", features = ["macros"] }
async-tempfile = "^0.2"
async-tempfile = "^0.2"
serial_test = "0.9.0"

12
core/src/crypto.rs
View file

@ -238,8 +238,8 @@ async fn age_decrypt_with_private_key<R: tokio::io::AsyncRead + Unpin>(
};
let mut decrypt_writer = decryptor.decrypt_async(iter::once(
&age::x25519::Identity::from_str(key).map_err(|e| ServiceError::AgeKeyError(e.to_string()))?
as &dyn age::Identity,
&age::x25519::Identity::from_str(key)
.map_err(|e| ServiceError::AgeKeyError(e.to_string()))? as &dyn age::Identity,
))?;
decrypt_writer.read_to_end(output_buffer).await?;
@ -289,12 +289,18 @@ pub async fn encrypt_file_with_recipients<P: AsRef<Path>>(
tokio::io::AsyncReadExt::read_to_end(&mut plain_file, &mut plain_file_contents).await?;
drop(plain_file);
age_encrypt_with_recipients(
plain_file_contents.as_slice(),
&mut cipher_file,
&recipients,
)
.await
.await?;
tokio::io::AsyncWriteExt::shutdown(&mut cipher_file).await?;
Ok(())
}
pub async fn decrypt_file_with_private_key<P: AsRef<Path>>(

2
core/src/error.rs
View file

@ -89,7 +89,7 @@ impl ServiceError {
ServiceError::AesError(_) => 500,
ServiceError::ArgonConfigError(_) => 500,
//TODO: Correct code
ServiceError::IncompletePortfolio => 500,
ServiceError::IncompletePortfolio => 406,
ServiceError::ZipError(_) => 500,
}
}

433
core/src/services/candidate_service.rs
View file

@ -1,4 +1,4 @@
use std::path::Path;
use std::path::{Path, PathBuf};
use entity::candidate;
use sea_orm::{prelude::Uuid, DbConn};
@ -18,6 +18,12 @@ const FIELD_OF_STUDY_PREFIXES: [&str; 3] = ["101", "102", "103"];
pub struct CandidateService;
impl CandidateService {
// Get root path or local directory
fn get_file_store_path() -> PathBuf {
dotenv::dotenv().ok();
Path::new(&std::env::var("STORE_PATH").unwrap_or_else(|_| "".to_string())).to_path_buf()
}
/// Creates a new candidate with:
/// Encrypted personal identification number
/// Hashed password
@ -47,13 +53,12 @@ impl CandidateService {
let (pubkey, priv_key_plain_text) = crypto::create_identity();
let encrypted_priv_key = crypto::encrypt_password(priv_key_plain_text, plain_text_password.to_string()).await?;
let encrypted_priv_key =
crypto::encrypt_password(priv_key_plain_text, plain_text_password.to_string()).await?;
let hashed_personal_id_number = hash_password(personal_id_number).await?;
// TODO: Specify root path in config?
tokio::fs::create_dir_all(Path::new(&application_id.to_string()).join("cache")).await?;
tokio::fs::create_dir_all(Self::get_file_store_path().join(&application_id.to_string()).join("cache")).await?;
let candidate = Mutation::create_candidate(
db,
@ -76,7 +81,7 @@ impl CandidateService {
Ok(model)
}
pub fn is_set_up(candidate: &candidate::Model) -> bool {
pub fn is_candidate_info(candidate: &candidate::Model) -> bool {
candidate.name.is_some()
&& candidate.surname.is_some()
&& candidate.birthplace.is_some()
@ -94,7 +99,7 @@ impl CandidateService {
data: Vec<u8>,
filename: &str,
) -> Result<(), ServiceError> {
let cache_path = Path::new(&candidate_id.to_string()).join("cache");
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
let mut file = tokio::fs::File::create(cache_path.join(filename)).await?;
@ -103,79 +108,117 @@ impl CandidateService {
Ok(())
}
pub async fn add_cover_letter(candidate_id: i32, letter: Vec<u8>) -> Result<(), ServiceError> {
pub async fn add_cover_letter_to_cache(
candidate_id: i32,
letter: Vec<u8>,
) -> Result<(), ServiceError> {
Self::write_portfolio_file(candidate_id, letter, "MOTIVACNI_DOPIS.pdf").await
}
pub async fn add_portfolio_letter(
pub async fn is_cover_letter(candidate_id: i32) -> bool {
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
tokio::fs::metadata(cache_path.join(cache_path.join("MOTIVACNI_DOPIS.pdf")))
.await
.is_ok()
}
pub async fn add_portfolio_letter_to_cache(
candidate_id: i32,
letter: Vec<u8>,
) -> Result<(), ServiceError> {
Self::write_portfolio_file(candidate_id, letter, "PORTFOLIO.pdf").await
}
pub async fn add_portfolio_zip(candidate_id: i32, zip: Vec<u8>) -> Result<(), ServiceError> {
pub async fn is_portfolio_letter(candidate_id: i32) -> bool {
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
tokio::fs::metadata(cache_path.join(cache_path.join("PORTFOLIO.pdf")))
.await
.is_ok()
}
pub async fn add_portfolio_zip_to_cache(
candidate_id: i32,
zip: Vec<u8>,
) -> Result<(), ServiceError> {
Self::write_portfolio_file(candidate_id, zip, "PORTFOLIO.zip").await
}
pub async fn is_portfolio_complete(candidate_id: i32) -> bool {
let cache_path = Path::new(&candidate_id.to_string()).join("cache");
pub async fn is_portfolio_zip(candidate_id: i32) -> bool {
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
tokio::fs::metadata(cache_path.join("MOTIVACNI_DOPIS.pdf"))
tokio::fs::metadata(cache_path.join(cache_path.join("PORTFOLIO.zip")))
.await
.is_ok()
&& tokio::fs::metadata(cache_path.join("PORTFOLIO.pdf"))
.await
.is_ok()
&& tokio::fs::metadata(cache_path.join("PORTFOLIO.zip"))
.await
.is_ok()
}
pub async fn submit_portfolio(candidate_id: i32, db: &DbConn) -> Result<(), ServiceError> {
let path = Path::new(&candidate_id.to_string()).to_path_buf();
pub async fn is_portfolio_prepared(candidate_id: i32) -> bool {
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
let filenames = vec!["MOTIVACNI_DOPIS.pdf", "PORTFOLIO.pdf", "PORTFOLIO.zip"];
for filename in filenames {
if !tokio::fs::metadata(cache_path.join(filename)).await.is_ok() {
return false;
}
}
true
}
pub async fn delete_cache(candidate_id: i32) -> Result<(), ServiceError> {
let cache_path = Self::get_file_store_path().join(&candidate_id.to_string()).join("cache");
tokio::fs::remove_dir_all(&cache_path).await?;
// Recreate blank cache directory
tokio::fs::create_dir_all(&cache_path).await?;
Ok(())
}
pub async fn add_portfolio(candidate_id: i32, db: &DbConn) -> Result<(), ServiceError> {
let path = Self::get_file_store_path().join(&candidate_id.to_string()).to_path_buf();
let cache_path = path.join("cache");
if Self::is_portfolio_complete(candidate_id).await == false {
if Self::is_portfolio_prepared(candidate_id).await == false {
return Err(ServiceError::IncompletePortfolio);
}
let mut archive = tokio::fs::File::create(path.join("PORTFOLIO.zip")).await?;
let mut writer = async_zip::write::ZipFileWriter::new(&mut archive);
for entry in vec!["MOTIVACNI_DOPIS.pdf", "PORTFOLIO.pdf", "PORTFOLIO.zip"] {
let mut entry_file = tokio::fs::File::open(cache_path.join(entry))
.await?;
let mut buffer = vec![vec![], vec![], vec![]];
let mut contents = vec![];
let filenames = vec!["MOTIVACNI_DOPIS.pdf", "PORTFOLIO.pdf", "PORTFOLIO.zip"];
entry_file
.read_to_end(&mut contents)
.await?;
for (index, entry) in buffer.iter_mut().enumerate() {
let filename = filenames[index];
let mut entry_file = tokio::fs::File::open(cache_path.join(filename)).await?;
let builder =
async_zip::ZipEntryBuilder::new(entry.to_string(), async_zip::Compression::Deflate);
let mut entry_writer = writer
.write_entry_stream(builder)
.await?;
// TODO: write_all_buf?
entry_writer
.write_all(&mut contents)
.await?;
entry_file.read_to_end(entry).await?;
}
// TODO: Ne unwrap
writer.close().await.unwrap();
archive.shutdown().await.unwrap();
Self::delete_cache(candidate_id).await?;
let admin_public_keys = Query::get_all_admin_public_keys(db)
.await?;
for (index, entry) in buffer.iter_mut().enumerate() {
let filename = filenames[index];
let builder = async_zip::ZipEntryBuilder::new(
filename.to_string(),
async_zip::Compression::Deflate,
);
let candidate = Query::find_candidate_by_id(db, candidate_id).await?
writer.write_entry_whole(builder, &entry).await?;
}
writer.close().await?;
archive.shutdown().await?;
let admin_public_keys = Query::get_all_admin_public_keys(db).await?;
let candidate = Query::find_candidate_by_id(db, candidate_id)
.await?
.ok_or(ServiceError::CandidateNotFound)?;
let candidate_public_key = candidate.public_key;
@ -187,27 +230,58 @@ impl CandidateService {
recipients.append(&mut admin_public_keys_refrence);
let final_path = path.join("PORTFOLIO.zip");
let Ok(_) = crypto::encrypt_file_with_recipients(
path.join("PORTFOLIO.zip"),
path.join("PORTFOLIO.zip"),
&final_path,
&final_path.with_extension("age"),
recipients,
)
.await else {
return Err(ServiceError::CryptoEncryptFailed);
};
tokio::fs::remove_file(final_path).await?;
Ok(())
}
pub async fn delete_portfolio(candidate_id: i32) -> Result<(), ServiceError> {
let path = Self::get_file_store_path().join(&candidate_id.to_string()).to_path_buf();
let portfolio_path = path.join("PORTFOLIO.zip");
let portfolio_age_path = portfolio_path.with_extension("age");
if tokio::fs::metadata(&portfolio_path).await.is_ok() {
tokio::fs::remove_file(&portfolio_path).await?;
}
if tokio::fs::metadata(&portfolio_age_path).await.is_ok() {
tokio::fs::remove_file(&portfolio_age_path).await?;
}
Ok(())
}
pub async fn is_portfolio_submitted(candidate_id: i32) -> bool {
let path = Self::get_file_store_path().join(&candidate_id.to_string()).to_path_buf();
tokio::fs::metadata(path.join("PORTFOLIO.age")).await.is_ok()
}
pub async fn get_portfolio(candidate_id: i32, db: &DbConn) -> Result<Vec<u8>, ServiceError> {
let candidate = Query::find_candidate_by_id(db, candidate_id).await?
let path = Self::get_file_store_path().join(&candidate_id.to_string()).to_path_buf();
let candidate = Query::find_candidate_by_id(db, candidate_id)
.await?
.ok_or(ServiceError::CandidateNotFound)?;
let candidate_public_key = candidate.public_key;
let path = Path::new(&candidate_id.to_string()).join("PORTFOLIO.zip");
let path = path.join("PORTFOLIO.age");
let buffer = crypto::decrypt_file_with_private_key_as_buffer(path, &candidate_public_key).await?;
let buffer =
crypto::decrypt_file_with_private_key_as_buffer(path, &candidate_public_key).await?;
Ok(buffer)
}
@ -269,6 +343,7 @@ impl CandidateService {
#[cfg(test)]
mod tests {
use sea_orm::{Database, DbConn};
use serial_test::serial;
use crate::util::get_memory_sqlite_connection;
use crate::{crypto, services::candidate_service::CandidateService, Mutation};
@ -280,6 +355,10 @@ mod tests {
use crate::candidate_details::ApplicationDetails;
use crate::services::application_service::ApplicationService;
use std::path::{PathBuf};
const APPLICATION_ID: i32 = 103151;
#[tokio::test]
async fn test_application_id_validation() {
assert!(CandidateService::is_application_id_valid(101_101));
@ -299,12 +378,12 @@ mod tests {
let secret_message = "trnka".to_string();
let candidate = CandidateService::create(&db, 103151, &plain_text_password, "".to_string())
let candidate = CandidateService::create(&db, APPLICATION_ID, &plain_text_password, "".to_string())
.await
.ok()
.unwrap();
Mutation::create_parent(&db, 103151).await.unwrap();
Mutation::create_parent(&db, APPLICATION_ID).await.unwrap();
let encrypted_message =
crypto::encrypt_password_with_recipients(&secret_message, &vec![&candidate.public_key])
@ -327,9 +406,9 @@ mod tests {
#[cfg(test)]
async fn put_user_data(db: &DbConn) -> (candidate::Model, parent::Model) {
let plain_text_password = "test".to_string();
let (candidate, parent) = ApplicationService::create_candidate_with_parent(
let (candidate, _parent) = ApplicationService::create_candidate_with_parent(
&db,
103151,
APPLICATION_ID,
&plain_text_password,
"".to_string(),
)
@ -384,4 +463,246 @@ mod tests {
assert_eq!(dec_details.name, "test"); // TODO: test every element
assert_eq!(dec_details.parent_surname, "test");
}
#[cfg(test)]
async fn create_data_store_temp_dir(application_id: i32) -> (PathBuf, PathBuf, PathBuf) {
let random_number: u32 = rand::Rng::gen(&mut rand::thread_rng());
let temp_dir = std::env::temp_dir().join("portfolio_test_tempdir").join(random_number.to_string());
let application_dir = temp_dir.join(application_id.to_string());
let application_cache_dir = application_dir.join("cache");
tokio::fs::create_dir_all(application_cache_dir.clone()).await.unwrap();
std::env::set_var("STORE_PATH", temp_dir.to_str().unwrap());
(temp_dir, application_dir, application_cache_dir)
}
#[cfg(test)]
async fn clear_data_store_temp_dir(temp_dir: PathBuf) {
tokio::fs::remove_dir_all(temp_dir).await.unwrap();
}
#[tokio::test]
#[serial]
async fn test_folder_creation() {
let db = get_memory_sqlite_connection().await;
let plain_text_password = "test".to_string();
let temp_dir = std::env::temp_dir().join("portfolio_test_tempdir").join("create_folder");
std::env::set_var("STORE_PATH", temp_dir.to_str().unwrap());
CandidateService::create(&db, APPLICATION_ID, &plain_text_password, "".to_string())
.await
.ok()
.unwrap();
assert!(tokio::fs::metadata(temp_dir.join(APPLICATION_ID.to_string())).await.is_ok());
assert!(tokio::fs::metadata(temp_dir.join(APPLICATION_ID.to_string()).join("cache")).await.is_ok());
tokio::fs::remove_dir_all(temp_dir).await.unwrap();
}
#[tokio::test]
#[serial]
async fn test_write_portfolio_file() {
let (temp_dir, _, application_cache_dir) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::write_portfolio_file(APPLICATION_ID, vec![0], "test").await.unwrap();
assert!(tokio::fs::metadata(application_cache_dir.join("test")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_add_cover_letter_to_cache() {
let (temp_dir, _, application_cache_dir) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(tokio::fs::metadata(application_cache_dir.join("MOTIVACNI_DOPIS.pdf")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_is_cover_letter() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(CandidateService::is_cover_letter(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_add_portfolio_letter_to_cache() {
let (temp_dir, _, application_cache_dir) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(tokio::fs::metadata(application_cache_dir.join("PORTFOLIO.pdf")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_is_portfolio_letter() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(CandidateService::is_portfolio_letter(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_add_portfolio_zip_to_cache() {
let (temp_dir, _, application_cache_dir) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(tokio::fs::metadata(application_cache_dir.join("PORTFOLIO.zip")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_is_portfolio_zip() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(CandidateService::is_portfolio_zip(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_is_portfolio_prepared() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(CandidateService::is_portfolio_prepared(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
//CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(!CandidateService::is_portfolio_prepared(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_delete_cache() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
assert!(CandidateService::is_portfolio_zip(APPLICATION_ID).await);
CandidateService::delete_cache(APPLICATION_ID).await.unwrap();
assert!(!CandidateService::is_portfolio_zip(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_add_portfolio() {
let (temp_dir, application_dir, _) = create_data_store_temp_dir(APPLICATION_ID).await;
let db = get_memory_sqlite_connection().await;
put_user_data(&db).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio(APPLICATION_ID, &db).await.unwrap();
assert!(tokio::fs::metadata(application_dir.join("PORTFOLIO.age")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_delete_portfolio() {
let (temp_dir, application_dir, _) = create_data_store_temp_dir(APPLICATION_ID).await;
let db = get_memory_sqlite_connection().await;
put_user_data(&db).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio(APPLICATION_ID, &db).await.unwrap();
assert!(tokio::fs::metadata(application_dir.join("PORTFOLIO.age")).await.is_ok());
CandidateService::delete_portfolio(APPLICATION_ID).await.unwrap();
assert!(!tokio::fs::metadata(application_dir.join("PORTFOLIO.age")).await.is_ok());
clear_data_store_temp_dir(temp_dir).await;
}
#[tokio::test]
#[serial]
async fn test_is_portfolio_submitted() {
let (temp_dir, _, _) = create_data_store_temp_dir(APPLICATION_ID).await;
let db = get_memory_sqlite_connection().await;
put_user_data(&db).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio(APPLICATION_ID, &db).await.unwrap();
assert!(CandidateService::is_portfolio_submitted(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
let (temp_dir, application_dir, _) = create_data_store_temp_dir(APPLICATION_ID).await;
CandidateService::add_cover_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_letter_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio_zip_to_cache(APPLICATION_ID, vec![0]).await.unwrap();
CandidateService::add_portfolio(APPLICATION_ID, &db).await.unwrap();
tokio::fs::remove_file(application_dir.join("PORTFOLIO.age")).await.unwrap();
assert!(!CandidateService::is_portfolio_submitted(APPLICATION_ID).await);
clear_data_store_temp_dir(temp_dir).await;
}
}