aspotify 0.7.1

Deprecated in favour of rspotify
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Endpoint functions relating to albums.

use std::fmt::Display;

use itertools::Itertools as _;
use serde::Deserialize;

use super::chunked_sequence;
use crate::{Album, Client, Error, Market, Page, Response, TrackSimplified};

/// Album-related endpoints.
#[derive(Debug, Clone, Copy)]
pub struct Albums<'a>(pub &'a Client);

impl Albums<'_> {
    /// Get information about an album.
    ///
    /// [Reference](https://developer.spotify.com/documentation/web-api/reference/albums/get-album/).
    pub async fn get_album(
        self,
        id: &str,
        market: Option<Market>,
    ) -> Result<Response<Album>, Error> {
        self.0
            .send_json(
                self.0
                    .client
                    .get(endpoint!("/v1/albums/{}", id))
                    .query(&[market.map(Market::query)]),
            )
            .await
    }

    /// Get information about several albums.
    ///
    /// [Reference](https://developer.spotify.com/documentation/web-api/reference/albums/get-several-albums/).
    pub async fn get_albums<I: IntoIterator>(
        self,
        ids: I,
        market: Option<Market>,
    ) -> Result<Response<Vec<Album>>, Error>
    where
        I::Item: Display,
    {
        #[derive(Deserialize)]
        struct Albums {
            albums: Vec<Album>,
        }

        chunked_sequence(ids, 20, |mut ids| {
            let req = self
                .0
                .client
                .get(endpoint!("/v1/albums"))
                .query(&(("ids", ids.join(",")), market.map(Market::query)));
            async move { Ok(self.0.send_json::<Albums>(req).await?.map(|res| res.albums)) }
        })
        .await
    }

    /// Get an album's tracks.
    ///
    /// It does not return all the tracks, but a page of tracks. Limit and offset determine
    /// attributes of the page. Limit has a maximum of 50.
    ///
    /// [Reference](https://developer.spotify.com/documentation/web-api/reference/albums/get-albums-tracks/).
    pub async fn get_album_tracks(
        self,
        id: &str,
        limit: usize,
        offset: usize,
        market: Option<Market>,
    ) -> Result<Response<Page<TrackSimplified>>, Error> {
        self.0
            .send_json(
                self.0
                    .client
                    .get(endpoint!("/v1/albums/{}/tracks", id))
                    .query(&(
                        ("limit", limit),
                        ("offset", offset),
                        market.map(Market::query),
                    )),
            )
            .await
    }
}

#[cfg(test)]
mod tests {
    use crate::endpoints::client;

    #[tokio::test]
    async fn test_get_album() {
        let album = client()
            .albums()
            .get_album("03JPFQvZRnHHysSZrSFmKY", None)
            .await
            .unwrap()
            .data;
        assert_eq!(album.name, "Inside In / Inside Out");
        assert_eq!(album.artists.len(), 1);
        assert_eq!(album.artists[0].name, "The Kooks");
        assert_eq!(album.tracks.total, 14);
        assert_eq!(album.tracks.items[0].name, "Seaside");
    }

    #[tokio::test]
    async fn test_get_albums() {
        let albums = client()
            .albums()
            .get_albums(&["29Xikj6r9kQDSbnZWCCW2s", "0axbvqBOAejn8DgTUcJAp1"], None)
            .await
            .unwrap()
            .data;
        assert_eq!(albums.len(), 2);
        assert_eq!(albums[0].name, "Neotheater");
        assert_eq!(albums[1].name, "Absentee");
    }

    #[tokio::test]
    async fn test_get_album_tracks() {
        let tracks = client()
            .albums()
            .get_album_tracks("62U7xIHcID94o20Of5ea4D", 3, 1, None)
            .await
            .unwrap()
            .data;
        assert_eq!(tracks.limit, 3);
        assert_eq!(tracks.total, 10);
        assert_eq!(tracks.offset, 1);
        assert_eq!(tracks.items.len(), 3);
        assert_eq!(tracks.items[0].name, "Make Believe");
        assert_eq!(tracks.items[1].name, "I Won't Hold You Back");
        assert_eq!(tracks.items[2].name, "Good for You");
    }
}