fixing some test

src/core/images.rs

@@ -217,9 +217,10 @@ mod test {
     pub async fn test_db_and_model() {
         let mut image_model: Model<Image> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Image,
         };
-        image_model.load_from_db().await;
+        let mut db = crate::core::model::get_db().await;
+        image_model.load_from_db(&mut db).await;
         if let Some(image) = image_model.find(|i| i.id == 3) {
             let test_image = test_image("nccq5".into());
             assert_eq!(test_image.title, image.title);
@@ -233,7 +234,7 @@ mod test {
         let image = test_image("A new image".into());
         let mut image_model: Model<Image> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Image,
         };
         let result = image_model.add_item(image.clone());
         let new_image = test_image("A newer image".into());

src/core/presentations.rs

@@ -275,9 +275,10 @@ mod test {
     async fn test_db_and_model() {
         let mut presentation_model: Model<Presentation> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Presentation,
         };
-        presentation_model.load_from_db().await;
+        let mut db = crate::core::model::get_db().await;
+        presentation_model.load_from_db(&mut db).await;
         if let Some(presentation) =
             presentation_model.find(|p| p.id == 54)
         {

src/core/songs.rs

@@ -641,15 +641,17 @@ You saved my soul"
     async fn model() -> Model<Song> {
         let song_model: Model<Song> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Song,
+            // db: crate::core::model::get_db().await,
         };
         song_model
     }
 
     #[tokio::test]
     async fn test_db_and_model() {
+        let mut db = crate::core::model::get_db().await;
         let mut song_model = model().await;
-        song_model.load_from_db().await;
+        song_model.load_from_db(&mut db).await;
         if let Some(song) = song_model.find(|s| s.id == 7) {
             let test_song = test_song();
             assert_eq!(&test_song, song);
@@ -662,7 +664,7 @@ You saved my soul"
     #[tokio::test]
     async fn test_song_from_db() {
         let song = test_song();
-        let mut db = model().await.db;
+        let mut db = crate::core::model::get_db().await;
         let result = get_song_from_db(7, &mut db).await;
         match result {
             Ok(db_song) => assert_eq!(song, db_song),
@@ -672,10 +674,11 @@ You saved my soul"
 
     #[tokio::test]
     async fn test_update() {
+        let mut db = crate::core::model::get_db().await;
         let song = test_song();
         let cloned_song = song.clone();
         let mut song_model: Model<Song> = model().await;
-        song_model.load_from_db().await;
+        song_model.load_from_db(&mut db).await;
 
         match song_model.update_item(song, 2) {
             Ok(()) => assert_eq!(

src/core/videos.rs

@@ -259,9 +259,10 @@ mod test {
     async fn test_db_and_model() {
         let mut video_model: Model<Video> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Video,
         };
-        video_model.load_from_db().await;
+        let mut db = crate::core::model::get_db().await;
+        video_model.load_from_db(&mut db).await;
         if let Some(video) = video_model.find(|v| v.id == 73) {
             let test_video = test_video(
                 "Getting started with Tokio. The ultimate starter guide to writing async Rust."
@@ -278,7 +279,7 @@ mod test {
         let video = test_video("A new video".into());
         let mut video_model: Model<Video> = Model {
             items: vec![],
-            db: crate::core::model::get_db().await,
+            kind: LibraryKind::Video,
         };
         let result = video_model.add_item(video.clone());
         let new_video = test_video("A newer video".into());

src/lisp.rs

@@ -41,10 +41,10 @@ mod test {
 
     use crate::{
         core::{
-            images::Image, kinds::ServiceItemKind, songs::Song,
+            images::Image, kinds::ServiceItemKind,
-            videos::Video,
+            service_items::ServiceTrait, songs::Song, videos::Video,
         },
-        Background, SlideBuilder, TextAlignment,
+        Background, Slide, SlideBuilder, TextAlignment,
     };
 
     use super::*;
@@ -55,15 +55,16 @@ mod test {
         let lisp =
             read_to_string("./test_slides.lisp").expect("oops");
         let lisp_value = crisp::reader::read(&lisp);
-        let test_vec = vec![service_item_1(), service_item_2()];
+        let hard_coded_items =
+            vec![service_item_1(), service_item_2()];
         match lisp_value {
             Value::List(value) => {
-                let mut item_vec = vec![];
+                let mut lisp_items = vec![];
                 for value in value {
                     let mut vec = parse_lisp(value);
-                    item_vec.append(&mut vec);
+                    lisp_items.append(&mut vec);
                 }
-                assert_eq!(item_vec, test_vec)
+                assert_eq!(lisp_items, hard_coded_items)
             }
             _ => panic!("this should be a lisp"),
         }
@@ -73,39 +74,41 @@ mod test {
     fn test_parsing_lisp_presentation() {
         let lisp = read_to_string("./testypres.lisp").expect("oops");
         let lisp_value = crisp::reader::read(&lisp);
-        let test_vec = vec![
+        let hard_coded_items = vec![
             service_item_1(),
             service_item_2(),
             service_item_3(),
         ];
         match lisp_value {
             Value::List(value) => {
-                let mut item_vec = vec![];
+                let mut lisp_items = vec![];
                 for value in value {
                     let mut vec = parse_lisp(value);
-                    item_vec.append(&mut vec);
+                    lisp_items.append(&mut vec);
                 }
-                let item_1 = &item_vec[0];
+                let item_1 = &lisp_items[0];
-                let item_2 = &item_vec[1];
+                let item_2 = &lisp_items[1];
-                let item_3 = &item_vec[2];
+                let item_3 = &lisp_items[2];
-                assert_eq!(item_1, &test_vec[0]);
+                assert_eq!(item_1, &hard_coded_items[0]);
-                assert_eq!(item_2, &test_vec[1]);
+                assert_eq!(item_2, &hard_coded_items[1]);
-                assert_eq!(item_3, &test_vec[2]);
+                assert_eq!(item_3, &hard_coded_items[2]);
 
-                assert_eq!(item_vec, test_vec);
+                assert_eq!(lisp_items, hard_coded_items);
             }
             _ => panic!("this should be a lisp"),
         }
     }
 
     fn service_item_1() -> ServiceItem {
-        ServiceItem {
+        let image = Image {
-            title: "frodo.jpg".to_string(),
-            kind: ServiceItemKind::Image(Image {
             title: "frodo.jpg".to_string(),
             path: PathBuf::from("~/pics/frodo.jpg"),
             ..Default::default()
-            }),
+        };
+        let slide = &image.to_slides().unwrap()[0];
+        ServiceItem {
+            title: "frodo.jpg".to_string(),
+            kind: ServiceItemKind::Content(slide.clone()),
             ..Default::default()
         }
     }

src/ui/presenter.rs

@@ -50,7 +50,7 @@ pub(crate) struct Presenter {
     current_font: Font,
 }
 
-pub enum Action {
+pub(crate) enum Action {
     Task(Task<Message>),
     None,
 }