refactor: change YTM search API

codegen/src/download_testfiles.rs

@@ -607,7 +607,11 @@ async fn music_search_tracks(testfiles: &Path) {
         }
 
         let rp = rp_testfile(&json_path);
-        rp.query().music_search_tracks(query, videos).await.unwrap();
+        if videos {
+            rp.query().music_search_videos(query).await.unwrap();
+        } else {
+            rp.query().music_search_tracks(query).await.unwrap();
+        }
     }
 }
 
@@ -649,7 +653,7 @@ async fn music_search_playlists(testfiles: &Path) {
 
         let rp = rp_testfile(&json_path);
         rp.query()
-            .music_search_playlists("pop", community)
+            .music_search_playlists_filter("pop", community)
             .await
             .unwrap();
     }
@@ -664,11 +668,7 @@ async fn music_search_cont(testfiles: &Path) {
     }
 
     let rp = RustyPipe::new();
-    let res = rp
+    let res = rp.query().music_search_tracks("black mamba").await.unwrap();
-        .query()
-        .music_search_tracks("black mamba", false)
-        .await
-        .unwrap();
 
     let rp = rp_testfile(&json_path);
     res.items.next(&rp.query()).await.unwrap().unwrap();

src/client/music_search.rs

@@ -34,8 +34,10 @@ enum Params {
     Albums,
     #[serde(rename = "EgWKAQIgAWoMEAMQBBAJEA4QChAF")]
     Artists,
+    #[serde(rename = "EgWKAQIoAWoMEAMQBBAJEA4QChAF")]
+    Playlists,
     #[serde(rename = "EgeKAQQoADgBagwQAxAEEAkQDhAKEAU%3D")]
-    FeaturedPlaylists,
+    YtmPlaylists,
     #[serde(rename = "EgeKAQQoAEABagwQAxAEEAkQDhAKEAU%3D")]
     CommunityPlaylists,
 }
