Add support for running under a context path, ie. /bonob, replace BONOB_WEB_ADDRESS with BONOB_URL

README.md

@@ -63,7 +63,7 @@ Start bonob outside the lan with sonos discovery & registration disabled as they
 ```bash
 docker run \
     -e BONOB_PORT=4534 \
-    -e BONOB_WEB_ADDRESS=https://my-bonob-service.com \
+    -e BONOB_URL=https://my-server.example.com/bonob \
     -e BONOB_SONOS_AUTO_REGISTER=false \
     -e BONOB_SONOS_DEVICE_DISCOVERY=false \
     -e BONOB_NAVIDROME_URL=https://my-navidrome-service.com:4533 \
@@ -71,11 +71,11 @@ docker run \
     simojenki/bonob
 ```
 
-Now inside the lan that contains the sonos devices run bonob registration, using the same BONOB_WEB_ADDRESS as above, and with discovery enabled.  Make sure to use host networking so that bonob can find the sonos devices (or provide a BONOB_SONOS_SEED_HOST)
+Now inside the lan that contains the sonos devices run bonob registration, using the same BONOB_URL as above, and with discovery enabled.  Make sure to use host networking so that bonob can find the sonos devices (or provide a BONOB_SONOS_SEED_HOST)
 
 ```bash
 docker run \
-    -e BONOB_WEB_ADDRESS=https://my-bonob-service.com \
+    -e BONOB_URL=https://my-server.example.com/bonob \
     -e BONOB_SONOS_DEVICE_DISCOVERY=true \
     --network host \
     simojenki/bonob register
@@ -86,7 +86,7 @@ docker run \
 item | default value | description
 ---- | ------------- | -----------
 BONOB_PORT | 4534 | Default http port for bonob to listen on
-BONOB_WEB_ADDRESS | http://$(hostname):4534 | URL for bonob so that sonos devices can communicate. **This must be either the public IP or DNS entry of the bonob instance so that the sonos devices can communicate with it.**
+BONOB_URL | http://$(hostname):4534 | URL (including path) for bonob so that sonos devices can communicate. **This must be either the public IP or DNS entry of the bonob instance so that the sonos devices can communicate with it.**
 BONOB_SECRET | bonob | secret used for encrypting credentials
 BONOB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
 BONOB_SONOS_DEVICE_DISCOVERY | true | whether or not sonos device discovery should be enabled

src/app.ts

@@ -7,6 +7,7 @@ import { InMemoryLinkCodes } from "./link_codes";
 import readConfig from "./config";
 import sonos, { bonobService } from "./sonos";
 import { MusicService } from "./music_service";
+import { SystemClock } from "./clock";
 
 const config = readConfig();
 
@@ -15,7 +16,7 @@ logger.info(`Starting bonob with config ${JSON.stringify(config)}`);
 const bonob = bonobService(
   config.sonos.serviceName,
   config.sonos.sid,
-  config.webAddress,
+  config.bonobUrl,
   "AppLink"
 );
 
@@ -40,15 +41,15 @@ const featureFlagAwareMusicService: MusicService = {
         scrobble: (id: string) => {
           if (config.scrobbleTracks) return library.scrobble(id);
           else {
-            logger.info("Track Scrobbling not enabled")
+            logger.info("Track Scrobbling not enabled");
-            return Promise.resolve(false);
+            return Promise.resolve(true);
           }
         },
         nowPlaying: (id: string) => {
           if (config.reportNowPlaying) return library.nowPlaying(id);
           else {
             logger.info("Reporting track now playing not enabled");
-            return Promise.resolve(false);
+            return Promise.resolve(true);
           }
         },
       };
@@ -58,10 +59,12 @@ const featureFlagAwareMusicService: MusicService = {
 const app = server(
   sonosSystem,
   bonob,
-  config.webAddress,
+  config.bonobUrl,
   featureFlagAwareMusicService,
   new InMemoryLinkCodes(),
-  new InMemoryAccessTokens(sha256(config.secret))
+  new InMemoryAccessTokens(sha256(config.secret)),
+  SystemClock,
+  true,
 );
 
 if (config.sonos.autoRegister) {
@@ -75,7 +78,7 @@ if (config.sonos.autoRegister) {
 }
 
 app.listen(config.port, () => {
-  logger.info(`Listening on ${config.port} available @ ${config.webAddress}`);
+  logger.info(`Listening on ${config.port} available @ ${config.bonobUrl}`);
 });
 
 export default app;

src/config.ts

@@ -1,28 +1,32 @@
 import { hostname } from "os";
 import logger from "./logger";
+import url from "./url_builder";
 
 export default function () {
   const port = +(process.env["BONOB_PORT"] || 4534);
-  const webAddress =
+  const bonobUrl =
-    process.env["BONOB_WEB_ADDRESS"] || `http://${hostname()}:${port}`;
+    process.env["BONOB_URL"] ||
+    process.env["BONOB_WEB_ADDRESS"] ||
+    `http://${hostname()}:${port}`;
 
