mirror of
https://github.com/wkulhanek/bonob.git
synced 2025-12-21 17:33:29 +01:00
601 lines
19 KiB
TypeScript
601 lines
19 KiB
TypeScript
import { v4 as uuid } from "uuid";
|
|
import dayjs from "dayjs";
|
|
import request from "supertest";
|
|
import { MusicService } from "../src/music_service";
|
|
import makeServer, { BONOB_ACCESS_TOKEN_HEADER } from "../src/server";
|
|
import { SONOS_DISABLED, Sonos, Device } from "../src/sonos";
|
|
|
|
import { aDevice, aService } from "./builders";
|
|
import { InMemoryMusicService } from "./in_memory_music_service";
|
|
import { ExpiringAccessTokens } from "../src/access_tokens";
|
|
import { InMemoryLinkCodes } from "../src/link_codes";
|
|
|
|
describe("server", () => {
|
|
beforeEach(() => {
|
|
jest.clearAllMocks();
|
|
jest.resetAllMocks();
|
|
});
|
|
|
|
describe("/", () => {
|
|
describe("when sonos integration is disabled", () => {
|
|
const server = makeServer(
|
|
SONOS_DISABLED,
|
|
aService(),
|
|
"http://localhost:1234",
|
|
new InMemoryMusicService()
|
|
);
|
|
|
|
describe("devices list", () => {
|
|
it("should be empty", async () => {
|
|
const res = await request(server).get("/").send();
|
|
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).not.toMatch(/class=device/);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("when there are 2 devices and bonob is not registered", () => {
|
|
const service1 = aService({
|
|
name: "s1",
|
|
sid: 1,
|
|
});
|
|
const service2 = aService({
|
|
name: "s2",
|
|
sid: 2,
|
|
});
|
|
const service3 = aService({
|
|
name: "s3",
|
|
sid: 3,
|
|
});
|
|
const service4 = aService({
|
|
name: "s4",
|
|
sid: 4,
|
|
});
|
|
const missingBonobService = aService({
|
|
name: "bonobMissing",
|
|
sid: 88,
|
|
});
|
|
|
|
const device1: Device = aDevice({
|
|
name: "device1",
|
|
ip: "172.0.0.1",
|
|
port: 4301,
|
|
});
|
|
|
|
const device2: Device = aDevice({
|
|
name: "device2",
|
|
ip: "172.0.0.2",
|
|
port: 4302,
|
|
});
|
|
|
|
const fakeSonos: Sonos = {
|
|
devices: () => Promise.resolve([device1, device2]),
|
|
services: () =>
|
|
Promise.resolve([service1, service2, service3, service4]),
|
|
register: () => Promise.resolve(false),
|
|
};
|
|
|
|
const server = makeServer(
|
|
fakeSonos,
|
|
missingBonobService,
|
|
"http://localhost:1234",
|
|
new InMemoryMusicService()
|
|
);
|
|
|
|
describe("devices list", () => {
|
|
it("should contain the devices returned from sonos", async () => {
|
|
const res = await request(server).get("/").send();
|
|
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).toMatch(/device1\s+\(172.0.0.1:4301\)/);
|
|
expect(res.text).toMatch(/device2\s+\(172.0.0.2:4302\)/);
|
|
});
|
|
});
|
|
|
|
describe("services", () => {
|
|
it("should contain a list of services returned from sonos", async () => {
|
|
const res = await request(server).get("/").send();
|
|
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).toMatch(/Services\s+4/);
|
|
expect(res.text).toMatch(/s1\s+\(1\)/);
|
|
expect(res.text).toMatch(/s2\s+\(2\)/);
|
|
expect(res.text).toMatch(/s3\s+\(3\)/);
|
|
expect(res.text).toMatch(/s4\s+\(4\)/);
|
|
});
|
|
});
|
|
|
|
describe("registration status", () => {
|
|
it("should be not-registered", async () => {
|
|
const res = await request(server).get("/").send();
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).toMatch(/No existing service registration/);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("when there are 2 devices and bonob is registered", () => {
|
|
const service1 = aService();
|
|
|
|
const service2 = aService();
|
|
|
|
const bonobService = aService({
|
|
name: "bonobNotMissing",
|
|
sid: 99,
|
|
});
|
|
|
|
const fakeSonos: Sonos = {
|
|
devices: () => Promise.resolve([]),
|
|
services: () => Promise.resolve([service1, service2, bonobService]),
|
|
register: () => Promise.resolve(false),
|
|
};
|
|
|
|
const server = makeServer(
|
|
fakeSonos,
|
|
bonobService,
|
|
"http://localhost:1234",
|
|
new InMemoryMusicService()
|
|
);
|
|
|
|
describe("registration status", () => {
|
|
it("should be registered", async () => {
|
|
const res = await request(server).get("/").send();
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).toMatch(/Existing service config/);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("/register", () => {
|
|
const sonos = {
|
|
register: jest.fn(),
|
|
};
|
|
const theService = aService({
|
|
name: "We can all live a life of service",
|
|
sid: 999,
|
|
});
|
|
const server = makeServer(
|
|
(sonos as unknown) as Sonos,
|
|
theService,
|
|
"http://localhost:1234",
|
|
new InMemoryMusicService()
|
|
);
|
|
|
|
describe("when is succesfull", () => {
|
|
it("should return a nice message", async () => {
|
|
sonos.register.mockResolvedValue(true);
|
|
|
|
const res = await request(server).post("/register").send();
|
|
|
|
expect(res.status).toEqual(200);
|
|
expect(res.text).toMatch("Successfully registered");
|
|
|
|
expect(sonos.register.mock.calls.length).toEqual(1);
|
|
expect(sonos.register.mock.calls[0][0]).toBe(theService);
|
|
});
|
|
});
|
|
|
|
describe("when is unsuccesfull", () => {
|
|
it("should return a failure message", async () => {
|
|
sonos.register.mockResolvedValue(false);
|
|
|
|
const res = await request(server).post("/register").send();
|
|
|
|
expect(res.status).toEqual(500);
|
|
expect(res.text).toMatch("Registration failed!");
|
|
|
|
expect(sonos.register.mock.calls.length).toEqual(1);
|
|
expect(sonos.register.mock.calls[0][0]).toBe(theService);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("/stream", () => {
|
|
const musicService = {
|
|
login: jest.fn(),
|
|
};
|
|
const musicLibrary = {
|
|
stream: jest.fn(),
|
|
};
|
|
let now = dayjs();
|
|
const accessTokens = new ExpiringAccessTokens({ now: () => now });
|
|
|
|
const server = makeServer(
|
|
(jest.fn() as unknown) as Sonos,
|
|
aService(),
|
|
"http://localhost:1234",
|
|
(musicService as unknown) as MusicService,
|
|
new InMemoryLinkCodes(),
|
|
accessTokens
|
|
);
|
|
|
|
const authToken = uuid();
|
|
const trackId = uuid();
|
|
let accessToken: string;
|
|
|
|
beforeEach(() => {
|
|
accessToken = accessTokens.mint(authToken);
|
|
});
|
|
|
|
describe("when there is no access-token", () => {
|
|
it("should return a 401", async () => {
|
|
const res = await request(server).get(`/stream/track/${trackId}`);
|
|
|
|
expect(res.status).toEqual(401);
|
|
});
|
|
});
|
|
|
|
describe("when the access-token has expired", () => {
|
|
it("should return a 401", async () => {
|
|
now = now.add(1, "day");
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(401);
|
|
});
|
|
});
|
|
|
|
describe("when sonos does not ask for a range", () => {
|
|
describe("when the music service does not return a content-range, content-length or accept-ranges", () => {
|
|
it("should return a 200 with the data, without adding the undefined headers", async () => {
|
|
const stream = {
|
|
status: 200,
|
|
headers: {
|
|
"content-type": "audio/mp3",
|
|
},
|
|
data: Buffer.from("some track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.headers["content-type"]).toEqual("audio/mp3")
|
|
expect(res.headers["content-length"]).toEqual(`${stream.data.length}`)
|
|
expect(Object.keys(res.headers)).not.toContain("content-range")
|
|
expect(Object.keys(res.headers)).not.toContain("accept-ranges")
|
|
});
|
|
});
|
|
|
|
describe("when the music service returns undefined values for content-range, content-length or accept-ranges", () => {
|
|
it("should return a 200 with the data, without adding the undefined headers", async () => {
|
|
const stream = {
|
|
status: 200,
|
|
headers: {
|
|
"content-type": "audio/mp3",
|
|
"content-length": undefined,
|
|
"accept-ranges": undefined,
|
|
"content-range": undefined,
|
|
},
|
|
data: Buffer.from("some track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.headers["content-type"]).toEqual("audio/mp3")
|
|
expect(res.headers["content-length"]).toEqual(`${stream.data.length}`)
|
|
expect(Object.keys(res.headers)).not.toContain("content-range")
|
|
expect(Object.keys(res.headers)).not.toContain("accept-ranges")
|
|
});
|
|
});
|
|
|
|
describe("when the music service returns a 200", () => {
|
|
it("should return a 200 with the data", async () => {
|
|
const stream = {
|
|
status: 200,
|
|
headers: {
|
|
"content-type": "audio/mp3",
|
|
"content-length": "222",
|
|
"accept-ranges": "bytes",
|
|
"content-range": "-100",
|
|
},
|
|
data: Buffer.from("some track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.header["content-type"]).toEqual(
|
|
stream.headers["content-type"]
|
|
);
|
|
expect(res.header["accept-ranges"]).toEqual(
|
|
stream.headers["accept-ranges"]
|
|
);
|
|
expect(res.header["content-range"]).toEqual(
|
|
stream.headers["content-range"]
|
|
);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
|
|
});
|
|
});
|
|
|
|
describe("when the music service returns a 206", () => {
|
|
it("should return a 206 with the data", async () => {
|
|
const stream = {
|
|
status: 206,
|
|
headers: {
|
|
"content-type": "audio/ogg",
|
|
"content-length": "333",
|
|
"accept-ranges": "bytez",
|
|
"content-range": "100-200",
|
|
},
|
|
data: Buffer.from("some other track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.header["content-type"]).toEqual(
|
|
stream.headers["content-type"]
|
|
);
|
|
expect(res.header["accept-ranges"]).toEqual(
|
|
stream.headers["accept-ranges"]
|
|
);
|
|
expect(res.header["content-range"]).toEqual(
|
|
stream.headers["content-range"]
|
|
);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("when sonos does ask for a range", () => {
|
|
describe("when the music service returns a 200", () => {
|
|
it("should return a 200 with the data", async () => {
|
|
const stream = {
|
|
status: 200,
|
|
headers: {
|
|
"content-type": "audio/mp3",
|
|
"content-length": "222",
|
|
"accept-ranges": "bytes",
|
|
"content-range": "-100",
|
|
},
|
|
data: Buffer.from("some track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken)
|
|
.set("Range", "3000-4000");
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.header["content-type"]).toEqual(
|
|
stream.headers["content-type"]
|
|
);
|
|
expect(res.header["accept-ranges"]).toEqual(
|
|
stream.headers["accept-ranges"]
|
|
);
|
|
expect(res.header["content-range"]).toEqual(
|
|
stream.headers["content-range"]
|
|
);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.stream).toHaveBeenCalledWith({
|
|
trackId,
|
|
range: "3000-4000",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("when the music service returns a 206", () => {
|
|
it("should return a 206 with the data", async () => {
|
|
const stream = {
|
|
status: 206,
|
|
headers: {
|
|
"content-type": "audio/ogg",
|
|
"content-length": "333",
|
|
"accept-ranges": "bytez",
|
|
"content-range": "100-200",
|
|
},
|
|
data: Buffer.from("some other track", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.stream.mockResolvedValue(stream);
|
|
|
|
const res = await request(server)
|
|
.get(`/stream/track/${trackId}`)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken)
|
|
.set("Range", "4000-5000");
|
|
|
|
expect(res.status).toEqual(stream.status);
|
|
expect(res.header["content-type"]).toEqual(
|
|
stream.headers["content-type"]
|
|
);
|
|
expect(res.header["accept-ranges"]).toEqual(
|
|
stream.headers["accept-ranges"]
|
|
);
|
|
expect(res.header["content-range"]).toEqual(
|
|
stream.headers["content-range"]
|
|
);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.stream).toHaveBeenCalledWith({
|
|
trackId,
|
|
range: "4000-5000",
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("art", () => {
|
|
const musicService = {
|
|
login: jest.fn(),
|
|
};
|
|
const musicLibrary = {
|
|
coverArt: jest.fn(),
|
|
};
|
|
let now = dayjs();
|
|
const accessTokens = new ExpiringAccessTokens({ now: () => now });
|
|
|
|
const server = makeServer(
|
|
(jest.fn() as unknown) as Sonos,
|
|
aService(),
|
|
"http://localhost:1234",
|
|
(musicService as unknown) as MusicService,
|
|
new InMemoryLinkCodes(),
|
|
accessTokens
|
|
);
|
|
|
|
const authToken = uuid();
|
|
const albumId = uuid();
|
|
let accessToken: string;
|
|
|
|
beforeEach(() => {
|
|
accessToken = accessTokens.mint(authToken);
|
|
});
|
|
|
|
describe("when there is no access-token", () => {
|
|
it("should return a 401", async () => {
|
|
const res = await request(server).get(`/album/123/art/size/180`);
|
|
|
|
expect(res.status).toEqual(401);
|
|
});
|
|
});
|
|
|
|
describe("when the access-token has expired", () => {
|
|
it("should return a 401", async () => {
|
|
now = now.add(1, "day");
|
|
|
|
const res = await request(server).get(
|
|
`/album/123/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
);
|
|
|
|
expect(res.status).toEqual(401);
|
|
});
|
|
});
|
|
|
|
describe("when there is a valid access token", () => {
|
|
describe("some invalid art type", () => {
|
|
it("should return the image and a 200", async () => {
|
|
const res = await request(server)
|
|
.get(
|
|
`/foo/${albumId}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(400);
|
|
});
|
|
});
|
|
|
|
describe("artist art", () => {
|
|
describe("when there is some", () => {
|
|
it("should return the image and a 200", async () => {
|
|
const coverArt = {
|
|
status: 200,
|
|
contentType: "image/jpeg",
|
|
data: Buffer.from("some image", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
|
|
musicLibrary.coverArt.mockResolvedValue(coverArt);
|
|
|
|
const res = await request(server)
|
|
.get(
|
|
`/artist/${albumId}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(coverArt.status);
|
|
expect(res.header["content-type"]).toEqual(coverArt.contentType);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.coverArt).toHaveBeenCalledWith(albumId, "artist", 180);
|
|
});
|
|
});
|
|
|
|
describe("when there isn't one", () => {
|
|
it("should return a 404", async () => {
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
|
|
musicLibrary.coverArt.mockResolvedValue(undefined);
|
|
|
|
const res = await request(server)
|
|
.get(
|
|
`/artist/${albumId}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(404);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("album art", () => {
|
|
describe("when there is some", () => {
|
|
it("should return the image and a 200", async () => {
|
|
const coverArt = {
|
|
status: 200,
|
|
contentType: "image/jpeg",
|
|
data: Buffer.from("some image", "ascii"),
|
|
};
|
|
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.coverArt.mockResolvedValue(coverArt);
|
|
|
|
const res = await request(server)
|
|
.get(
|
|
`/album/${albumId}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(coverArt.status);
|
|
expect(res.header["content-type"]).toEqual(coverArt.contentType);
|
|
|
|
expect(musicService.login).toHaveBeenCalledWith(authToken);
|
|
expect(musicLibrary.coverArt).toHaveBeenCalledWith(albumId, "album", 180);
|
|
});
|
|
});
|
|
|
|
describe("when there isnt any", () => {
|
|
it("should return a 404", async () => {
|
|
musicService.login.mockResolvedValue(musicLibrary);
|
|
musicLibrary.coverArt.mockResolvedValue(undefined);
|
|
|
|
const res = await request(server)
|
|
.get(
|
|
`/album/${albumId}/art/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${accessToken}`
|
|
)
|
|
.set(BONOB_ACCESS_TOKEN_HEADER, accessToken);
|
|
|
|
expect(res.status).toEqual(404);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
});
|