Remove register button when there are no sonos devices (#39)

src/i8n.ts

@@ -36,7 +36,8 @@ export type KEY =
   | "failedToRemoveRegistration"
   | "invalidLinkCode"
   | "loginSuccessful"
-  | "loginFailed";
+  | "loginFailed" 
+  | "noSonosDevices";
 
 const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
   "en-US": {
@@ -71,6 +72,7 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     invalidLinkCode: "Invalid linkCode!",
     loginSuccessful: "Login successful!",
     loginFailed: "Login failed!",
+    noSonosDevices: "No sonos devices",
   },
   "nl-NL": {
     AppLinkMessage: "Sonos koppelen aan $BONOB_SONOS_SERVICE_NAME",
@@ -104,6 +106,7 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
     invalidLinkCode: "Ongeldige linkcode!",
     loginSuccessful: "Inloggen gelukt!",
     loginFailed: "Inloggen mislukt!",
+    noSonosDevices: "Geen Sonos-apparaten",
   },
 };
 

tests/scenarios.test.ts

@@ -9,6 +9,7 @@ import {
   GetMetadataResponse,
 } from "../src/smapi";
 import {
+  aDevice,
   BLONDIE,
   BOB_MARLEY,
   getAppLinkMessage,
@@ -19,7 +20,7 @@ import { InMemoryMusicService } from "./in_memory_music_service";
 import { InMemoryLinkCodes } from "../src/link_codes";
 import { Credentials } from "../src/music_service";
 import makeServer from "../src/server";
-import { Service, bonobService, SONOS_DISABLED } from "../src/sonos";
+import { Service, bonobService, Sonos } from "../src/sonos";
 import supersoap from "./supersoap";
 import url, { URLBuilder } from "../src/url_builder";
 
@@ -171,6 +172,17 @@ describe("scenarios", () => {
   );
   const linkCodes = new InMemoryLinkCodes();
 
+  const fakeSonos: Sonos = {
+    devices: () => Promise.resolve([aDevice({
+      name: "device1",
+      ip: "172.0.0.1",
+      port: 4301,
+    })]),
+    services: () => Promise.resolve([]),
+    remove: () => Promise.resolve(true),
+    register: () => Promise.resolve(true),
+  };
+
   beforeEach(() => {
     musicService.clear();
     linkCodes.clear();
@@ -255,7 +267,7 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,
@@ -273,7 +285,7 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234/");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,
@@ -291,7 +303,7 @@ describe("scenarios", () => {
     const bonobUrl = url("http://localhost:1234/context-for-bonob");
     const bonob = bonobService("bonob", 123, bonobUrl);
     const server = makeServer(
-      SONOS_DISABLED,
+      fakeSonos,
       bonob,
       bonobUrl,
       musicService,

tests/server.test.ts

@@ -193,6 +193,7 @@ describe("server", () => {
           it("should display it", async () => {
             const res = await request(server)
               .get(bonobUrl.append({ pathname: "/" }).pathname())
+              .set("accept-language", acceptLanguage)
               .send();
 
             expect(res.status).toEqual(200);
@@ -212,155 +213,220 @@ describe("server", () => {
             it("should be empty", async () => {
               const res = await request(server)
                 .get(bonobUrl.append({ pathname: "/" }).pathname())
+                .set("accept-language", acceptLanguage)
                 .send();
 
               expect(res.status).toEqual(200);
+              expect(res.text).toMatch(`<h2>${lang("devices")} \(0\)</h2>`);
               expect(res.text).not.toMatch(/class=device/);
+              expect(res.text).toContain(lang("noSonosDevices"));
             });
           });
         });
 
-        describe("when there are 2 devices and bonob is not registered", () => {
+        describe("when sonos integration is enabled", () => {
-          const service1 = aService({
+          describe("there are no devices and bonob is not registered", () => {
-            name: "s1",
+            const missingBonobService = aService({
-            sid: 1,
+              name: "bonobMissing",
-          });
+              sid: 88,
-          const service2 = aService({
+            });
-            name: "s2",
-            sid: 2,
-          });
-          const service3 = aService({
-            name: "s3",
-            sid: 3,
-          });
-          const service4 = aService({
-            name: "s4",
-            sid: 4,
-          });
-          const missingBonobService = aService({
-            name: "bonobMissing",
-            sid: 88,
-          });
   
-          const device1: Device = aDevice({
+            const fakeSonos: Sonos = {
-            name: "device1",
+              devices: () => Promise.resolve([]),
-            ip: "172.0.0.1",
+              services: () =>
-            port: 4301,
+                Promise.resolve([]),
-          });
+              remove: () => Promise.resolve(false),
+              register: () => Promise.resolve(false),
+            };
   
-          const device2: Device = aDevice({
+            const server = makeServer(
-            name: "device2",
+              fakeSonos,
-            ip: "172.0.0.2",
+              missingBonobService,
-            port: 4302,
+              bonobUrl,
-          });
+              new InMemoryMusicService()
+            );
   
-          const fakeSonos: Sonos = {
+            describe("devices list", () => {
-            devices: () => Promise.resolve([device1, device2]),
+              it("should be empty", async () => {
-            services: () =>
+                const res = await request(server)
-              Promise.resolve([service1, service2, service3, service4]),
+                  .get(bonobUrl.append({ pathname: "/" }).path())
-            remove: () => Promise.resolve(false),
+                  .set("accept-language", acceptLanguage)
-            register: () => Promise.resolve(false),
+                  .send();
-          };
   
-          const server = makeServer(
+                expect(res.status).toEqual(200);
-            fakeSonos,
+                expect(res.text).toMatch(`<h2>${lang("devices")} \(0\)</h2>`);
-            missingBonobService,
+                expect(res.text).not.toMatch(/class=device/);
-            bonobUrl,
+                expect(res.text).toContain(lang("noSonosDevices"));                
-            new InMemoryMusicService()
+              });
-          );
+            });
   
-          describe("devices list", () => {
+            describe("services", () => {
-            it("should contain the devices returned from sonos", async () => {
+              it("should be empty", async () => {
-              const res = await request(server)
+                const res = await request(server)
-                .get(bonobUrl.append({ pathname: "/" }).path())
+                  .get(bonobUrl.append({ pathname: "/" }).path())
-                .set("accept-language", acceptLanguage)
+                  .set("accept-language", acceptLanguage)
-                .send();
+                  .send();
   
-              expect(res.status).toEqual(200);
+                expect(res.status).toEqual(200);
-              expect(res.text).toMatch(`<h2>${lang("devices")} \(2\)</h2>`);
+                expect(res.text).toMatch(`<h2>${lang("services")} \(0\)</h2>`);
-              expect(res.text).toMatch(/device1\s+\(172.0.0.1:4301\)/);
+              });
-              expect(res.text).toMatch(/device2\s+\(172.0.0.2:4302\)/);
             });
           });
           
-          describe("services", () => {
+          describe("there are 2 devices and bonob is not registered", () => {
-            it("should contain a list of services returned from sonos", async () => {
+            const service1 = aService({
-              const res = await request(server)
+              name: "s1",
-                .get(bonobUrl.append({ pathname: "/" }).path())
+              sid: 1,
-                .set("accept-language", acceptLanguage)
+            });
-                .send();
+            const service2 = aService({
+              name: "s2",
+              sid: 2,
+            });
+            const service3 = aService({
+              name: "s3",
+              sid: 3,
+            });
+            const service4 = aService({
+              name: "s4",
+              sid: 4,
+            });
+            const missingBonobService = aService({
+              name: "bonobMissing",
+              sid: 88,
+            });
   
-              expect(res.status).toEqual(200);
+            const device1: Device = aDevice({
-              expect(res.text).toMatch(`<h2>${lang("services")} \(4\)</h2>`);
+              name: "device1",
-              expect(res.text).toMatch(/s1\s+\(1\)/);
+              ip: "172.0.0.1",
-              expect(res.text).toMatch(/s2\s+\(2\)/);
+              port: 4301,
-              expect(res.text).toMatch(/s3\s+\(3\)/);
+            });
-              expect(res.text).toMatch(/s4\s+\(4\)/);
+  
+            const device2: Device = aDevice({
+              name: "device2",
+              ip: "172.0.0.2",
+              port: 4302,
+            });
+  
+            const fakeSonos: Sonos = {
+              devices: () => Promise.resolve([device1, device2]),
+              services: () =>
+                Promise.resolve([service1, service2, service3, service4]),
+              remove: () => Promise.resolve(false),
+              register: () => Promise.resolve(false),
+            };
+  
+            const server = makeServer(
+              fakeSonos,
+              missingBonobService,
+              bonobUrl,
+              new InMemoryMusicService()
+            );
+  
+            describe("devices list", () => {
+              it("should contain the devices returned from sonos", async () => {
+                const res = await request(server)
+                  .get(bonobUrl.append({ pathname: "/" }).path())
+                  .set("accept-language", acceptLanguage)
+                  .send();
+  
+                expect(res.status).toEqual(200);
+                expect(res.text).toMatch(`<h2>${lang("devices")} \(2\)</h2>`);
+                expect(res.text).toMatch(/device1\s+\(172.0.0.1:4301\)/);
+                expect(res.text).toMatch(/device2\s+\(172.0.0.2:4302\)/);
+              });
+            });
+  
+            describe("services", () => {
+              it("should contain a list of services returned from sonos", async () => {
+                const res = await request(server)
+                  .get(bonobUrl.append({ pathname: "/" }).path())
+                  .set("accept-language", acceptLanguage)
+                  .send();
+  
+                expect(res.status).toEqual(200);
+                expect(res.text).toMatch(`<h2>${lang("services")} \(4\)</h2>`);
+                expect(res.text).toMatch(/s1\s+\(1\)/);
+                expect(res.text).toMatch(/s2\s+\(2\)/);
+                expect(res.text).toMatch(/s3\s+\(3\)/);
+                expect(res.text).toMatch(/s4\s+\(4\)/);
+              });
+            });
+  
+            describe("registration status", () => {
+              it("should be not-registered", async () => {
+                const res = await request(server)
+                  .get(bonobUrl.append({ pathname: "/" }).path())
+                  .set("accept-language", acceptLanguage)
+                  .send();
+                expect(res.status).toEqual(200);
+                expect(res.text).toMatch(
+                  `<input type="submit" value="${lang("register")}">`
+                );
+                expect(res.text).toMatch(`<h3>${lang("expectedConfig")}</h3>`);
+                expect(res.text).toMatch(
+                  `<h3>${lang("noExistingServiceRegistration")}</h3>`
+                );
+                expect(res.text).not.toMatch(
+                  `<input type="submit" value="${lang("removeRegistration")}">`
+                );
+              });
             });
           });
   
-          describe("registration status", () => {
+          describe("there are 2 devices and bonob is registered", () => {
-            it("should be not-registered", async () => {
+            const service1 = aService();
-              const res = await request(server)
+  
-                .get(bonobUrl.append({ pathname: "/" }).path())
+            const service2 = aService();
-                .set("accept-language", acceptLanguage)
+
-                .send();
+            const device1: Device = aDevice({
-              expect(res.status).toEqual(200);
+              name: "device1",
-              expect(res.text).toMatch(
+              ip: "172.0.0.1",
-                `<input type="submit" value="${lang("register")}">`
+              port: 4301,
-              );
-              expect(res.text).toMatch(`<h3>${lang("expectedConfig")}</h3>`);
-              expect(res.text).toMatch(
-                `<h3>${lang("noExistingServiceRegistration")}</h3>`
-              );
-              expect(res.text).not.toMatch(
-                `<input type="submit" value="${lang("removeRegistration")}">`
-              );
             });
-          });
-        });
   
-        describe("when there are 2 devices and bonob is registered", () => {
+            const device2: Device = aDevice({
-          const service1 = aService();
+              name: "device2",
+              ip: "172.0.0.2",
+              port: 4302,
+            });
   
-          const service2 = aService();
+            const bonobService = aService({
+              name: "bonobNotMissing",
+              sid: 99,
+            });
   
-          const bonobService = aService({
+            const fakeSonos: Sonos = {
-            name: "bonobNotMissing",
+              devices: () => Promise.resolve([device1, device2]),
-            sid: 99,
+              services: () => Promise.resolve([service1, service2, bonobService]),
-          });
+              remove: () => Promise.resolve(false),
+              register: () => Promise.resolve(false),
+            };
   
-          const fakeSonos: Sonos = {
+            const server = makeServer(
-            devices: () => Promise.resolve([]),
+              fakeSonos,
-            services: () => Promise.resolve([service1, service2, bonobService]),
+              bonobService,
-            remove: () => Promise.resolve(false),
+              bonobUrl,
-            register: () => Promise.resolve(false),
+              new InMemoryMusicService()
-          };
+            );
   
-          const server = makeServer(
+            describe("registration status", () => {
-            fakeSonos,
+              it("should be registered", async () => {
-            bonobService,
+                const res = await request(server)
-            bonobUrl,
+                  .get(bonobUrl.append({ pathname: "/" }).path())
-            new InMemoryMusicService()
+                  .set("accept-language", acceptLanguage)
-          );
+                  .send();
-
+                expect(res.status).toEqual(200);
-          describe("registration status", () => {
+                expect(res.text).toMatch(
-            it("should be registered", async () => {
+                  `<input type="submit" value="${lang("register")}">`
-              const res = await request(server)
+                );
-                .get(bonobUrl.append({ pathname: "/" }).path())
+                expect(res.text).toMatch(`<h3>${lang("expectedConfig")}</h3>`);
-                .set("accept-language", acceptLanguage)
+                expect(res.text).toMatch(
-                .send();
+                  `<h3>${lang("existingServiceConfig")}</h3>`
-              expect(res.status).toEqual(200);
+                );
-              expect(res.text).toMatch(
+                expect(res.text).toMatch(
-                `<input type="submit" value="${lang("register")}">`
+                  `<input type="submit" value="${lang("removeRegistration")}">`
-              );
+                );
-              expect(res.text).toMatch(`<h3>${lang("expectedConfig")}</h3>`);
+              });
-              expect(res.text).toMatch(
-                `<h3>${lang("existingServiceConfig")}</h3>`
-              );
-              expect(res.text).toMatch(
-                `<input type="submit" value="${lang("removeRegistration")}">`
-              );
             });
           });
         });

web/views/index.eta

@@ -6,10 +6,15 @@
   <h3><%= it.lang("expectedConfig") %></h3>
   <div><%= JSON.stringify(it.bonobService) %></div>
   <br/>
+  <% if(it.devices.length > 0) { %>
   <form action="<%= it.createRegistrationRoute %>" method="POST">
     <input type="submit" value="<%= it.lang("register") %>">
   </form>
   <br/>
+  <% } else { %>
+  <h3><%= it.lang("noSonosDevices") %></h3>
+  <br/>
+  <% } %>
 
   <% if(it.registeredBonobService) { %>
     <h3><%= it.lang("existingServiceConfig") %></h3>