feat(api): create a dto for post

Author: robertohuertasm

api.http

@@ -1,5 +1,6 @@
-@host = https://devbcn.shuttleapp.rs
-# @host = http://localhost:8000
+# @host = https://devbcn.shuttleapp.rs
+@host = http://localhost:8080
+@film_id = 6f05e5f2-133c-11ee-be9f-0ab7e0d8c876
 
 ### health
 GET {{host}}/api/health HTTP/1.1
@@ -9,7 +10,6 @@ POST {{host}}/api/v1/films HTTP/1.1
 Content-Type: application/json
 
 {
-    "id": "356e42a8-e659-406f-98bb-6124414675e8",
     "title": "Death in Venice",
     "director": "Luchino Visconti",
     "year": 1971,
@@ -21,7 +21,7 @@ PUT {{host}}/api/v1/films HTTP/1.1
 Content-Type: application/json
 
 {
-    "id": "356e42a8-e659-406f-98bb-6124414675e8",
+    "id": "{{film_id}}",
     "title": "Death in Venice",
     "director": "Benjamin Britten",
     "year": 1981,
@@ -32,11 +32,11 @@ Content-Type: application/json
 GET {{host}}/api/v1/films HTTP/1.1
 
 ### get film
-GET {{host}}/api/v1/films/356e42a8-e659-406f-98bb-6124414675e8 HTTP/1.1
+GET {{host}}/api/v1/films/{{film_id}} HTTP/1.1
 
 ### get bad film
 GET {{host}}/api/v1/films/356e42a8-e659-406f-98 HTTP/1.1
 
 
 ### delete film
-DELETE {{host}}/api/v1/films/356e42a8-e659-406f-98bb-6124414675e8 HTTP/1.1
+DELETE {{host}}/api/v1/films/{{film_id}} HTTP/1.1

api/lib/src/film_repository/film_repository.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use shared::models::Film;
+use shared::models::{CreateFilm, Film};
 use uuid::Uuid;
 
 pub type FilmError = String;
@@ -10,7 +10,7 @@ pub type FilmResult<T> = Result<T, FilmError>;
 pub trait FilmRepository: Send + Sync + 'static {
     async fn get_films(&self) -> FilmResult<Vec<Film>>;
     async fn get_film(&self, id: &Uuid) -> FilmResult<Film>;
-    async fn create_film(&self, id: &Film) -> FilmResult<Film>;
+    async fn create_film(&self, id: &CreateFilm) -> FilmResult<Film>;
     async fn update_film(&self, id: &Film) -> FilmResult<Film>;
     async fn delete_film(&self, id: &Uuid) -> FilmResult<Uuid>;
 }

api/lib/src/film_repository/memory_film_repository.rs

@@ -2,7 +2,7 @@ use std::{collections::HashMap, sync::RwLock};
 
 use async_trait::async_trait;
 use chrono::Utc;
-use shared::models::Film;
+use shared::models::{CreateFilm, Film};
 use uuid::Uuid;
 
 use super::{film_repository::FilmResult, FilmRepository};
@@ -63,20 +63,21 @@ impl FilmRepository for MemoryFilmRepository {
         result
     }
 
-    async fn create_film(&self, film: &Film) -> FilmResult<Film> {
+    async fn create_film(&self, create_film: &CreateFilm) -> FilmResult<Film> {
         match self.films.write() {
             Ok(mut films) => {
-                if films.get(&film.id).is_some() {
-                    let err = format!("Film with id {} already exists", film.id);
-                    tracing::error!(err);
-                    Err(err)
-                } else {
-                    let mut new_film = film.to_owned();
-                    new_film.created_at = Some(Utc::now());
-                    films.insert(film.id, new_film.clone());
-                    tracing::trace!("Film with id {} correctly created", film.id);
-                    Ok(new_film)
-                }
+                let new_film = Film {
+                    id: uuid::Uuid::new_v4(),
+                    title: create_film.title.clone(),
+                    director: create_film.director.clone(),
+                    year: create_film.year,
+                    poster: create_film.poster.clone(),
+                    created_at: Some(Utc::now()),
+                    updated_at: None,
+                };
+                films.insert(new_film.id, new_film.clone());
+                tracing::trace!("Film with id {} correctly created", new_film.id);
+                Ok(new_film)
             }
             Err(e) => {
                 let err = format!("An error happened while trying to update film: {}", e);
@@ -133,7 +134,7 @@ impl FilmRepository for MemoryFilmRepository {
 mod tests {
     use super::MemoryFilmRepository;
     use crate::film_repository::FilmRepository;
-    use shared::models::Film;
+    use shared::models::{CreateFilm, Film};
     use std::{collections::HashMap, sync::RwLock};
 
     fn create_test_film(id: &'static str) -> Film {
@@ -148,6 +149,15 @@ mod tests {
         }
     }
 
+    fn create_test_create_film(id: &'static str) -> CreateFilm {
+        CreateFilm {
+            title: format!("title-{}", id),
+            director: format!("director-{}", id),
+            poster: format!("poster-{}", id),
+            year: 2001,
+        }
+    }
+
     #[actix_rt::test]
     async fn repo_must_be_empty_on_new() {
         let repo = MemoryFilmRepository::new();
@@ -217,36 +227,20 @@ mod tests {
     #[actix_rt::test]
     async fn create_film_works() {
         let store = RwLock::new(HashMap::new());
-        let mut film = create_test_film("1");
-        film.created_at = None;
+        let create_film = create_test_create_film("1");
 
         let repo = MemoryFilmRepository { films: store };
-        let result = repo.create_film(&film).await;
+        let result = repo.create_film(&create_film).await;
 
         assert!(result.is_ok());
         let created_file = result.unwrap();
-        assert_eq!(created_file.id, film.id);
-        assert_eq!(created_file.title, film.title);
-        assert_eq!(created_file.director, film.director);
-        assert_eq!(created_file.poster, film.poster);
-        assert_eq!(created_file.year, film.year);
+        assert_eq!(created_file.title, create_film.title);
+        assert_eq!(created_file.director, create_film.director);
+        assert_eq!(created_file.poster, create_film.poster);
+        assert_eq!(created_file.year, create_film.year);
         assert!(created_file.created_at.is_some());
     }
 
-    #[actix_rt::test]
-    async fn create_film_fails_if_the_film_already_exists() {
-        let store = RwLock::new(HashMap::new());
-        let film = create_test_film("1");
-        store.write().unwrap().insert(film.id, film.clone());
-
-        let repo = MemoryFilmRepository { films: store };
-        let result = repo.create_film(&film).await;
-
-        assert!(result.is_err());
-        let err = result.unwrap_err();
-        assert!(err.ends_with("already exists"));
-    }
-
     #[actix_rt::test]
     async fn update_film_works() {
         let store = RwLock::new(HashMap::new());

api/lib/src/film_repository/postgres_film_repository.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use shared::models::Film;
+use shared::models::{CreateFilm, Film};
 use uuid::Uuid;
 
 use super::film_repository::{FilmRepository, FilmResult};
@@ -42,19 +42,18 @@ impl FilmRepository for PostgresFilmRepository {
         .map_err(|e| e.to_string())
     }
 
-    async fn create_film(&self, film: &Film) -> FilmResult<Film> {
+    async fn create_film(&self, create_film: &CreateFilm) -> FilmResult<Film> {
         sqlx::query_as::<_, Film>(
             r#"
-      INSERT INTO films (id, title, director, year, poster)
-      VALUES ($1, $2, $3, $4, $5)
+      INSERT INTO films (title, director, year, poster)
+      VALUES ($1, $2, $3, $4)
       RETURNING id, title, director, year, poster, created_at, updated_at
       "#,
         )
-        .bind(film.id)
-        .bind(&film.title)
-        .bind(&film.director)
-        .bind(film.year as i16)
-        .bind(&film.poster)
+        .bind(&create_film.title)
+        .bind(&create_film.director)
+        .bind(create_film.year as i16)
+        .bind(&create_film.poster)
         .fetch_one(&self.pool)
         .await
         .map_err(|e| e.to_string())

api/lib/src/v1/films.rs

@@ -2,7 +2,7 @@ use actix_web::{
     web::{self, ServiceConfig},
     HttpResponse,
 };
-use shared::models::Film;
+use shared::models::{CreateFilm, Film};
 use uuid::Uuid;
 
 use crate::film_repository::FilmRepository;
@@ -36,8 +36,11 @@ async fn get<R: FilmRepository>(film_id: web::Path<Uuid>, repo: web::Data<R>) ->
     }
 }
 
-async fn post<R: FilmRepository>(film: web::Json<Film>, repo: web::Data<R>) -> HttpResponse {
-    match repo.create_film(&film).await {
+async fn post<R: FilmRepository>(
+    create_film: web::Json<CreateFilm>,
+    repo: web::Data<R>,
+) -> HttpResponse {
+    match repo.create_film(&create_film).await {
         Ok(film) => HttpResponse::Ok().json(film),
         Err(e) => {
             HttpResponse::InternalServerError().body(format!("Internal server error: {:?}", e))
@@ -127,20 +130,34 @@ mod tests {
     #[actix_rt::test]
     async fn create_works() {
         let film_id = uuid::Uuid::new_v4();
-        let film_title = "Film test title";
-        let new_film = create_test_film(film_id, film_title.to_string());
+        let title = "Film test title";
+        let create_film = CreateFilm {
+            title: title.to_string(),
+            director: "Director test name".to_string(),
+            year: 2001,
+            poster: "Poster test name".to_string(),
+        };
 
         let mut repo = MockFilmRepository::default();
-        repo.expect_create_film()
-            .returning(|film| Ok(film.to_owned()));
+        repo.expect_create_film().returning(move |create_film| {
+            Ok(Film {
+                id: film_id,
+                title: create_film.title.to_owned(),
+                director: create_film.director.to_owned(),
+                year: create_film.year,
+                poster: create_film.poster.to_owned(),
+                created_at: Some(Utc::now()),
+                updated_at: None,
+            })
+        });
 
-        let result = post(web::Json(new_film), web::Data::new(repo)).await;
+        let result = post(web::Json(create_film), web::Data::new(repo)).await;
 
         let body = to_bytes(result.into_body()).await.unwrap();
         let film = serde_json::from_slice::<'_, Film>(&body).unwrap();
 
         assert_eq!(film.id, film_id);
-        assert_eq!(film.title, film_title);
+        assert_eq!(film.title, title);
     }
 
     #[actix_rt::test]