wkulhanek/bonob
1
0
Fork 0
mirror of https://github.com/wkulhanek/bonob.git synced 2025-12-21 17:33:29 +01:00
Code Issues 1 Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
simojenki
2021-07-23 18:11:32 +10:00
parent 8ed9bef7d8
commit 1153f8e318
16 changed files with 3700 additions and 3053 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@@ -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

17
src/app.ts
View File

@@ -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")
return Promise.resolve(false);
logger.info("Track Scrobbling not enabled");
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;

19
src/config.ts
View File

@@ -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 =
process.env["BONOB_WEB_ADDRESS"] || `http://${hostname()}:${port}`;
const bonobUrl =
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",
};
}

2
src/register.ts
View File

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

23
src/server.ts
View File

@@ -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;

100
src/smapi.ts
View File

@@ -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) {
this.webAddress = webAddress;
constructor(bonobUrl: URLBuilder, linkCodes: LinkCodes) {
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 = (
webAddress: string,
accessToken: string,
album: AlbumSummary
) =>
`${webAddress}/album/${album.id}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`;
export const defaultAlbumArtURI = (bonobUrl: URLBuilder, album: AlbumSummary) =>
bonobUrl.append({ pathname: `/album/${album.id}/art/size/180` });
export const defaultArtistArtURI = (
webAddress: string,
accessToken: string,
bonobUrl: URLBuilder,
artist: ArtistSummary
) =>
`${webAddress}/artist/${artist.id}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`;
) => bonobUrl.append({ pathname: `/artist/${artist.id}/art/size/180` });
export const album = (
webAddress: string,
accessToken: string,
album: AlbumSummary
) => ({
export const album = (bonobUrl: URLBuilder, 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 = (
webAddress: string,
accessToken: string,
track: Track
) => ({
export const track = (bonobUrl: URLBuilder, 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 = (
webAddress: string,
accessToken: string,
artist: ArtistSummary
) => ({
export const artist = (bonobUrl: URLBuilder, 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,
accessToken,
urlWithToken(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,

15
src/sonos.ts
View File

@@ -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}`,
secureUri: `${stripTailingSlash(bonobRoot)}${SOAP_PATH}`,
uri: bonobUrl.append({pathname: SOAP_PATH }).href(),
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 => ({

72
src/url_builder.ts Normal file
View File

@@ -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);
}

102
tests/config.test.ts
View File

@@ -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("reportNowPlaying", "BONOB_REPORT_NOW_PLAYING", true, config => config.reportNowPlaying);
describeBooleanConfigValue(
"scrobbleTracks",
"BONOB_SCROBBLE_TRACKS",
true,
(config) => config.scrobbleTracks
);
describeBooleanConfigValue(
"reportNowPlaying",
"BONOB_REPORT_NOW_PLAYING",
true,
(config) => config.reportNowPlaying
);
});

226
tests/scenarios.test.ts
View File

@@ -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(
(it) => it.id
);
const childIds =
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)
.get(this.stripServiceRoot(regUrl))
.expect(200);
const action = await request(this.server)
.get(this.extractPathname(regUrl))
.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", () => {
describe("when the user doesnt exists within the music service", () => {
const username = "invaliduser";
const password = "invalidpassword";
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);
function itShouldBeAbleToAddTheService(sonosDriver: SonosDriver) {
describe("registering bonob with the sonos device", () => {
it("should complete successfully", async () => {
await sonosDriver.register();
});
});
describe("when the user exists within the music service", () => {
const username = "validuser";
const password = "validpassword";
describe("adding the service", () => {
describe("when the user doesnt exists within the music service", () => {
const username = "invaliduser";
const password = "invalidpassword";
beforeEach(() => {
musicService.hasUser({ username, password });
musicService.hasArtists(BLONDIE, BOB_MARLEY, MADONNA);
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);
});
});
it("should successfuly sign up", async () => {
await sonosDriver
.addService()
.then((it) => it.login({ username, password }))
.then((it) => it.expectSuccess());
describe("when the user exists within the music service", () => {
const username = "validuser";
const password = "validpassword";
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 () => {
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 successfuly sign up", async () => {
await sonosDriver
.addService()
.then((it) => it.login({ username, password }))
.then((it) => it.expectSuccess());
expect(linkCodes.count()).toEqual(1);
});
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 () => {
await sonosDriver
.addService()
.then((it) => it.login({ username, password }))
.then((it) => it.expectSuccess())
.then((it) => it.navigate("root", "albums"))
.then((it) =>
it.expectTitles(
[...BLONDIE.albums, ...BOB_MARLEY.albums, ...MADONNA.albums].map(
(it) => it.name
it("should be able to list the albums", async () => {
await sonosDriver
.addService()
.then((it) => it.login({ username, password }))
.then((it) => it.expectSuccess())
.then((it) => it.navigate("root", "albums"))
.then((it) =>
it.expectTitles(
[
...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);
});
});

1506
tests/server.test.ts
View File

File diff suppressed because it is too large Load Diff

4402
tests/smapi.test.ts
View File

File diff suppressed because it is too large Load Diff

36
tests/sonos.test.ts
View File

@@ -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);
});
});

5
tests/supersoap.ts
View File

@@ -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()

212
tests/url_builder.test.ts Normal file
View File

@@ -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")
});
});
});
});
});

2
web/views/index.eta
View File

@@ -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){ %>