Query for genres

tests/in_memory_music_service.test.ts

@@ -346,7 +346,11 @@ describe("InMemoryMusicService", () => {
         describe("fetching all on one page", () => {
           it.only("should return all the albums of that genre for all the artists", async () => {
             expect(
-              await musicLibrary.albums({ _index: 0, _count: 100, genre: "Pop" })
+              await musicLibrary.albums({
+                _index: 0,
+                _count: 100,
+                genre: "Pop",
+              })
             ).toEqual({
               results: [
                 albumToAlbumSummary(artist1_album1),
@@ -379,7 +383,7 @@ describe("InMemoryMusicService", () => {
               });
             });
           });
-  
+
           describe("can fetch the last page", () => {
             it("should return only the albums for the last page", async () => {
               expect(
@@ -394,7 +398,6 @@ describe("InMemoryMusicService", () => {
               });
             });
           });
- 
         });
 
         it("should return empty list if there are no albums for the genre", async () => {
@@ -411,5 +414,27 @@ describe("InMemoryMusicService", () => {
         });
       });
     });
+
+    describe("genres", () => {
+      const artist1 = anArtist({ albums: [anAlbum({ genre: "Pop" }),     anAlbum({ genre: "Rock" }), anAlbum({ genre: "Pop" })] });
+      const artist2 = anArtist({ albums: [anAlbum({ genre: "Hip-Hop" }), anAlbum({ genre: "Rap" }), anAlbum({ genre: "Pop" })] });
+
+      beforeEach(() => {
+        service.hasArtists(artist1, artist2);
+      });
+
+      describe("fetching all in one page", () => {
+        it("should provide an array of artists", async () => {
+          expect(
+            await musicLibrary.genres()
+          ).toEqual([
+            "Hip-Hop",
+            "Pop",
+            "Rap",
+            "Rock"
+          ]);
+        });
+      });
+    });
   });
 });

tests/in_memory_music_service.ts

@@ -1,5 +1,8 @@
 import { option as O } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { eqString } from "fp-ts/lib/Eq";
 import { pipe } from "fp-ts/lib/function";
