From 1b452517e36c2f074ae54b27fcdca89837e1e703 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Tue, 31 May 2022 17:06:39 +0200
Subject: [PATCH 1/9] feat: add first Youtube search functionality

---
 Cargo.toml         |   1 +
 src/main.rs        |   1 +
 src/youtube/mod.rs | 106 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 108 insertions(+)
 create mode 100644 src/youtube/mod.rs

diff --git a/Cargo.toml b/Cargo.toml
index 8bfef7d..c46a54d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,3 +12,4 @@ pretty_env_logger = "0.4.0"
 tokio = { version =  "1.18.2", features = ["rt-multi-thread", "macros"] }
 rspotify = { version = "0.11.5", features = ["default"]}
 sentry = "0.26.0"
+invidious = "0.2.1"
diff --git a/src/main.rs b/src/main.rs
index 1a8ff7c..27b24f2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -11,6 +11,7 @@ use crate::utils::{human_readable_duration, truncate_with_dots};
 
 mod spotify;
 mod utils;
+mod youtube;
 
 static MAX_ARTISTS_CHARS: usize = 140;
 
diff --git a/src/youtube/mod.rs b/src/youtube/mod.rs
new file mode 100644
index 0000000..aa7456b
--- /dev/null
+++ b/src/youtube/mod.rs
@@ -0,0 +1,106 @@
+use invidious::asynchronous::Client;
+use std::error::Error;
+
+#[derive(Debug, Clone)]
+pub(crate) struct YoutubeClient {
+    client: Client,
+}
+
+pub(crate) struct VideoSearch {
+    items: Vec<Video>,
+}
+
+pub(crate) struct Video {
+    title: String,
+    videoId: String,
+    author: String,
+    authorId: String,
+    authorUrl: String,
+    lengthSeconds: u64,
+    description: String,
+    descriptionHtml: String,
+    viewCount: u64,
+    published: u64,
+    publishedText: String,
+    liveNow: bool,
+    paid: bool,
+    premium: bool,
+}
+
+type SearchSortBy = str;
+
+const BY_RELEVANCE: &SearchSortBy = "relevance";
+const BY_RATING: &SearchSortBy = "rating";
+const BY_UPLOAD_DATE: &SearchSortBy = "upload_date";
+const BY_VIEW_COUNT: &SearchSortBy = "view_count";
+
+impl YoutubeClient {
+    async fn new() -> YoutubeClient {
+        // TODO check for a stable instance
+        let client = Client::new(String::from("https://vid.puffyan.us"));
+
+        YoutubeClient { client }
+    }
+
+    async fn search_video(
+        &self,
+        keyword: &str,
+        sort_by: Option<&SearchSortBy>,
+    ) -> Result<VideoSearch, Box<dyn Error>> {
+        let mut query = Vec::<String>::new();
+        query.push(format!("{}={}", "q", keyword));
+        match sort_by {
+            Some(sorting_type) => query.push(format!("{}={}", "sort_by", sorting_type)),
+            None => {}
+        }
+        query.push(format!("{}={}", "type", "video"));
+
+        let generated_query = query.join(",");
+        let search = self.client.search(Some(generated_query.as_str())).await?;
+
+        let videos: Vec<Video> = search
+            .items
+            .iter()
+            .map(|search_result| match search_result {
+                invidious::structs::hidden::SearchItem::Video {
+                    title,
+                    videoId,
+                    author,
+                    authorId,
+                    authorUrl,
+                    lengthSeconds,
+                    videoThumbnails,
+                    description,
+                    descriptionHtml,
+                    viewCount,
+                    published,
+                    publishedText,
+                    liveNow,
+                    paid,
+                    premium,
+                } => Some(Video {
+                    title: title.clone(),
+                    videoId: videoId.clone(),
+                    author: author.clone(),
+                    authorId: authorId.clone(),
+                    authorUrl: authorUrl.clone(),
+                    lengthSeconds: lengthSeconds.clone(),
+                    description: description.clone(),
+                    descriptionHtml: descriptionHtml.clone(),
+                    viewCount: viewCount.clone(),
+                    published: published.clone(),
+                    publishedText: publishedText.clone(),
+                    liveNow: liveNow.clone(),
+                    paid: paid.clone(),
+                    premium: premium.clone(),
+                }),
+                _ => None,
+            })
+            .filter(|x| x.is_some())
+            .map(|x| x.unwrap())
+            .filter(|x| !x.premium && !x.paid && !x.liveNow)
+            .collect();
+
+        Result::Ok(VideoSearch { items: videos })
+    }
+}
-- 
2.40.1


From 469991d20b8b4a30efaf6e07216b015ee7ae6768 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Tue, 31 May 2022 22:07:53 +0200
Subject: [PATCH 2/9] feat: add first engine draft for music search

---
 .idea/runConfigurations/Run_all_tests.xml |  19 ++
 Cargo.toml                                |   4 +
 src/engine.rs                             |  76 ++++++
 src/main.rs                               |  38 +--
 src/spotify/mod.rs                        | 289 +++++++++++++---------
 src/youtube/mod.rs                        |  57 +++--
 6 files changed, 314 insertions(+), 169 deletions(-)
 create mode 100644 .idea/runConfigurations/Run_all_tests.xml
 create mode 100644 src/engine.rs

diff --git a/.idea/runConfigurations/Run_all_tests.xml b/.idea/runConfigurations/Run_all_tests.xml
new file mode 100644
index 0000000..abc81eb
--- /dev/null
+++ b/.idea/runConfigurations/Run_all_tests.xml
@@ -0,0 +1,19 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Run all tests" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
+    <option name="command" value="test" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$" />
+    <option name="channel" value="DEFAULT" />
+    <option name="requiredFeatures" value="true" />
+    <option name="allFeatures" value="false" />
+    <option name="emulateTerminal" value="false" />
+    <option name="withSudo" value="false" />
+    <option name="buildTarget" value="REMOTE" />
+    <option name="backtrace" value="SHORT" />
+    <envs />
+    <option name="isRedirectInput" value="false" />
+    <option name="redirectInputPath" value="" />
+    <method v="2">
+      <option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
+    </method>
+  </configuration>
+</component>
diff --git a/Cargo.toml b/Cargo.toml
index c46a54d..f7e7809 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,3 +13,7 @@ tokio = { version =  "1.18.2", features = ["rt-multi-thread", "macros"] }
 rspotify = { version = "0.11.5", features = ["default"]}
 sentry = "0.26.0"
 invidious = "0.2.1"
