707 lines
24 KiB
TypeScript
707 lines
24 KiB
TypeScript
import { signal } from '@angular/core';
|
|
import { TestBed } from '@angular/core/testing';
|
|
import { Store } from '@ngrx/store';
|
|
import { TranslateService } from '@ngx-translate/core';
|
|
import { selectAllPlaylistsMeta, selectPlaylistsLoadingFlag } from 'm3u-state';
|
|
import { of } from 'rxjs';
|
|
import { DatabaseService, PlaylistsService } from 'services';
|
|
import { Playlist, PlaylistMeta } from 'shared-interfaces';
|
|
import { DashboardDataService } from './dashboard-data.service';
|
|
|
|
describe('DashboardDataService', () => {
|
|
let service: DashboardDataService;
|
|
const playlistsLoadedSignal = signal(true);
|
|
|
|
const createDefaultPlaylists = (): PlaylistMeta[] => [
|
|
{
|
|
_id: 'm3u-1',
|
|
title: 'M3U Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
favorites: ['channel-1', 'https://example.com/stream-2.m3u8'],
|
|
recentlyViewed: [
|
|
{
|
|
source: 'm3u',
|
|
id: 'https://example.com/stream-1.m3u8',
|
|
url: 'https://example.com/stream-1.m3u8',
|
|
title: 'Channel One',
|
|
channel_id: 'channel-1',
|
|
poster_url: 'https://example.com/logo-1.png',
|
|
tvg_id: 'tvg-1',
|
|
tvg_name: 'Channel One',
|
|
group_title: 'News',
|
|
category_id: 'live',
|
|
added_at: '2026-02-01T12:00:00.000Z',
|
|
},
|
|
],
|
|
},
|
|
{
|
|
_id: 'xtream-1',
|
|
title: 'Xtream Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
serverUrl: 'https://example.com',
|
|
},
|
|
];
|
|
|
|
const playlistsSignal = signal<PlaylistMeta[]>(createDefaultPlaylists());
|
|
|
|
const storeMock = {
|
|
selectSignal: jest.fn((selector: unknown) => {
|
|
if (selector === selectAllPlaylistsMeta) {
|
|
return playlistsSignal;
|
|
}
|
|
if (selector === selectPlaylistsLoadingFlag) {
|
|
return playlistsLoadedSignal;
|
|
}
|
|
return signal(null);
|
|
}),
|
|
dispatch: jest.fn(),
|
|
};
|
|
|
|
const dbServiceMock = {
|
|
getGlobalRecentlyAdded: jest.fn().mockResolvedValue([]),
|
|
getGlobalRecentlyViewed: jest.fn().mockResolvedValue([]),
|
|
getAllGlobalFavorites: jest.fn().mockResolvedValue([]),
|
|
removeFromFavorites: jest.fn().mockResolvedValue(undefined),
|
|
removeRecentItem: jest.fn().mockResolvedValue(undefined),
|
|
};
|
|
const playlistMock: Playlist = {
|
|
_id: 'm3u-1',
|
|
title: 'M3U Playlist',
|
|
count: 2,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
lastUsage: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
favorites: ['channel-1', 'https://example.com/stream-2.m3u8'],
|
|
playlist: {
|
|
items: [
|
|
{
|
|
id: 'channel-1',
|
|
name: 'Channel One',
|
|
url: 'https://example.com/stream-1.m3u8',
|
|
tvg: {
|
|
logo: 'https://example.com/logo-1.png',
|
|
id: 'tvg-1',
|
|
name: 'Channel One',
|
|
},
|
|
},
|
|
{
|
|
id: 'channel-2',
|
|
name: 'Channel Two',
|
|
url: 'https://example.com/stream-2.m3u8',
|
|
tvg: {
|
|
logo: 'https://example.com/logo-2.png',
|
|
id: 'tvg-2',
|
|
name: 'Channel Two',
|
|
},
|
|
},
|
|
],
|
|
},
|
|
} as Playlist;
|
|
const playlistsServiceMock = {
|
|
getPlaylistById: jest.fn().mockReturnValue(of(playlistMock)),
|
|
setFavorites: jest.fn().mockReturnValue(of(undefined)),
|
|
removeFromM3uRecentlyViewed: jest.fn().mockReturnValue(
|
|
of({
|
|
...playlistMock,
|
|
recentlyViewed: [],
|
|
})
|
|
),
|
|
};
|
|
|
|
beforeEach(() => {
|
|
Object.defineProperty(window, 'electron', {
|
|
value: {} as Window['electron'],
|
|
configurable: true,
|
|
});
|
|
playlistsLoadedSignal.set(true);
|
|
playlistsSignal.set(createDefaultPlaylists());
|
|
playlistsServiceMock.getPlaylistById.mockClear();
|
|
playlistsServiceMock.getPlaylistById.mockReturnValue(of(playlistMock));
|
|
playlistsServiceMock.setFavorites.mockClear();
|
|
playlistsServiceMock.setFavorites.mockReturnValue(of(undefined));
|
|
playlistsServiceMock.removeFromM3uRecentlyViewed.mockClear();
|
|
playlistsServiceMock.removeFromM3uRecentlyViewed.mockReturnValue(
|
|
of({
|
|
...playlistMock,
|
|
recentlyViewed: [],
|
|
})
|
|
);
|
|
dbServiceMock.getAllGlobalFavorites.mockClear();
|
|
dbServiceMock.getAllGlobalFavorites.mockResolvedValue([]);
|
|
dbServiceMock.getGlobalRecentlyAdded.mockClear();
|
|
dbServiceMock.getGlobalRecentlyAdded.mockResolvedValue([]);
|
|
dbServiceMock.getGlobalRecentlyViewed.mockClear();
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([]);
|
|
dbServiceMock.removeFromFavorites.mockClear();
|
|
dbServiceMock.removeRecentItem.mockClear();
|
|
storeMock.dispatch.mockClear();
|
|
|
|
TestBed.configureTestingModule({
|
|
providers: [
|
|
DashboardDataService,
|
|
{ provide: Store, useValue: storeMock },
|
|
{ provide: DatabaseService, useValue: dbServiceMock },
|
|
{
|
|
provide: PlaylistsService,
|
|
useValue: playlistsServiceMock,
|
|
},
|
|
{
|
|
provide: TranslateService,
|
|
useValue: {
|
|
instant: (key: string) => key,
|
|
onLangChange: of(null),
|
|
currentLang: 'en',
|
|
defaultLang: 'en',
|
|
},
|
|
},
|
|
],
|
|
});
|
|
service = TestBed.inject(DashboardDataService);
|
|
});
|
|
|
|
afterEach(() => {
|
|
jest.clearAllMocks();
|
|
});
|
|
|
|
it('does not eagerly load dashboard datasets on construction', () => {
|
|
expect(dbServiceMock.getGlobalRecentlyViewed).not.toHaveBeenCalled();
|
|
expect(dbServiceMock.getAllGlobalFavorites).not.toHaveBeenCalled();
|
|
expect(dbServiceMock.getGlobalRecentlyAdded).not.toHaveBeenCalled();
|
|
expect(playlistsServiceMock.getPlaylistById).not.toHaveBeenCalled();
|
|
expect(service.dashboardReady()).toBe(false);
|
|
});
|
|
|
|
it('keeps dashboardReady false until xtream recently added finishes its first load', async () => {
|
|
expect(service.dashboardReady()).toBe(false);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
expect(service.dashboardReady()).toBe(false);
|
|
|
|
await service.reloadGlobalFavorites();
|
|
expect(service.dashboardReady()).toBe(false);
|
|
|
|
await service.reloadXtreamRecentlyAddedItems();
|
|
expect(service.dashboardReady()).toBe(true);
|
|
});
|
|
|
|
it('does not wait on xtream recently added when no xtream playlists exist', async () => {
|
|
playlistsSignal.set([
|
|
{
|
|
_id: 'm3u-1',
|
|
title: 'M3U Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
favorites: [],
|
|
recentlyViewed: [],
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
expect(service.dashboardReady()).toBe(false);
|
|
|
|
await service.reloadGlobalFavorites();
|
|
expect(service.dashboardReady()).toBe(true);
|
|
});
|
|
|
|
it('includes M3U favorites in global favorite items', async () => {
|
|
await service.reloadGlobalFavorites();
|
|
|
|
expect(service.globalFavoriteItems()).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: 'channel-1',
|
|
title: 'Channel One',
|
|
type: 'live',
|
|
playlist_id: 'm3u-1',
|
|
source: 'm3u',
|
|
poster_url: 'https://example.com/logo-1.png',
|
|
}),
|
|
expect.objectContaining({
|
|
id: 'https://example.com/stream-2.m3u8',
|
|
title: 'Channel Two',
|
|
type: 'live',
|
|
playlist_id: 'm3u-1',
|
|
source: 'm3u',
|
|
poster_url: 'https://example.com/logo-2.png',
|
|
}),
|
|
])
|
|
);
|
|
});
|
|
|
|
it('includes Xtream movies and series in global favorite items', async () => {
|
|
dbServiceMock.getAllGlobalFavorites.mockResolvedValue([
|
|
{
|
|
id: 51,
|
|
category_id: 12,
|
|
title: 'Action Movie',
|
|
rating: '8.0',
|
|
added_at: '2026-02-02T10:00:00.000Z',
|
|
poster_url: 'https://example.com/movie.png',
|
|
xtream_id: 5001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
{
|
|
id: 52,
|
|
category_id: 13,
|
|
title: 'Sci-Fi Series',
|
|
rating: '8.7',
|
|
added_at: '2026-02-03T10:00:00.000Z',
|
|
poster_url: 'https://example.com/series.png',
|
|
xtream_id: 5002,
|
|
type: 'series',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalFavorites();
|
|
|
|
expect(service.globalFavoriteItems()).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: 51,
|
|
title: 'Action Movie',
|
|
type: 'movie',
|
|
source: 'xtream',
|
|
}),
|
|
expect.objectContaining({
|
|
id: 52,
|
|
title: 'Sci-Fi Series',
|
|
type: 'series',
|
|
source: 'xtream',
|
|
}),
|
|
])
|
|
);
|
|
expect(
|
|
service
|
|
.globalFavoriteItems()
|
|
.filter((item) => item.type === 'movie')
|
|
).toHaveLength(1);
|
|
expect(
|
|
service
|
|
.globalFavoriteItems()
|
|
.filter((item) => item.type === 'series')
|
|
).toHaveLength(1);
|
|
});
|
|
|
|
it('builds the M3U favorites route', async () => {
|
|
await service.reloadGlobalFavorites();
|
|
const m3uItem = service
|
|
.globalFavoriteItems()
|
|
.find((item) => item.source === 'm3u');
|
|
|
|
expect(m3uItem).toBeDefined();
|
|
expect(service.getGlobalFavoriteLink(m3uItem!)).toEqual([
|
|
'/workspace',
|
|
'playlists',
|
|
'm3u-1',
|
|
'favorites',
|
|
]);
|
|
expect(service.getGlobalFavoriteNavigationState(m3uItem!)).toEqual({
|
|
openLiveCollectionItem: {
|
|
contentType: 'live',
|
|
sourceType: 'm3u',
|
|
playlistId: 'm3u-1',
|
|
itemId: 'channel-1',
|
|
title: 'Channel One',
|
|
imageUrl: 'https://example.com/logo-1.png',
|
|
},
|
|
});
|
|
});
|
|
|
|
it('routes Xtream non-live favorites through the global favorites page with inline detail state', async () => {
|
|
dbServiceMock.getAllGlobalFavorites.mockResolvedValue([
|
|
{
|
|
id: 51,
|
|
category_id: 12,
|
|
title: 'Action Movie',
|
|
rating: '8.0',
|
|
added_at: '2026-02-02T10:00:00.000Z',
|
|
poster_url: 'https://example.com/movie.png',
|
|
xtream_id: 5001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalFavorites();
|
|
const movieItem = service
|
|
.globalFavoriteItems()
|
|
.find((item) => item.type === 'movie');
|
|
|
|
expect(movieItem).toBeDefined();
|
|
expect(service.getGlobalFavoriteLink(movieItem!)).toEqual([
|
|
'/workspace',
|
|
'global-favorites',
|
|
]);
|
|
expect(service.getGlobalFavoriteNavigationState(movieItem!)).toEqual({
|
|
openCollectionDetailItem: {
|
|
item: expect.objectContaining({
|
|
uid: 'xtream::xtream-1::movie:5001',
|
|
name: 'Action Movie',
|
|
contentType: 'movie',
|
|
sourceType: 'xtream',
|
|
playlistId: 'xtream-1',
|
|
}),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('removes M3U favorites via PlaylistsService', async () => {
|
|
await service.reloadGlobalFavorites();
|
|
const m3uItem = service
|
|
.globalFavoriteItems()
|
|
.find((item) => item.id === 'channel-1');
|
|
|
|
expect(m3uItem).toBeDefined();
|
|
|
|
await service.removeGlobalFavorite(m3uItem!);
|
|
|
|
expect(playlistsServiceMock.setFavorites).toHaveBeenCalledWith(
|
|
'm3u-1',
|
|
['https://example.com/stream-2.m3u8']
|
|
);
|
|
});
|
|
|
|
it('includes M3U recently viewed items in global recent items', () => {
|
|
expect(service.globalRecentItems()).toEqual(
|
|
expect.arrayContaining([
|
|
expect.objectContaining({
|
|
id: 'https://example.com/stream-1.m3u8',
|
|
title: 'Channel One',
|
|
type: 'live',
|
|
playlist_id: 'm3u-1',
|
|
source: 'm3u',
|
|
xtream_id: 'https://example.com/stream-1.m3u8',
|
|
}),
|
|
])
|
|
);
|
|
});
|
|
|
|
it('prioritizes recently used Xtream sources over newer imported M3U sources', async () => {
|
|
playlistsSignal.set([
|
|
{
|
|
_id: 'm3u-fresh',
|
|
title: 'Fresh Import',
|
|
count: 1,
|
|
importDate: '2026-04-20T12:00:00.000Z',
|
|
autoRefresh: false,
|
|
favorites: [],
|
|
recentlyViewed: [],
|
|
},
|
|
{
|
|
_id: 'xtream-1',
|
|
title: 'Xtream Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
serverUrl: 'https://example.com',
|
|
},
|
|
]);
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([
|
|
{
|
|
id: 91,
|
|
category_id: 18,
|
|
title: 'Recent Movie',
|
|
rating: '7.8',
|
|
viewed_at: '2026-04-21T10:00:00.000Z',
|
|
poster_url: 'https://example.com/recent-movie.png',
|
|
xtream_id: 7001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
|
|
expect(service.recentPlaylists().map((playlist) => playlist._id)).toEqual(
|
|
['xtream-1', 'm3u-fresh']
|
|
);
|
|
});
|
|
|
|
it('includes M3U, Xtream, and Stalker sources when all have recent activity', async () => {
|
|
playlistsSignal.set([
|
|
{
|
|
_id: 'm3u-1',
|
|
title: 'M3U Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
favorites: [],
|
|
recentlyViewed: [
|
|
{
|
|
source: 'm3u',
|
|
id: 'https://example.com/stream-1.m3u8',
|
|
url: 'https://example.com/stream-1.m3u8',
|
|
title: 'Channel One',
|
|
category_id: 'live',
|
|
added_at: '2026-04-19T10:00:00.000Z',
|
|
},
|
|
],
|
|
},
|
|
{
|
|
_id: 'stalker-1',
|
|
title: 'Stalker Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
macAddress: '00:11:22:33:44:55',
|
|
recentlyViewed: [
|
|
{
|
|
id: 'stalker-item-1',
|
|
name: 'Stalker Movie',
|
|
category_id: 'vod',
|
|
added_at: '2026-04-20T10:00:00.000Z',
|
|
},
|
|
],
|
|
},
|
|
{
|
|
_id: 'xtream-1',
|
|
title: 'Xtream Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
serverUrl: 'https://example.com',
|
|
},
|
|
]);
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([
|
|
{
|
|
id: 91,
|
|
category_id: 18,
|
|
title: 'Recent Movie',
|
|
rating: '7.8',
|
|
viewed_at: '2026-04-21T10:00:00.000Z',
|
|
poster_url: 'https://example.com/recent-movie.png',
|
|
xtream_id: 7001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
|
|
expect(service.recentPlaylists().map((playlist) => playlist._id)).toEqual(
|
|
['xtream-1', 'stalker-1', 'm3u-1']
|
|
);
|
|
});
|
|
|
|
it('falls back to playlist metadata ordering when sources have no recent activity', async () => {
|
|
playlistsSignal.set([
|
|
{
|
|
_id: 'xtream-1',
|
|
title: 'Xtream Playlist',
|
|
count: 1,
|
|
importDate: '2026-01-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
serverUrl: 'https://example.com',
|
|
},
|
|
{
|
|
_id: 'stalker-1',
|
|
title: 'Stalker Playlist',
|
|
count: 1,
|
|
importDate: '2026-03-01T00:00:00.000Z',
|
|
autoRefresh: false,
|
|
macAddress: '00:11:22:33:44:55',
|
|
recentlyViewed: [],
|
|
},
|
|
{
|
|
_id: 'm3u-1',
|
|
title: 'M3U Playlist',
|
|
count: 1,
|
|
importDate: '2026-02-01T00:00:00.000Z',
|
|
updateDate: Date.parse('2026-04-01T00:00:00.000Z'),
|
|
autoRefresh: false,
|
|
favorites: [],
|
|
recentlyViewed: [],
|
|
},
|
|
]);
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
|
|
expect(service.recentPlaylists().map((playlist) => playlist._id)).toEqual(
|
|
['m3u-1', 'stalker-1', 'xtream-1']
|
|
);
|
|
});
|
|
|
|
it('maps recently added Xtream rows for the widget', async () => {
|
|
dbServiceMock.getGlobalRecentlyAdded.mockResolvedValue([
|
|
{
|
|
id: 11,
|
|
category_id: 77,
|
|
title: 'Fresh Movie',
|
|
rating: '8.1',
|
|
added: '1774298340',
|
|
added_at: '1774298340',
|
|
poster_url: 'https://example.com/poster.png',
|
|
xtream_id: 501,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await expect(
|
|
service.getGlobalRecentlyAddedItems('all', 25)
|
|
).resolves.toEqual([
|
|
expect.objectContaining({
|
|
id: 11,
|
|
title: 'Fresh Movie',
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
source: 'xtream',
|
|
added_at: expect.any(String),
|
|
}),
|
|
]);
|
|
expect(dbServiceMock.getGlobalRecentlyAdded).toHaveBeenCalledWith(
|
|
'all',
|
|
25
|
|
);
|
|
});
|
|
|
|
it('builds the Xtream recently added route', () => {
|
|
const item = {
|
|
id: 11,
|
|
title: 'Fresh Series',
|
|
type: 'series',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
added_at: '2026-03-27T14:39:00.000Z',
|
|
category_id: 77,
|
|
xtream_id: 501,
|
|
poster_url: 'https://example.com/poster.png',
|
|
source: 'xtream',
|
|
} as const;
|
|
|
|
expect(service.getRecentlyAddedLink(item)).toEqual([
|
|
'/workspace',
|
|
'xtreams',
|
|
'xtream-1',
|
|
'series',
|
|
'77',
|
|
'501',
|
|
]);
|
|
expect(service.getRecentlyAddedNavigationState(item)).toBeUndefined();
|
|
});
|
|
|
|
it('builds the M3U recent route with collection auto-open state', () => {
|
|
const m3uItem = service
|
|
.globalRecentItems()
|
|
.find((item) => item.source === 'm3u');
|
|
|
|
expect(m3uItem).toBeDefined();
|
|
expect(service.getRecentItemLink(m3uItem!)).toEqual([
|
|
'/workspace',
|
|
'playlists',
|
|
'm3u-1',
|
|
'recent',
|
|
]);
|
|
expect(service.getRecentItemNavigationState(m3uItem!)).toEqual({
|
|
openLiveCollectionItem: {
|
|
contentType: 'live',
|
|
sourceType: 'm3u',
|
|
playlistId: 'm3u-1',
|
|
itemId: 'https://example.com/stream-1.m3u8',
|
|
title: 'Channel One',
|
|
imageUrl: 'https://example.com/logo-1.png',
|
|
},
|
|
});
|
|
});
|
|
|
|
it('routes Xtream non-live recents through the global recent page with inline detail state', async () => {
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([
|
|
{
|
|
id: 91,
|
|
category_id: 18,
|
|
title: 'Recent Movie',
|
|
rating: '7.8',
|
|
viewed_at: '2026-02-04T10:00:00.000Z',
|
|
poster_url: 'https://example.com/recent-movie.png',
|
|
backdrop_url: 'https://example.com/recent-movie-backdrop.png',
|
|
xtream_id: 7001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
const movieItem = service
|
|
.globalRecentItems()
|
|
.find((item) => item.source === 'xtream');
|
|
|
|
expect(movieItem).toEqual(
|
|
expect.objectContaining({
|
|
backdrop_url: 'https://example.com/recent-movie-backdrop.png',
|
|
})
|
|
);
|
|
expect(service.getRecentItemLink(movieItem!)).toEqual([
|
|
'/workspace',
|
|
'global-recent',
|
|
]);
|
|
expect(service.getRecentItemNavigationState(movieItem!)).toEqual({
|
|
openCollectionDetailItem: {
|
|
item: expect.objectContaining({
|
|
uid: 'xtream::xtream-1::movie:7001',
|
|
name: 'Recent Movie',
|
|
contentType: 'movie',
|
|
sourceType: 'xtream',
|
|
playlistId: 'xtream-1',
|
|
}),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('normalizes SQLite-style Xtream recent timestamps before sorting and rendering', async () => {
|
|
dbServiceMock.getGlobalRecentlyViewed.mockResolvedValue([
|
|
{
|
|
id: 91,
|
|
category_id: 18,
|
|
title: 'Recent Movie',
|
|
rating: '7.8',
|
|
viewed_at: '2026-02-04 10:00:00',
|
|
poster_url: 'https://example.com/recent-movie.png',
|
|
xtream_id: 7001,
|
|
type: 'movie',
|
|
playlist_id: 'xtream-1',
|
|
playlist_name: 'Xtream Playlist',
|
|
},
|
|
]);
|
|
|
|
await service.reloadGlobalRecentItems();
|
|
const movieItem = service
|
|
.globalRecentItems()
|
|
.find((item) => item.source === 'xtream');
|
|
|
|
expect(movieItem).toEqual(
|
|
expect.objectContaining({
|
|
viewed_at: '2026-02-04T10:00:00.000Z',
|
|
})
|
|
);
|
|
});
|
|
|
|
it('removes M3U recently viewed via PlaylistsService', async () => {
|
|
const m3uItem = service
|
|
.globalRecentItems()
|
|
.find((item) => item.source === 'm3u');
|
|
|
|
expect(m3uItem).toBeDefined();
|
|
|
|
await service.removeGlobalRecentItem(m3uItem!);
|
|
|
|
expect(
|
|
playlistsServiceMock.removeFromM3uRecentlyViewed
|
|
).toHaveBeenCalledWith('m3u-1', 'https://example.com/stream-1.m3u8');
|
|
});
|
|
});
|