-  if (webAddress.match("localhost")) {
+  if (bonobUrl.match("localhost")) {
     logger.error(
-      "BONOB_WEB_ADDRESS containing localhost is almost certainly incorrect, sonos devices will not be able to communicate with bonob using localhost, please specify either public IP or DNS entry"
+      "BONOB_URL containing localhost is almost certainly incorrect, sonos devices will not be able to communicate with bonob using localhost, please specify either public IP or DNS entry"
     );
     process.exit(1);
   }
 
   return {
     port,
-    webAddress,
+    bonobUrl: url(bonobUrl),
     secret: process.env["BONOB_SECRET"] || "bonob",
     sonos: {
       serviceName: process.env["BONOB_SONOS_SERVICE_NAME"] || "bonob",
       deviceDiscovery:
         (process.env["BONOB_SONOS_DEVICE_DISCOVERY"] || "true") == "true",
       seedHost: process.env["BONOB_SONOS_SEED_HOST"],
-      autoRegister: (process.env["BONOB_SONOS_AUTO_REGISTER"] || "false") == "true",
+      autoRegister:
+        (process.env["BONOB_SONOS_AUTO_REGISTER"] || "false") == "true",
       sid: Number(process.env["BONOB_SONOS_SERVICE_ID"] || "246"),
     },
     navidrome: {
@@ -31,6 +35,7 @@ export default function () {
         process.env["BONOB_NAVIDROME_CUSTOM_CLIENTS"] || undefined,
     },
     scrobbleTracks: (process.env["BONOB_SCROBBLE_TRACKS"] || "true") == "true",
-    reportNowPlaying: (process.env["BONOB_REPORT_NOW_PLAYING"] || "true") == "true",
+    reportNowPlaying:
+      (process.env["BONOB_REPORT_NOW_PLAYING"] || "true") == "true",
   };
 }

src/register.ts

@@ -7,7 +7,7 @@ const config = readConfig();
 const bonob = bonobService(
     config.sonos.serviceName,
     config.sonos.sid,
-    config.webAddress,
+    config.bonobUrl,
     "AppLink"
 );
 

src/server.ts

@@ -12,6 +12,7 @@ import {
   PRESENTATION_MAP_ROUTE,
   SONOS_RECOMMENDED_IMAGE_SIZES,
   LOGIN_ROUTE,
+  REGISTER_ROUTE,
 } from "./smapi";
 import { LinkCodes, InMemoryLinkCodes } from "./link_codes";
 import { MusicService, isSuccess } from "./music_service";
@@ -20,6 +21,7 @@ import { AccessTokens, AccessTokenPerAuthToken } from "./access_tokens";
 import logger from "./logger";
 import { Clock, SystemClock } from "./clock";
 import { pipe } from "fp-ts/lib/function";
+import { URLBuilder } from "./url_builder";
 
 export const BONOB_ACCESS_TOKEN_HEADER = "bonob-access-token";
 
@@ -63,17 +65,19 @@ export class RangeBytesFromFilter extends Transform {
 function server(
   sonos: Sonos,
   service: Service,
-  webAddress: string,
+  bonobUrl: URLBuilder,
   musicService: MusicService,
   linkCodes: LinkCodes = new InMemoryLinkCodes(),
   accessTokens: AccessTokens = new AccessTokenPerAuthToken(),
-  clock: Clock = SystemClock
+  clock: Clock = SystemClock,
+  applyContextPath = true
 ): Express {
   const app = express();
 
   app.use(morgan("combined"));
   app.use(express.urlencoded({ extended: false }));
 
+  // todo: pass options in here?
   app.use(express.static("./web/public"));
   app.engine("eta", Eta.renderFile);
 
@@ -91,12 +95,13 @@ function server(
           services,
           bonobService: service,
           registeredBonobService,
+          registerRoute: bonobUrl.append({ pathname: REGISTER_ROUTE }).pathname(),
         });
       }
     );
   });
 