+chrono = "0.4.19"
+
+[dev-dependencies]
+tokio-test = "0.4.2"
diff --git a/src/engine.rs b/src/engine.rs
new file mode 100644
index 0000000..83f0cfa
--- /dev/null
+++ b/src/engine.rs
@@ -0,0 +1,76 @@
+use crate::{spotify, youtube};
+use chrono::{Date, Utc};
+use std::time::Duration;
+
+pub(crate) enum MusicData {
+    Track(Track),
+    Album(Album),
+}
+
+pub(crate) struct Track {
+    name: String,
+    authors: Vec<Author>,
+    duration: Duration,
+    album: Vec<Album>,
+    description: String,
+    lyrics: String,
+}
+
+pub(crate) struct Album {
+    name: String,
+    authors: Vec<Author>,
+    description: String,
+    year: Date<Utc>,
+}
+
+pub(crate) struct Author {
+    name: String,
+    surname: String,
+    date_of_birth: Date<Utc>,
+}
+
+// The enum holds all the currently supported type of Id which the engine can search for
+pub(crate) enum ServiceIdKind {
+    Spotify(String),
+    Youtube(String),
+    Automatic(String),
+}
+
+// This struct will allow us in the future to search, cache and store data and metadata regarding
+// tracks, albums and playlists
+pub(crate) struct MusicEngine {
+    spotify: spotify::Client,
+    youtube: youtube::Client,
+}
+
+impl MusicEngine {
+    pub(crate) async fn new() -> Self {
+        MusicEngine {
+            spotify: spotify::Client::new().await,
+            youtube: youtube::Client::new().await,
+        }
+    }
+
+    pub(crate) fn new_with_dependencies(
+        spotify_client: spotify::Client,
+        youtube_client: youtube::Client,
+    ) -> Self {
+        MusicEngine {
+            spotify: spotify_client,
+            youtube: youtube_client,
+        }
+    }
+
+    pub(crate) async fn search_by_name(&self, name: &str) {
+        todo!("In the future it would be possible to search for all metadata on a record from this call")
+    }
+    pub(crate) async fn search_by_id(&self, id: ServiceIdKind) {
+        match id {
+            ServiceIdKind::Spotify(id) => {
+                let entry_kind = spotify::get_entry_kind(id.as_str());
+            }
+            ServiceIdKind::Youtube(id) => {}
+            ServiceIdKind::Automatic(id) => {}
+        }
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 27b24f2..01fa125 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -9,6 +9,7 @@ use spotify::SpotifyKind::Track;
 use crate::spotify::SpotifyKind::{Album, Episode, Playlist, Podcast};
 use crate::utils::{human_readable_duration, truncate_with_dots};
 
+mod engine;
 mod spotify;
 mod utils;
 mod youtube;
@@ -50,11 +51,11 @@ async fn main() {
         let text = message.text().and_then(spotify::get_entry_kind);
         match text {
             Some(spotify) => {
-                let spotify_client = spotify::get_client().await;
+                let spotify_client = spotify::Client::new().await;
                 match spotify {
                     Track(id) => {
                         log::debug!("Parsing spotify song: {}", id);
-                        let track_info = spotify::get_track(spotify_client, &id).await;
+                        let track_info = spotify_client.get_track(&id).await;
                         match track_info {
                             Some(info) => {
                                 let reply = format!(
@@ -76,7 +77,7 @@ async fn main() {
                     }
                     Album(id) => {
                         log::debug!("Parsing spotify album: {}", id);
-                        let album_info = spotify::get_album(spotify_client, &id).await;
+                        let album_info = spotify_client.get_album(&id).await;
                         match album_info {
                             Some(info) => {
                                 let mut reply = format!(
@@ -103,7 +104,7 @@ async fn main() {
                     }
                     Playlist(id) => {
                         log::debug!("Parsing spotify playlist: {}", id);
-                        let playlist_info = spotify::get_playlist(spotify_client, &id).await;
+                        let playlist_info = spotify_client.get_playlist(&id).await;
                         match playlist_info {
                             Some(info) => {
                                 let reply = format!(
@@ -140,32 +141,3 @@ async fn main() {
 
     log::info!("Exiting...");
 }
-
-fn add_track_section_for_playlist(tracks: Vec<PlayableKind>, reply: String) -> String {
-    if !tracks.is_empty() {
-        let songs = tracks
-            .iter()
-            .map(|x| match x {
-                PlayableKind::Track(t) => t.name.clone(),
-                PlayableKind::Podcast(e) => e.name.clone()
-            } + "\n")
-            .collect::<String>();
-        reply
-            .clone()
-            .push_str(format!("\n🎶 {} Track(s): {}", tracks.len(), songs).as_str())
-    }
-    reply
-}
-
-fn add_track_section(tracks: Vec<TrackInfo>, reply: String) -> String {
-    if !tracks.is_empty() {
-        let songs = tracks
-            .iter()
-            .map(|x| x.name.clone() + "\n")
-            .collect::<String>();
-        reply
-            .clone()
-            .push_str(format!("\n🎶 {} Track(s): {}", tracks.len(), songs).as_str())
-    }
-    reply
-}
diff --git a/src/spotify/mod.rs b/src/spotify/mod.rs
index b27de44..6635de9 100644
--- a/src/spotify/mod.rs
+++ b/src/spotify/mod.rs
@@ -2,6 +2,8 @@ use rspotify::model::PlayableItem::{Episode, Track};
 use rspotify::model::{AlbumId, FullTrack, PlaylistId, TrackId};
 use rspotify::prelude::*;
 use rspotify::{ClientCredsSpotify, Credentials};
+use std::any::Any;
+use std::sync::Arc;
 use std::time::Duration;
 
 pub enum SpotifyKind {
@@ -45,6 +47,125 @@ pub struct PlaylistInfo {
     pub(crate) tracks: Vec<PlayableKind>,
 }
 
+#[derive(Clone, Debug)]
+pub(crate) struct Client {
+    client: Arc<ClientCredsSpotify>,
+}
+
+impl Client {
+    pub(crate) async fn new() -> Self {
+        let spotify_creds = Credentials::from_env()
+            .expect("RSPOTIFY_CLIENT_ID and RSPOTIFY_CLIENT_SECRET not found.");
+        let mut spotify = ClientCredsSpotify::new(spotify_creds);
+        spotify.request_token().await.unwrap();
+        Client {
+            client: Arc::new(spotify),
+        }
+    }
+
+    pub(crate) fn new_with_dependencies(client: ClientCredsSpotify) -> Self {
+        Client {
+            client: Arc::new(client),
+        }
+    }
+
+    pub async fn get_track(&self, id: &str) -> Option<TrackInfo> {
+        let track_id = match TrackId::from_id(id) {
+            Ok(track) => track,
+            Err(_e) => return None,
+        };
+
+        match self.client.track(&track_id).await {
+            Ok(track) => Some(TrackInfo {
+                name: track.name,
+                artists: track.artists.iter().map(|x| x.name.clone()).collect(),
+                duration: track.duration,
+            }),
+            Err(_e) => None,
+        }
+    }
+
+    pub async fn get_album(&self, id: &str) -> Option<AlbumInfo> {
+        let album_id = match AlbumId::from_id(id) {
+            Ok(album) => album,
+            Err(_e) => return None,
+        };
+
+        match self.client.album(&album_id).await {
+            Ok(album) => Some(AlbumInfo {
+                name: album.name,
+                artists: album.artists.iter().map(|x| x.name.clone()).collect(),
+                genres: album.genres,
+                tracks: album
+                    .tracks
+                    .items
+                    .iter()
+                    .map(|t| TrackInfo {
+                        name: t.name.clone(),
+                        artists: t.artists.iter().map(|x| x.name.clone()).collect(),
+                        duration: t.duration,
+                    })
+                    .collect(),
+            }),
+            Err(_e) => None,
+        }
+    }
+
+    pub async fn get_playlist(&self, id: &String) -> Option<PlaylistInfo> {
+        let playlist_id = match PlaylistId::from_id(id.as_str()) {
+            Ok(playlist) => playlist,
+            Err(_e) => return None,
+        };
+
+        match self.client.playlist(&playlist_id, None, None).await {
+            Ok(playlist) => Some(PlaylistInfo {
+                name: playlist.name,
+                artists: playlist
+                    .tracks
+                    .items
+                    .iter()
+                    .flat_map(|p| {
+                        match &p.track {
+                            Some(t) => match t {
+                                Track(t) => t.artists.iter().map(|a| a.name.clone()).collect(),
+                                Episode(e) => vec![e.show.publisher.clone()],
+                            },
+                            None => Vec::new(),
+                        }
+                        .into_iter()
+                    })
+                    .collect(),
+                tracks: playlist
+                    .tracks
+                    .items
+                    .iter()
+                    .map(|p| match &p.track {
+                        Some(t) => match t {
+                            Track(t) => Some(PlayableKind::Track(TrackInfo {
+                                name: t.name.clone(),
+                                artists: t.artists.iter().map(|a| a.name.clone()).collect(),
+                                duration: t.duration,
+                            })),
+                            Episode(e) => Some(PlayableKind::Podcast(EpisodeInfo {
+                                name: e.name.clone(),
+                                show: e.show.name.clone(),
+                                duration: e.duration,
+                                description: e.description.clone(),
+                                languages: e.languages.clone(),
+                                release_date: e.release_date.clone(),
+                            })),
+                        },
+                        None => None,
+                    })
+                    .filter(|i| i.is_some())
+                    .map(|i| i.unwrap())
+                    .collect(),
+            }),
+            Err(_e) => None,
+        }
+    }
+}
+
 fn get_id_in_url(url: &str) -> Option<&str> {
     url.rsplit('/')
         .next()
@@ -52,44 +173,76 @@ fn get_id_in_url(url: &str) -> Option<&str> {
         .and_then(|x| x.split('?').next())
 }
 
-fn extract_artists_from_tracks(tracks: Vec<FullTrack>) -> Vec<String> {
-    tracks
-        .iter()
-        .flat_map(|t| t.artists.iter().map(|a| a.name.clone()))
-        .collect()
+fn get_id_in_uri(uri: &str) -> Option<&str> {
+    uri.rsplit(':').next()
 }
 
-pub fn get_entry_kind(url: &str) -> Option<SpotifyKind> {
-    if url.contains("https://open.spotify.com/track/") {
-        let track_id = get_id_in_url(url);
+pub fn get_entry_kind(uri: &str) -> Option<SpotifyKind> {
+    if uri.contains("spotify:track:") {
+        let track_id = get_id_in_uri(uri);
         return match track_id {
             Some(id) => Some(SpotifyKind::Track(id.to_string())),
             None => None,
         };
     }
-    if url.contains("https://open.spotify.com/album/") {
-        let album_id = get_id_in_url(url);
+    if uri.contains("https://open.spotify.com/track/") {
+        let track_id = get_id_in_url(uri);
+        return match track_id {
+            Some(id) => Some(SpotifyKind::Track(id.to_string())),
+            None => None,
+        };
+    }
+    if uri.contains("spotify:album:") {
+        let track_id = get_id_in_uri(uri);
+        return match track_id {
+            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            None => None,
+        };
+    }
+    if uri.contains("https://open.spotify.com/album/") {
+        let album_id = get_id_in_url(uri);
         return match album_id {
             Some(id) => Some(SpotifyKind::Album(id.to_string())),
             None => None,
         };
     }
-    if url.contains("https://open.spotify.com/playlist/") {
-        let playlist_id = get_id_in_url(url);
+    if uri.contains("spotify:playlist:") {
+        let track_id = get_id_in_uri(uri);
+        return match track_id {
+            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            None => None,
+        };
+    }
+    if uri.contains("https://open.spotify.com/playlist/") {
+        let playlist_id = get_id_in_url(uri);
         return match playlist_id {
             Some(id) => Some(SpotifyKind::Playlist(id.to_string())),
             None => None,
         };
     }
-    if url.contains("https://open.spotify.com/show/") {
-        let playlist_id = get_id_in_url(url);
+    if uri.contains("spotify:show:") {
+        let track_id = get_id_in_uri(uri);
+        return match track_id {
+            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            None => None,
+        };
+    }
+    if uri.contains("https://open.spotify.com/show/") {
+        let playlist_id = get_id_in_url(uri);
         return match playlist_id {
             Some(id) => Some(SpotifyKind::Podcast(id.to_string())),
             None => None,
         };
     }
-    if url.contains("https://open.spotify.com/episode/") {
-        let playlist_id = get_id_in_url(url);
+    if uri.contains("spotify:episode:") {
+        let track_id = get_id_in_uri(uri);
+        return match track_id {
+            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            None => None,
+        };
+    }
+    if uri.contains("https://open.spotify.com/episode/") {
+        let playlist_id = get_id_in_url(uri);
         return match playlist_id {
             Some(id) => Some(SpotifyKind::Episode(id.to_string())),
             None => None,
@@ -97,107 +250,3 @@ pub fn get_entry_kind(url: &str) -> Option<SpotifyKind> {
     }
     return None;
 }
-
-pub async fn get_client() -> Box<ClientCredsSpotify> {
-    let spotify_creds =
-        Credentials::from_env().expect("RSPOTIFY_CLIENT_ID and RSPOTIFY_CLIENT_SECRET not found.");
-    let mut spotify = ClientCredsSpotify::new(spotify_creds);
-    spotify.request_token().await.unwrap();
-    Box::new(spotify)
-}
-
-pub async fn get_track(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<TrackInfo> {
-    let track_id = match TrackId::from_id(id.as_str()) {
-        Ok(track) => track,
-        Err(_e) => return None,
-    };
-
-    match spotify.track(&track_id).await {
-        Ok(track) => Some(TrackInfo {
-            name: track.name,
-            artists: track.artists.iter().map(|x| x.name.clone()).collect(),
-            duration: track.duration,
-        }),
-        Err(_e) => None,
-    }
-}
-
-pub async fn get_album(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<AlbumInfo> {
-    let album_id = match AlbumId::from_id(id.as_str()) {
-        Ok(album) => album,
-        Err(_e) => return None,
-    };
-
-    match spotify.album(&album_id).await {
-        Ok(album) => Some(AlbumInfo {
-            name: album.name,
-            artists: album.artists.iter().map(|x| x.name.clone()).collect(),
-            genres: album.genres,
-            tracks: album
-                .tracks
-                .items
-                .iter()
-                .map(|t| TrackInfo {
-                    name: t.name.clone(),
-                    artists: t.artists.iter().map(|x| x.name.clone()).collect(),
-                    duration: t.duration,
-                })
-                .collect(),
-        }),
-        Err(_e) => None,
-    }
-}
-
-pub async fn get_playlist(spotify: Box<ClientCredsSpotify>, id: &String) -> Option<PlaylistInfo> {
-    let playlist_id = match PlaylistId::from_id(id.as_str()) {
-        Ok(playlist) => playlist,
-        Err(_e) => return None,
-    };
-
-    match spotify.playlist(&playlist_id, None, None).await {
-        Ok(playlist) => Some(PlaylistInfo {
-            name: playlist.name,
-            artists: playlist
-                .tracks
-                .items
-                .iter()
-                .flat_map(|p| {
-                    match &p.track {
-                        Some(t) => match t {
-                            Track(t) => t.artists.iter().map(|a| a.name.clone()).collect(),
-                            Episode(e) => vec![e.show.publisher.clone()],
-                        },
-                        None => Vec::new(),
-                    }
-                    .into_iter()
-                })
-                .collect(),
-            tracks: playlist
-                .tracks
-                .items
-                .iter()
-                .map(|p| match &p.track {
-                    Some(t) => match t {
-                        Track(t) => Some(PlayableKind::Track(TrackInfo {
-                            name: t.name.clone(),
-                            artists: t.artists.iter().map(|a| a.name.clone()).collect(),
-                            duration: t.duration,
-                        })),
-                        Episode(e) => Some(PlayableKind::Podcast(EpisodeInfo {
-                            name: e.name.clone(),
-                            show: e.show.name.clone(),
-                            duration: e.duration,
-                            description: e.description.clone(),
-                            languages: e.languages.clone(),
-                            release_date: e.release_date.clone(),
-                        })),
-                    },
-                    None => None,
-                })
-                .filter(|i| i.is_some())
-                .map(|i| i.unwrap())
-                .collect(),
-        }),
-        Err(_e) => None,
-    }
-}
diff --git a/src/youtube/mod.rs b/src/youtube/mod.rs
index aa7456b..2077244 100644
--- a/src/youtube/mod.rs
+++ b/src/youtube/mod.rs
@@ -1,10 +1,5 @@
-use invidious::asynchronous::Client;
 use std::error::Error;
-
-#[derive(Debug, Clone)]
-pub(crate) struct YoutubeClient {
-    client: Client,
-}
+use std::sync::Arc;
 
 pub(crate) struct VideoSearch {
     items: Vec<Video>,
@@ -22,7 +17,7 @@ pub(crate) struct Video {
     viewCount: u64,
     published: u64,
     publishedText: String,
-    liveNow: bool,
+    live_now: bool,
     paid: bool,
     premium: bool,
 }
@@ -34,15 +29,28 @@ const BY_RATING: &SearchSortBy = "rating";
 const BY_UPLOAD_DATE: &SearchSortBy = "upload_date";
 const BY_VIEW_COUNT: &SearchSortBy = "view_count";
 
-impl YoutubeClient {
-    async fn new() -> YoutubeClient {
-        // TODO check for a stable instance
-        let client = Client::new(String::from("https://vid.puffyan.us"));
+#[derive(Debug, Clone)]
+pub(crate) struct Client {
+    client: Arc<invidious::asynchronous::Client>,
+}
 
-        YoutubeClient { client }
+impl Client {
+    pub(crate) async fn new() -> Self {
+        // TODO check for a stable instance
+        let client = invidious::asynchronous::Client::new(String::from("https://vid.puffyan.us"));
+
+        Client {
+            client: Arc::new(client),
+        }
     }
 
-    async fn search_video(
+    pub(crate) fn new_with_dependencies(client: invidious::asynchronous::Client) -> Self {
+        Client {
+            client: Arc::new(client),
+        }
+    }
+
+    pub async fn search_video(
         &self,
         keyword: &str,
         sort_by: Option<&SearchSortBy>,
@@ -69,7 +77,7 @@ impl YoutubeClient {
                     authorId,
                     authorUrl,
                     lengthSeconds,
-                    videoThumbnails,
+                    videoThumbnails: _,
                     description,
                     descriptionHtml,
                     viewCount,
@@ -90,7 +98,7 @@ impl YoutubeClient {
                     viewCount: viewCount.clone(),
                     published: published.clone(),
                     publishedText: publishedText.clone(),
-                    liveNow: liveNow.clone(),
+                    live_now: liveNow.clone(),
                     paid: paid.clone(),
                     premium: premium.clone(),
                 }),
@@ -98,9 +106,26 @@ impl YoutubeClient {
             })
             .filter(|x| x.is_some())
             .map(|x| x.unwrap())
-            .filter(|x| !x.premium && !x.paid && !x.liveNow)
+            .filter(|x| !x.premium && !x.paid && !x.live_now)
             .collect();
 
         Result::Ok(VideoSearch { items: videos })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_search_properly() {
+        let client = tokio_test::block_on(Client::new());
+
+        let result = tokio_test::block_on(client.search_video(
+            "vfdskvnfdsjklvnfdsjklvnfsdjkldsvmdlfmvkdfslvsdfmklsdvlvfdnjkvnfdsjkvnfsdjk",
+            Some(BY_UPLOAD_DATE),
+        ))
+        .unwrap();
+        assert_eq!(30, result.items.len())
+    }
+}
-- 
2.40.1


From 06fff8e972500dd15583ccb78707d4c5ba07eb83 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Tue, 31 May 2022 23:13:28 +0200
Subject: [PATCH 3/9] feat: finish first method draft implementation

---
 src/engine.rs      | 62 ++++++++++++++++++++++++++++++++++++++--------
 src/main.rs        |  4 +--
 src/spotify/mod.rs | 26 +++++++++----------
 3 files changed, 67 insertions(+), 25 deletions(-)

diff --git a/src/engine.rs b/src/engine.rs
index 83f0cfa..08b2174 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -1,3 +1,4 @@
+use crate::spotify::ContentKind;
 use crate::{spotify, youtube};
 use chrono::{Date, Utc};
 use std::time::Duration;
@@ -7,26 +8,27 @@ pub(crate) enum MusicData {
     Album(Album),
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct Track {
     name: String,
     authors: Vec<Author>,
     duration: Duration,
-    album: Vec<Album>,
-    description: String,
-    lyrics: String,
+    album: Option<Album>,
+    description: Option<String>,
+    lyrics: Option<String>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct Album {
     name: String,
     authors: Vec<Author>,
-    description: String,
-    year: Date<Utc>,
+    description: Option<String>,
+    year: Option<Date<Utc>>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct Author {
     name: String,
-    surname: String,
-    date_of_birth: Date<Utc>,
 }
 
 // The enum holds all the currently supported type of Id which the engine can search for
@@ -64,13 +66,53 @@ impl MusicEngine {
     pub(crate) async fn search_by_name(&self, name: &str) {
         todo!("In the future it would be possible to search for all metadata on a record from this call")
     }
-    pub(crate) async fn search_by_id(&self, id: ServiceIdKind) {
+
+    pub(crate) async fn search_by_id(&self, id: ServiceIdKind) -> Option<MusicData> {
         match id {
             ServiceIdKind::Spotify(id) => {
                 let entry_kind = spotify::get_entry_kind(id.as_str());
+                match entry_kind {
+                    None => None,
+                    Some(entry) => match entry {
+                        ContentKind::Track(id) => {
+                            self.spotify.get_track(id.as_str()).await.map(|track| {
+                                MusicData::Track(Track {
+                                    name: track.name.clone(),
+                                    authors: track
+                                        .artists
+                                        .iter()
+                                        .map(|artist| Author {
+                                            name: artist.clone(),
+                                        })
+                                        .collect(),
+                                    duration: track.duration.clone(),
+                                    album: None,       // FIXME missing metadata
+                                    description: None, // FIXME missing metadata
+                                    lyrics: None,      // FIXME missing metadata
+                                })
+                            })
+                        }
+                        ContentKind::Album(id) => {
+                            self.spotify.get_album(id.as_str()).await.map(|album| {
+                                MusicData::Album(Album {
+                                    name: album.name.clone(),
+                                    authors: album
+                                        .artists
+                                        .iter()
+                                        .map(|artist| Author {
+                                            name: artist.clone(),
+                                        })
+                                        .collect(),
+                                    description: None, // FIXME missing metadata
+                                    year: None,        // FIXME missing metadata
+                                })
+                            })
+                        }
+                        _ => None,
+                    },
+                }
             }
-            ServiceIdKind::Youtube(id) => {}
-            ServiceIdKind::Automatic(id) => {}
+            _ => todo!("Search type not present yet"), //TODO implement
         }
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 01fa125..4932ca4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,9 +4,9 @@ use std::env;
 use teloxide::prelude::*;
 
 use crate::spotify::{PlayableKind, TrackInfo};
-use spotify::SpotifyKind::Track;
+use spotify::ContentKind::Track;
 
-use crate::spotify::SpotifyKind::{Album, Episode, Playlist, Podcast};
+use crate::spotify::ContentKind::{Album, Episode, Playlist, Podcast};
 use crate::utils::{human_readable_duration, truncate_with_dots};
 
 mod engine;
diff --git a/src/spotify/mod.rs b/src/spotify/mod.rs
index 6635de9..a392137 100644
--- a/src/spotify/mod.rs
+++ b/src/spotify/mod.rs
@@ -6,7 +6,7 @@ use std::any::Any;
 use std::sync::Arc;
 use std::time::Duration;
 
-pub enum SpotifyKind {
+pub enum ContentKind {
     Track(String),
     Album(String),
     Playlist(String),
@@ -81,7 +81,7 @@ impl Client {
                 artists: track.artists.iter().map(|x| x.name.clone()).collect(),
                 duration: track.duration,
             }),
-            Err(_e) => None,
+            Err(_e) => return None,
         }
     }
 
@@ -177,74 +177,74 @@ fn get_id_in_uri(uri: &str) -> Option<&str> {
     uri.rsplit(':').next()
 }
 
-pub fn get_entry_kind(uri: &str) -> Option<SpotifyKind> {
+pub fn get_entry_kind(uri: &str) -> Option<ContentKind> {
     if uri.contains("spotify:track:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Track(id.to_string())),
+            Some(id) => Some(ContentKind::Track(id.to_string())),
             None => None,
         };
     }
     if uri.contains("https://open.spotify.com/track/") {
         let track_id = get_id_in_url(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Track(id.to_string())),
+            Some(id) => Some(ContentKind::Track(id.to_string())),
             None => None,
         };
     }
     if uri.contains("spotify:album:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Album(id.to_string())),
             None => None,
         };
     }
     if uri.contains("https://open.spotify.com/album/") {
         let album_id = get_id_in_url(uri);
         return match album_id {
-            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Album(id.to_string())),
             None => None,
         };
     }
     if uri.contains("spotify:playlist:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Album(id.to_string())),
             None => None,
         };
     }
     if uri.contains("https://open.spotify.com/playlist/") {
         let playlist_id = get_id_in_url(uri);
         return match playlist_id {
-            Some(id) => Some(SpotifyKind::Playlist(id.to_string())),
+            Some(id) => Some(ContentKind::Playlist(id.to_string())),
             None => None,
         };
     }
     if uri.contains("spotify:show:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Album(id.to_string())),
             None => None,
         };
     }
     if uri.contains("https://open.spotify.com/show/") {
         let playlist_id = get_id_in_url(uri);
         return match playlist_id {
-            Some(id) => Some(SpotifyKind::Podcast(id.to_string())),
+            Some(id) => Some(ContentKind::Podcast(id.to_string())),
             None => None,
         };
     }
     if uri.contains("spotify:episode:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(SpotifyKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Album(id.to_string())),
             None => None,
         };
     }
     if uri.contains("https://open.spotify.com/episode/") {
         let playlist_id = get_id_in_url(uri);
         return match playlist_id {
-            Some(id) => Some(SpotifyKind::Episode(id.to_string())),
+            Some(id) => Some(ContentKind::Episode(id.to_string())),
             None => None,
         };
     }
-- 
2.40.1


From ba2b689e772bea128f6f7f4873cb8a5d41dfdb39 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Wed, 8 Jun 2022 18:17:22 +0200
Subject: [PATCH 4/9] feat: add first engine song search

---
 src/engine.rs      | 130 +++++++++++++++++++--------------------------
 src/spotify/mod.rs |   7 +++
 src/youtube/mod.rs |  31 +++++------
 3 files changed, 78 insertions(+), 90 deletions(-)

diff --git a/src/engine.rs b/src/engine.rs
index 08b2174..9348114 100644
--- a/src/engine.rs
+++ b/src/engine.rs
@@ -1,37 +1,15 @@
 use crate::spotify::ContentKind;
-use crate::{spotify, youtube};
-use chrono::{Date, Utc};
-use std::time::Duration;
-
-pub(crate) enum MusicData {
-    Track(Track),
-    Album(Album),
-}
+use crate::youtube::Video;
+use crate::{spotify, youtube, TrackInfo};
 
 #[derive(Debug, Clone)]
-pub(crate) struct Track {
-    name: String,
-    authors: Vec<Author>,
-    duration: Duration,
-    album: Option<Album>,
-    description: Option<String>,
-    lyrics: Option<String>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Album {
-    name: String,
-    authors: Vec<Author>,
-    description: Option<String>,
-    year: Option<Date<Utc>>,
-}
-
-#[derive(Debug, Clone)]
-pub(crate) struct Author {
-    name: String,
+pub(crate) struct TrackItem {
+    spotify_track: Option<TrackInfo>,
+    youtube_track: Option<Vec<Video>>,
 }
 
 // The enum holds all the currently supported type of Id which the engine can search for
+#[derive(Debug, Clone)]
 pub(crate) enum ServiceIdKind {
     Spotify(String),
     Youtube(String),
@@ -40,6 +18,7 @@ pub(crate) enum ServiceIdKind {
 
 // This struct will allow us in the future to search, cache and store data and metadata regarding
 // tracks, albums and playlists
+#[derive(Debug, Clone)]
 pub(crate) struct MusicEngine {
     spotify: spotify::Client,
     youtube: youtube::Client,
@@ -63,56 +42,57 @@ impl MusicEngine {
         }
     }
 
-    pub(crate) async fn search_by_name(&self, name: &str) {
+    pub(crate) async fn search_song_by_name(&self, name: &str) {
         todo!("In the future it would be possible to search for all metadata on a record from this call")
     }
 
-    pub(crate) async fn search_by_id(&self, id: ServiceIdKind) -> Option<MusicData> {
-        match id {
-            ServiceIdKind::Spotify(id) => {
-                let entry_kind = spotify::get_entry_kind(id.as_str());
-                match entry_kind {
-                    None => None,
-                    Some(entry) => match entry {
-                        ContentKind::Track(id) => {
-                            self.spotify.get_track(id.as_str()).await.map(|track| {
-                                MusicData::Track(Track {
-                                    name: track.name.clone(),
-                                    authors: track
-                                        .artists
-                                        .iter()
-                                        .map(|artist| Author {
-                                            name: artist.clone(),
-                                        })
-                                        .collect(),
-                                    duration: track.duration.clone(),
-                                    album: None,       // FIXME missing metadata
-                                    description: None, // FIXME missing metadata
-                                    lyrics: None,      // FIXME missing metadata
-                                })
-                            })
-                        }
-                        ContentKind::Album(id) => {
-                            self.spotify.get_album(id.as_str()).await.map(|album| {
-                                MusicData::Album(Album {
-                                    name: album.name.clone(),
-                                    authors: album
-                                        .artists
-                                        .iter()
-                                        .map(|artist| Author {
-                                            name: artist.clone(),
-                                        })
-                                        .collect(),
-                                    description: None, // FIXME missing metadata
-                                    year: None,        // FIXME missing metadata
-                                })
-                            })
-                        }
-                        _ => None,
-                    },
-                }
-            }
-            _ => todo!("Search type not present yet"), //TODO implement
+    pub(crate) async fn search_song_by_id(&self, id: &str) -> Option<TrackItem> {
+        let entry_kind = spotify::get_entry_kind(id);
+        let track_info = match entry_kind {
+            Some(entry) => match entry {
+                ContentKind::Track(id) => self.spotify.get_track(id.as_str()).await,
+                _ => None,
+            },
+            None => None,
+        };
+
+        if track_info.is_some() {
+            let ti = track_info.unwrap();
+            let youtube_search = match self
+                .youtube
+                .search_video(
+                    format!(
+                        "{} {}",
+                        ti.artists
+                            .get(0)
+                            .map(|artist| format!("{} -", artist))
+                            .unwrap_or("".to_string()),
+                        ti.name
+                    )
+                    .as_str(),
+                    None,
+                )
+                .await
+            {
+                Err(_) => None,
+                Ok(search) => Some(search),
+            };
+
+            return Some(TrackItem {
+                spotify_track: Some(ti),
+                youtube_track: youtube_search.map(|search| search.items),
+            });
         }
+        return None;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn should_search_track_by_spotify_id() {
+        todo!("Implement me!")
     }
 }
diff --git a/src/spotify/mod.rs b/src/spotify/mod.rs
index a392137..9d04991 100644
--- a/src/spotify/mod.rs
+++ b/src/spotify/mod.rs
@@ -6,6 +6,7 @@ use std::any::Any;
 use std::sync::Arc;
 use std::time::Duration;
 
+#[derive(Debug, Clone)]
 pub enum ContentKind {
     Track(String),
     Album(String),
@@ -14,17 +15,20 @@ pub enum ContentKind {
     Episode(String),
 }
 
+#[derive(Debug, Clone)]
 pub enum PlayableKind {
     Track(TrackInfo),
     Podcast(EpisodeInfo),
 }
 
+#[derive(Debug, Clone)]
 pub struct TrackInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
     pub(crate) duration: Duration,
 }
 
+#[derive(Debug, Clone)]
 pub struct EpisodeInfo {
     pub(crate) name: String,
     pub(crate) show: String,
@@ -34,6 +38,7 @@ pub struct EpisodeInfo {
     pub(crate) release_date: String,
 }
 
+#[derive(Debug, Clone)]
 pub struct AlbumInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
@@ -41,6 +46,7 @@ pub struct AlbumInfo {
     pub(crate) tracks: Vec<TrackInfo>,
 }
 
+#[derive(Debug, Clone)]
 pub struct PlaylistInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
@@ -70,6 +76,7 @@ impl Client {
     }
 
     pub async fn get_track(&self, id: &str) -> Option<TrackInfo> {
+        // FIXME should we really return Option here? We're hiding a possible error or a entry not found
         let track_id = match TrackId::from_id(id) {
             Ok(track) => track,
             Err(_e) => return None,
diff --git a/src/youtube/mod.rs b/src/youtube/mod.rs
index 2077244..3d2d98d 100644
--- a/src/youtube/mod.rs
+++ b/src/youtube/mod.rs
@@ -2,21 +2,22 @@ use std::error::Error;
 use std::sync::Arc;
 
 pub(crate) struct VideoSearch {
-    items: Vec<Video>,
+    pub(crate) items: Vec<Video>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct Video {
     title: String,
-    videoId: String,
+    video_id: String,
     author: String,
-    authorId: String,
-    authorUrl: String,
-    lengthSeconds: u64,
+    author_id: String,
+    author_url: String,
+    length_seconds: u64,
     description: String,
-    descriptionHtml: String,
-    viewCount: u64,
+    description_html: String,
+    view_count: u64,
     published: u64,
-    publishedText: String,
+    published_text: String,
     live_now: bool,
     paid: bool,
     premium: bool,
@@ -88,16 +89,16 @@ impl Client {
                     premium,
                 } => Some(Video {
                     title: title.clone(),
-                    videoId: videoId.clone(),
+                    video_id: videoId.clone(),
                     author: author.clone(),
-                    authorId: authorId.clone(),
-                    authorUrl: authorUrl.clone(),
-                    lengthSeconds: lengthSeconds.clone(),
+                    author_id: authorId.clone(),
+                    author_url: authorUrl.clone(),
+                    length_seconds: lengthSeconds.clone(),
                     description: description.clone(),
-                    descriptionHtml: descriptionHtml.clone(),
-                    viewCount: viewCount.clone(),
+                    description_html: descriptionHtml.clone(),
+                    view_count: viewCount.clone(),
                     published: published.clone(),
-                    publishedText: publishedText.clone(),
+                    published_text: publishedText.clone(),
                     live_now: liveNow.clone(),
                     paid: paid.clone(),
                     premium: premium.clone(),
-- 
2.40.1


From ff86b4c26dddb310be5825b1191005e57b759df4 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Thu, 23 Jun 2022 18:33:16 +0200
Subject: [PATCH 5/9] feat: add youtube search for tracks. Still WIP

* missing tests, docs and other stuff
* missing playlist porting and other content too (maybe)
---
 Cargo.toml                         |   1 +
 src/main.rs                        | 139 +++++++++--------------------
 src/{engine.rs => search/mod.rs}   |  71 +++++++++++----
 src/{ => search}/spotify/mod.rs    |  12 +--
 src/{ => search}/youtube/mod.rs    |  31 +++----
 src/tgformatter/mod.rs             | 132 +++++++++++++++++++++++++++
 src/{ => tgformatter}/utils/mod.rs |   0
 7 files changed, 249 insertions(+), 137 deletions(-)
 rename src/{engine.rs => search/mod.rs} (56%)
 rename src/{ => search}/spotify/mod.rs (96%)
 rename src/{ => search}/youtube/mod.rs (86%)
 create mode 100644 src/tgformatter/mod.rs
 rename src/{ => tgformatter}/utils/mod.rs (100%)

diff --git a/Cargo.toml b/Cargo.toml
index f7e7809..a6a988c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,6 +14,7 @@ rspotify = { version = "0.11.5", features = ["default"]}
 sentry = "0.26.0"
 invidious = "0.2.1"
 chrono = "0.4.19"
+itertools = "0.10.3"
 
 [dev-dependencies]
 tokio-test = "0.4.2"
diff --git a/src/main.rs b/src/main.rs
index 4932ca4..8037b05 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,20 +1,20 @@
-use log::LevelFilter;
+use log::{info, log, LevelFilter};
+use search::spotify;
 use sentry::ClientInitGuard;
 use std::env;
+use std::sync::Arc;
 use teloxide::prelude::*;
 
-use crate::spotify::{PlayableKind, TrackInfo};
-use spotify::ContentKind::Track;
+use search::spotify::ContentKind::Track;
+use search::spotify::{PlayableKind, TrackInfo};
 
-use crate::spotify::ContentKind::{Album, Episode, Playlist, Podcast};
-use crate::utils::{human_readable_duration, truncate_with_dots};
+use crate::search::get_spotify_kind;
+use crate::spotify::ContentKind;
+use search::spotify::ContentKind::{Album, Episode, Playlist, Podcast};
+use tgformatter::utils::{human_readable_duration, truncate_with_dots};
 
-mod engine;
-mod spotify;
-mod utils;
-mod youtube;
-
-static MAX_ARTISTS_CHARS: usize = 140;
+mod search;
+mod tgformatter;
 
 #[tokio::main]
 async fn main() {
@@ -48,94 +48,39 @@ async fn main() {
 
     let bot = Bot::from_env().auto_send();
     teloxide::repl(bot, |message: Message, bot: AutoSend<Bot>| async move {
-        let text = message.text().and_then(spotify::get_entry_kind);
-        match text {
-            Some(spotify) => {
-                let spotify_client = spotify::Client::new().await;
-                match spotify {
-                    Track(id) => {
-                        log::debug!("Parsing spotify song: {}", id);
-                        let track_info = spotify_client.get_track(&id).await;
-                        match track_info {
-                            Some(info) => {
-                                let reply = format!(
-                                    "Track information:\n\
-                                🎵 Track name: {}\n\
-                                🧑‍🎤 Artist(s): {}\n\
-                                ⏳ Duration: {}",
-                                    info.name,
-                                    truncate_with_dots(info.artists.join(", "), MAX_ARTISTS_CHARS),
-                                    human_readable_duration(info.duration)
-                                );
-                                bot.send_message(message.chat.id, reply)
-                                    .reply_to_message_id(message.id)
-                                    .await?;
-                                Some(respond(()))
-                            }
-                            None => None,
-                        }
-                    }
-                    Album(id) => {
-                        log::debug!("Parsing spotify album: {}", id);
-                        let album_info = spotify_client.get_album(&id).await;
-                        match album_info {
-                            Some(info) => {
-                                let mut reply = format!(
-                                    "Album information:\n\
-                                    🎵 Album name: {}\n\
-                                    🧑‍🎤 {} artist(s): {}",
-                                    info.name,
-                                    info.artists.len(),
-                                    truncate_with_dots(info.artists.join(", "), MAX_ARTISTS_CHARS)
-                                );
-                                if !info.genres.is_empty() {
-                                    reply.push_str(
-                                        format!("\n💿 Genre(s): {}", info.genres.join(", "))
-                                            .as_str(),
-                                    );
-                                }
-                                bot.send_message(message.chat.id, reply)
-                                    .reply_to_message_id(message.id)
-                                    .await?;
-                                Some(respond(()))
-                            }
-                            None => None,
-                        }
-                    }
-                    Playlist(id) => {
-                        log::debug!("Parsing spotify playlist: {}", id);
-                        let playlist_info = spotify_client.get_playlist(&id).await;
-                        match playlist_info {
-                            Some(info) => {
-                                let reply = format!(
-                                    "Playlist information:\n\
-                                    ✒️ Playlist name: {}\n\
-                                    🧑‍🎤 {} artist(s): {}",
-                                    info.name,
-                                    info.artists.len(),
-                                    truncate_with_dots(info.artists.join(", "), MAX_ARTISTS_CHARS)
-                                );
-                                bot.send_message(message.chat.id, reply)
-                                    .reply_to_message_id(message.id)
-                                    .await?;
-                                Some(respond(()))
-                            }
-                            None => None,
-                        }
-                    }
-                    Episode(id) => {
-                        log::warn!("Support for episodes ({}) has not be implemented yet!", id);
-                        None
-                    }
-                    Podcast(id) => {
-                        log::warn!("Support for podcasts ({}) has not be implemented yet!", id);
-                        None
-                    }
+        let music_engine = search::Engine::new().await;
+        let opt_text_message = message.text();
+        if opt_text_message.is_none() {
+            return respond(());
+        }
+        let text_message = opt_text_message.unwrap();
+        let content_kind = opt_text_message.and_then(|x| get_spotify_kind(x));
+        let option_reply = match content_kind {
+            None => return respond(()),
+            Some(content) => match content {
+                Track(id) => {
+                    info!("Processing song with spotify id: {}", id);
+                    let track_item = music_engine.get_song_from_spotify_id(text_message).await;
+                    tgformatter::format_track_message(track_item)
                 }
-            }
-            None => None,
+                Album(id) => {
+                    info!("Processing album with spotify id: {}", id);
+                    let album_item = music_engine.get_album_by_spotify_id(text_message).await;
+                    tgformatter::format_album_message(album_item)
+                }
+                _ => None,
+            },
         };
-        respond(())
+
+        if option_reply.is_some() {
+            info!("Got value to send back");
+            let reply = option_reply.unwrap();
+            bot.send_message(message.chat.id, reply)
+                .reply_to_message_id(message.id)
+                .await?;
+        }
+
+        return respond(());
     })
     .await;
 
diff --git a/src/engine.rs b/src/search/mod.rs
similarity index 56%
rename from src/engine.rs
rename to src/search/mod.rs
index 9348114..09beaf1 100644
--- a/src/engine.rs
+++ b/src/search/mod.rs
@@ -1,15 +1,25 @@
-use crate::spotify::ContentKind;
-use crate::youtube::Video;
-use crate::{spotify, youtube, TrackInfo};
+use crate::spotify::{get_entry_kind, AlbumInfo};
+use crate::TrackInfo;
+use log::info;
+use spotify::ContentKind;
+use youtube::Video;
 
-#[derive(Debug, Clone)]
+pub mod spotify;
+mod youtube;
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct TrackItem {
-    spotify_track: Option<TrackInfo>,
-    youtube_track: Option<Vec<Video>>,
+    pub(crate) spotify_track: Option<TrackInfo>,
+    pub(crate) youtube_track: Option<Vec<Video>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct AlbumItem {
+    pub(crate) spotify_track: Option<AlbumInfo>,
 }
 
 // The enum holds all the currently supported type of Id which the engine can search for
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum ServiceIdKind {
     Spotify(String),
     Youtube(String),
@@ -19,14 +29,14 @@ pub(crate) enum ServiceIdKind {
 // This struct will allow us in the future to search, cache and store data and metadata regarding
 // tracks, albums and playlists
 #[derive(Debug, Clone)]
-pub(crate) struct MusicEngine {
+pub(crate) struct Engine {
     spotify: spotify::Client,
     youtube: youtube::Client,
 }
 
-impl MusicEngine {
+impl Engine {
     pub(crate) async fn new() -> Self {
-        MusicEngine {
+        Engine {
             spotify: spotify::Client::new().await,
             youtube: youtube::Client::new().await,
         }
@@ -36,18 +46,18 @@ impl MusicEngine {
         spotify_client: spotify::Client,
         youtube_client: youtube::Client,
     ) -> Self {
-        MusicEngine {
+        Engine {
             spotify: spotify_client,
             youtube: youtube_client,
         }
     }
 
-    pub(crate) async fn search_song_by_name(&self, name: &str) {
+    pub(crate) async fn get_song_by_name(&self, name: &str) -> TrackItem {
         todo!("In the future it would be possible to search for all metadata on a record from this call")
     }
 
-    pub(crate) async fn search_song_by_id(&self, id: &str) -> Option<TrackItem> {
-        let entry_kind = spotify::get_entry_kind(id);
+    pub(crate) async fn get_song_from_spotify_id(&self, message: &str) -> TrackItem {
+        let entry_kind = spotify::get_entry_kind(message);
         let track_info = match entry_kind {
             Some(entry) => match entry {
                 ContentKind::Track(id) => self.spotify.get_track(id.as_str()).await,
@@ -62,10 +72,10 @@ impl MusicEngine {
                 .youtube
                 .search_video(
                     format!(
-                        "{} {}",
+                        "{}{}",
                         ti.artists
                             .get(0)
-                            .map(|artist| format!("{} -", artist))
+                            .map(|artist| format!("{} - ", artist))
                             .unwrap_or("".to_string()),
                         ti.name
                     )
@@ -78,13 +88,36 @@ impl MusicEngine {
                 Ok(search) => Some(search),
             };
 
-            return Some(TrackItem {
+            return TrackItem {
                 spotify_track: Some(ti),
                 youtube_track: youtube_search.map(|search| search.items),
-            });
+            };
         }
-        return None;
+        return TrackItem {
+            spotify_track: None,
+            youtube_track: None,
+        };
     }
+
+    pub(crate) async fn get_album_by_spotify_id(&self, message: &str) -> AlbumItem {
+        let entry_kind = spotify::get_entry_kind(message);
+
+        let album_info = match entry_kind {
+            Some(entry) => match entry {
+                ContentKind::Album(id) => self.spotify.get_album(id.as_str()).await,
+                _ => None,
+            },
+            None => None,
+        };
+
+        AlbumItem {
+            spotify_track: album_info,
+        }
+    }
+}
+
+pub(crate) fn get_spotify_kind(spotify_id: &str) -> Option<ContentKind> {
+    get_entry_kind(spotify_id)
 }
 
 #[cfg(test)]
diff --git a/src/spotify/mod.rs b/src/search/spotify/mod.rs
similarity index 96%
rename from src/spotify/mod.rs
rename to src/search/spotify/mod.rs
index 9d04991..e54436c 100644
--- a/src/spotify/mod.rs
+++ b/src/search/spotify/mod.rs
@@ -6,7 +6,7 @@ use std::any::Any;
 use std::sync::Arc;
 use std::time::Duration;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ContentKind {
     Track(String),
     Album(String),
@@ -15,20 +15,20 @@ pub enum ContentKind {
     Episode(String),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum PlayableKind {
     Track(TrackInfo),
     Podcast(EpisodeInfo),
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct TrackInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
     pub(crate) duration: Duration,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct EpisodeInfo {
     pub(crate) name: String,
     pub(crate) show: String,
@@ -38,7 +38,7 @@ pub struct EpisodeInfo {
     pub(crate) release_date: String,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct AlbumInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
@@ -46,7 +46,7 @@ pub struct AlbumInfo {
     pub(crate) tracks: Vec<TrackInfo>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PlaylistInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
diff --git a/src/youtube/mod.rs b/src/search/youtube/mod.rs
similarity index 86%
rename from src/youtube/mod.rs
rename to src/search/youtube/mod.rs
index 3d2d98d..2e9ad68 100644
--- a/src/youtube/mod.rs
+++ b/src/search/youtube/mod.rs
@@ -1,26 +1,27 @@
 use std::error::Error;
 use std::sync::Arc;
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct VideoSearch {
     pub(crate) items: Vec<Video>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct Video {
-    title: String,
-    video_id: String,
-    author: String,
-    author_id: String,
-    author_url: String,
-    length_seconds: u64,
-    description: String,
-    description_html: String,
-    view_count: u64,
-    published: u64,
-    published_text: String,
-    live_now: bool,
-    paid: bool,
-    premium: bool,
+    pub(crate) title: String,
+    pub(crate) video_id: String,
+    pub(crate) author: String,
+    pub(crate) author_id: String,
+    pub(crate) author_url: String,
+    pub(crate) length_seconds: u64,
+    pub(crate) description: String,
+    pub(crate) description_html: String,
+    pub(crate) view_count: u64,
+    pub(crate) published: u64,
+    pub(crate) published_text: String,
+    pub(crate) live_now: bool,
+    pub(crate) paid: bool,
+    pub(crate) premium: bool,
 }
 
 type SearchSortBy = str;
diff --git a/src/tgformatter/mod.rs b/src/tgformatter/mod.rs
new file mode 100644
index 0000000..930ecaa
--- /dev/null
+++ b/src/tgformatter/mod.rs
@@ -0,0 +1,132 @@
+use crate::search::{AlbumItem, TrackItem};
+use crate::TrackInfo;
+use log::{info, log};
+use std::borrow::Borrow;
+use std::collections::HashSet;
+use std::fmt::format;
+use std::time::Duration;
+use teloxide::repl;
+
+pub mod utils;
+
+static MAX_ARTISTS_CHARS: usize = 140;
+
+pub(crate) fn format_track_message(track_info: TrackItem) -> Option<String> {
+    // Let's avoid copying all the structure...we place it in the heap and pass the pointer to all the other functions
+    let boxed_info = Box::new(track_info);
+    if boxed_info.spotify_track.is_none() && boxed_info.youtube_track.is_none() {
+        return None;
+    }
+
+    let mut reply = format!(
+        "Track information:\n\
+                                🎵 Track name: {}\n\
+                                🧑‍🎤 Artist(s): {}\n\
+                                ⏳ Duration: {}",
+        get_track_name(boxed_info.clone()),
+        get_track_artists(boxed_info.clone()),
+        get_track_duration(boxed_info.clone())
+    );
+
+    let possible_first_video_link = boxed_info
+        .youtube_track
+        .and_then(|x| x.get(0).map(|x| format!("https://youtu.be/{}", x.video_id)));
+
+    if possible_first_video_link.is_some() {
+        reply.push_str(
+            format!("\n\n🔗Youtube link: {}", possible_first_video_link.unwrap()).as_str(),
+        );
+    }
+
+    Some(reply)
+}
+
+pub(crate) fn format_album_message(album_info: AlbumItem) -> Option<String> {
+    let boxed_info = Box::new(album_info);
+    if boxed_info.spotify_track.is_none() {
+        return None;
+    }
+
+    let mut artists = get_album_artists(boxed_info.clone());
+    let mut artists_names = "Unknown artist list".to_string();
+
+    if artists.len() > 0 {
+        artists_names = itertools::join(&artists, ", ");
+    }
+
+    let mut reply = format!(
+        "Album information:\n\
+                                    🎵 Album name: {}\n\
+                                    🧑‍🎤 {} artist(s): {}",
+        get_album_name(boxed_info.clone()),
+        artists.len(),
+        artists_names
+    );
+
+    let mut album_genres = get_album_genres(boxed_info.clone());
+    if album_genres.len() > 0 {
+        reply.push_str(format!("\n💿 Genre(s): {}", itertools::join(&artists, ", ")).as_str());
+    }
+
+    return Some(reply);
+}
+
+fn get_album_name(ai: Box<AlbumItem>) -> String {
+    ai.spotify_track
+        .map(|s| s.name)
+        .unwrap_or("Unknown album name".to_string())
+}
+
+fn get_album_genres(ai: Box<AlbumItem>) -> HashSet<String> {
+    if ai.spotify_track.is_some() {
+        return ai.spotify_track.unwrap().genres.into_iter().collect();
+    }
+
+    return HashSet::new();
+}
+
+fn get_album_artists(ai: Box<AlbumItem>) -> HashSet<String> {
+    if ai.spotify_track.is_some() {
+        return ai.spotify_track.unwrap().artists.into_iter().collect();
+    }
+
+    return HashSet::new();
+}
+
+fn get_track_name(ti: Box<TrackItem>) -> String {
+    if ti.spotify_track.is_some() {
+        ti.spotify_track.unwrap().name
+    } else {
+        ti.youtube_track
+            .and_then(|youtube_tracks| youtube_tracks.get(0).map(|t| t.title.clone()))
+            .unwrap_or("Unknown title".to_string())
+    }
+}
+
+fn get_track_artists(ti: Box<TrackItem>) -> String {
+    if ti.spotify_track.is_some() {
+        utils::truncate_with_dots(
+            ti.spotify_track.unwrap().artists.join(", "),
+            MAX_ARTISTS_CHARS,
+        )
+    } else {
+        ti.youtube_track
+            .and_then(|youtube_tracks| youtube_tracks.get(0).map(|t| t.author.clone()))
+            .unwrap_or("Unknown artist".to_string())
+    }
+}
+
+fn get_track_duration(ti: Box<TrackItem>) -> String {
+    if ti.spotify_track.is_some() {
+        utils::human_readable_duration(ti.spotify_track.unwrap().duration)
+    } else {
+        ti.youtube_track
+            .map(|youtube_tracks| {
+                let seconds_in_string =
+                    youtube_tracks.get(0).map(|t| t.length_seconds).unwrap_or(0);
+
+                utils::human_readable_duration(Duration::from_secs(seconds_in_string))
+            })
+            .unwrap_or("Unknown duration".to_string())
+    }
+}
diff --git a/src/utils/mod.rs b/src/tgformatter/utils/mod.rs
similarity index 100%
rename from src/utils/mod.rs
rename to src/tgformatter/utils/mod.rs
-- 
2.40.1


From 66bb5d1333a22a6f8baf2220c5f6dc600c70716e Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Fri, 15 Jul 2022 17:46:14 +0200
Subject: [PATCH 6/9] feat: add back playlist support

---
 src/main.rs               |  20 ++++++--
 src/search/mod.rs         | 101 +++++++++++++++++++++++++++++++++++++-
 src/search/spotify/mod.rs |   6 ++-
 src/search/youtube/mod.rs |   3 +-
 src/tgformatter/mod.rs    |  76 ++++++++++++++++------------
 5 files changed, 164 insertions(+), 42 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 8037b05..e463ee1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,8 @@
-use log::{info, log, LevelFilter};
+use log::{debug, info, log, LevelFilter};
 use search::spotify;
 use sentry::ClientInitGuard;
 use std::env;
+use std::process::id;
 use std::sync::Arc;
 use teloxide::prelude::*;
 
@@ -11,7 +12,6 @@ use search::spotify::{PlayableKind, TrackInfo};
 use crate::search::get_spotify_kind;
 use crate::spotify::ContentKind;
 use search::spotify::ContentKind::{Album, Episode, Playlist, Podcast};
-use tgformatter::utils::{human_readable_duration, truncate_with_dots};
 
 mod search;
 mod tgformatter;
@@ -65,15 +65,25 @@ async fn main() {
                 }
                 Album(id) => {
                     info!("Processing album with spotify id: {}", id);
-                    let album_item = music_engine.get_album_by_spotify_id(text_message).await;
+                    let album_item = music_engine.get_album_from_spotify_id(text_message).await;
                     tgformatter::format_album_message(album_item)
                 }
-                _ => None,
+                Playlist(id) => {
+                    info!("Processing playlist with spotify id: {}", id);
+                    let playlist_item = music_engine
+                        .get_playlist_from_spotify_id(text_message)
+                        .await;
+                    tgformatter::format_playlist_message(playlist_item)
+                }
+                _ => {
+                    log::warn!("This kind of media has been not supported yet");
+                    None
+                }
             },
         };
 
         if option_reply.is_some() {
-            info!("Got value to send back");
+            debug!("Got reply to send back");
             let reply = option_reply.unwrap();
             bot.send_message(message.chat.id, reply)
                 .reply_to_message_id(message.id)
diff --git a/src/search/mod.rs b/src/search/mod.rs
index 09beaf1..6579582 100644
--- a/src/search/mod.rs
+++ b/src/search/mod.rs
@@ -1,23 +1,94 @@
-use crate::spotify::{get_entry_kind, AlbumInfo};
+use crate::spotify::{get_entry_kind, AlbumInfo, PlaylistInfo};
 use crate::TrackInfo;
 use log::info;
 use spotify::ContentKind;
+use std::collections::HashSet;
 use youtube::Video;
 
 pub mod spotify;
 mod youtube;
 
+pub(crate) trait ArtistComposed {
+    fn get_artists_name(&self) -> HashSet<String>;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct TrackItem {
     pub(crate) spotify_track: Option<TrackInfo>,
     pub(crate) youtube_track: Option<Vec<Video>>,
 }
 
+impl ArtistComposed for TrackItem {
+    fn get_artists_name(&self) -> HashSet<String> {
+        if self.spotify_track.is_some() {
+            return self
+                .spotify_track
+                .clone()
+                .unwrap()
+                .artists
+                .into_iter()
+                .collect();
+        } else {
+            self.youtube_track
+                .clone()
+                .and_then(|youtube_tracks| {
+                    youtube_tracks.get(0).map(|t| {
+                        let mut hash = HashSet::new();
+                        hash.insert(t.author.clone());
+                        return hash;
+                    })
+                })
+                .unwrap_or_else(|| {
+                    let mut hash = HashSet::new();
+                    hash.insert("Unknown artist".to_string());
+                    return hash;
+                })
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct AlbumItem {
     pub(crate) spotify_track: Option<AlbumInfo>,
 }
 
+impl ArtistComposed for AlbumItem {
+    fn get_artists_name(&self) -> HashSet<String> {
+        if self.spotify_track.is_some() {
+            return self
+                .spotify_track
+                .clone()
+                .unwrap()
+                .artists
+                .into_iter()
+                .collect();
+        }
+
+        return HashSet::new();
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct PlaylistItem {
+    pub(crate) spotify_playlist: Option<PlaylistInfo>,
+}
+
+impl ArtistComposed for PlaylistItem {
+    fn get_artists_name(&self) -> HashSet<String> {
+        if self.spotify_playlist.is_some() {
+            return self
+                .spotify_playlist
+                .clone()
+                .unwrap()
+                .artists
+                .into_iter()
+                .collect();
+        }
+
+        return HashSet::new();
+    }
+}
+
 // The enum holds all the currently supported type of Id which the engine can search for
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum ServiceIdKind {
@@ -99,7 +170,7 @@ impl Engine {
         };
     }
 
-    pub(crate) async fn get_album_by_spotify_id(&self, message: &str) -> AlbumItem {
+    pub(crate) async fn get_album_from_spotify_id(&self, message: &str) -> AlbumItem {
         let entry_kind = spotify::get_entry_kind(message);
 
         let album_info = match entry_kind {
@@ -114,6 +185,22 @@ impl Engine {
             spotify_track: album_info,
         }
     }
+
+    pub(crate) async fn get_playlist_from_spotify_id(&self, message: &str) -> PlaylistItem {
+        let entry_kind = spotify::get_entry_kind(message);
+
+        let playlist_info = match entry_kind {
+            Some(entry) => match entry {
+                ContentKind::Playlist(id) => self.spotify.get_playlist(id.as_str()).await,
+                _ => None,
+            },
+            None => None,
+        };
+
+        PlaylistItem {
+            spotify_playlist: playlist_info,
+        }
+    }
 }
 
 pub(crate) fn get_spotify_kind(spotify_id: &str) -> Option<ContentKind> {
@@ -128,4 +215,14 @@ mod tests {
     fn should_search_track_by_spotify_id() {
         todo!("Implement me!")
     }
+
+    #[test]
+    fn should_search_album_by_spotify_id() {
+        todo!("Implement me!")
+    }
+
+    #[test]
+    fn should_search_playlist_by_spotify_id() {
+        todo!("Implement me!")
+    }
 }
diff --git a/src/search/spotify/mod.rs b/src/search/spotify/mod.rs
index e54436c..7485b44 100644
--- a/src/search/spotify/mod.rs
+++ b/src/search/spotify/mod.rs
@@ -51,6 +51,7 @@ pub struct PlaylistInfo {
     pub(crate) name: String,
     pub(crate) artists: Vec<String>,
     pub(crate) tracks: Vec<PlayableKind>,
+    pub(crate) owner: Option<String>,
 }
 
 #[derive(Clone, Debug)]
@@ -118,8 +119,8 @@ impl Client {
         }
     }
 
-    pub async fn get_playlist(&self, id: &String) -> Option<PlaylistInfo> {
-        let playlist_id = match PlaylistId::from_id(id.as_str()) {
+    pub async fn get_playlist(&self, id: &str) -> Option<PlaylistInfo> {
+        let playlist_id = match PlaylistId::from_id(id) {
             Ok(playlist) => playlist,
             Err(_e) => return None,
         };
@@ -167,6 +168,7 @@ impl Client {
                     .filter(|i| i.is_some())
                     .map(|i| i.unwrap())
                     .collect(),
+                owner: playlist.owner.display_name,
             }),
             Err(_e) => None,
         }
diff --git a/src/search/youtube/mod.rs b/src/search/youtube/mod.rs
index 2e9ad68..da645dc 100644
--- a/src/search/youtube/mod.rs
+++ b/src/search/youtube/mod.rs
@@ -39,7 +39,8 @@ pub(crate) struct Client {
 impl Client {
     pub(crate) async fn new() -> Self {
         // TODO check for a stable instance
-        let client = invidious::asynchronous::Client::new(String::from("https://vid.puffyan.us"));
+        let client =
+            invidious::asynchronous::Client::new(String::from("https://inv.bp.projectsegfau.lt"));
 
         Client {
             client: Arc::new(client),
diff --git a/src/tgformatter/mod.rs b/src/tgformatter/mod.rs
index 930ecaa..1e7b11b 100644
--- a/src/tgformatter/mod.rs
+++ b/src/tgformatter/mod.rs
@@ -1,4 +1,6 @@
-use crate::search::{AlbumItem, TrackItem};
+mod utils;
+
+use crate::search::{AlbumItem, ArtistComposed, PlaylistItem, TrackItem};
 use crate::TrackInfo;
 use log::{info, log};
 use std::borrow::Borrow;
@@ -7,9 +9,7 @@ use std::fmt::format;
 use std::time::Duration;
 use teloxide::repl;
 
-pub mod utils;
-
-static MAX_ARTISTS_CHARS: usize = 140;
+static MAX_ARTISTS_CHARS: usize = 200;
 
 pub(crate) fn format_track_message(track_info: TrackItem) -> Option<String> {
     // Let's avoid copying all the structure...we place it in the heap and pass the pointer to all the other functions
@@ -24,7 +24,7 @@ pub(crate) fn format_track_message(track_info: TrackItem) -> Option<String> {
                                 🧑‍🎤 Artist(s): {}\n\
                                 ⏳ Duration: {}",
         get_track_name(boxed_info.clone()),
-        get_track_artists(boxed_info.clone()),
+        get_artists(boxed_info.clone()),
         get_track_duration(boxed_info.clone())
     );
 
@@ -47,30 +47,52 @@ pub(crate) fn format_album_message(album_info: AlbumItem) -> Option<String> {
         return None;
     }
 
-    let mut artists = get_album_artists(boxed_info.clone());
-    let mut artists_names = "Unknown artist list".to_string();
-
-    if artists.len() > 0 {
-        artists_names = itertools::join(&artists, ", ");
-    }
+    let artists = boxed_info.get_artists_name().len();
 
     let mut reply = format!(
         "Album information:\n\
                                     🎵 Album name: {}\n\
                                     🧑‍🎤 {} artist(s): {}",
         get_album_name(boxed_info.clone()),
-        artists.len(),
-        artists_names
+        artists,
+        get_artists(boxed_info.clone())
     );
 
     let mut album_genres = get_album_genres(boxed_info.clone());
     if album_genres.len() > 0 {
-        reply.push_str(format!("\n💿 Genre(s): {}", itertools::join(&artists, ", ")).as_str());
+        reply.push_str(format!("\n💿 Genre(s): {}", itertools::join(&album_genres, ", ")).as_str());
     }
 
     return Some(reply);
 }
 
+pub(crate) fn format_playlist_message(playlist_info: PlaylistItem) -> Option<String> {
+    let boxed_info = Box::new(playlist_info);
+    if boxed_info.spotify_playlist.is_none() {
+        return None;
+    }
+
+    let artists = boxed_info.clone().get_artists_name().len();
+
+    let mut reply = format!(
+        "Playlist information:\n\
+✒️ Playlist name: {}\n\
+🧞 Made by: {}\n\
+🧑‍🎤 {} artist(s): {}",
+        boxed_info.clone().spotify_playlist.unwrap().name,
+        boxed_info
+            .clone()
+            .spotify_playlist
+            .unwrap()
+            .owner
+            .unwrap_or("Unknown 🤷".to_string()),
+        artists,
+        get_artists(boxed_info)
+    );
+
+    return Some(reply);
+}
+
 fn get_album_name(ai: Box<AlbumItem>) -> String {
     ai.spotify_track
         .map(|s| s.name)
@@ -85,14 +107,6 @@ fn get_album_genres(ai: Box<AlbumItem>) -> HashSet<String> {
     return HashSet::new();
 }
 
-fn get_album_artists(ai: Box<AlbumItem>) -> HashSet<String> {
-    if ai.spotify_track.is_some() {
-        return ai.spotify_track.unwrap().artists.into_iter().collect();
-    }
-
-    return HashSet::new();
-}
-
 fn get_track_name(ti: Box<TrackItem>) -> String {
     if ti.spotify_track.is_some() {
         ti.spotify_track.unwrap().name
@@ -103,17 +117,15 @@ fn get_track_name(ti: Box<TrackItem>) -> String {
     }
 }
 
-fn get_track_artists(ti: Box<TrackItem>) -> String {
-    if ti.spotify_track.is_some() {
-        utils::truncate_with_dots(
-            ti.spotify_track.unwrap().artists.join(", "),
-            MAX_ARTISTS_CHARS,
-        )
-    } else {
-        ti.youtube_track
-            .and_then(|youtube_tracks| youtube_tracks.get(0).map(|t| t.author.clone()))
-            .unwrap_or("Unknown artist".to_string())
+fn get_artists(ti: Box<dyn ArtistComposed>) -> String {
+    let artists = ti.get_artists_name();
+    let mut artists_names = "Unknown artist list".to_string();
+
+    if artists.len() > 0 {
+        artists_names = itertools::join(&artists, ", ");
     }
+
+    utils::truncate_with_dots(artists_names, MAX_ARTISTS_CHARS)
 }
 
 fn get_track_duration(ti: Box<TrackItem>) -> String {
-- 
2.40.1


From a1efd07c2e5acad2724ae7897e2c87d05ad1fb9a Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Fri, 15 Jul 2022 17:54:07 +0200
Subject: [PATCH 7/9] chore: set beta version, update deps

---
 Cargo.toml                | 8 ++++----
 src/main.rs               | 9 +++------
 src/search/mod.rs         | 9 ---------
 src/search/spotify/mod.rs | 3 +--
 src/tgformatter/mod.rs    | 9 ++-------
 5 files changed, 10 insertions(+), 28 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index a6a988c..b5546c6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,17 +1,17 @@
 [package]
 name = "songlify"
-version = "0.3.3"
+version = "0.3.3-beta"
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-teloxide = { version = "0.9.1", features = ["auto-send", "macros"] }
+teloxide = { version = "0.9.2", features = ["auto-send", "macros"] }
 log = "0.4.17"
 pretty_env_logger = "0.4.0"
-tokio = { version =  "1.18.2", features = ["rt-multi-thread", "macros"] }
+tokio = { version =  "1.20.0", features = ["rt-multi-thread", "macros"] }
 rspotify = { version = "0.11.5", features = ["default"]}
-sentry = "0.26.0"
+sentry = "0.27.0"
 invidious = "0.2.1"
 chrono = "0.4.19"
 itertools = "0.10.3"
diff --git a/src/main.rs b/src/main.rs
index e463ee1..7505725 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,14 @@
-use log::{debug, info, log, LevelFilter};
+use log::{debug, info, LevelFilter};
 use search::spotify;
 use sentry::ClientInitGuard;
 use std::env;
-use std::process::id;
-use std::sync::Arc;
 use teloxide::prelude::*;
 
 use search::spotify::ContentKind::Track;
-use search::spotify::{PlayableKind, TrackInfo};
+use search::spotify::TrackInfo;
 
 use crate::search::get_spotify_kind;
-use crate::spotify::ContentKind;
-use search::spotify::ContentKind::{Album, Episode, Playlist, Podcast};
+use search::spotify::ContentKind::{Album, Playlist};
 
 mod search;
 mod tgformatter;
diff --git a/src/search/mod.rs b/src/search/mod.rs
index 6579582..1d85b71 100644
--- a/src/search/mod.rs
+++ b/src/search/mod.rs
@@ -1,6 +1,5 @@
 use crate::spotify::{get_entry_kind, AlbumInfo, PlaylistInfo};
 use crate::TrackInfo;
-use log::info;
 use spotify::ContentKind;
 use std::collections::HashSet;
 use youtube::Video;
@@ -89,14 +88,6 @@ impl ArtistComposed for PlaylistItem {
     }
 }
 
-// The enum holds all the currently supported type of Id which the engine can search for
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) enum ServiceIdKind {
-    Spotify(String),
-    Youtube(String),
-    Automatic(String),
-}
-
 // This struct will allow us in the future to search, cache and store data and metadata regarding
 // tracks, albums and playlists
 #[derive(Debug, Clone)]
diff --git a/src/search/spotify/mod.rs b/src/search/spotify/mod.rs
index 7485b44..5b6e3ca 100644
--- a/src/search/spotify/mod.rs
+++ b/src/search/spotify/mod.rs
@@ -1,8 +1,7 @@
 use rspotify::model::PlayableItem::{Episode, Track};
-use rspotify::model::{AlbumId, FullTrack, PlaylistId, TrackId};
+use rspotify::model::{AlbumId, PlaylistId, TrackId};
 use rspotify::prelude::*;
 use rspotify::{ClientCredsSpotify, Credentials};
-use std::any::Any;
 use std::sync::Arc;
 use std::time::Duration;
 
diff --git a/src/tgformatter/mod.rs b/src/tgformatter/mod.rs
index 1e7b11b..a4da140 100644
--- a/src/tgformatter/mod.rs
+++ b/src/tgformatter/mod.rs
@@ -1,13 +1,8 @@
 mod utils;
 
 use crate::search::{AlbumItem, ArtistComposed, PlaylistItem, TrackItem};
-use crate::TrackInfo;
-use log::{info, log};
-use std::borrow::Borrow;
 use std::collections::HashSet;
-use std::fmt::format;
 use std::time::Duration;
-use teloxide::repl;
 
 static MAX_ARTISTS_CHARS: usize = 200;
 
@@ -58,7 +53,7 @@ pub(crate) fn format_album_message(album_info: AlbumItem) -> Option<String> {
         get_artists(boxed_info.clone())
     );
 
-    let mut album_genres = get_album_genres(boxed_info.clone());
+    let album_genres = get_album_genres(boxed_info.clone());
     if album_genres.len() > 0 {
         reply.push_str(format!("\n💿 Genre(s): {}", itertools::join(&album_genres, ", ")).as_str());
     }
@@ -74,7 +69,7 @@ pub(crate) fn format_playlist_message(playlist_info: PlaylistItem) -> Option<Str
 
     let artists = boxed_info.clone().get_artists_name().len();
 
-    let mut reply = format!(
+    let reply = format!(
         "Playlist information:\n\
 ✒️ Playlist name: {}\n\
 🧞 Made by: {}\n\
-- 
2.40.1


From c94e00231179d29cd11a1d78070c6e71a4ef9af4 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Fri, 15 Jul 2022 17:57:19 +0200
Subject: [PATCH 8/9] chore: bump Dockerfile deps

---
 Dockerfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Dockerfile b/Dockerfile
index b372676..01a5337 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -3,7 +3,7 @@ FROM rust:1.59.0-slim-bullseye as builder
 WORKDIR /build
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    libssl-dev=1.1.1k-1+deb11u2 \
+    libssl-dev=1.1.1n-0+deb11u3 \
     pkg-config=0.29.2-1
 
 COPY ./ /build
-- 
2.40.1


From c7427d1b6cfd39f0427529f2d40db1df9610e619 Mon Sep 17 00:00:00 2001
From: Davide Polonio <poloniodavide@gmail.com>
Date: Sun, 17 Jul 2022 17:07:59 +0200
Subject: [PATCH 9/9] feat: add tests, start using traits

* Fix ContentKind bug
---
 Cargo.toml                |   4 +-
 Dockerfile                |   2 +-
 src/search/mod.rs         |  47 +++++-------
 src/search/spotify/mod.rs |  26 +++++--
 src/search/tests.rs       | 147 ++++++++++++++++++++++++++++++++++++++
 src/search/youtube/mod.rs |  31 +++++++-
 src/tgformatter/mod.rs    |   8 +--
 7 files changed, 222 insertions(+), 43 deletions(-)
 create mode 100644 src/search/tests.rs

diff --git a/Cargo.toml b/Cargo.toml
index b5546c6..20c965f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "songlify"
-version = "0.3.3-beta"
+version = "0.3.4"
 edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -15,6 +15,8 @@ sentry = "0.27.0"
 invidious = "0.2.1"
 chrono = "0.4.19"
 itertools = "0.10.3"
+async-trait = "0.1.56"
 
 [dev-dependencies]
 tokio-test = "0.4.2"
+mockall = "0.11.1"
diff --git a/Dockerfile b/Dockerfile
index 01a5337..aa4c59a 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,4 +1,4 @@
-FROM rust:1.59.0-slim-bullseye as builder
+FROM rust:1.62.0-slim-bullseye as builder
 
 WORKDIR /build
 
diff --git a/src/search/mod.rs b/src/search/mod.rs
index 1d85b71..a631ab9 100644
--- a/src/search/mod.rs
+++ b/src/search/mod.rs
@@ -7,6 +7,9 @@ use youtube::Video;
 pub mod spotify;
 mod youtube;
 
+#[cfg(test)]
+mod tests;
+
 pub(crate) trait ArtistComposed {
     fn get_artists_name(&self) -> HashSet<String>;
 }
@@ -48,14 +51,14 @@ impl ArtistComposed for TrackItem {
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct AlbumItem {
-    pub(crate) spotify_track: Option<AlbumInfo>,
+    pub(crate) spotify_album: Option<AlbumInfo>,
 }
 
 impl ArtistComposed for AlbumItem {
     fn get_artists_name(&self) -> HashSet<String> {
-        if self.spotify_track.is_some() {
+        if self.spotify_album.is_some() {
             return self
-                .spotify_track
+                .spotify_album
                 .clone()
                 .unwrap()
                 .artists
@@ -90,23 +93,25 @@ impl ArtistComposed for PlaylistItem {
 
 // This struct will allow us in the future to search, cache and store data and metadata regarding
 // tracks, albums and playlists
-#[derive(Debug, Clone)]
 pub(crate) struct Engine {
-    spotify: spotify::Client,
-    youtube: youtube::Client,
+    spotify: Box<dyn spotify::SearchableClient + Send + Sync>,
+    youtube: Box<dyn youtube::SearchableClient + Send + Sync>,
 }
 
 impl Engine {
     pub(crate) async fn new() -> Self {
         Engine {
-            spotify: spotify::Client::new().await,
-            youtube: youtube::Client::new().await,
+            spotify: Box::new(spotify::Client::new().await),
+            youtube: Box::new(youtube::Client::new().await),
         }
     }
 
+    #[allow(dead_code)]
+    #[allow(unused_variables)]
+    #[cfg(test)]
     pub(crate) fn new_with_dependencies(
-        spotify_client: spotify::Client,
-        youtube_client: youtube::Client,
+        spotify_client: Box<dyn spotify::SearchableClient + Send + Sync>,
+        youtube_client: Box<dyn youtube::SearchableClient + Send + Sync>,
     ) -> Self {
         Engine {
             spotify: spotify_client,
@@ -173,7 +178,7 @@ impl Engine {
         };
 
         AlbumItem {
-            spotify_track: album_info,
+            spotify_album: album_info,
         }
     }
 
@@ -197,23 +202,3 @@ impl Engine {
 pub(crate) fn get_spotify_kind(spotify_id: &str) -> Option<ContentKind> {
     get_entry_kind(spotify_id)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn should_search_track_by_spotify_id() {
-        todo!("Implement me!")
-    }
-
-    #[test]
-    fn should_search_album_by_spotify_id() {
-        todo!("Implement me!")
-    }
-
-    #[test]
-    fn should_search_playlist_by_spotify_id() {
-        todo!("Implement me!")
-    }
-}
diff --git a/src/search/spotify/mod.rs b/src/search/spotify/mod.rs
index 5b6e3ca..36e86a3 100644
--- a/src/search/spotify/mod.rs
+++ b/src/search/spotify/mod.rs
@@ -1,3 +1,6 @@
+use async_trait::async_trait;
+#[cfg(test)]
+use mockall::{automock, mock, predicate::*};
 use rspotify::model::PlayableItem::{Episode, Track};
 use rspotify::model::{AlbumId, PlaylistId, TrackId};
 use rspotify::prelude::*;
@@ -5,6 +8,14 @@ use rspotify::{ClientCredsSpotify, Credentials};
 use std::sync::Arc;
 use std::time::Duration;
 
+#[cfg_attr(test, automock)]
+#[async_trait]
+pub(crate) trait SearchableClient {
+    async fn get_track(&self, id: &str) -> Option<TrackInfo>;
+    async fn get_album(&self, id: &str) -> Option<AlbumInfo>;
+    async fn get_playlist(&self, id: &str) -> Option<PlaylistInfo>;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum ContentKind {
     Track(String),
@@ -69,13 +80,19 @@ impl Client {
         }
     }
 
+    #[allow(dead_code)]
+    #[allow(unused_variables)]
+    #[cfg(test)]
     pub(crate) fn new_with_dependencies(client: ClientCredsSpotify) -> Self {
         Client {
             client: Arc::new(client),
         }
     }
+}
 
-    pub async fn get_track(&self, id: &str) -> Option<TrackInfo> {
+#[async_trait]
+impl SearchableClient for Client {
+    async fn get_track(&self, id: &str) -> Option<TrackInfo> {
         // FIXME should we really return Option here? We're hiding a possible error or a entry not found
         let track_id = match TrackId::from_id(id) {
             Ok(track) => track,
@@ -92,7 +109,7 @@ impl Client {
         }
     }
 
-    pub async fn get_album(&self, id: &str) -> Option<AlbumInfo> {
+    async fn get_album(&self, id: &str) -> Option<AlbumInfo> {
         let album_id = match AlbumId::from_id(id) {
             Ok(album) => album,
             Err(_e) => return None,
@@ -118,7 +135,7 @@ impl Client {
         }
     }
 
-    pub async fn get_playlist(&self, id: &str) -> Option<PlaylistInfo> {
+    async fn get_playlist(&self, id: &str) -> Option<PlaylistInfo> {
         let playlist_id = match PlaylistId::from_id(id) {
             Ok(playlist) => playlist,
             Err(_e) => return None,
@@ -186,6 +203,7 @@ fn get_id_in_uri(uri: &str) -> Option<&str> {
 }
 
 pub fn get_entry_kind(uri: &str) -> Option<ContentKind> {
+    // TODO WE SHOULD PROPERLY TEST THIS FUNCTION
     if uri.contains("spotify:track:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
@@ -217,7 +235,7 @@ pub fn get_entry_kind(uri: &str) -> Option<ContentKind> {
     if uri.contains("spotify:playlist:") {
         let track_id = get_id_in_uri(uri);
         return match track_id {
-            Some(id) => Some(ContentKind::Album(id.to_string())),
+            Some(id) => Some(ContentKind::Playlist(id.to_string())),
             None => None,
         };
     }
diff --git a/src/search/tests.rs b/src/search/tests.rs
new file mode 100644
index 0000000..cc5c9fb
--- /dev/null
+++ b/src/search/tests.rs
@@ -0,0 +1,147 @@
+use super::*;
+use crate::search::youtube::VideoSearch;
+use crate::spotify::PlayableKind;
+use mockall::predicate;
+
+#[tokio::test]
+async fn should_search_track_by_spotify_id() {
+    let spotify_id = "spotify:track:no-value-kek";
+    let mut spotify_mock = spotify::MockSearchableClient::new();
+    spotify_mock
+        .expect_get_track()
+        .with(predicate::eq("no-value-kek"))
+        .returning(|_id| {
+            Some(TrackInfo {
+                name: "A name".to_string(),
+                artists: vec!["Art1".to_string()],
+                duration: Default::default(),
+            })
+        });
+    let mut youtube_mock = youtube::MockSearchableClient::new();
+    youtube_mock
+        .expect_search_video()
+        .returning(|_id, _sort_by| {
+            Ok(VideoSearch {
+                items: vec![Video {
+                    title: "An example".to_string(),
+                    video_id: "id123".to_string(),
+                    author: "An Art".to_string(),
+                    author_id: "artId123".to_string(),
+                    author_url: "https://example.com".to_string(),
+                    length_seconds: 42,
+                    description: "A song".to_string(),
+                    description_html: "A song 2".to_string(),
+                    view_count: 0,
+                    published: 0,
+                    published_text: "".to_string(),
+                    live_now: false,
+                    paid: false,
+                    premium: false,
+                }],
+            })
+        });
+
+    let engine = Engine::new_with_dependencies(Box::new(spotify_mock), Box::new(youtube_mock));
+    let got = engine.get_song_from_spotify_id(spotify_id).await;
+
+    assert_eq!(true, got.spotify_track.is_some());
+    let boxed_st = Box::new(got.spotify_track.unwrap());
+    assert_eq!(1, boxed_st.artists.len());
+    assert_eq!("Art1".to_string(), boxed_st.artists.get(0).unwrap().clone());
+    assert_eq!("A name".to_string(), boxed_st.name);
+
+    assert_eq!(true, got.youtube_track.is_some());
+    let boxed_yt = Box::new(got.youtube_track.unwrap());
+    assert_eq!(1, boxed_yt.len());
+    let got_video = boxed_yt.get(0).unwrap();
+    assert_eq!("An example".to_string(), got_video.title);
+}
+
+#[tokio::test]
+async fn should_search_album_by_spotify_id() {
+    let spotify_id = "spotify:album:no-value-kek";
+    let mut spotify_mock = spotify::MockSearchableClient::new();
+    spotify_mock
+        .expect_get_album()
+        .with(predicate::eq("no-value-kek"))
+        .returning(|_id| {
+            Some(AlbumInfo {
+                name: "An album".to_string(),
+                artists: vec!["Art1".to_string(), "Art2".to_string()],
+                genres: vec!["Rock".to_string(), "Hip-hop".to_string()],
+                tracks: vec![TrackInfo {
+                    name: "Track info 1".to_string(),
+                    artists: vec!["Art1".to_string()],
+                    duration: Default::default(),
+                }],
+            })
+        });
+    let youtube_mock = youtube::MockSearchableClient::new();
+
+    let engine = Engine::new_with_dependencies(Box::new(spotify_mock), Box::new(youtube_mock));
+    let got = engine.get_album_from_spotify_id(spotify_id).await;
+
+    assert_eq!(true, got.spotify_album.is_some());
+    let boxed_st = Box::new(got.spotify_album.unwrap());
+    assert_eq!(2, boxed_st.artists.len());
+    assert_eq!("Art1".to_string(), boxed_st.artists.get(0).unwrap().clone());
+    assert_eq!("Art2".to_string(), boxed_st.artists.get(1).unwrap().clone());
+    assert_eq!("An album".to_string(), boxed_st.name);
+    assert_eq!(2, boxed_st.genres.len());
+    assert_eq!("Rock".to_string(), boxed_st.genres.get(0).unwrap().clone());
+    assert_eq!(
+        "Hip-hop".to_string(),
+        boxed_st.genres.get(1).unwrap().clone()
+    );
+    assert_eq!(1, boxed_st.tracks.len());
+    assert_eq!(
+        TrackInfo {
+            name: "Track info 1".to_string(),
+            artists: vec!["Art1".to_string()],
+            duration: Default::default(),
+        },
+        boxed_st.tracks.get(0).unwrap().clone()
+    );
+}
+
+#[tokio::test]
+async fn should_search_playlist_by_spotify_id() {
+    let spotify_id = "spotify:playlist:no-value-kek";
+    let mut spotify_mock = spotify::MockSearchableClient::new();
+    spotify_mock
+        .expect_get_playlist()
+        .with(predicate::eq("no-value-kek"))
+        .returning(|_id| {
+            Some(PlaylistInfo {
+                name: "A playlist".to_string(),
+                artists: vec!["Art1".to_string(), "Art2".to_string()],
+                tracks: vec![PlayableKind::Track(TrackInfo {
+                    name: "A track".to_string(),
+                    artists: vec!["Art1".to_string()],
+                    duration: Default::default(),
+                })],
+                owner: Some("Frodo".to_string()),
+            })
+        });
+    let youtube_mock = youtube::MockSearchableClient::new();
+
+    let engine = Engine::new_with_dependencies(Box::new(spotify_mock), Box::new(youtube_mock));
+    let got = engine.get_playlist_from_spotify_id(spotify_id).await;
+
+    assert_eq!(true, got.spotify_playlist.is_some());
+    let boxed_st = Box::new(got.spotify_playlist.unwrap());
+    assert_eq!(2, boxed_st.artists.len());
+    assert_eq!("Art1".to_string(), boxed_st.artists.get(0).unwrap().clone());
+    assert_eq!("Art2".to_string(), boxed_st.artists.get(1).unwrap().clone());
+    assert_eq!("A playlist".to_string(), boxed_st.name);
+    assert_eq!(1, boxed_st.tracks.len());
+    assert_eq!(
+        PlayableKind::Track(TrackInfo {
+            name: "A track".to_string(),
+            artists: vec!["Art1".to_string()],
+            duration: Default::default(),
+        }),
+        boxed_st.tracks.get(0).unwrap().clone()
+    );
+    assert_eq!(Some("Frodo".to_string()), boxed_st.owner);
+}
diff --git a/src/search/youtube/mod.rs b/src/search/youtube/mod.rs
index da645dc..e52bc35 100644
--- a/src/search/youtube/mod.rs
+++ b/src/search/youtube/mod.rs
@@ -1,6 +1,19 @@
+use async_trait::async_trait;
+#[cfg(test)]
+use mockall::{automock, mock, predicate::*};
 use std::error::Error;
 use std::sync::Arc;
 
+#[cfg_attr(test, automock)]
+#[async_trait]
+pub(crate) trait SearchableClient {
+    async fn search_video<'a>(
+        &self,
+        id: &str,
+        sort_by: Option<&'a SearchSortBy>,
+    ) -> Result<VideoSearch, Box<dyn Error>>;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct VideoSearch {
     pub(crate) items: Vec<Video>,
@@ -26,9 +39,17 @@ pub(crate) struct Video {
 
 type SearchSortBy = str;
 
+#[allow(dead_code)]
+#[allow(unused_variables)]
 const BY_RELEVANCE: &SearchSortBy = "relevance";
+#[allow(dead_code)]
+#[allow(unused_variables)]
 const BY_RATING: &SearchSortBy = "rating";
+#[allow(dead_code)]
+#[allow(unused_variables)]
 const BY_UPLOAD_DATE: &SearchSortBy = "upload_date";
+#[allow(dead_code)]
+#[allow(unused_variables)]
 const BY_VIEW_COUNT: &SearchSortBy = "view_count";
 
 #[derive(Debug, Clone)]
@@ -47,16 +68,22 @@ impl Client {
         }
     }
 
+    #[allow(dead_code)]
+    #[allow(unused_variables)]
+    #[cfg(test)]
     pub(crate) fn new_with_dependencies(client: invidious::asynchronous::Client) -> Self {
         Client {
             client: Arc::new(client),
         }
     }
+}
 
-    pub async fn search_video(
+#[async_trait]
+impl SearchableClient for Client {
+    async fn search_video<'a>(
         &self,
         keyword: &str,
-        sort_by: Option<&SearchSortBy>,
+        sort_by: Option<&'a SearchSortBy>,
     ) -> Result<VideoSearch, Box<dyn Error>> {
         let mut query = Vec::<String>::new();
         query.push(format!("{}={}", "q", keyword));
diff --git a/src/tgformatter/mod.rs b/src/tgformatter/mod.rs
index a4da140..3c07d1a 100644
--- a/src/tgformatter/mod.rs
+++ b/src/tgformatter/mod.rs
@@ -38,7 +38,7 @@ pub(crate) fn format_track_message(track_info: TrackItem) -> Option<String> {
 
 pub(crate) fn format_album_message(album_info: AlbumItem) -> Option<String> {
     let boxed_info = Box::new(album_info);
-    if boxed_info.spotify_track.is_none() {
+    if boxed_info.spotify_album.is_none() {
         return None;
     }
 
@@ -89,14 +89,14 @@ pub(crate) fn format_playlist_message(playlist_info: PlaylistItem) -> Option<Str
 }
 
 fn get_album_name(ai: Box<AlbumItem>) -> String {
-    ai.spotify_track
+    ai.spotify_album
         .map(|s| s.name)
         .unwrap_or("Unknown album name".to_string())
 }
 
 fn get_album_genres(ai: Box<AlbumItem>) -> HashSet<String> {
-    if ai.spotify_track.is_some() {
-        return ai.spotify_track.unwrap().genres.into_iter().collect();
+    if ai.spotify_album.is_some() {
+        return ai.spotify_album.unwrap().genres.into_iter().collect();
     }
 
     return HashSet::new();
-- 
2.40.1