Version 1.0.1

Author: mcamara

Diff for: Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "youtube_search"
-version = "1.0.0"
+version = "1.0.1"
 edition = "2021"
 authors = ["Marc Cámara"]
 description = "A crate to navigate the YouTube API"
@@ -17,9 +17,6 @@ categories = [
     "api", 'youtube'
 ]
 
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 anyhow = "1.0.44"
 async-trait = "0.1.72"

Diff for: README.md

@@ -21,7 +21,7 @@ This Rust library provides an asynchronous interface for interacting with YouTub
 Add the following line to your `Cargo.toml` file under the `[dependencies]` section:
 
 ```toml
-youtube_search = "1.0.0"
+youtube_search = "1.0.1"
 ```
 
 ## Usage
@@ -37,7 +37,7 @@ use youtube_search::{
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let channel = find_youtube_channel("ChannelName").await?;
-    println!("Channel ID: {}", channel.channel_id);
+    println!("Channel Title: {}", channel.title);
 
     let videos = find_latest_videos(&channel, 5).await?;
     println!("Latest videos: {:?}", videos);

Diff for: src/lib.rs

@@ -11,10 +11,10 @@ use youtube::{
     video::{Video, VideoError},
 };
 
-/// Find a youtube channel by name
-pub async fn find_youtube_channel(name: &str) -> Result<Channel, ChannelError> {
+/// Find a youtube channel by handle: https://www.youtube.com/user/@{handle}
+pub async fn find_youtube_channel(handle: &str) -> Result<Channel, ChannelError> {
     let client = Arc::new(HttpClient::new());
-    Channel::initialize(name.to_string(), client.clone()).await
+    Channel::initialize(handle.to_string(), client.clone()).await
 }
 
 /// Find latest videos from a channel, will return an error if the channel has no videos

Diff for: src/test_utils.rs

@@ -30,7 +30,7 @@ impl HttpClientTrait for MockHttpClient {
         let mut server = mockito::Server::new();
 
         let mut responses = self.responses.lock().await;
-        let response = responses.pop().unwrap_or_else(|| "".to_string());
+        let response = responses.pop().unwrap_or_default();
 
         let _mock = server
             .mock("GET", "/")

Diff for: src/youtube/channel.rs

@@ -11,7 +11,8 @@ use super::video::Video;
 // A youtube channel with some useful data
 #[derive(Debug)]
 pub struct Channel {
-    pub name: String,
+    pub handle: String,
+    pub title: String,
     pub channel_id: String,
 }
 
@@ -23,22 +24,27 @@ pub struct ChannelError {
 }
 
 impl Channel {
-    fn new(name: String, channel_id: String) -> Self {
-        Self { name, channel_id }
+    fn new(handle: String, title: String, channel_id: String) -> Self {
+        Self {
+            handle,
+            title,
+            channel_id,
+        }
     }
 
     pub async fn initialize<T: HttpClientTrait>(
-        name: String,
+        handle: String,
         client: Arc<T>,
     ) -> Result<Self, ChannelError> {
-        let channel_id = retrieve_channel_id(&name, &client)
-            .await
-            .map_err(|e| ChannelError {
-                source: Some(e.into()),
-                msg: "Failed to get channel id".to_owned(),
-            })?;
+        let (channel_id, title) =
+            retrieve_channel_id(&handle, &client)
+                .await
+                .map_err(|e| ChannelError {
+                    source: Some(e.into()),
+                    msg: "Failed to get channel id".to_owned(),
+                })?;
 
-        Ok(Self::new(name, channel_id))
+        Ok(Self::new(handle, title, channel_id))
     }
 
     async fn get_main_playlist_id<T: HttpClientTrait>(
@@ -78,19 +84,33 @@ mod tests {
     #[tokio::test]
     async fn channel_initialization_succeeds_with_valid_id() {
         let client = create_client_with_responses(vec![
-            r#"{"items": [
-            {
-                "id": "id_channel1"
-            }
-        ]}"#,
+            r#"{
+                "items": [
+                    {
+                        "snippet": {
+                            "channelId": "channel_id",
+                            "channelTitle": "Another title",
+                            "channelHandle": "@another_channel"
+                        }
+                    },
+                    {
+                        "snippet": {
+                            "channelId": "channel_id",
+                            "channelTitle": "Channel title",
+                            "channelHandle": "@channel1"
+                        }
+                    }
+                ]
+            }"#,
         ])
         .await;
         let channel = Channel::initialize("channel1".to_string(), client)
             .await
             .ok()
             .unwrap();
-        assert_eq!(channel.channel_id, "id_channel1");
-        assert_eq!(channel.name, "channel1");
+        assert_eq!(channel.channel_id, "channel_id");
+        assert_eq!(channel.title, "Channel title");
+        assert_eq!(channel.handle, "channel1");
     }
 
     #[tokio::test]
@@ -108,13 +128,19 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn channel_initialization_fails_with_null_id() {
+    async fn channel_initialization_fails_with_no_id() {
         let client = create_client_with_responses(vec![
-            r#"{"items": [
-            {
-                "id": null
-            }
-        ]}"#,
+            r#"{
+                "items": [
+                    {
+                        "snippet": {
+                            "channelId": "channel_id",
+                            "channelTitle": "Channel title",
+                            "channelHandle": "@no_match"
+                        }
+                    }
+                ]
+            }"#,
         ])
         .await;
         let channel = Channel::initialize("channel1".to_string(), client).await;
@@ -123,7 +149,11 @@ mod tests {
 
     #[tokio::test]
     async fn main_playlist_is_found_for_a_channel() {
-        let channel = Channel::new("channel1".to_string(), "id_channel1".to_string());
+        let channel = Channel::new(
+            "channel1".to_string(),
+            "title".to_string(),
+            "id_channel1".to_string(),
+        );
         let client = create_client_with_responses(vec![
             r#"{"items": [
             {
@@ -143,7 +173,11 @@ mod tests {
 
     #[tokio::test]
     async fn main_playlist_search_fails_if_channel_do_not_have_any_playlist() {
-        let channel = Channel::new("channel1".to_string(), "id_channel1".to_string());
+        let channel = Channel::new(
+            "channel1".to_string(),
+            "title".to_string(),
+            "id_channel1".to_string(),
+        );
         let client = create_client_with_responses(vec![
             r#"{"items": [
             {
@@ -163,7 +197,11 @@ mod tests {
 
     #[tokio::test]
     async fn videos_from_channel_are_returned() {
-        let channel = Channel::new("channel1".to_string(), "id_channel1".to_string());
+        let channel = Channel::new(
+            "channel1".to_string(),
+            "title".to_string(),
+            "id_channel1".to_string(),
+        );
         let playlist_response = r#"{"items": [
             {
                 "contentDetails": {
@@ -222,7 +260,11 @@ mod tests {
 
     #[tokio::test]
     async fn videos_from_channel_cannot_be_retrieved_when_response_is_empty() {
-        let channel = Channel::new("channel1".to_string(), "id_channel1".to_string());
+        let channel = Channel::new(
+            "channel1".to_string(),
+            "title".to_string(),
+            "id_channel1".to_string(),
+        );
         let playlist_response = r#"{"items": [
             {
                 "contentDetails": {

Diff for: src/youtube/requests/channel.rs

@@ -11,28 +11,54 @@ struct ChannelReturn {
 
 #[derive(Deserialize)]
 struct ChannelItemsReturn {
-    id: Option<String>,
+    snippet: ChannelSnippetReturn,
+}
+
+#[derive(Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ChannelSnippetReturn {
+    channel_id: String,
+    channel_title: String,
+    channel_handle: String,
 }
 
 pub async fn retrieve_channel_id<T: HttpClientTrait>(
-    name: &str,
+    handle: &str,
     client: &Arc<T>,
-) -> Result<String, RequestError> {
-    let url = Url::parse_with_params("https://yt.lemnoslife.com/channels", &[("cId", name)])
-        .map_err(|e| RequestError::Other(e.to_string()))?;
+) -> Result<(String, String), RequestError> {
+    let url = Url::parse_with_params(
+        "https://yt.lemnoslife.com/search",
+        &[
+            ("q", handle),
+            ("type", "channel"),
+            ("part", "snippet"),
+            ("maxResults", "10"),
+        ],
+    )
+    .map_err(|e| RequestError::Other(e.to_string()))?;
 
     let response = client.get(url.as_str()).await.map_err(RequestError::Http)?;
     let channel_data: ChannelReturn = process_response(response).await?;
 
-    let channel_id = channel_data
-        .items
-        .first()
-        .map(|item| item.id.clone())
-        .ok_or(RequestError::NotFound);
+    match find_channel_by_handle(&channel_data.items, handle) {
+        Ok(channel_snippet) => Ok((
+            channel_snippet.channel_id.clone(),
+            channel_snippet.channel_title.clone(),
+        )),
+        Err(e) => Err(e),
+    }
+}
 
-    match channel_id {
-        Ok(Some(channel_id)) => Ok(channel_id),
-        Ok(None) => Err(RequestError::NotFound),
-        Err(e) => Err(RequestError::ResponseNotParsed(e.into())),
+fn find_channel_by_handle(
+    channels: &[ChannelItemsReturn],
+    target_handle: &str,
+) -> Result<ChannelSnippetReturn, RequestError> {
+    let target_handle = format!("@{}", target_handle);
+    match channels
+        .iter()
+        .find(|&channel| channel.snippet.channel_handle == target_handle)
+    {
+        Some(channel) => Ok(channel.snippet.clone()),
+        None => Err(RequestError::NotFound),
     }
 }