mirror of
https://github.com/advplyr/audiobookshelf.git
synced 2026-07-07 09:51:37 +00:00
585 lines
18 KiB
JavaScript
585 lines
18 KiB
JavaScript
const { expect } = require('chai')
|
|
const { Sequelize } = require('sequelize')
|
|
const sinon = require('sinon')
|
|
|
|
const Database = require('../../../server/Database')
|
|
const PlaylistController = require('../../../server/controllers/PlaylistController')
|
|
const Logger = require('../../../server/Logger')
|
|
const SocketAuthority = require('../../../server/SocketAuthority')
|
|
|
|
describe('PlaylistController - Series Entries', () => {
|
|
let user1, library, library2, series1, series2, book1, book2, libraryItem1, libraryItem2
|
|
|
|
beforeEach(async () => {
|
|
global.ServerSettings = {}
|
|
Database.sequelize = new Sequelize({ dialect: 'sqlite', storage: ':memory:', logging: false })
|
|
Database.sequelize.uppercaseFirst = (str) => (str ? `${str[0].toUpperCase()}${str.substr(1)}` : '')
|
|
await Database.buildModels()
|
|
|
|
sinon.stub(Logger, 'info')
|
|
sinon.stub(Logger, 'error')
|
|
sinon.stub(Logger, 'warn')
|
|
sinon.stub(Logger, 'debug')
|
|
sinon.stub(SocketAuthority, 'clientEmitter')
|
|
|
|
// Create test data
|
|
library = await Database.libraryModel.create({ name: 'Test Library', mediaType: 'book' })
|
|
library2 = await Database.libraryModel.create({ name: 'Other Library', mediaType: 'book' })
|
|
|
|
user1 = await Database.userModel.create({
|
|
username: 'user1',
|
|
pash: 'hashed_password_1',
|
|
type: 'user',
|
|
isActive: true
|
|
})
|
|
user1.mediaProgresses = []
|
|
|
|
series1 = await Database.seriesModel.create({
|
|
name: 'The Expanse',
|
|
nameIgnorePrefix: 'Expanse',
|
|
libraryId: library.id
|
|
})
|
|
|
|
series2 = await Database.seriesModel.create({
|
|
name: 'Foundation',
|
|
nameIgnorePrefix: 'Foundation',
|
|
libraryId: library.id
|
|
})
|
|
|
|
book1 = await Database.bookModel.create({
|
|
title: 'Book One',
|
|
authorName: 'Author 1',
|
|
audioFiles: [],
|
|
chapters: [],
|
|
tags: [],
|
|
narrators: [],
|
|
genres: []
|
|
})
|
|
|
|
libraryItem1 = await Database.libraryItemModel.create({
|
|
path: '/books/book1',
|
|
relPath: 'book1',
|
|
mediaId: book1.id,
|
|
mediaType: 'book',
|
|
libraryId: library.id,
|
|
libraryFiles: []
|
|
})
|
|
|
|
book2 = await Database.bookModel.create({
|
|
title: 'Book Two',
|
|
authorName: 'Author 2',
|
|
audioFiles: [],
|
|
chapters: [],
|
|
tags: [],
|
|
narrators: [],
|
|
genres: []
|
|
})
|
|
|
|
libraryItem2 = await Database.libraryItemModel.create({
|
|
path: '/books/book2',
|
|
relPath: 'book2',
|
|
mediaId: book2.id,
|
|
mediaType: 'book',
|
|
libraryId: library.id,
|
|
libraryFiles: []
|
|
})
|
|
})
|
|
|
|
afterEach(async () => {
|
|
sinon.restore()
|
|
await Database.sequelize.sync({ force: true })
|
|
})
|
|
|
|
function makeFakeRes() {
|
|
return {
|
|
sendStatus: sinon.spy(),
|
|
status: sinon.stub().returnsThis(),
|
|
send: sinon.spy(),
|
|
json: sinon.spy()
|
|
}
|
|
}
|
|
|
|
describe('create', () => {
|
|
it('should create playlist with items and seriesIds', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'My Playlist',
|
|
items: [{ libraryItemId: libraryItem1.id }],
|
|
seriesIds: [series1.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
// items should only contain book entries
|
|
expect(response.items).to.have.length(1)
|
|
expect(response.items[0].libraryItemId).to.equal(libraryItem1.id)
|
|
|
|
// entries should contain both book and series
|
|
expect(response.entries).to.have.length(2)
|
|
expect(response.entries[0].type).to.equal('libraryItem')
|
|
expect(response.entries[0].libraryItemId).to.equal(libraryItem1.id)
|
|
expect(response.entries[0].order).to.equal(1)
|
|
expect(response.entries[1].type).to.equal('series')
|
|
expect(response.entries[1].seriesId).to.equal(series1.id)
|
|
expect(response.entries[1].seriesName).to.equal('The Expanse')
|
|
expect(response.entries[1].order).to.equal(2)
|
|
|
|
// Socket event
|
|
expect(SocketAuthority.clientEmitter.calledOnce).to.be.true
|
|
const [userId, event] = SocketAuthority.clientEmitter.firstCall.args
|
|
expect(userId).to.equal(user1.id)
|
|
expect(event).to.equal('playlist_added')
|
|
})
|
|
|
|
it('should create playlist with only seriesIds (no items)', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'Series Only Playlist',
|
|
seriesIds: [series1.id, series2.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
// items should be empty (no book/episode entries)
|
|
expect(response.items).to.have.length(0)
|
|
|
|
// entries should contain both series
|
|
expect(response.entries).to.have.length(2)
|
|
expect(response.entries[0].type).to.equal('series')
|
|
expect(response.entries[0].seriesId).to.equal(series1.id)
|
|
expect(response.entries[1].type).to.equal('series')
|
|
expect(response.entries[1].seriesId).to.equal(series2.id)
|
|
})
|
|
|
|
it('should reject seriesIds for podcast playlists', async () => {
|
|
const podcast = await Database.podcastModel.create({ title: 'Test Podcast' })
|
|
const podcastLI = await Database.libraryItemModel.create({
|
|
path: '/podcasts/p1',
|
|
relPath: 'p1',
|
|
mediaId: podcast.id,
|
|
mediaType: 'podcast',
|
|
libraryId: library.id
|
|
})
|
|
const episode = await Database.podcastEpisodeModel.create({
|
|
title: 'Episode 1',
|
|
podcastId: podcast.id
|
|
})
|
|
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'Podcast Playlist',
|
|
items: [{ libraryItemId: podcastLI.id, episodeId: episode.id }],
|
|
seriesIds: [series1.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.status.calledWith(400)).to.be.true
|
|
expect(fakeRes.send.calledWith('Series entries are not valid for podcast playlists')).to.be.true
|
|
})
|
|
|
|
it('should reject invalid seriesId', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'Bad Playlist',
|
|
seriesIds: ['00000000-0000-0000-0000-000000000000']
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.status.calledWith(400)).to.be.true
|
|
expect(fakeRes.send.calledWith('Invalid playlist data. Invalid series')).to.be.true
|
|
})
|
|
|
|
it('should reject seriesId from different library', async () => {
|
|
const otherSeries = await Database.seriesModel.create({
|
|
name: 'Other Series',
|
|
nameIgnorePrefix: 'Other Series',
|
|
libraryId: library2.id
|
|
})
|
|
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'Cross Library',
|
|
seriesIds: [otherSeries.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.status.calledWith(400)).to.be.true
|
|
})
|
|
|
|
it('should reject playlist with no items and no seriesIds', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
body: {
|
|
libraryId: library.id,
|
|
name: 'Empty Playlist'
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.create(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.status.calledWith(400)).to.be.true
|
|
})
|
|
})
|
|
|
|
describe('addBatch', () => {
|
|
let playlist
|
|
|
|
beforeEach(async () => {
|
|
// Create a playlist with one book
|
|
playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Test Playlist'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book1.id,
|
|
mediaItemType: 'book',
|
|
order: 1
|
|
})
|
|
})
|
|
|
|
it('should add series to existing playlist', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
body: {
|
|
seriesIds: [series1.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.addBatch(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
expect(response.entries).to.have.length(2)
|
|
expect(response.entries[0].type).to.equal('libraryItem')
|
|
expect(response.entries[0].order).to.equal(1)
|
|
expect(response.entries[1].type).to.equal('series')
|
|
expect(response.entries[1].seriesId).to.equal(series1.id)
|
|
expect(response.entries[1].order).to.equal(2)
|
|
})
|
|
|
|
it('should skip duplicate series', async () => {
|
|
// Add series first
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 2
|
|
})
|
|
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
body: {
|
|
seriesIds: [series1.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.addBatch(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
// Should still have only 2 entries (no duplicate)
|
|
expect(response.entries).to.have.length(2)
|
|
expect(SocketAuthority.clientEmitter.called).to.be.false
|
|
})
|
|
|
|
it('should add only series (no items in request)', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
body: {
|
|
seriesIds: [series1.id, series2.id]
|
|
}
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.addBatch(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
expect(response.entries).to.have.length(3)
|
|
expect(response.entries[1].type).to.equal('series')
|
|
expect(response.entries[2].type).to.equal('series')
|
|
})
|
|
})
|
|
|
|
describe('removeSeries', () => {
|
|
let playlist
|
|
|
|
beforeEach(async () => {
|
|
playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Test Playlist'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book1.id,
|
|
mediaItemType: 'book',
|
|
order: 1
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 2
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book2.id,
|
|
mediaItemType: 'book',
|
|
order: 3
|
|
})
|
|
})
|
|
|
|
it('should remove series and re-compact orders', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
params: { id: playlist.id, seriesId: series1.id }
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.removeSeries(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
// Should have 2 entries left (both books)
|
|
expect(response.entries).to.have.length(2)
|
|
expect(response.entries[0].order).to.equal(1)
|
|
expect(response.entries[1].order).to.equal(2)
|
|
|
|
// items should still have both books
|
|
expect(response.items).to.have.length(2)
|
|
|
|
expect(SocketAuthority.clientEmitter.calledOnce).to.be.true
|
|
expect(SocketAuthority.clientEmitter.firstCall.args[1]).to.equal('playlist_updated')
|
|
})
|
|
|
|
it('should return 200 for non-existent series (idempotent)', async () => {
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
params: { id: playlist.id, seriesId: '00000000-0000-0000-0000-000000000000' }
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.removeSeries(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
// All 3 entries should remain
|
|
expect(response.entries).to.have.length(3)
|
|
})
|
|
|
|
it('should delete playlist when last entry is removed', async () => {
|
|
// Create a playlist with only one series entry
|
|
const soloPlaylist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Solo Series Playlist'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: soloPlaylist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 1
|
|
})
|
|
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist: soloPlaylist,
|
|
params: { id: soloPlaylist.id, seriesId: series1.id }
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.removeSeries(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
expect(SocketAuthority.clientEmitter.calledOnce).to.be.true
|
|
expect(SocketAuthority.clientEmitter.firstCall.args[1]).to.equal('playlist_removed')
|
|
|
|
// Playlist should be deleted from DB
|
|
const deletedPlaylist = await Database.playlistModel.findByPk(soloPlaylist.id)
|
|
expect(deletedPlaylist).to.be.null
|
|
})
|
|
})
|
|
|
|
describe('findOne', () => {
|
|
it('should include entries in response', async () => {
|
|
const playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Test Playlist'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book1.id,
|
|
mediaItemType: 'book',
|
|
order: 1
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 2
|
|
})
|
|
|
|
const fakeReq = {
|
|
user: user1,
|
|
playlist,
|
|
params: { id: playlist.id }
|
|
}
|
|
const fakeRes = makeFakeRes()
|
|
|
|
await PlaylistController.findOne(fakeReq, fakeRes)
|
|
|
|
expect(fakeRes.json.calledOnce).to.be.true
|
|
const response = fakeRes.json.firstCall.args[0]
|
|
|
|
expect(response.entries).to.be.an('array')
|
|
expect(response.entries).to.have.length(2)
|
|
expect(response.items).to.be.an('array')
|
|
expect(response.items).to.have.length(1)
|
|
})
|
|
})
|
|
|
|
describe('backward compatibility', () => {
|
|
it('items array should only contain book/episode entries', async () => {
|
|
const playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Mixed Playlist'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book1.id,
|
|
mediaItemType: 'book',
|
|
order: 1
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 2
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book2.id,
|
|
mediaItemType: 'book',
|
|
order: 3
|
|
})
|
|
|
|
playlist.playlistMediaItems = await playlist.getMediaItemsExpandedWithLibraryItem()
|
|
const json = playlist.toOldJSONExpanded()
|
|
|
|
// items should only have books, not series
|
|
expect(json.items).to.have.length(2)
|
|
json.items.forEach((item) => {
|
|
expect(item.libraryItemId).to.be.a('string')
|
|
})
|
|
|
|
// entries should have all three
|
|
expect(json.entries).to.have.length(3)
|
|
expect(json.entries.filter((e) => e.type === 'libraryItem')).to.have.length(2)
|
|
expect(json.entries.filter((e) => e.type === 'series')).to.have.length(1)
|
|
})
|
|
})
|
|
|
|
describe('removeSeriesFromPlaylists', () => {
|
|
it('should clean up playlist when series is removed', async () => {
|
|
const playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Cleanup Test'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: book1.id,
|
|
mediaItemType: 'book',
|
|
order: 1
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 2
|
|
})
|
|
|
|
await Database.playlistModel.removeSeriesFromPlaylists([series1.id])
|
|
|
|
// Verify series PMI was removed
|
|
const remainingPmis = await Database.playlistMediaItemModel.findAll({
|
|
where: { playlistId: playlist.id }
|
|
})
|
|
expect(remainingPmis).to.have.length(1)
|
|
expect(remainingPmis[0].mediaItemType).to.equal('book')
|
|
expect(remainingPmis[0].order).to.equal(1)
|
|
|
|
// Socket should emit update
|
|
expect(SocketAuthority.clientEmitter.calledOnce).to.be.true
|
|
expect(SocketAuthority.clientEmitter.firstCall.args[1]).to.equal('playlist_updated')
|
|
})
|
|
|
|
it('should delete playlist when series removal empties it', async () => {
|
|
const playlist = await Database.playlistModel.create({
|
|
libraryId: library.id,
|
|
userId: user1.id,
|
|
name: 'Series Only'
|
|
})
|
|
await Database.playlistMediaItemModel.create({
|
|
playlistId: playlist.id,
|
|
mediaItemId: series1.id,
|
|
mediaItemType: 'series',
|
|
order: 1
|
|
})
|
|
|
|
await Database.playlistModel.removeSeriesFromPlaylists([series1.id])
|
|
|
|
const deletedPlaylist = await Database.playlistModel.findByPk(playlist.id)
|
|
expect(deletedPlaylist).to.be.null
|
|
|
|
expect(SocketAuthority.clientEmitter.calledOnce).to.be.true
|
|
expect(SocketAuthority.clientEmitter.firstCall.args[1]).to.equal('playlist_removed')
|
|
})
|
|
})
|
|
})
|