-  app.post("/register", (_, res) => {
+  app.post(REGISTER_ROUTE, (_, res) => {
     sonos.register(service).then((success) => {
       if (success) {
         res.render("success", {
@@ -114,7 +119,7 @@ function server(
     res.render("login", {
       bonobService: service,
       linkCode: req.query.linkCode,
-      loginRoute: LOGIN_ROUTE,
+      loginRoute: bonobUrl.append({ pathname: LOGIN_ROUTE }).pathname(),
     });
   });
 
@@ -317,14 +322,20 @@ function server(
   bindSmapiSoapServiceToExpress(
     app,
     SOAP_PATH,
-    webAddress,
+    bonobUrl,
     linkCodes,
     musicService,
     accessTokens,
     clock
   );
 
-  return app;
+  if (applyContextPath) {
+    const container = express();
+    container.use(bonobUrl.path(), app);
+    return container;
+  } else {
+    return app;
+  }
 }
 
 export default server;

src/smapi.ts

@@ -20,8 +20,10 @@ import {
 import { AccessTokens } from "./access_tokens";
 import { BONOB_ACCESS_TOKEN_HEADER } from "./server";
 import { Clock } from "./clock";
+import { URLBuilder } from "./url_builder";
 
 export const LOGIN_ROUTE = "/login";
+export const REGISTER_ROUTE = "/register";
 export const SOAP_PATH = "/ws/sonos";
 export const STRINGS_ROUTE = "/sonos/strings.xml";
 export const PRESENTATION_MAP_ROUTE = "/sonos/presentationMap.xml";
@@ -131,10 +133,10 @@ export function searchResult(
 
 class SonosSoap {
   linkCodes: LinkCodes;
-  webAddress: string;
+  bonobUrl: URLBuilder;
 
-  constructor(webAddress: string, linkCodes: LinkCodes) {
+  constructor(bonobUrl: URLBuilder, linkCodes: LinkCodes) {
-    this.webAddress = webAddress;
+    this.bonobUrl = bonobUrl;
     this.linkCodes = linkCodes;
   }
 
@@ -145,7 +147,10 @@ class SonosSoap {
         authorizeAccount: {
           appUrlStringId: "AppLinkMessage",
           deviceLink: {
-            regUrl: `${this.webAddress}${LOGIN_ROUTE}?linkCode=${linkCode}`,
+            regUrl: this.bonobUrl
+              .append({ pathname: LOGIN_ROUTE })
+              .with({ searchParams: { linkCode } })
+              .href(),
             linkCode: linkCode,
             showLinkCode: false,
           },
@@ -216,31 +221,21 @@ const playlist = (playlist: PlaylistSummary) => ({
   },
 });
 
-export const defaultAlbumArtURI = (
+export const defaultAlbumArtURI = (bonobUrl: URLBuilder, album: AlbumSummary) =>
-  webAddress: string,
+  bonobUrl.append({ pathname: `/album/${album.id}/art/size/180` });
-  accessToken: string,
-  album: AlbumSummary
-) =>
-  `${webAddress}/album/${album.id}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`;
 
 export const defaultArtistArtURI = (
-  webAddress: string,
+  bonobUrl: URLBuilder,
-  accessToken: string,
   artist: ArtistSummary
-) =>
+) => bonobUrl.append({ pathname: `/artist/${artist.id}/art/size/180` });
-  `${webAddress}/artist/${artist.id}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`;
 
-export const album = (
+export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
-  webAddress: string,
-  accessToken: string,
-  album: AlbumSummary
-) => ({
   itemType: "album",
   id: `album:${album.id}`,
   artist: album.artistName,
   artistId: album.artistId,
   title: album.name,
-  albumArtURI: defaultAlbumArtURI(webAddress, accessToken, album),
+  albumArtURI: defaultAlbumArtURI(bonobUrl, album).href(),
   canPlay: true,
   // defaults
   // canScroll: false,
@@ -248,11 +243,7 @@ export const album = (
   // canAddToFavorites: true
 });
 
-export const track = (
+export const track = (bonobUrl: URLBuilder, track: Track) => ({
-  webAddress: string,
-  accessToken: string,
-  track: Track
-) => ({
   itemType: "track",
   id: `track:${track.id}`,
   mimeType: track.mimeType,
@@ -263,7 +254,7 @@ export const track = (
     albumId: track.album.id,
     albumArtist: track.artist.name,
     albumArtistId: track.artist.id,
-    albumArtURI: defaultAlbumArtURI(webAddress, accessToken, track.album),
+    albumArtURI: defaultAlbumArtURI(bonobUrl, track.album).href(),
     artist: track.artist.name,
     artistId: track.artist.id,
     duration: track.duration,
@@ -273,16 +264,12 @@ export const track = (
   },
 });
 
-export const artist = (
+export const artist = (bonobUrl: URLBuilder, artist: ArtistSummary) => ({
-  webAddress: string,
-  accessToken: string,
-  artist: ArtistSummary
-) => ({
   itemType: "artist",
   id: `artist:${artist.id}`,
   artistId: artist.id,
   title: artist.name,
-  albumArtURI: defaultArtistArtURI(webAddress, accessToken, artist),
+  albumArtURI: defaultArtistArtURI(bonobUrl, artist).href(),
 });
 
 const auth = async (
@@ -334,13 +321,20 @@ type SoapyHeaders = {
 function bindSmapiSoapServiceToExpress(
   app: Express,
   soapPath: string,
-  webAddress: string,
+  bonobUrl: URLBuilder,
   linkCodes: LinkCodes,
   musicService: MusicService,
   accessTokens: AccessTokens,
   clock: Clock
 ) {
-  const sonosSoap = new SonosSoap(webAddress, linkCodes);
+  const sonosSoap = new SonosSoap(bonobUrl, linkCodes);
+  const urlWithToken = (accessToken: string) =>
+    bonobUrl.append({
+      searchParams: {
+        "bonob-access-token": accessToken,
+      },
+    });
+
   const soapyService = listen(
     app,
     soapPath,
@@ -366,7 +360,11 @@ function bindSmapiSoapServiceToExpress(
             auth(musicService, accessTokens, headers)
               .then(splitId(id))
               .then(({ accessToken, type, typeId }) => ({
-                getMediaURIResult: `${webAddress}/stream/${type}/${typeId}`,
+                getMediaURIResult: bonobUrl
+                  .append({
+                    pathname: `/stream/${type}/${typeId}`,
+                  })
+                  .href(),
                 httpHeaders: [
                   {
                     header: BONOB_ACCESS_TOKEN_HEADER,
@@ -383,7 +381,10 @@ function bindSmapiSoapServiceToExpress(
               .then(splitId(id))
               .then(async ({ musicLibrary, accessToken, typeId }) =>
                 musicLibrary.track(typeId!).then((it) => ({
-                  getMediaMetadataResult: track(webAddress, accessToken, it),
+                  getMediaMetadataResult: track(
+                    urlWithToken(accessToken),
+                    it
+                  ),
                 }))
               ),
           search: async (
@@ -400,7 +401,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((albumSummary) =>
-                          album(webAddress, accessToken, albumSummary)
+                          album(urlWithToken(accessToken), albumSummary)
                         ),
                       })
                     );
@@ -409,7 +410,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((artistSummary) =>
-                          artist(webAddress, accessToken, artistSummary)
+                          artist(urlWithToken(accessToken), artistSummary)
                         ),
                       })
                     );
@@ -418,7 +419,7 @@ function bindSmapiSoapServiceToExpress(
                       searchResult({
                         count: it.length,
                         mediaCollection: it.map((aTrack) =>
-                          album(webAddress, accessToken, aTrack.album)
+                          album(urlWithToken(accessToken), aTrack.album)
                         ),
                       })
                     );
@@ -452,7 +453,7 @@ function bindSmapiSoapServiceToExpress(
                           index: paging._index,
                           total,
                           mediaCollection: page.map((it) =>
-                            album(webAddress, accessToken, it)
+                            album(urlWithToken(accessToken), it)
                           ),
                           relatedBrowse:
                             artist.similarArtists.length > 0
@@ -483,10 +484,9 @@ function bindSmapiSoapServiceToExpress(
                             genreId: it.genre?.id,
                             duration: it.duration,
                             albumArtURI: defaultAlbumArtURI(
-                              webAddress,
+                              urlWithToken(accessToken),
-                              accessToken,
                               it.album
-                            ),
+                            ).href(),
                           },
                         },
                       },
@@ -500,7 +500,7 @@ function bindSmapiSoapServiceToExpress(
                             userContent: false,
                             renameable: false,
                           },
-                          ...album(webAddress, accessToken, it),
+                          ...album(urlWithToken(accessToken), it),
                         },
                         // <mediaCollection readonly="true">
                         //   </mediaCollection>
@@ -537,7 +537,7 @@ function bindSmapiSoapServiceToExpress(
                   musicLibrary.albums(q).then((result) => {
                     return getMetadataResult({
                       mediaCollection: result.results.map((it) =>
-                        album(webAddress, accessToken, it)
+                        album(urlWithToken(accessToken), it)
                       ),
                       index: paging._index,
                       total: result.total,
@@ -616,7 +616,7 @@ function bindSmapiSoapServiceToExpress(
                     return musicLibrary.artists(paging).then((result) => {
                       return getMetadataResult({
                         mediaCollection: result.results.map((it) =>
-                          artist(webAddress, accessToken, it)
+                          artist(urlWithToken(accessToken), it)
                         ),
                         index: paging._index,
                         total: result.total,
@@ -689,7 +689,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(webAddress, accessToken, it)
+                            track(urlWithToken(accessToken), it)
                           ),
                           index: paging._index,
                           total,
@@ -703,7 +703,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            album(webAddress, accessToken, it)
+                            album(urlWithToken(accessToken), it)
                           ),
                           index: paging._index,
                           total,
@@ -717,7 +717,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaCollection: page.map((it) =>
-                            artist(webAddress, accessToken, it)
+                            artist(urlWithToken(accessToken), it)
                           ),
                           index: paging._index,
                           total,
@@ -730,7 +730,7 @@ function bindSmapiSoapServiceToExpress(
                       .then(([page, total]) => {
                         return getMetadataResult({
                           mediaMetadata: page.map((it) =>
-                            track(webAddress, accessToken, it)
+                            track(urlWithToken(accessToken), it)
                           ),
                           index: paging._index,
                           total,

src/sonos.ts

@@ -6,6 +6,7 @@ import { head } from "underscore";
 import logger from "./logger";
 import { SOAP_PATH, STRINGS_ROUTE, PRESENTATION_MAP_ROUTE } from "./smapi";
 import qs from "querystring";
+import { URLBuilder } from "./url_builder";
 
 export const PRESENTATION_AND_STRINGS_VERSION = "18";
 
@@ -49,25 +50,25 @@ export type Service = {
   authType: "Anonymous" | "AppLink" | "DeviceLink" | "UserId";
 };
 
-export const stripTailingSlash = (url: string) =>
+export const stripTrailingSlash = (url: string) =>
   url.endsWith("/") ? url.substring(0, url.length - 1) : url;
 
 export const bonobService = (
   name: string,
   sid: number,
-  bonobRoot: string,
+  bonobUrl: URLBuilder,
   authType: "Anonymous" | "AppLink" | "DeviceLink" | "UserId" = "AppLink"
 ): Service => ({
   name,
   sid,
-  uri: `${stripTailingSlash(bonobRoot)}${SOAP_PATH}`,
+  uri: bonobUrl.append({pathname: SOAP_PATH }).href(),
-  secureUri: `${stripTailingSlash(bonobRoot)}${SOAP_PATH}`,
+  secureUri: bonobUrl.append({pathname: SOAP_PATH }).href(),
   strings: {
-    uri: `${stripTailingSlash(bonobRoot)}${STRINGS_ROUTE}`,
+    uri: bonobUrl.append({pathname: STRINGS_ROUTE }).href(),
     version: PRESENTATION_AND_STRINGS_VERSION,
   },
   presentation: {
-    uri: `${stripTailingSlash(bonobRoot)}${PRESENTATION_MAP_ROUTE}`,
+    uri: bonobUrl.append({pathname: PRESENTATION_MAP_ROUTE }).href(),
     version: PRESENTATION_AND_STRINGS_VERSION,
   },
   pollInterval: 1200,
@@ -83,7 +84,7 @@ export interface Sonos {
 export const SONOS_DISABLED: Sonos = {
   devices: () => Promise.resolve([]),
   services: () => Promise.resolve([]),
-  register: (_: Service) => Promise.resolve(false),
+  register: (_: Service) => Promise.resolve(true),
 };
 
 export const asService = (musicService: MusicService): Service => ({

src/url_builder.ts

@@ -0,0 +1,72 @@
+function isURL(url: string | URL): url is URL {
+  return (url as URL).href !== undefined;
+}
+
+function isURLSearchParams(
+  searchParams: Record<string, string> | URLSearchParams
+): searchParams is URLSearchParams {
+  return (searchParams as URLSearchParams).getAll !== undefined;
+}
+
+const stripTrailingSlash = (url: string) =>
+  url.endsWith("/") ? url.substring(0, url.length - 1) : url;
+
+export class URLBuilder {
+  private url: URL;
+
+  constructor(url: string | URL) {
+    this.url = isURL(url) ? url : new URL(url);
+  }
+
+  public append = (
+    bits: Partial<{
+      pathname: string | undefined;
+      searchParams: Record<string, string> | URLSearchParams;
+    }> = { pathname: undefined, searchParams: undefined }
+  ) => {
+    let result = new URLBuilder(this.url);
+    if (bits.pathname)
+      result = result.with({
+        pathname: stripTrailingSlash(this.url.pathname) + bits.pathname,
+      });
+    if (bits.searchParams) {
+      const newSearchParams = new URLSearchParams(this.url.searchParams);
+      (isURLSearchParams(bits.searchParams)
+        ? bits.searchParams
+        : new URLSearchParams(bits.searchParams)
+      ).forEach((v, k) => newSearchParams.append(k, v));
+      result = result.with({ searchParams: newSearchParams });
+    }
+    return result;
+  };
+
+  public with = (
+    bits: Partial<{
+      pathname: string | undefined;
+      searchParams: Record<string, string> | URLSearchParams;
+    }> = { pathname: undefined, searchParams: undefined }
+  ) => {
+    const result = new URL(this.url.href);
+    if (bits.pathname) result.pathname = bits.pathname;
+    if (bits.searchParams) {
+      const keysToDelete: string[] = [];
+      result.searchParams.forEach((_, k) => keysToDelete.push(k));
+      keysToDelete.forEach((k) => result.searchParams.delete(k));
+      (isURLSearchParams(bits.searchParams)
+        ? bits.searchParams
+        : new URLSearchParams(bits.searchParams)
+      ).forEach((v, k) => result.searchParams.append(k, v));
+    }
+    return new URLBuilder(result);
+  };
+
+  public href = () => this.url.href;
+  public pathname = () => this.url.pathname;
+  public searchParams = () => this.url.searchParams;
+  public path = () => this.url.pathname + this.url.search;
+  public toString = () => this.url.href;
+}
+
+export default function url(url: string | URL): URLBuilder {
+  return new URLBuilder(url);
+}

tests/config.test.ts

@@ -13,7 +13,12 @@ describe("config", () => {
     process.env = OLD_ENV;
   });
 
-  function describeBooleanConfigValue(name: string, envVar: string, expectedDefault: boolean, propertyGetter: (config: any) => any) {
+  function describeBooleanConfigValue(
+    name: string,
+    envVar: string,
+    expectedDefault: boolean,
+    propertyGetter: (config: any) => any
+  ) {
     describe(name, () => {
       function expecting({
         value,
@@ -35,7 +40,72 @@ describe("config", () => {
       expecting({ value: "false", expected: false });
       expecting({ value: "foo", expected: false });
     });
-  };
+  }
+
+  describe("bonobUrl", () => {
+    describe("when BONOB_URL is specified", () => {
+      it("should be used", () => {
+        const url = "http://bonob1.example.com:8877/";
+        process.env["BONOB_URL"] = url;
+
+        expect(config().bonobUrl.href()).toEqual(url);
+      });
+    });
+
+    describe("when BONOB_URL is not specified, however legacy BONOB_WEB_ADDRESS is specified", () => {
+      it("should be used", () => {
+        const url = "http://bonob2.example.com:9988/";
+        process.env["BONOB_URL"] = "";
+        process.env["BONOB_WEB_ADDRESS"] = url;
+
+        expect(config().bonobUrl.href()).toEqual(url);
+      });
+    });
+
+    describe("when neither BONOB_URL nor BONOB_WEB_ADDRESS are specified", () => {
+      describe("when BONOB_PORT is not specified", () => {
+        it(`should default to http://${hostname()}:4534`, () => {
+          expect(config().bonobUrl.href()).toEqual(
+            `http://${hostname()}:4534/`
+          );
+        });
+      });
+
+      describe("when BONOB_PORT is specified as 3322", () => {
+        it(`should default to http://${hostname()}:3322`, () => {
+          process.env["BONOB_PORT"] = "3322";
+          expect(config().bonobUrl.href()).toEqual(
+            `http://${hostname()}:3322/`
+          );
+        });
+      });
+    });
+  });
+
+  describe("navidrome", () => {
+    describe("url", () => {
+      describe("when BONOB_NAVIDROME_URL is not specified", () => {
+        it(`should default to http://${hostname()}:4533`, () => {
+          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
+        });
+      });
+
+      describe("when BONOB_NAVIDROME_URL is ''", () => {
+        it(`should default to http://${hostname()}:4533`, () => {
+          process.env["BONOB_NAVIDROME_URL"] = "";
+          expect(config().navidrome.url).toEqual(`http://${hostname()}:4533`);
+        });
+      });
+
+      describe("when BONOB_NAVIDROME_URL is specified", () => {
+        it(`should use it`, () => {
+          const url = "http://navidrome.example.com:1234";
+          process.env["BONOB_NAVIDROME_URL"] = url;
+          expect(config().navidrome.url).toEqual(url);
+        });
+      });
+    });
+  });
 
   describe("secret", () => {
     it("should default to bonob", () => {
@@ -60,7 +130,12 @@ describe("config", () => {
       });
     });
 
-    describeBooleanConfigValue("deviceDiscovery", "BONOB_SONOS_DEVICE_DISCOVERY", true, config => config.sonos.deviceDiscovery);
+    describeBooleanConfigValue(
+      "deviceDiscovery",
+      "BONOB_SONOS_DEVICE_DISCOVERY",
+      true,
+      (config) => config.sonos.deviceDiscovery
+    );
 
     describe("seedHost", () => {
       it("should default to undefined", () => {
@@ -73,7 +148,12 @@ describe("config", () => {
       });
     });
 
-    describeBooleanConfigValue("autoRegister", "BONOB_SONOS_AUTO_REGISTER", false, config => config.sonos.autoRegister);
+    describeBooleanConfigValue(
+      "autoRegister",
+      "BONOB_SONOS_AUTO_REGISTER",
+      false,
+      (config) => config.sonos.autoRegister
+    );
 
     describe("sid", () => {
       it("should default to 246", () => {
@@ -111,6 +191,16 @@ describe("config", () => {
     });
   });
 
-  describeBooleanConfigValue("scrobbleTracks", "BONOB_SCROBBLE_TRACKS", true, config => config.scrobbleTracks);
+  describeBooleanConfigValue(
-  describeBooleanConfigValue("reportNowPlaying", "BONOB_REPORT_NOW_PLAYING", true, config => config.reportNowPlaying);
+    "scrobbleTracks",
+    "BONOB_SCROBBLE_TRACKS",
+    true,
+    (config) => config.scrobbleTracks
+  );
+  describeBooleanConfigValue(
+    "reportNowPlaying",
+    "BONOB_REPORT_NOW_PLAYING",
+    true,
+    (config) => config.reportNowPlaying
+  );
 });

tests/scenarios.test.ts

@@ -21,6 +21,7 @@ import { Credentials } from "../src/music_service";
 import makeServer from "../src/server";
 import { Service, bonobService, SONOS_DISABLED } from "../src/sonos";
 import supersoap from "./supersoap";
+import url, { URLBuilder } from "../src/url_builder";
 
 class LoggedInSonosDriver {
   client: Client;
@@ -41,9 +42,10 @@ class LoggedInSonosDriver {
     let next = path.shift();
     while (next) {
       if (next != "root") {
-        const childIds = this.currentMetadata!.getMetadataResult.mediaCollection!.map(
+        const childIds =
-          (it) => it.id
+          this.currentMetadata!.getMetadataResult.mediaCollection!.map(
-        );
+            (it) => it.id
+          );
         if (!childIds.includes(next)) {
           throw `Expected to find a child element with id=${next} in order to browse, but found only ${childIds}`;
         }
@@ -74,31 +76,50 @@ class LoggedInSonosDriver {
 
 class SonosDriver {
   server: Express;
-  rootUrl: string;
+  bonobUrl: URLBuilder;
   service: Service;
 
-  constructor(server: Express, rootUrl: string, service: Service) {
+  constructor(server: Express, bonobUrl: URLBuilder, service: Service) {
     this.server = server;
-    this.rootUrl = rootUrl;
+    this.bonobUrl = bonobUrl;
     this.service = service;
   }
 
-  stripServiceRoot = (url: string) => url.replace(this.rootUrl, "");
+  extractPathname = (url: string) => new URL(url).pathname;
+
+  async register() {
+    const action = await request(this.server)
+      .get(this.bonobUrl.append({ pathname: "/" }).pathname())
+      .expect(200)
+      .then((response) => {
+        const m = response.text.match(/ action="(.*)" /i);
+        return m![1]!;
+      });
+
+    return request(this.server)
+      .post(action)
+      .type("form")
+      .send({})
+      .expect(200)
+      .then((response) =>
+        expect(response.text).toContain("Successfully registered")
+      );
+  }
 
   async addService() {
     expect(this.service.authType).toEqual("AppLink");
 
     await request(this.server)
-      .get(this.stripServiceRoot(this.service.strings!.uri!))
+      .get(this.extractPathname(this.service.strings!.uri!))
       .expect(200);
 
     await request(this.server)
-      .get(this.stripServiceRoot(this.service.presentation!.uri!))
+      .get(this.extractPathname(this.service.presentation!.uri!))
       .expect(200);
 
     const client = await createClientAsync(`${this.service.uri}?wsdl`, {
       endpoint: this.service.uri,
-      httpClient: supersoap(this.server, this.rootUrl),
+      httpClient: supersoap(this.server),
     });
 
     return client
@@ -109,12 +130,18 @@ class SonosDriver {
       )
       .then(({ regUrl, linkCode }: { regUrl: string; linkCode: string }) => ({
         login: async ({ username, password }: Credentials) => {
-          await request(this.server)
+          const action = await request(this.server)
-            .get(this.stripServiceRoot(regUrl))
+            .get(this.extractPathname(regUrl))
-            .expect(200);
+            .expect(200)
+            .then((response) => {
+              const m = response.text.match(/ action="(.*)" /i);
+              return m![1]!;
+            });
+
+          console.log(`posting to action ${action}`);
 
           return request(this.server)
-            .post(this.stripServiceRoot(regUrl))
+            .post(action)
             .type("form")
             .send({ username, password, linkCode })
             .then((response) => ({
@@ -140,92 +167,137 @@ class SonosDriver {
 }
 
 describe("scenarios", () => {
-  const bonobUrl = "http://localhost:1234";
-  const bonob = bonobService("bonob", 123, bonobUrl);
   const musicService = new InMemoryMusicService().hasArtists(
     BOB_MARLEY,
     BLONDIE
   );
   const linkCodes = new InMemoryLinkCodes();
-  const server = makeServer(
-    SONOS_DISABLED,
-    bonob,
-    bonobUrl,
-    musicService,
-    linkCodes
-  );
-
-  const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
 
   beforeEach(() => {
     musicService.clear();
     linkCodes.clear();
   });
 
-  describe("adding the service", () => {
+  function itShouldBeAbleToAddTheService(sonosDriver: SonosDriver) {
-    describe("when the user doesnt exists within the music service", () => {
+    describe("registering bonob with the sonos device", () => {
-      const username = "invaliduser";
+      it("should complete successfully", async () => {
-      const password = "invalidpassword";
+        await sonosDriver.register();
-
-      it("should fail to sign up", async () => {
-        musicService.hasNoUsers();
-
-        await sonosDriver
-          .addService()
-          .then((it) => it.login({ username, password }))
-          .then((it) => it.expectFailure());
-
-        expect(linkCodes.count()).toEqual(1);
       });
     });
 
-    describe("when the user exists within the music service", () => {
+    describe("adding the service", () => {
-      const username = "validuser";
+      describe("when the user doesnt exists within the music service", () => {
-      const password = "validpassword";
+        const username = "invaliduser";
+        const password = "invalidpassword";
 
-      beforeEach(() => {
+        it("should fail to sign up", async () => {
-        musicService.hasUser({ username, password });
+          musicService.hasNoUsers();
-        musicService.hasArtists(BLONDIE, BOB_MARLEY, MADONNA);
+
+          await sonosDriver
+            .addService()
+            .then((it) => it.login({ username, password }))
+            .then((it) => it.expectFailure());
+
+          expect(linkCodes.count()).toEqual(1);
+        });
       });
 
-      it("should successfuly sign up", async () => {
+      describe("when the user exists within the music service", () => {
-        await sonosDriver
+        const username = "validuser";
-          .addService()
+        const password = "validpassword";
-          .then((it) => it.login({ username, password }))
-          .then((it) => it.expectSuccess());
 
-        expect(linkCodes.count()).toEqual(1);
+        beforeEach(() => {
-      });
+          musicService.hasUser({ username, password });
+          musicService.hasArtists(BLONDIE, BOB_MARLEY, MADONNA);
+        });
 
-      it("should be able to list the artists", async () => {
+        it("should successfuly sign up", async () => {
-        await sonosDriver
+          await sonosDriver
-          .addService()
+            .addService()
-          .then((it) => it.login({ username, password }))
+            .then((it) => it.login({ username, password }))
-          .then((it) => it.expectSuccess())
+            .then((it) => it.expectSuccess());
-          .then((it) => it.navigate("root", "artists"))
+
-          .then((it) =>
+          expect(linkCodes.count()).toEqual(1);
-            it.expectTitles(
+        });
-              [BLONDIE, BOB_MARLEY, MADONNA].map(
+
-                (it) => it.name
+        it("should be able to list the artists", async () => {
+          await sonosDriver
+            .addService()
+            .then((it) => it.login({ username, password }))
+            .then((it) => it.expectSuccess())
+            .then((it) => it.navigate("root", "artists"))
+            .then((it) =>
+              it.expectTitles(
+                [BLONDIE, BOB_MARLEY, MADONNA].map((it) => it.name)
               )
-            )
+            );
-          );
+        });
-      });
 
-      it("should be able to list the albums", async () => {
+        it("should be able to list the albums", async () => {
-        await sonosDriver
+          await sonosDriver
-          .addService()
+            .addService()
-          .then((it) => it.login({ username, password }))
+            .then((it) => it.login({ username, password }))
-          .then((it) => it.expectSuccess())
+            .then((it) => it.expectSuccess())
-          .then((it) => it.navigate("root", "albums"))
+            .then((it) => it.navigate("root", "albums"))
-          .then((it) =>
+            .then((it) =>
-            it.expectTitles(
+              it.expectTitles(
-              [...BLONDIE.albums, ...BOB_MARLEY.albums, ...MADONNA.albums].map(
+                [
-                (it) => it.name
+                  ...BLONDIE.albums,
+                  ...BOB_MARLEY.albums,
+                  ...MADONNA.albums,
+                ].map((it) => it.name)
               )
-            )
+            );
-          );
+        });
       });
     });
+  }
+
+  describe("when the bonobUrl has no context path and no trailing slash", () => {
+    const bonobUrl = url("http://localhost:1234");
+    const bonob = bonobService("bonob", 123, bonobUrl);
+    const server = makeServer(
+      SONOS_DISABLED,
+      bonob,
+      bonobUrl,
+      musicService,
+      linkCodes
+    );
+
+    const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
+
+    itShouldBeAbleToAddTheService(sonosDriver);
+  });
+
+  describe("when the bonobUrl has no context path, but does have a trailing slash", () => {
+    const bonobUrl = url("http://localhost:1234/");
+    const bonob = bonobService("bonob", 123, bonobUrl);
+    const server = makeServer(
+      SONOS_DISABLED,
+      bonob,
+      bonobUrl,
+      musicService,
+      linkCodes
+    );
+
+    const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
+
+    itShouldBeAbleToAddTheService(sonosDriver);
+  });
+
+  describe("when the bonobUrl has a context path", () => {
+    const bonobUrl = url("http://localhost:1234/context-for-bonob");
+    const bonob = bonobService("bonob", 123, bonobUrl);
+    const server = makeServer(
+      SONOS_DISABLED,
+      bonob,
+      bonobUrl,
+      musicService,
+      linkCodes
+    );
+
+    const sonosDriver = new SonosDriver(server, bonobUrl, bonob);
+
+    itShouldBeAbleToAddTheService(sonosDriver);
   });
 });

tests/sonos.test.ts

@@ -25,6 +25,7 @@ import sonos, {
 } from "../src/sonos";
 
 import { aSonosDevice, aService } from "./builders";
+import url from "../src/url_builder";
 
 const mockSonosManagerConstructor = <jest.Mock<SonosManager>>SonosManager;
 
@@ -107,10 +108,10 @@ describe("sonos", () => {
   });
 
   describe("bonobService", () => {
-    describe("when the bonob root does not have a trailing /", () => {
+    describe("when the bonob url does not have a trailing /", () => {
       it("should return a valid bonob service", () => {
         expect(
-          bonobService("some-bonob", 876, "http://bonob.example.com")
+          bonobService("some-bonob", 876, url("http://bonob.example.com"))
         ).toEqual({
           name: "some-bonob",
           sid: 876,
@@ -130,10 +131,10 @@ describe("sonos", () => {
       });
     });
 
-    describe("when the bonob root does have a trailing /", () => {
+    describe("when the bonob url does have a trailing /", () => {
       it("should return a valid bonob service", () => {
         expect(
-          bonobService("some-bonob", 876, "http://bonob.example.com/")
+          bonobService("some-bonob", 876, url("http://bonob.example.com/"))
         ).toEqual({
           name: "some-bonob",
           sid: 876,
@@ -153,10 +154,33 @@ describe("sonos", () => {
       });
     });
 
+    describe("when the bonob url has a context of /some-context", () => {
+      it("should return a valid bonob service", () => {
+        expect(
+          bonobService("some-bonob", 876, url("http://bonob.example.com/some-context"))
+        ).toEqual({
+          name: "some-bonob",
+          sid: 876,
+          uri: `http://bonob.example.com/some-context/ws/sonos`,
+          secureUri: `http://bonob.example.com/some-context/ws/sonos`,
+          strings: {
+            uri: `http://bonob.example.com/some-context/sonos/strings.xml`,
+            version: PRESENTATION_AND_STRINGS_VERSION,
+          },
+          presentation: {
+            uri: `http://bonob.example.com/some-context/sonos/presentationMap.xml`,
+            version: PRESENTATION_AND_STRINGS_VERSION,
+          },
+          pollInterval: 1200,
+          authType: "AppLink",
+        });
+      });
+    });
+
     describe("when authType is specified", () => {
       it("should return a valid bonob service", () => {
         expect(
-          bonobService("some-bonob", 876, "http://bonob.example.com", 'DeviceLink')
+          bonobService("some-bonob", 876, url("http://bonob.example.com"), 'DeviceLink')
         ).toEqual({
           name: "some-bonob",
           sid: 876,
@@ -242,7 +266,7 @@ describe("sonos", () => {
       expect(disabled).toEqual(SONOS_DISABLED);
       expect(await disabled.devices()).toEqual([]);
       expect(await disabled.services()).toEqual([]);
-      expect(await disabled.register(aService())).toEqual(false);
+      expect(await disabled.register(aService())).toEqual(true);
     });
   });
 

tests/supersoap.ts

@@ -1,7 +1,7 @@
 import { Express } from "express";
 import request from "supertest";
 
-function supersoap(server: Express, rootUrl: string) {
+function supersoap(server: Express) {
   return {
     request: (
       rurl: string,
@@ -9,7 +9,8 @@ function supersoap(server: Express, rootUrl: string) {
       callback: (error: any, res?: any, body?: any) => any,
       exheaders?: any
     ) => {
-      const withoutHost = rurl.replace(rootUrl, "");
+      const url = new URL(rurl);
+      const withoutHost = `${url.pathname}${url.search}`;
       const req =
         data == null
           ? request(server).get(withoutHost).send()

tests/url_builder.test.ts

@@ -0,0 +1,212 @@
+import url from "../src/url_builder";
+
+describe("URLBuilder", () => {
+  describe("construction", () => {
+    it("with a string", () => {
+      expect(url("http://example.com/").href()).toEqual("http://example.com/");
+      expect(url("http://example.com/foobar?name=bob").href()).toEqual(
+        "http://example.com/foobar?name=bob"
+      );
+    });
+
+    it("with a URL", () => {
+      expect(url(new URL("http://example.com/")).href()).toEqual(
+        "http://example.com/"
+      );
+      expect(url(new URL("http://example.com/foobar?name=bob")).href()).toEqual(
+        "http://example.com/foobar?name=bob"
+      );
+    });
+  });
+
+  describe("toString", () => {
+    it("should print the href", () => {
+      expect(`${url("http://example.com/")}`).toEqual("http://example.com/");
+      expect(`${url("http://example.com/foobar?name=bob")}`).toEqual(
+        "http://example.com/foobar?name=bob"
+      );
+    });
+  });
+
+  describe("path", () => {
+    it("should be the pathname and search", () => {
+      expect(url("http://example.com/").path()).toEqual("/");
+      expect(url("http://example.com/?whoop=ie").path()).toEqual("/?whoop=ie");
+      expect(url("http://example.com/foo/bar").path()).toEqual("/foo/bar");
+      expect(url("http://example.com/with/search?q=bob&s=100").path()).toEqual("/with/search?q=bob&s=100");
+      expect(url("http://example.com/drops/hash#1234").path()).toEqual("/drops/hash");
+    });
+  });
+
+  describe("updating the pathname", () => {
+    describe("appending", () => {
+      describe("when there is no existing pathname", ()=>{
+        it("should return a new URLBuilder with the new pathname appended to the existing pathname", () => {
+          const original = url("https://example.com?a=b");
+          const updated = original.append({ pathname: "/the-appended-path" });
+    
+          expect(original.href()).toEqual("https://example.com/?a=b");
+          expect(original.pathname()).toEqual("/")
+    
+          expect(updated.href()).toEqual("https://example.com/the-appended-path?a=b");
+          expect(updated.pathname()).toEqual("/the-appended-path")
+        });
+      });
+
+      describe("when the existing pathname is /", ()=>{
+        it("should return a new URLBuilder with the new pathname appended to the existing pathname", () => {
+          const original = url("https://example.com/");
+          const updated = original.append({ pathname: "/the-appended-path" });
+    
+          expect(original.href()).toEqual("https://example.com/");
+          expect(original.pathname()).toEqual("/")
+    
+          expect(updated.href()).toEqual("https://example.com/the-appended-path");
+          expect(updated.pathname()).toEqual("/the-appended-path")
+        });
+      });
+
+      describe("when the existing pathname is /first-path", ()=>{
+        it("should return a new URLBuilder with the new pathname appended to the existing pathname", () => {
+          const original = url("https://example.com/first-path");
+          const updated = original.append({ pathname: "/the-appended-path" });
+    
+          expect(original.href()).toEqual("https://example.com/first-path");
+          expect(original.pathname()).toEqual("/first-path")
+    
+          expect(updated.href()).toEqual("https://example.com/first-path/the-appended-path");
+          expect(updated.pathname()).toEqual("/first-path/the-appended-path")
+        });
+      });
+
+      describe("when the existing pathname is /first-path/", ()=>{
+        it("should return a new URLBuilder with the new pathname appended to the existing pathname", () => {
+          const original = url("https://example.com/first-path/");
+          const updated = original.append({ pathname: "/the-appended-path" });
+    
+          expect(original.href()).toEqual("https://example.com/first-path/");
+          expect(original.pathname()).toEqual("/first-path/")
+    
+          expect(updated.href()).toEqual("https://example.com/first-path/the-appended-path");
+          expect(updated.pathname()).toEqual("/first-path/the-appended-path")
+        });
+      });
+
+      it("should return a new URLBuilder with the new pathname appended to the existing pathname", () => {
+        const original = url("https://example.com/some-path?a=b");
+        const updated = original.append({ pathname: "/some-new-path" });
+  
+        expect(original.href()).toEqual("https://example.com/some-path?a=b");
+        expect(original.pathname()).toEqual("/some-path")
+  
+        expect(updated.href()).toEqual("https://example.com/some-path/some-new-path?a=b");
+        expect(updated.pathname()).toEqual("/some-path/some-new-path")
+      });
+    });
+
+    describe("replacing", () => {
+      it("should return a new URLBuilder with the new pathname", () => {
+        const original = url("https://example.com/some-path?a=b");
+        const updated = original.with({ pathname: "/some-new-path" });
+  
+        expect(original.href()).toEqual("https://example.com/some-path?a=b");
+        expect(original.pathname()).toEqual("/some-path")
+  
+        expect(updated.href()).toEqual("https://example.com/some-new-path?a=b");
+        expect(updated.pathname()).toEqual("/some-new-path")
+      });
+    });
+  });
+
+  describe("updating search params", () => {
+    describe("appending", () => {
+      describe("with records", () => {
+        it("should return a new URLBuilder with the new search params appended", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.append({
+            searchParams: { x: "y", z: "1" },
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path?a=b&c=d&x=y&z=1");
+          expect(`${updated.searchParams()}`).toEqual("a=b&c=d&x=y&z=1")
+        });
+      });
+
+      describe("with URLSearchParams", () => {
+        it("should return a new URLBuilder with the new search params appended", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.append({
+            searchParams: new URLSearchParams({ x: "y", z: "1" }),
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path?a=b&c=d&x=y&z=1");
+          expect(`${updated.searchParams()}`).toEqual("a=b&c=d&x=y&z=1")
+        });
+      });
+    });
+
+    describe("replacing", () => {
+      describe("with records", () => {
+        it("should be able to remove all search params", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.with({
+            searchParams: {},
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path");
+          expect(`${updated.searchParams()}`).toEqual("")
+        });
+    
+        it("should return a new URLBuilder with the new search params", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.with({
+            searchParams: { x: "y", z: "1" },
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1");
+          expect(`${updated.searchParams()}`).toEqual("x=y&z=1")
+        });
+      });
+
+      describe("with URLSearchParams", () => {
+        it("should be able to remove all search params", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.with({
+            searchParams: new URLSearchParams({}),
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path");
+          expect(`${updated.searchParams()}`).toEqual("")
+        });
+    
+        it("should return a new URLBuilder with the new search params", () => {
+          const original = url("https://example.com/some-path?a=b&c=d");
+          const updated = original.with({
+            searchParams: new URLSearchParams({ x: "y", z: "1" }),
+          });
+    
+          expect(original.href()).toEqual("https://example.com/some-path?a=b&c=d");
+          expect(`${original.searchParams()}`).toEqual("a=b&c=d")
+    
+          expect(updated.href()).toEqual("https://example.com/some-path?x=y&z=1");
+          expect(`${updated.searchParams()}`).toEqual("x=y&z=1")
+        });
+      });
+    });
+  });
+});

web/views/index.eta

@@ -10,7 +10,7 @@
   <% } else { %>
   <h3>No existing service registration</h3>
   <% } %>
-  <form action="/register" method="POST"><button>Re-register</button></form>
+  <form action="<%= it.registerRoute %>" method="POST"><button>Re-register</button></form>
   <h2>Devices</h2>
   <ul>
     <% it.devices.forEach(function(d){ %>