@@ -62,16 +64,27 @@ impl RustyPipeQuery {
     pub async fn music_search_tracks(
         &self,
         query: &str,
-        videos: bool,
+    ) -> Result<MusicSearchFiltered<TrackItem>, Error> {
+        self._music_search_tracks(query, Params::Tracks).await
+    }
+
+    pub async fn music_search_videos(
+        &self,
+        query: &str,
+    ) -> Result<MusicSearchFiltered<TrackItem>, Error> {
+        self._music_search_tracks(query, Params::Videos).await
+    }
+
+    async fn _music_search_tracks(
+        &self,
+        query: &str,
+        params: Params,
     ) -> Result<MusicSearchFiltered<TrackItem>, Error> {
         let context = self.get_context(ClientType::DesktopMusic, true, None).await;
         let request_body = QSearch {
             context,
             query,
-            params: Some(match videos {
+            params: Some(params),
-                true => Params::Videos,
-                false => Params::Tracks,
-            }),
         };
 
         self.execute_request::<response::MusicSearch, _, _>(
@@ -129,21 +142,40 @@ impl RustyPipeQuery {
     pub async fn music_search_playlists(
         &self,
         query: &str,
+    ) -> Result<MusicSearchFiltered<MusicPlaylistItem>, Error> {
+        self._music_search_playlists(query, Params::Playlists).await
+    }
+
+    pub async fn music_search_playlists_filter(
+        &self,
+        query: &str,
         community: bool,
+    ) -> Result<MusicSearchFiltered<MusicPlaylistItem>, Error> {
+        self._music_search_playlists(
+            query,
+            match community {
+                true => Params::CommunityPlaylists,
+                false => Params::YtmPlaylists,
+            },
+        )
+        .await
+    }
+
+    async fn _music_search_playlists(
+        &self,
+        query: &str,
+        params: Params,
     ) -> Result<MusicSearchFiltered<MusicPlaylistItem>, Error> {
         let context = self.get_context(ClientType::DesktopMusic, true, None).await;
         let request_body = QSearch {
             context,
             query,
-            params: Some(match community {
+            params: Some(params),
-                true => Params::CommunityPlaylists,
-                false => Params::FeaturedPlaylists,
-            }),
         };
 
         self.execute_request::<response::MusicSearch, _, _>(
             ClientType::DesktopMusic,
-            "music_playlists",
+            "music_search_playlists",
             query,
             "search",
             &request_body,

tests/youtube.rs

@@ -1501,22 +1501,15 @@ async fn music_search(#[case] typo: bool) {
     assert_eq!(track.track_nr, None);
 }
 
-#[rstest]
-#[case::tracks(false)]
-#[case::videos(true)]
 #[tokio::test]
-async fn music_search_tracks(#[case] videos: bool) {
+async fn music_search_tracks() {
     let rp = RustyPipe::builder().strict().build();
-    let res = rp
+    let res = rp.query().music_search_tracks("black mamba").await.unwrap();
-        .query()
-        .music_search_tracks("black mamba", videos)
-        .await
-        .unwrap();
 
     let track = &res.items.items[0];
     assert_eq!(track.title, "Black Mamba");
     assert!(!track.cover.is_empty(), "got no cover");
-    assert_eq!(track.is_video, videos);
+    assert!(!track.is_video);
     assert_eq!(track.track_nr, None);
 
     assert_eq!(track.artists.len(), 1);
@@ -1527,19 +1520,39 @@ async fn music_search_tracks(#[case] videos: bool) {
     );
     assert_eq!(track_artist.name, "aespa");
 
-    if videos {
+    assert_eq!(track.id, "BL-aIpCLWnU");
-        assert_eq!(track.id, "ZeerrnuLi5E");
+    assert_eq!(track.duration.unwrap(), 175);
-        assert_eq!(track.duration.unwrap(), 230);
-        assert_eq!(track.album, None);
-        assert_gte(track.view_count.unwrap(), 230_000_000, "views");
-    } else {
-        assert_eq!(track.id, "BL-aIpCLWnU");
-        assert_eq!(track.duration.unwrap(), 175);
 
-        let album = track.album.as_ref().unwrap();
+    let album = track.album.as_ref().unwrap();
-        assert_eq!(album.id, "MPREb_OpHWHwyNOuY");
+    assert_eq!(album.id, "MPREb_OpHWHwyNOuY");
-        assert_eq!(album.name, "Black Mamba");
+    assert_eq!(album.name, "Black Mamba");
-    }
+
+    assert_next(res.items, &rp.query(), 15, 2).await;
+}
+
+#[tokio::test]
+async fn music_search_videos() {
+    let rp = RustyPipe::builder().strict().build();
+    let res = rp.query().music_search_videos("black mamba").await.unwrap();
+
+    let track = &res.items.items[0];
+    assert_eq!(track.title, "Black Mamba");
+    assert!(!track.cover.is_empty(), "got no cover");
+    assert!(track.is_video);
+    assert_eq!(track.track_nr, None);
+
+    assert_eq!(track.artists.len(), 1);
+    let track_artist = &track.artists[0];
+    assert_eq!(
+        track_artist.id.as_ref().unwrap(),
+        "UCEdZAdnnKqbaHOlv8nM6OtA"
+    );
+    assert_eq!(track_artist.name, "aespa");
+
+    assert_eq!(track.id, "ZeerrnuLi5E");
+    assert_eq!(track.duration.unwrap(), 230);
+    assert_eq!(track.album, None);
+    assert_gte(track.view_count.unwrap(), 230_000_000, "views");
 
     assert_next(res.items, &rp.query(), 15, 2).await;
 }
@@ -1637,14 +1650,20 @@ async fn music_search_artists_cont() {
     assert_next(res.items, &rp.query(), 15, 2).await;
 }
 
+#[rstest]
+#[case::ytm(false)]
+#[case::ytm_community(true)]
 #[tokio::test]
-async fn music_search_playlists() {
+async fn music_search_playlists(#[case] with_community: bool) {
     let rp = RustyPipe::builder().strict().build();
-    let res = rp
+    let res = if with_community {
-        .query()
+        rp.query().music_search_playlists("easy pop").await.unwrap()
-        .music_search_playlists("easy pop", false)
+    } else {
-        .await
+        rp.query()
-        .unwrap();
+            .music_search_playlists_filter("easy pop", false)
+            .await
+            .unwrap()
+    };
 
     assert_eq!(res.corrected_query, None);
     let playlist = &res.items.items[0];
@@ -1662,7 +1681,7 @@ async fn music_search_playlists_community() {
     let rp = RustyPipe::builder().strict().build();
     let res = rp
         .query()
-        .music_search_playlists("Best Pop Music Videos - Top Pop Hits Playlist", true)
+        .music_search_playlists_filter("Best Pop Music Videos - Top Pop Hits Playlist", true)
         .await
         .unwrap();