+import { ordString } from "fp-ts/lib/Ord";
 
 import {
   MusicService,
@@ -53,6 +56,7 @@ export class InMemoryMusicService implements MusicService {
     const credentials = JSON.parse(token) as Credentials;
     if (this.users[credentials.username] != credentials.password)
       return Promise.reject("Invalid auth token");
+
     return Promise.resolve({
       artists: (q: ArtistQuery) =>
         Promise.resolve(this.artists.map(artistToArtistSummary))
@@ -71,15 +75,9 @@ export class InMemoryMusicService implements MusicService {
             .flatMap((artist) => artist.albums.map((album) => [artist, album]))
             .filter(
               pipe(
-                pipe(
-                  O.fromNullable(q.artistId), 
-                  O.map(albumByArtist)
-                ),
+                pipe(O.fromNullable(q.artistId), O.map(albumByArtist)),
                 O.alt(() =>
-                  pipe(
-                    O.fromNullable(q.genre), 
-                    O.map(albumWithGenre)
-                  )
+                  pipe(O.fromNullable(q.genre), O.map(albumWithGenre))
                 ),
                 O.getOrElse(() => all)
               )
@@ -96,6 +94,18 @@ export class InMemoryMusicService implements MusicService {
           O.map((it) => Promise.resolve(it)),
           O.getOrElse(() => Promise.reject(`No album with id '${id}'`))
         ),
+      genres: () =>
+        Promise.resolve(
+          pipe(
+            this.artists,
+            A.map((it) => it.albums),
+            A.flatten,
+            A.map((it) => O.fromNullable(it.genre)),
+            A.compact,
+            A.uniq(eqString),
+            A.sort(ordString)
+          )
+        ),
     });
   }
 

tests/navidrome.test.ts

@@ -13,6 +13,8 @@ import {
   AuthSuccess,
   Images,
   albumToAlbumSummary,
+  range,
+  asArtistAlbumPairs,
 } from "../src/music_service";
 import { anAlbum, anArtist } from "./builders";
 
@@ -99,6 +101,17 @@ const artistXml = (
         </artist>
         </subsonic-response>`;
 
+const genresXml = (
+  genres: string[]
+) => `<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="0.40.0 (8799358a)">
+                                          <genres>
+                                            ${genres.map(
+                                              (it) =>
+                                                `<genre songCount="1475" albumCount="86">${it}</genre>`
+                                            )}
+                                          </genres>
+                                          </subsonic-response>`;
+
 const PING_OK = `<subsonic-response xmlns="http://subsonic.org/restapi" status="ok" version="1.16.1" type="navidrome" serverVersion="0.40.0 (8799358a)"></subsonic-response>`;
 
 describe("Navidrome", () => {
@@ -163,6 +176,31 @@ describe("Navidrome", () => {
     });
   });
 
+  describe("getting genres", () => {
+    const genres = ["HipHop", "Rap", "TripHop", "Pop", "Rock"];
+    beforeEach(() => {
+      mockGET
+        .mockImplementationOnce(() => Promise.resolve(ok(PING_OK)))
+        .mockImplementationOnce(() => Promise.resolve(ok(genresXml(genres))));
+    });
+
+    it.only("should return them alphabetically sorted", async () => {
+      const result = await navidrome
+        .generateToken({ username, password })
+        .then((it) => it as AuthSuccess)
+        .then((it) => navidrome.login(it.authToken))
+        .then((it) => it.genres());
+
+      expect(result).toEqual(genres.sort());
+
+      expect(axios.get).toHaveBeenCalledWith(`${url}/rest/getGenres`, {
+        params: {
+          ...authParams,
+        },
+      });
+    });
+  });
+
   describe("getting an artist", () => {
     const album1: Album = anAlbum();
 
@@ -386,30 +424,30 @@ describe("Navidrome", () => {
     });
   });
 
-  const range = (size: number) => [...Array(size).keys()];
-
-  const asArtistAlbumPairs = (artists: Artist[]): [Artist, Album][] =>
-    artists.flatMap((artist) =>
-      artist.albums.map((album) => [artist, album] as [Artist, Album])
-    );
-
   describe("getting albums", () => {
     describe("filtering", () => {
       const album1 = anAlbum({ genre: "Pop" });
       const album2 = anAlbum({ genre: "Rock" });
       const album3 = anAlbum({ genre: "Pop" });
-      
-      const artist = anArtist({ albums: [album1, album2, album3]});
+
+      const artist = anArtist({ albums: [album1, album2, album3] });
 
       describe("by genre", () => {
         beforeEach(() => {
           mockGET
             .mockImplementationOnce(() => Promise.resolve(ok(PING_OK)))
             .mockImplementationOnce(() =>
-              Promise.resolve(ok(albumListXml([[artist, album1], [artist, album3]])))
+              Promise.resolve(
+                ok(
+                  albumListXml([
+                    [artist, album1],
+                    [artist, album3],
+                  ])
+                )
+              )
             );
         });
-  
+
         it("should pass the filter to navidrome", async () => {
           const q = { _index: 0, _count: 500, genre: "Pop" };
           const result = await navidrome
@@ -417,12 +455,12 @@ describe("Navidrome", () => {
             .then((it) => it as AuthSuccess)
             .then((it) => navidrome.login(it.authToken))
             .then((it) => it.albums(q));
-  
+
           expect(result).toEqual({
             results: [album1, album3].map(albumToAlbumSummary),
             total: 2,
           });
-  
+
           expect(axios.get).toHaveBeenCalledWith(`${url}/rest/getAlbumList`, {
             params: {
               type: "byGenre",
@@ -434,7 +472,6 @@ describe("Navidrome", () => {
           });
         });
       });
-  
     });
 
     describe("when there are less than 500 albums", () => {
@@ -505,7 +542,7 @@ describe("Navidrome", () => {
             },
           });
         });
-      });  
+      });
     });
 
     describe("when there are more than 500 albums", () => {