{program?.title}
@@ -252,11 +268,11 @@ vi.mock('../../utils/guideUtils', async () => {
fetchPrograms: vi.fn(),
createRecording: vi.fn(),
createSeriesRule: vi.fn(),
- evaluateSeriesRule: vi.fn(),
fetchRules: vi.fn(),
filterGuideChannels: vi.fn(),
getGroupOptions: vi.fn(),
getProfileOptions: vi.fn(),
+ sortChannels: vi.fn((ch) => ch),
};
});
vi.mock('../../utils/cards/RecordingCardUtils.js', async () => {
@@ -403,7 +419,6 @@ describe('Guide', () => {
);
guideUtils.createRecording.mockResolvedValue(undefined);
guideUtils.createSeriesRule.mockResolvedValue(undefined);
- guideUtils.evaluateSeriesRule.mockResolvedValue(undefined);
guideUtils.getGroupOptions.mockReturnValue([
{ value: 'all', label: 'All Groups' },
{ value: 'group-1', label: 'News' },
@@ -666,8 +681,7 @@ describe('Guide', () => {
await waitFor(() => {
expect(guideUtils.createRecording).toHaveBeenCalledWith(
- expect.objectContaining({ id: 'channel-1' }),
- expect.objectContaining({ id: 'prog-1' })
+ expect.objectContaining({ channel: 'channel-1' }),
);
});
});
diff --git a/frontend/src/pages/__tests__/guideUtils.test.js b/frontend/src/pages/__tests__/guideUtils.test.js
index 18307016..2cd321ca 100644
--- a/frontend/src/pages/__tests__/guideUtils.test.js
+++ b/frontend/src/pages/__tests__/guideUtils.test.js
@@ -48,6 +48,8 @@ describe('guideUtils', () => {
vi.clearAllMocks();
});
+ // ── buildChannelIdMap ──────────────────────────────────────────────────────
+
describe('buildChannelIdMap', () => {
it('should create map with channel UUIDs when no EPG data', () => {
const channels = [
@@ -123,850 +125,638 @@ describe('guideUtils', () => {
});
});
+ // ── mapProgramsByChannel ───────────────────────────────────────────────────
+
describe('mapProgramsByChannel', () => {
it('should return empty map when no programs', () => {
- const channelIdByTvgId = new Map();
-
- const result = guideUtils.mapProgramsByChannel([], channelIdByTvgId);
-
+ const result = guideUtils.mapProgramsByChannel([], new Map([['tvg-1', [1]]]));
expect(result.size).toBe(0);
});
it('should return empty map when no channel mapping', () => {
- const programs = [{ tvg_id: 'tvg-1' }];
-
+ const programs = [{ tvg_id: 'tvg-1', startMs: 1000, endMs: 2000 }];
const result = guideUtils.mapProgramsByChannel(programs, new Map());
-
expect(result.size).toBe(0);
});
it('should map programs to channels', () => {
- const nowMs = 1000000;
- dateTimeUtils.getNowMs.mockReturnValue(nowMs);
-
- const programs = [
- {
- id: 1,
- tvg_id: 'tvg-1',
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
+ const nowMs = dayjs().valueOf();
+ const startMs = nowMs - 10000;
+ const endMs = nowMs + 10000;
+ const programs = [{ tvg_id: 'tvg-1', startMs, endMs }];
const channelIdByTvgId = new Map([['tvg-1', [1]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(nowMs);
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
+
+ expect(result.has(1)).toBe(true);
expect(result.get(1)).toHaveLength(1);
- expect(result.get(1)[0]).toMatchObject({
- id: 1,
- tvg_id: 'tvg-1',
- });
});
it('should precompute startMs and endMs', () => {
- dateTimeUtils.getNowMs.mockReturnValue(1000000);
- dateTimeUtils.convertToMs.mockImplementation((time) =>
- typeof time === 'number' ? time : dayjs(time).valueOf()
- );
+ const startTime = '2024-01-01T10:00:00Z';
+ const endTime = '2024-01-01T11:00:00Z';
+ const expectedStartMs = dayjs(startTime).valueOf();
+ const expectedEndMs = dayjs(endTime).valueOf();
- const programs = [
- {
- id: 1,
- tvg_id: 'tvg-1',
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
+ vi.mocked(dateTimeUtils.convertToMs)
+ .mockReturnValueOnce(expectedStartMs)
+ .mockReturnValueOnce(expectedEndMs);
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(expectedStartMs - 1000);
+
+ const programs = [{ tvg_id: 'tvg-1', start_time: startTime, end_time: endTime }];
const channelIdByTvgId = new Map([['tvg-1', [1]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
+ const mapped = result.get(1)[0];
- expect(result.get(1)[0]).toHaveProperty('startMs');
- expect(result.get(1)[0]).toHaveProperty('endMs');
+ expect(mapped.startMs).toBe(expectedStartMs);
+ expect(mapped.endMs).toBe(expectedEndMs);
});
it('should mark program as live when now is between start and end', () => {
+ const nowMs = 5000;
const startMs = 1000;
- const endMs = 2000;
- const nowMs = 1500;
- dateTimeUtils.getNowMs.mockReturnValue(nowMs);
+ const endMs = 10000;
- const programs = [
- {
- id: 1,
- tvg_id: 'tvg-1',
- startMs,
- endMs,
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(nowMs);
+
+ const programs = [{ tvg_id: 'tvg-1', startMs, endMs }];
const channelIdByTvgId = new Map([['tvg-1', [1]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
expect(result.get(1)[0].isLive).toBe(true);
expect(result.get(1)[0].isPast).toBe(false);
});
it('should mark program as past when now is after end', () => {
+ const nowMs = 20000;
const startMs = 1000;
- const endMs = 2000;
- const nowMs = 3000;
- dateTimeUtils.getNowMs.mockReturnValue(nowMs);
+ const endMs = 10000;
- const programs = [
- {
- id: 1,
- tvg_id: 'tvg-1',
- startMs,
- endMs,
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(nowMs);
+
+ const programs = [{ tvg_id: 'tvg-1', startMs, endMs }];
const channelIdByTvgId = new Map([['tvg-1', [1]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
- expect(result.get(1)[0].isLive).toBe(false);
expect(result.get(1)[0].isPast).toBe(true);
+ expect(result.get(1)[0].isLive).toBe(false);
});
it('should add program to multiple channels with same tvg_id', () => {
- dateTimeUtils.getNowMs.mockReturnValue(1000000);
+ const nowMs = 5000;
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(nowMs);
- const programs = [
- {
- id: 1,
- tvg_id: 'tvg-1',
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
- const channelIdByTvgId = new Map([['tvg-1', [1, 2, 3]]]);
+ const programs = [{ tvg_id: 'tvg-1', startMs: 1000, endMs: 10000 }];
+ const channelIdByTvgId = new Map([['tvg-1', [1, 2]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
expect(result.get(1)).toHaveLength(1);
expect(result.get(2)).toHaveLength(1);
- expect(result.get(3)).toHaveLength(1);
});
it('should sort programs by start time', () => {
- dateTimeUtils.getNowMs.mockReturnValue(1000000);
+ const nowMs = 0;
+ vi.mocked(dateTimeUtils.getNowMs).mockReturnValue(nowMs);
const programs = [
- {
- id: 2,
- tvg_id: 'tvg-1',
- startMs: 2000,
- endMs: 3000,
- start_time: '2024-01-15T11:00:00Z',
- end_time: '2024-01-15T12:00:00Z',
- },
- {
- id: 1,
- tvg_id: 'tvg-1',
- startMs: 1000,
- endMs: 2000,
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
+ { tvg_id: 'tvg-1', startMs: 3000, endMs: 4000 },
+ { tvg_id: 'tvg-1', startMs: 1000, endMs: 2000 },
];
const channelIdByTvgId = new Map([['tvg-1', [1]]]);
- const result = guideUtils.mapProgramsByChannel(
- programs,
- channelIdByTvgId
- );
+ const result = guideUtils.mapProgramsByChannel(programs, channelIdByTvgId);
+ const list = result.get(1);
- expect(result.get(1)[0].id).toBe(1);
- expect(result.get(1)[1].id).toBe(2);
+ expect(list[0].startMs).toBe(1000);
+ expect(list[1].startMs).toBe(3000);
});
});
+ // ── computeRowHeights ─────────────────────────────────────────────────────
+
describe('computeRowHeights', () => {
it('should return empty array when no channels', () => {
- const result = guideUtils.computeRowHeights([]);
-
- expect(result).toEqual([]);
+ expect(guideUtils.computeRowHeights([])).toEqual([]);
+ expect(guideUtils.computeRowHeights(null)).toEqual([]);
});
it('should return default height for all channels', () => {
- const channels = [{ id: 1 }, { id: 2 }];
-
+ const channels = [{}, {}, {}];
const result = guideUtils.computeRowHeights(channels);
-
- expect(result).toEqual([
- guideUtils.PROGRAM_HEIGHT,
- guideUtils.PROGRAM_HEIGHT,
- ]);
+ expect(result).toEqual([90, 90, 90]);
});
it('should use custom default height when provided', () => {
- const channels = [{ id: 1 }];
- const customDefault = 100;
-
- const result = guideUtils.computeRowHeights(channels, customDefault);
-
- expect(result).toEqual([customDefault]);
+ const channels = [{}, {}];
+ const result = guideUtils.computeRowHeights(channels, 60);
+ expect(result).toEqual([60, 60]);
});
});
+ // ── fetchPrograms ─────────────────────────────────────────────────────────
+
describe('fetchPrograms', () => {
it('should fetch and transform programs', async () => {
- const mockPrograms = [
- {
- id: 1,
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- },
- ];
- API.getGrid.mockResolvedValue(mockPrograms);
- dateTimeUtils.convertToMs.mockReturnValue(1000);
+ const startTime = '2024-01-01T10:00:00Z';
+ const endTime = '2024-01-01T11:00:00Z';
+ const raw = [{ id: 1, start_time: startTime, end_time: endTime }];
+ vi.mocked(API.getGrid).mockResolvedValue(raw);
+ vi.mocked(dateTimeUtils.convertToMs)
+ .mockReturnValueOnce(dayjs(startTime).valueOf())
+ .mockReturnValueOnce(dayjs(endTime).valueOf());
const result = await guideUtils.fetchPrograms();
- expect(API.getGrid).toHaveBeenCalledTimes(1);
- expect(result).toHaveLength(1);
- expect(result[0]).toHaveProperty('startMs');
- expect(result[0]).toHaveProperty('endMs');
+ expect(API.getGrid).toHaveBeenCalled();
+ expect(result[0].startMs).toBe(dayjs(startTime).valueOf());
+ expect(result[0].endMs).toBe(dayjs(endTime).valueOf());
});
});
+ // ── sortChannels ──────────────────────────────────────────────────────────
+
describe('sortChannels', () => {
it('should sort channels by channel number', () => {
const channels = {
- 1: { id: 1, channel_number: 3 },
- 2: { id: 2, channel_number: 1 },
- 3: { id: 3, channel_number: 2 },
+ a: { id: 1, channel_number: 3 },
+ b: { id: 2, channel_number: 1 },
+ c: { id: 3, channel_number: 2 },
};
-
const result = guideUtils.sortChannels(channels);
-
- expect(result[0].channel_number).toBe(1);
- expect(result[1].channel_number).toBe(2);
- expect(result[2].channel_number).toBe(3);
+ expect(result.map((c) => c.channel_number)).toEqual([1, 2, 3]);
});
it('should put channels without number at end', () => {
const channels = {
- 1: { id: 1, channel_number: 2 },
- 2: { id: 2, channel_number: null },
- 3: { id: 3, channel_number: 1 },
+ a: { id: 1, channel_number: 2 },
+ b: { id: 2, channel_number: null },
+ c: { id: 3, channel_number: 1 },
};
-
const result = guideUtils.sortChannels(channels);
-
expect(result[0].channel_number).toBe(1);
expect(result[1].channel_number).toBe(2);
expect(result[2].channel_number).toBeNull();
});
});
+ // ── filterGuideChannels ───────────────────────────────────────────────────
+
describe('filterGuideChannels', () => {
+ const channels = [
+ { id: 1, name: 'ESPN', channel_group_id: 10 },
+ { id: 2, name: 'CNN', channel_group_id: 20 },
+ { id: 3, name: 'ESPN2', channel_group_id: 10 },
+ ];
+
it('should return all channels when no filters', () => {
- const channels = [
- { id: 1, name: 'Channel 1' },
- { id: 2, name: 'Channel 2' },
- ];
-
- const result = guideUtils.filterGuideChannels(
- channels,
- '',
- 'all',
- 'all',
- {}
- );
-
- expect(result).toHaveLength(2);
+ const result = guideUtils.filterGuideChannels(channels, '', 'all', 'all', {});
+ expect(result).toHaveLength(3);
});
it('should filter by search query', () => {
- const channels = [
- { id: 1, name: 'ESPN' },
- { id: 2, name: 'CNN' },
- ];
-
- const result = guideUtils.filterGuideChannels(
- channels,
- 'espn',
- 'all',
- 'all',
- {}
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].name).toBe('ESPN');
+ const result = guideUtils.filterGuideChannels(channels, 'espn', 'all', 'all', {});
+ expect(result).toHaveLength(2);
+ expect(result.map((c) => c.name)).toEqual(['ESPN', 'ESPN2']);
});
it('should filter by channel group', () => {
- const channels = [
- { id: 1, name: 'Channel 1', channel_group_id: 1 },
- { id: 2, name: 'Channel 2', channel_group_id: 2 },
- ];
-
- const result = guideUtils.filterGuideChannels(
- channels,
- '',
- '1',
- 'all',
- {}
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].channel_group_id).toBe(1);
+ const result = guideUtils.filterGuideChannels(channels, '', '10', 'all', {});
+ expect(result).toHaveLength(2);
+ expect(result.every((c) => c.channel_group_id === 10)).toBe(true);
});
it('should filter by profile with array of channels', () => {
- const channels = [
- { id: 1, name: 'Channel 1' },
- { id: 2, name: 'Channel 2' },
- ];
const profiles = {
- profile1: {
+ 'p1': {
channels: [
{ id: 1, enabled: true },
{ id: 2, enabled: false },
- ],
- },
- };
-
- const result = guideUtils.filterGuideChannels(
- channels,
- '',
- 'all',
- 'profile1',
- profiles
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].id).toBe(1);
- });
-
- it('should filter by profile with Set of channels', () => {
- const channels = [
- { id: 1, name: 'Channel 1' },
- { id: 2, name: 'Channel 2' },
- ];
- const profiles = {
- profile1: {
- channels: new Set([1]),
- },
- };
-
- const result = guideUtils.filterGuideChannels(
- channels,
- '',
- 'all',
- 'profile1',
- profiles
- );
-
- expect(result).toHaveLength(1);
- expect(result[0].id).toBe(1);
- });
-
- it('should apply multiple filters together', () => {
- const channels = [
- { id: 1, name: 'ESPN', channel_group_id: 1 },
- { id: 2, name: 'ESPN2', channel_group_id: 2 },
- { id: 3, name: 'CNN', channel_group_id: 1 },
- ];
- const profiles = {
- profile1: {
- channels: [
- { id: 1, enabled: true },
{ id: 3, enabled: true },
],
},
};
+ const result = guideUtils.filterGuideChannels(channels, '', 'all', 'p1', profiles);
+ expect(result.map((c) => c.id)).toEqual([1, 3]);
+ });
- const result = guideUtils.filterGuideChannels(
- channels,
- 'espn',
- '1',
- 'profile1',
- profiles
- );
+ it('should filter by profile with Set of channels', () => {
+ const profiles = {
+ 'p1': { channels: new Set([1, 3]) },
+ };
+ const result = guideUtils.filterGuideChannels(channels, '', 'all', 'p1', profiles);
+ expect(result.map((c) => c.id)).toEqual([1, 3]);
+ });
+ it('should apply multiple filters together', () => {
+ const profiles = {
+ 'p1': { channels: [{ id: 1, enabled: true }, { id: 3, enabled: true }] },
+ };
+ const result = guideUtils.filterGuideChannels(channels, 'espn2', '10', 'p1', profiles);
expect(result).toHaveLength(1);
- expect(result[0].id).toBe(1);
+ expect(result[0].name).toBe('ESPN2');
});
});
+ // ── calculateEarliestProgramStart ─────────────────────────────────────────
+
describe('calculateEarliestProgramStart', () => {
it('should return default when no programs', () => {
- const defaultStart = dayjs('2024-01-15T00:00:00Z');
-
+ const defaultStart = dayjs('2024-01-01T10:00:00Z');
const result = guideUtils.calculateEarliestProgramStart([], defaultStart);
-
expect(result).toBe(defaultStart);
});
it('should return earliest program start', () => {
- dateTimeUtils.initializeTime.mockImplementation((time) =>
- dayjs.utc(time)
- );
- dateTimeUtils.isBefore.mockImplementation((a, b) =>
- dayjs(a).isBefore(dayjs(b))
- );
+ vi.mocked(dateTimeUtils.initializeTime).mockImplementation((t) => dayjs(t));
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) => dayjs(a).isBefore(dayjs(b)));
+ const defaultStart = dayjs('2024-01-01T10:00:00Z');
const programs = [
- { start_time: '2024-01-15T12:00:00Z' },
- { start_time: '2024-01-15T10:00:00Z' },
- { start_time: '2024-01-15T14:00:00Z' },
+ { start_time: '2024-01-01T09:00:00Z' },
+ { start_time: '2024-01-01T08:00:00Z' },
+ { start_time: '2024-01-01T11:00:00Z' },
];
- const defaultStart = dayjs.utc('2024-01-16T00:00:00Z');
- const result = guideUtils.calculateEarliestProgramStart(
- programs,
- defaultStart
- );
-
- expect(result.hour()).toBe(10);
+ const result = guideUtils.calculateEarliestProgramStart(programs, defaultStart);
+ expect(dayjs(result).toISOString()).toBe(dayjs('2024-01-01T08:00:00Z').toISOString());
});
});
+ // ── calculateLatestProgramEnd ─────────────────────────────────────────────
+
describe('calculateLatestProgramEnd', () => {
it('should return default when no programs', () => {
- const defaultEnd = dayjs('2024-01-16T00:00:00Z');
-
+ const defaultEnd = dayjs('2024-01-01T22:00:00Z');
const result = guideUtils.calculateLatestProgramEnd([], defaultEnd);
-
expect(result).toBe(defaultEnd);
});
it('should return latest program end', () => {
- dateTimeUtils.initializeTime.mockImplementation((time) =>
- dayjs.utc(time)
- );
- dateTimeUtils.isAfter.mockImplementation((a, b) =>
- dayjs(a).isAfter(dayjs(b))
- );
+ vi.mocked(dateTimeUtils.initializeTime).mockImplementation((t) => dayjs(t));
+ vi.mocked(dateTimeUtils.isAfter).mockImplementation((a, b) => dayjs(a).isAfter(dayjs(b)));
+ const defaultEnd = dayjs('2024-01-01T22:00:00Z');
const programs = [
- { end_time: '2024-01-15T12:00:00Z' },
- { end_time: '2024-01-15T18:00:00Z' },
- { end_time: '2024-01-15T14:00:00Z' },
+ { end_time: '2024-01-01T20:00:00Z' },
+ { end_time: '2024-01-01T23:00:00Z' },
+ { end_time: '2024-01-01T21:00:00Z' },
];
- const defaultEnd = dayjs.utc('2024-01-15T00:00:00Z');
const result = guideUtils.calculateLatestProgramEnd(programs, defaultEnd);
-
- expect(result.hour()).toBe(18);
+ expect(dayjs(result).toISOString()).toBe(dayjs('2024-01-01T23:00:00Z').toISOString());
});
});
+ // ── calculateStart ────────────────────────────────────────────────────────
+
describe('calculateStart', () => {
it('should return earliest when before default', () => {
- const earliest = dayjs('2024-01-15T08:00:00Z');
- const defaultStart = dayjs('2024-01-15T10:00:00Z');
- dateTimeUtils.isBefore.mockReturnValue(true);
+ const earliest = dayjs('2024-01-01T08:00:00Z');
+ const defaultStart = dayjs('2024-01-01T10:00:00Z');
+ vi.mocked(dateTimeUtils.isBefore).mockReturnValue(true);
const result = guideUtils.calculateStart(earliest, defaultStart);
-
expect(result).toBe(earliest);
});
it('should return default when earliest is after', () => {
- const earliest = dayjs('2024-01-15T12:00:00Z');
- const defaultStart = dayjs('2024-01-15T10:00:00Z');
- dateTimeUtils.isBefore.mockReturnValue(false);
+ const earliest = dayjs('2024-01-01T11:00:00Z');
+ const defaultStart = dayjs('2024-01-01T10:00:00Z');
+ vi.mocked(dateTimeUtils.isBefore).mockReturnValue(false);
const result = guideUtils.calculateStart(earliest, defaultStart);
-
expect(result).toBe(defaultStart);
});
});
+ // ── calculateEnd ──────────────────────────────────────────────────────────
+
describe('calculateEnd', () => {
it('should return latest when after default', () => {
- const latest = dayjs('2024-01-16T02:00:00Z');
- const defaultEnd = dayjs('2024-01-16T00:00:00Z');
- dateTimeUtils.isAfter.mockReturnValue(true);
+ const latest = dayjs('2024-01-01T23:00:00Z');
+ const defaultEnd = dayjs('2024-01-01T22:00:00Z');
+ vi.mocked(dateTimeUtils.isAfter).mockReturnValue(true);
const result = guideUtils.calculateEnd(latest, defaultEnd);
-
expect(result).toBe(latest);
});
it('should return default when latest is before', () => {
- const latest = dayjs('2024-01-15T22:00:00Z');
- const defaultEnd = dayjs('2024-01-16T00:00:00Z');
- dateTimeUtils.isAfter.mockReturnValue(false);
+ const latest = dayjs('2024-01-01T20:00:00Z');
+ const defaultEnd = dayjs('2024-01-01T22:00:00Z');
+ vi.mocked(dateTimeUtils.isAfter).mockReturnValue(false);
const result = guideUtils.calculateEnd(latest, defaultEnd);
-
expect(result).toBe(defaultEnd);
});
});
+ // ── mapChannelsById ───────────────────────────────────────────────────────
+
describe('mapChannelsById', () => {
it('should create map of channels by id', () => {
const channels = [
- { id: 1, name: 'Channel 1' },
- { id: 2, name: 'Channel 2' },
+ { id: 1, name: 'ESPN' },
+ { id: 2, name: 'CNN' },
];
-
const result = guideUtils.mapChannelsById(channels);
-
- expect(result.get(1).name).toBe('Channel 1');
- expect(result.get(2).name).toBe('Channel 2');
+ expect(result.get(1)).toEqual({ id: 1, name: 'ESPN' });
+ expect(result.get(2)).toEqual({ id: 2, name: 'CNN' });
});
});
+ // ── mapRecordingsByProgramId ───────────────────────────────────────────────
+
describe('mapRecordingsByProgramId', () => {
it('should return empty map for null recordings', () => {
const result = guideUtils.mapRecordingsByProgramId(null);
-
expect(result.size).toBe(0);
});
it('should map recordings by program id', () => {
const recordings = [
{
- id: 1,
- custom_properties: {
- program: { id: 'program-1' },
- },
- },
- {
- id: 2,
- custom_properties: {
- program: { id: 'program-2' },
- },
+ custom_properties: { program: { id: 42 }, status: 'pending' },
},
];
-
const result = guideUtils.mapRecordingsByProgramId(recordings);
-
- expect(result.get('program-1').id).toBe(1);
- expect(result.get('program-2').id).toBe(2);
+ expect(result.has(42)).toBe(true);
});
it('should skip recordings without program id', () => {
const recordings = [
- {
- id: 1,
- custom_properties: {},
- },
+ { custom_properties: { status: 'pending' } },
+ { custom_properties: { program: {}, status: 'pending' } },
];
-
const result = guideUtils.mapRecordingsByProgramId(recordings);
-
expect(result.size).toBe(0);
});
it('should exclude terminal status recordings', () => {
- const recordings = [
- {
- id: 1,
- custom_properties: { program: { id: 'p1' }, status: 'completed' },
- },
- {
- id: 2,
- custom_properties: { program: { id: 'p2' }, status: 'stopped' },
- },
- {
- id: 3,
- custom_properties: { program: { id: 'p3' }, status: 'interrupted' },
- },
- {
- id: 4,
- custom_properties: { program: { id: 'p4' }, status: 'failed' },
- },
- {
- id: 5,
- custom_properties: { program: { id: 'p5' }, status: 'recording' },
- },
- { id: 6, custom_properties: { program: { id: 'p6' } } },
- ];
-
+ const terminalStatuses = ['stopped', 'completed', 'interrupted', 'failed'];
+ const recordings = terminalStatuses.map((status, i) => ({
+ custom_properties: { program: { id: i + 1 }, status },
+ }));
const result = guideUtils.mapRecordingsByProgramId(recordings);
+ expect(result.size).toBe(0);
+ });
+ it('should include non-terminal status recordings', () => {
+ const recordings = [
+ { custom_properties: { program: { id: 1 }, status: 'pending' } },
+ { custom_properties: { program: { id: 2 }, status: 'recording' } },
+ ];
+ const result = guideUtils.mapRecordingsByProgramId(recordings);
expect(result.size).toBe(2);
- expect(result.get('p5').id).toBe(5);
- expect(result.get('p6').id).toBe(6);
});
});
+ // ── formatTime ────────────────────────────────────────────────────────────
+
describe('formatTime', () => {
it('should return "Today" for today', () => {
- const today = dayjs();
- dateTimeUtils.getNow.mockReturnValue(today);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
+ const now = dayjs();
+ vi.mocked(dateTimeUtils.getNow).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) => dayjs(t).startOf('day'));
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).isSame(dayjs(b), unit)
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
+ dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.isSame.mockReturnValueOnce(true);
-
- const result = guideUtils.formatTime(today, 'MM/DD');
+ const result = guideUtils.formatTime(now, 'MMM D');
expect(result).toBe('Today');
});
it('should return "Tomorrow" for tomorrow', () => {
- const today = dayjs();
- const tomorrow = today.add(1, 'day');
- dateTimeUtils.getNow.mockReturnValue(today);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
+ const now = dayjs();
+ const tomorrow = now.add(1, 'day');
+ vi.mocked(dateTimeUtils.getNow).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) => dayjs(t).startOf('day'));
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).isSame(dayjs(b), unit)
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
+ dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.isSame.mockReturnValueOnce(false).mockReturnValueOnce(true);
-
- const result = guideUtils.formatTime(tomorrow, 'MM/DD');
+ const result = guideUtils.formatTime(tomorrow, 'MMM D');
expect(result).toBe('Tomorrow');
});
it('should return day name within a week', () => {
- const today = dayjs();
- const future = today.add(3, 'day');
- dateTimeUtils.getNow.mockReturnValue(today);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
+ const now = dayjs();
+ const inThreeDays = now.add(3, 'day');
+ vi.mocked(dateTimeUtils.getNow).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) => dayjs(t).startOf('day'));
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).isSame(dayjs(b), unit)
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
+ dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.isSame.mockReturnValue(false);
- dateTimeUtils.isBefore.mockReturnValue(true);
- dateTimeUtils.format.mockReturnValue('Wednesday');
+ vi.mocked(dateTimeUtils.format).mockImplementation((t, fmt) => dayjs(t).format(fmt));
- const result = guideUtils.formatTime(future, 'MM/DD');
-
- expect(result).toBe('Wednesday');
+ const result = guideUtils.formatTime(inThreeDays, 'MMM D');
+ expect(result).toBe(inThreeDays.format('dddd'));
});
it('should return formatted date beyond a week', () => {
- const today = dayjs();
- const future = today.add(10, 'day');
- dateTimeUtils.getNow.mockReturnValue(today);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
+ const now = dayjs();
+ const beyondWeek = now.add(10, 'day');
+ vi.mocked(dateTimeUtils.getNow).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) => dayjs(t).startOf('day'));
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).isSame(dayjs(b), unit)
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
+ dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.isSame.mockReturnValue(false);
- dateTimeUtils.isBefore.mockReturnValue(false);
- dateTimeUtils.format.mockReturnValue('01/25');
+ vi.mocked(dateTimeUtils.format).mockImplementation((t, fmt) => dayjs(t).format(fmt));
- const result = guideUtils.formatTime(future, 'MM/DD');
-
- expect(result).toBe('01/25');
+ const result = guideUtils.formatTime(beyondWeek, 'MMM D');
+ expect(result).toBe(beyondWeek.format('MMM D'));
});
});
+ // ── calculateHourTimeline ─────────────────────────────────────────────────
+
describe('calculateHourTimeline', () => {
it('should generate hours between start and end', () => {
- const start = dayjs('2024-01-15T10:00:00Z');
- const end = dayjs('2024-01-15T13:00:00Z');
- dateTimeUtils.isBefore.mockImplementation((a, b) =>
+ const start = dayjs('2024-01-01T10:00:00Z');
+ const end = dayjs('2024-01-01T13:00:00Z');
+
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) => dayjs(t).startOf('day'));
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).isSame(dayjs(b), unit)
);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
- );
- dateTimeUtils.isSame.mockReturnValue(true);
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
- const formatDayLabel = vi.fn((time) => 'Today');
- const result = guideUtils.calculateHourTimeline(
- start,
- end,
- formatDayLabel
- );
+ const formatDayLabel = vi.fn((t) => dayjs(t).format('MMM D'));
+ const result = guideUtils.calculateHourTimeline(start, end, formatDayLabel);
expect(result).toHaveLength(3);
- expect(formatDayLabel).toHaveBeenCalledTimes(3);
});
it('should mark new day transitions', () => {
- const start = dayjs('2024-01-15T23:00:00Z');
- const end = dayjs('2024-01-16T02:00:00Z');
- dateTimeUtils.isBefore.mockImplementation((a, b) =>
+ const start = dayjs('2024-01-01T23:00:00Z');
+ const end = dayjs('2024-01-02T02:00:00Z');
+
+ vi.mocked(dateTimeUtils.isBefore).mockImplementation((a, b) =>
dayjs(a).isBefore(dayjs(b))
);
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
+ vi.mocked(dateTimeUtils.startOfDay).mockImplementation((t) =>
+ dayjs(t).utc().startOf('day')
);
- dateTimeUtils.startOfDay.mockImplementation((time) =>
- dayjs(time).startOf('day')
- );
- dateTimeUtils.isSame.mockImplementation((a, b, unit) =>
- dayjs(a).isSame(dayjs(b), unit)
+ vi.mocked(dateTimeUtils.isSame).mockImplementation((a, b, unit) =>
+ dayjs(a).utc().isSame(dayjs(b).utc(), unit)
);
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => dayjs(t).add(n, u));
- const formatDayLabel = vi.fn((time) => 'Day');
- const result = guideUtils.calculateHourTimeline(
- start,
- end,
- formatDayLabel
- );
+ const formatDayLabel = vi.fn((t) => dayjs(t).utc().format('MMM D'));
+ const result = guideUtils.calculateHourTimeline(start, end, formatDayLabel);
- expect(result[0].isNewDay).toBe(true);
+ expect(result).toHaveLength(3);
+ expect(result[0].isNewDay).toBe(true); // 23:00 UTC — first entry, always new day
+ expect(result[1].isNewDay).toBe(true); // 00:00 UTC — crosses into Jan 2
+ expect(result[2].isNewDay).toBe(false); // 01:00 UTC — same day as 00:00
});
});
+ // ── calculateNowPosition ──────────────────────────────────────────────────
+
describe('calculateNowPosition', () => {
it('should return -1 when now is before start', () => {
- const now = dayjs('2024-01-15T09:00:00Z');
- const start = dayjs('2024-01-15T10:00:00Z');
- const end = dayjs('2024-01-15T18:00:00Z');
- dateTimeUtils.isBefore.mockReturnValue(true);
+ const now = dayjs('2024-01-01T09:00:00Z');
+ const start = dayjs('2024-01-01T10:00:00Z');
+ const end = dayjs('2024-01-01T22:00:00Z');
+ vi.mocked(dateTimeUtils.isBefore).mockReturnValue(true);
+ vi.mocked(dateTimeUtils.isAfter).mockReturnValue(false);
const result = guideUtils.calculateNowPosition(now, start, end);
-
expect(result).toBe(-1);
});
it('should return -1 when now is after end', () => {
- const now = dayjs('2024-01-15T19:00:00Z');
- const start = dayjs('2024-01-15T10:00:00Z');
- const end = dayjs('2024-01-15T18:00:00Z');
- dateTimeUtils.isBefore.mockReturnValue(false);
- dateTimeUtils.isAfter.mockReturnValue(true);
+ const now = dayjs('2024-01-01T23:00:00Z');
+ const start = dayjs('2024-01-01T10:00:00Z');
+ const end = dayjs('2024-01-01T22:00:00Z');
+ vi.mocked(dateTimeUtils.isBefore).mockReturnValue(false);
+ vi.mocked(dateTimeUtils.isAfter).mockReturnValue(true);
const result = guideUtils.calculateNowPosition(now, start, end);
-
expect(result).toBe(-1);
});
it('should calculate position when now is between start and end', () => {
- const now = dayjs('2024-01-15T11:00:00Z');
- const start = dayjs('2024-01-15T10:00:00Z');
- const end = dayjs('2024-01-15T18:00:00Z');
- dateTimeUtils.isBefore.mockReturnValue(false);
- dateTimeUtils.isAfter.mockReturnValue(false);
- dateTimeUtils.diff.mockReturnValue(60);
+ const now = dayjs('2024-01-01T11:00:00Z');
+ const start = dayjs('2024-01-01T10:00:00Z');
+ const end = dayjs('2024-01-01T22:00:00Z');
+ vi.mocked(dateTimeUtils.isBefore).mockReturnValue(false);
+ vi.mocked(dateTimeUtils.isAfter).mockReturnValue(false);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(60); // 60 minutes
const result = guideUtils.calculateNowPosition(now, start, end);
-
- expect(result).toBeGreaterThan(0);
+ // 60 minutes / 15 min increment * MINUTE_BLOCK_WIDTH(112.5)
+ expect(result).toBe((60 / 15) * guideUtils.MINUTE_BLOCK_WIDTH);
});
});
+ // ── calculateScrollPosition ───────────────────────────────────────────────
+
describe('calculateScrollPosition', () => {
it('should calculate scroll position for current time', () => {
- const now = dayjs('2024-01-15T11:00:00Z');
- const start = dayjs('2024-01-15T10:00:00Z');
- const rounded = dayjs('2024-01-15T11:00:00Z');
- dateTimeUtils.roundToNearest.mockReturnValue(rounded);
- dateTimeUtils.diff.mockReturnValue(60);
+ const now = dayjs('2024-01-01T11:00:00Z');
+ const start = dayjs('2024-01-01T10:00:00Z');
+ vi.mocked(dateTimeUtils.roundToNearest).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(60);
const result = guideUtils.calculateScrollPosition(now, start);
-
- expect(result).toBeGreaterThanOrEqual(0);
+ expect(result).toBeGreaterThan(0);
});
it('should return 0 when calculated position is negative', () => {
- const now = dayjs('2024-01-15T10:00:00Z');
- const start = dayjs('2024-01-15T10:00:00Z');
- const rounded = dayjs('2024-01-15T10:00:00Z');
- dateTimeUtils.roundToNearest.mockReturnValue(rounded);
- dateTimeUtils.diff.mockReturnValue(0);
+ const now = dayjs('2024-01-01T10:00:00Z');
+ const start = dayjs('2024-01-01T10:00:00Z');
+ vi.mocked(dateTimeUtils.roundToNearest).mockReturnValue(now);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(0);
const result = guideUtils.calculateScrollPosition(now, start);
-
expect(result).toBe(0);
});
});
+ // ── matchChannelByTvgId ───────────────────────────────────────────────────
+
describe('matchChannelByTvgId', () => {
it('should return null when no matching channel ids', () => {
const channelIdByTvgId = new Map();
- const channelById = new Map();
-
- const result = guideUtils.matchChannelByTvgId(
- channelIdByTvgId,
- channelById,
- 'tvg-1'
- );
+ const channelById = new Map([[1, { id: 1, name: 'ESPN' }]]);
+ const result = guideUtils.matchChannelByTvgId(channelIdByTvgId, channelById, 'tvg-1');
expect(result).toBeNull();
});
it('should return first matching channel', () => {
- const channel = { id: 1, name: 'Channel 1' };
- const channelIdByTvgId = new Map([['tvg-1', [1, 2, 3]]]);
- const channelById = new Map([[1, channel]]);
+ const channelIdByTvgId = new Map([['tvg-1', [1, 2]]]);
+ const channelById = new Map([
+ [1, { id: 1, name: 'ESPN' }],
+ [2, { id: 2, name: 'ESPN HD' }],
+ ]);
- const result = guideUtils.matchChannelByTvgId(
- channelIdByTvgId,
- channelById,
- 'tvg-1'
- );
-
- expect(result).toBe(channel);
+ const result = guideUtils.matchChannelByTvgId(channelIdByTvgId, channelById, 'tvg-1');
+ expect(result).toEqual({ id: 1, name: 'ESPN' });
});
it('should return null when channel not in channelById map', () => {
- const channelIdByTvgId = new Map([['tvg-1', [999]]]);
- const channelById = new Map();
-
- const result = guideUtils.matchChannelByTvgId(
- channelIdByTvgId,
- channelById,
- 'tvg-1'
- );
+ const channelIdByTvgId = new Map([['tvg-1', [99]]]);
+ const channelById = new Map([[1, { id: 1 }]]);
+ const result = guideUtils.matchChannelByTvgId(channelIdByTvgId, channelById, 'tvg-1');
expect(result).toBeNull();
});
});
+ // ── fetchRules ────────────────────────────────────────────────────────────
+
describe('fetchRules', () => {
it('should fetch series rules from API', async () => {
- const mockRules = [{ id: 1, tvg_id: 'tvg-1' }];
- API.listSeriesRules.mockResolvedValue(mockRules);
+ const rules = [{ tvg_id: 'tvg-1', title: 'Show' }];
+ vi.mocked(API.listSeriesRules).mockResolvedValue(rules);
const result = await guideUtils.fetchRules();
- expect(API.listSeriesRules).toHaveBeenCalledTimes(1);
- expect(result).toBe(mockRules);
+ expect(API.listSeriesRules).toHaveBeenCalled();
+ expect(result).toEqual(rules);
});
});
+ // ── getRuleByProgram ──────────────────────────────────────────────────────
+
describe('getRuleByProgram', () => {
it('should return null when no rules', () => {
- const program = { tvg_id: 'tvg-1', title: 'Show' };
-
- const result = guideUtils.getRuleByProgram(null, program);
-
+ const result = guideUtils.getRuleByProgram(null, { tvg_id: 'tvg-1' });
expect(result).toBeUndefined();
});
it('should find rule by tvg_id without title', () => {
- const rules = [{ tvg_id: 'tvg-1', title: null }];
- const program = { tvg_id: 'tvg-1', title: 'Show' };
-
- const result = guideUtils.getRuleByProgram(rules, program);
-
- expect(result).toBe(rules[0]);
+ const rules = [{ tvg_id: 'tvg-1', title: '' }];
+ const result = guideUtils.getRuleByProgram(rules, { tvg_id: 'tvg-1', title: 'Anything' });
+ expect(result).toEqual(rules[0]);
});
it('should find rule by tvg_id and title', () => {
@@ -974,274 +764,272 @@ describe('guideUtils', () => {
{ tvg_id: 'tvg-1', title: 'Show A' },
{ tvg_id: 'tvg-1', title: 'Show B' },
];
- const program = { tvg_id: 'tvg-1', title: 'Show B' };
-
- const result = guideUtils.getRuleByProgram(rules, program);
-
- expect(result).toBe(rules[1]);
+ const result = guideUtils.getRuleByProgram(rules, { tvg_id: 'tvg-1', title: 'Show B' });
+ expect(result).toEqual(rules[1]);
});
it('should handle string comparison for tvg_id', () => {
- const rules = [{ tvg_id: 123, title: null }];
- const program = { tvg_id: '123', title: 'Show' };
-
- const result = guideUtils.getRuleByProgram(rules, program);
-
- expect(result).toBe(rules[0]);
+ const rules = [{ tvg_id: 123, title: '' }];
+ const result = guideUtils.getRuleByProgram(rules, { tvg_id: '123', title: 'Show' });
+ expect(result).toEqual(rules[0]);
});
});
+ // ── createRecording ───────────────────────────────────────────────────────
+
describe('createRecording', () => {
it('should create recording via API', async () => {
- const channel = { id: 1 };
- const program = {
- start_time: '2024-01-15T10:00:00Z',
- end_time: '2024-01-15T11:00:00Z',
- };
+ vi.mocked(API.createRecording).mockResolvedValue({});
+ const values = { channel_id: 1, start_time: '2024-01-01T10:00:00Z' };
- await guideUtils.createRecording(channel, program);
+ await guideUtils.createRecording(values);
- expect(API.createRecording).toHaveBeenCalledWith({
- channel: '1',
- start_time: program.start_time,
- end_time: program.end_time,
- custom_properties: { program },
- });
+ expect(API.createRecording).toHaveBeenCalledWith(values);
});
});
+ // ── createSeriesRule ──────────────────────────────────────────────────────
+
describe('createSeriesRule', () => {
it('should create series rule via API', async () => {
- const program = { tvg_id: 'tvg-1', title: 'Show' };
- const mode = 'all';
+ vi.mocked(API.createSeriesRule).mockResolvedValue({});
+ const values = { tvg_id: 'tvg-1', title: 'Show' };
- await guideUtils.createSeriesRule(program, mode);
+ await guideUtils.createSeriesRule(values);
- expect(API.createSeriesRule).toHaveBeenCalledWith({
- tvg_id: program.tvg_id,
- mode,
- title: program.title,
- });
+ expect(API.createSeriesRule).toHaveBeenCalledWith(values);
});
});
+ // ── evaluateSeriesRule ────────────────────────────────────────────────────
+
describe('evaluateSeriesRule', () => {
it('should evaluate series rule via API', async () => {
- const program = { tvg_id: 'tvg-1' };
+ vi.mocked(API.evaluateSeriesRules).mockResolvedValue({});
- await guideUtils.evaluateSeriesRule(program);
+ await guideUtils.evaluateSeriesRulesByTvgId('tvg-1');
- expect(API.evaluateSeriesRules).toHaveBeenCalledWith(program.tvg_id);
+ expect(API.evaluateSeriesRules).toHaveBeenCalledWith('tvg-1');
});
});
+ // ── calculateLeftScrollPosition ───────────────────────────────────────────
+
describe('calculateLeftScrollPosition', () => {
it('should calculate left position using startMs', () => {
- const program = {
- startMs: dayjs.utc('2024-01-15T11:00:00Z').valueOf(),
- };
- const start = dayjs.utc('2024-01-15T10:00:00Z').valueOf();
- dateTimeUtils.convertToMs.mockImplementation((time) => {
- if (typeof time === 'number') return time;
- return dayjs.utc(time).valueOf();
- });
+ const startMs = 60 * 60 * 1000; // 1 hour in ms
+ const start = '2024-01-01T00:00:00Z';
+ vi.mocked(dateTimeUtils.convertToMs).mockReturnValue(0);
+ const program = { startMs };
const result = guideUtils.calculateLeftScrollPosition(program, start);
- expect(result).toBeGreaterThanOrEqual(0);
+ // (60 min / 15 min increment) * MINUTE_BLOCK_WIDTH
+ expect(result).toBe((60 / 15) * guideUtils.MINUTE_BLOCK_WIDTH);
});
it('should calculate left position from start_time when no startMs', () => {
- const program = {
- start_time: '2024-01-15T10:30:00Z',
- };
- const start = '2024-01-15T10:00:00Z';
- dateTimeUtils.convertToMs.mockImplementation((time) =>
- dayjs(time).valueOf()
- );
+ const startTimeMs = 30 * 60 * 1000; // 30 min
+ vi.mocked(dateTimeUtils.convertToMs)
+ .mockReturnValueOnce(startTimeMs) // program start_time
+ .mockReturnValueOnce(0); // guide start
- const result = guideUtils.calculateLeftScrollPosition(program, start);
+ const program = { start_time: '2024-01-01T00:30:00Z' };
+ const result = guideUtils.calculateLeftScrollPosition(program, '2024-01-01T00:00:00Z');
- expect(result).toBeGreaterThanOrEqual(0);
+ expect(result).toBe((30 / 15) * guideUtils.MINUTE_BLOCK_WIDTH);
});
});
+ // ── calculateDesiredScrollPosition ────────────────────────────────────────
+
describe('calculateDesiredScrollPosition', () => {
it('should subtract 20 from left position', () => {
const result = guideUtils.calculateDesiredScrollPosition(100);
-
expect(result).toBe(80);
});
it('should return 0 when result would be negative', () => {
const result = guideUtils.calculateDesiredScrollPosition(10);
-
expect(result).toBe(0);
});
});
+ // ── calculateScrollPositionByTimeClick ────────────────────────────────────
+
describe('calculateScrollPositionByTimeClick', () => {
+ const makeEvent = (clientX, rectLeft, rectWidth) => ({
+ currentTarget: {
+ getBoundingClientRect: () => ({ left: rectLeft, width: rectWidth }),
+ },
+ clientX,
+ });
+
it('should calculate scroll position from time click', () => {
- const event = {
- currentTarget: {
- getBoundingClientRect: () => ({ left: 100, width: 450 }),
- },
- clientX: 325,
- };
- const clickedTime = dayjs('2024-01-15T10:00:00Z');
- const start = dayjs('2024-01-15T09:00:00Z');
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
- );
- dateTimeUtils.diff.mockReturnValue(60);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(60);
+ vi.mocked(dateTimeUtils.add).mockImplementation((t, n, u) => ({
+ ...dayjs(t).add(n, u),
+ minute: (m) => dayjs(t).add(n, u).minute(m),
+ }));
- const result = guideUtils.calculateScrollPositionByTimeClick(
- event,
- clickedTime,
- start
- );
+ const clickedTime = { minute: vi.fn().mockReturnThis() };
+ const start = dayjs('2024-01-01T10:00:00Z');
+ // Click at 50% of a 600px element → 30 min into hour → snaps to 30
+ const event = makeEvent(350, 100, 500);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(90);
+
+ const result = guideUtils.calculateScrollPositionByTimeClick(event, clickedTime, start);
expect(result).toBeGreaterThanOrEqual(0);
});
it('should snap to 15-minute increments', () => {
- const event = {
- currentTarget: {
- getBoundingClientRect: () => ({ left: 0, width: 450 }),
- },
- clientX: 112.5,
- };
- const clickedTime = dayjs('2024-01-15T10:00:00Z');
- const start = dayjs('2024-01-15T09:00:00Z');
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
- );
- dateTimeUtils.diff.mockReturnValue(75);
-
- guideUtils.calculateScrollPositionByTimeClick(event, clickedTime, start);
-
- expect(dateTimeUtils.diff).toHaveBeenCalled();
- });
-
- it('should handle click at end of hour', () => {
- const event = {
- currentTarget: {
- getBoundingClientRect: () => ({ left: 0, width: 450 }),
- },
- clientX: 450,
- };
- const clickedTime = dayjs('2024-01-15T10:00:00Z');
- const start = dayjs('2024-01-15T09:00:00Z');
- dateTimeUtils.add.mockImplementation((time, amount, unit) =>
- dayjs(time).add(amount, unit)
- );
- dateTimeUtils.diff.mockReturnValue(120);
+ // Click at 10% of a 600px element → 6 min → snaps to 0
+ const event = makeEvent(160, 100, 600);
+ const clickedTime = { minute: vi.fn().mockReturnThis() };
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(0);
const result = guideUtils.calculateScrollPositionByTimeClick(
event,
clickedTime,
- start
+ dayjs()
);
+ expect(result).toBe(0);
+ });
- expect(dateTimeUtils.add).toHaveBeenCalledWith(
- expect.anything(),
- 1,
- 'hour'
+ it('should handle click at end of hour (snappedMinute === 60)', () => {
+ // 100% across the element → 60 min → snappedMinute = 60 → use add(1, hour).minute(0)
+ const event = makeEvent(700, 100, 600);
+ const nextHour = dayjs('2024-01-01T11:00:00Z');
+ const addResult = { minute: vi.fn().mockReturnValue(nextHour) };
+ vi.mocked(dateTimeUtils.add).mockReturnValue(addResult);
+ vi.mocked(dateTimeUtils.diff).mockReturnValue(60);
+
+ const result = guideUtils.calculateScrollPositionByTimeClick(
+ event,
+ dayjs('2024-01-01T10:00:00Z'),
+ dayjs('2024-01-01T10:00:00Z')
);
+ expect(result).toBeGreaterThanOrEqual(0);
});
});
+ // ── getGroupOptions ───────────────────────────────────────────────────────
+
describe('getGroupOptions', () => {
it('should return only "All" when no channel groups', () => {
const result = guideUtils.getGroupOptions(null, []);
-
- expect(result).toHaveLength(1);
- expect(result[0].value).toBe('all');
+ expect(result).toEqual([{ value: 'all', label: 'All Channel Groups' }]);
});
it('should include groups used by channels', () => {
const channelGroups = {
- 1: { id: 1, name: 'Sports' },
- 2: { id: 2, name: 'News' },
+ 1: { id: 10, name: 'Sports' },
+ 2: { id: 20, name: 'News' },
};
- const channels = [
- { id: 1, channel_group_id: 1 },
- { id: 2, channel_group_id: 1 },
+ const guideChannels = [
+ { id: 1, channel_group_id: 10 },
+ { id: 2, channel_group_id: 20 },
];
- const result = guideUtils.getGroupOptions(channelGroups, channels);
-
- expect(result).toHaveLength(2);
- expect(result[1].label).toBe('Sports');
+ const result = guideUtils.getGroupOptions(channelGroups, guideChannels);
+ expect(result).toHaveLength(3);
+ expect(result.map((o) => o.label)).toContain('Sports');
+ expect(result.map((o) => o.label)).toContain('News');
});
it('should exclude groups not used by any channel', () => {
const channelGroups = {
- 1: { id: 1, name: 'Sports' },
- 2: { id: 2, name: 'News' },
+ 1: { id: 10, name: 'Sports' },
+ 2: { id: 99, name: 'Unused' },
};
- const channels = [{ id: 1, channel_group_id: 1 }];
+ const guideChannels = [{ id: 1, channel_group_id: 10 }];
- const result = guideUtils.getGroupOptions(channelGroups, channels);
-
- expect(result).toHaveLength(2);
- expect(result[1].label).toBe('Sports');
+ const result = guideUtils.getGroupOptions(channelGroups, guideChannels);
+ expect(result.map((o) => o.label)).not.toContain('Unused');
});
it('should sort groups alphabetically', () => {
const channelGroups = {
- 1: { id: 1, name: 'Z Group' },
- 2: { id: 2, name: 'A Group' },
- 3: { id: 3, name: 'M Group' },
+ 1: { id: 10, name: 'Sports' },
+ 2: { id: 20, name: 'Movies' },
+ 3: { id: 30, name: 'News' },
};
- const channels = [
- { id: 1, channel_group_id: 1 },
- { id: 2, channel_group_id: 2 },
- { id: 3, channel_group_id: 3 },
+ const guideChannels = [
+ { id: 1, channel_group_id: 10 },
+ { id: 2, channel_group_id: 20 },
+ { id: 3, channel_group_id: 30 },
];
- const result = guideUtils.getGroupOptions(channelGroups, channels);
-
- expect(result[1].label).toBe('A Group');
- expect(result[2].label).toBe('M Group');
- expect(result[3].label).toBe('Z Group');
+ const result = guideUtils.getGroupOptions(channelGroups, guideChannels);
+ const labels = result.slice(1).map((o) => o.label);
+ expect(labels).toEqual([...labels].sort());
});
});
+ // ── getProfileOptions ─────────────────────────────────────────────────────
+
describe('getProfileOptions', () => {
it('should return only "All" when no profiles', () => {
const result = guideUtils.getProfileOptions(null);
-
- expect(result).toHaveLength(1);
- expect(result[0].value).toBe('all');
+ expect(result).toEqual([{ value: 'all', label: 'All Profiles' }]);
});
it('should include all profiles except id 0', () => {
const profiles = {
- 0: { id: '0', name: 'All' },
- 1: { id: '1', name: 'Profile 1' },
- 2: { id: '2', name: 'Profile 2' },
+ '0': { id: '0', name: 'Default' },
+ '1': { id: '1', name: 'Kids' },
+ '2': { id: '2', name: 'Sports' },
};
const result = guideUtils.getProfileOptions(profiles);
-
- expect(result).toHaveLength(3);
- expect(result[1].label).toBe('Profile 1');
- expect(result[2].label).toBe('Profile 2');
+ expect(result).toHaveLength(3); // All + Kids + Sports
+ expect(result.map((o) => o.label)).not.toContain('Default');
+ expect(result.map((o) => o.label)).toContain('Kids');
+ expect(result.map((o) => o.label)).toContain('Sports');
});
});
+ // ── calcProgressPct ───────────────────────────────────────────────────────
+
+ describe('calcProgressPct', () => {
+ it('should return 0 when now is at start', () => {
+ const result = guideUtils.calcProgressPct(1000, 1000, 60000);
+ expect(result).toBeGreaterThanOrEqual(0);
+ });
+
+ it('should return 1 when now is at or past end', () => {
+ // nowMs >= startMs + durationMs → elapsed >= duration → clamped to 1
+ const startMs = 0;
+ const durationMs = 60 * 60 * 1000; // 1 hour
+ const nowMs = startMs + durationMs + 1000; // past the end
+ const result = guideUtils.calcProgressPct(nowMs, startMs, durationMs);
+ expect(result).toBe(1);
+ });
+
+ it('should return value between 0 and 1 for midpoint', () => {
+ const startMs = 0;
+ const durationMs = 60 * 60 * 1000; // 1 hour
+ const nowMs = 30 * 60 * 1000; // 30 minutes in
+ const result = guideUtils.calcProgressPct(nowMs, startMs, durationMs);
+ expect(result).toBeGreaterThan(0);
+ expect(result).toBeLessThan(1);
+ });
+ });
+
+ // ── formatSeasonEpisode ───────────────────────────────────────────────────
+
describe('formatSeasonEpisode', () => {
it('should format both season and episode', () => {
- expect(guideUtils.formatSeasonEpisode(1, 3)).toBe('S01E03');
+ expect(guideUtils.formatSeasonEpisode(1, 2)).toBe('S01E02');
});
it('should pad numbers to 2 digits', () => {
- expect(guideUtils.formatSeasonEpisode(1, 1)).toBe('S01E01');
+ expect(guideUtils.formatSeasonEpisode(3, 7)).toBe('S03E07');
});
it('should handle large numbers without truncation', () => {
- expect(guideUtils.formatSeasonEpisode(12, 24)).toBe('S12E24');
+ expect(guideUtils.formatSeasonEpisode(10, 10)).toBe('S10E10');
});
it('should handle numbers greater than 99', () => {
@@ -1249,19 +1037,19 @@ describe('guideUtils', () => {
});
it('should return season only when episode is null', () => {
- expect(guideUtils.formatSeasonEpisode(5, null)).toBe('S05');
+ expect(guideUtils.formatSeasonEpisode(2, null)).toBe('S02');
});
it('should return season only when episode is undefined', () => {
- expect(guideUtils.formatSeasonEpisode(5, undefined)).toBe('S05');
+ expect(guideUtils.formatSeasonEpisode(2, undefined)).toBe('S02');
});
it('should return episode only when season is null', () => {
- expect(guideUtils.formatSeasonEpisode(null, 7)).toBe('E07');
+ expect(guideUtils.formatSeasonEpisode(null, 5)).toBe('E05');
});
it('should return episode only when season is undefined', () => {
- expect(guideUtils.formatSeasonEpisode(undefined, 7)).toBe('E07');
+ expect(guideUtils.formatSeasonEpisode(undefined, 5)).toBe('E05');
});
it('should return null when both are null', () => {
@@ -1277,32 +1065,44 @@ describe('guideUtils', () => {
});
it('should handle season zero with episode', () => {
- expect(guideUtils.formatSeasonEpisode(0, 5)).toBe('S00E05');
+ expect(guideUtils.formatSeasonEpisode(0, 1)).toBe('S00E01');
});
});
+ // ── deleteSeriesRuleByTvgId ───────────────────────────────────────────────
+
describe('deleteSeriesRuleByTvgId', () => {
it('should delete series rule via API with tvg_id and title', async () => {
+ vi.mocked(API.deleteSeriesRule).mockResolvedValue({});
+
await guideUtils.deleteSeriesRuleByTvgId('tvg-1', 'My Show');
expect(API.deleteSeriesRule).toHaveBeenCalledWith('tvg-1', 'My Show');
});
it('should forward undefined title when not provided', async () => {
+ vi.mocked(API.deleteSeriesRule).mockResolvedValue({});
+
await guideUtils.deleteSeriesRuleByTvgId('tvg-1');
expect(API.deleteSeriesRule).toHaveBeenCalledWith('tvg-1', undefined);
});
it('should work with empty tvg_id for title-only rules', async () => {
+ vi.mocked(API.deleteSeriesRule).mockResolvedValue({});
+
await guideUtils.deleteSeriesRuleByTvgId('', 'Title-Only Show');
expect(API.deleteSeriesRule).toHaveBeenCalledWith('', 'Title-Only Show');
});
});
+ // ── evaluateSeriesRulesByTvgId ────────────────────────────────────────────
+
describe('evaluateSeriesRulesByTvgId', () => {
it('should evaluate series rules via API', async () => {
+ vi.mocked(API.evaluateSeriesRules).mockResolvedValue({});
+
await guideUtils.evaluateSeriesRulesByTvgId('tvg-1');
expect(API.evaluateSeriesRules).toHaveBeenCalledWith('tvg-1');
From e766c4dd54a9414536a9da4314a243b8ea5e9810 Mon Sep 17 00:00:00 2001
From: Nick Sandstrom <32273437+nick4810@users.noreply.github.com>
Date: Mon, 25 May 2026 18:06:52 -0700
Subject: [PATCH 05/10] Refactored components
---
frontend/src/components/forms/Recording.jsx | 252 ++++--------------
.../forms/RecordingDetailsModal.jsx | 70 ++---
.../components/forms/RecurringRuleModal.jsx | 91 ++-----
.../src/components/forms/ScheduleInput.jsx | 12 +-
.../components/forms/SeriesRecordingModal.jsx | 26 +-
.../forms/SeriesRuleEditorModal.jsx | 124 +++------
frontend/src/components/forms/Stream.jsx | 21 +-
.../src/components/forms/StreamProfile.jsx | 81 ++----
.../src/components/forms/SuperuserForm.jsx | 16 +-
frontend/src/components/forms/User.jsx | 228 ++++------------
frontend/src/components/forms/UserAgent.jsx | 28 +-
11 files changed, 270 insertions(+), 679 deletions(-)
diff --git a/frontend/src/components/forms/Recording.jsx b/frontend/src/components/forms/Recording.jsx
index 23f78867..163a43a7 100644
--- a/frontend/src/components/forms/Recording.jsx
+++ b/frontend/src/components/forms/Recording.jsx
@@ -1,86 +1,40 @@
import React, { useEffect, useMemo, useState } from 'react';
-import dayjs from 'dayjs';
-import API from '../../api';
import {
Alert,
Button,
+ Group,
+ Loader,
Modal,
+ MultiSelect,
+ SegmentedControl,
Select,
Stack,
- SegmentedControl,
- MultiSelect,
- Group,
TextInput,
- Loader,
} from '@mantine/core';
-import { DateTimePicker, TimeInput, DatePickerInput } from '@mantine/dates';
+import { DatePickerInput, DateTimePicker, TimeInput } from '@mantine/dates';
import { CircleAlert } from 'lucide-react';
-import { isNotEmpty, useForm } from '@mantine/form';
+import { useForm } from '@mantine/form';
import useChannelsStore from '../../store/channels';
-import { notifications } from '@mantine/notifications';
-
-const DAY_OPTIONS = [
- { value: '6', label: 'Sun' },
- { value: '0', label: 'Mon' },
- { value: '1', label: 'Tue' },
- { value: '2', label: 'Wed' },
- { value: '3', label: 'Thu' },
- { value: '4', label: 'Fri' },
- { value: '5', label: 'Sat' },
-];
-
-const asDate = (value) => {
- if (!value) return null;
- if (value instanceof Date) return value;
- const parsed = new Date(value);
- return Number.isNaN(parsed.getTime()) ? null : parsed;
-};
-
-const toIsoIfDate = (value) => {
- const dt = asDate(value);
- return dt ? dt.toISOString() : value;
-};
-
-// Accepts "h:mm A"/"hh:mm A"/"HH:mm"/Date, returns "HH:mm"
-const toTimeString = (value) => {
- if (!value) return '00:00';
- if (typeof value === 'string') {
- const parsed = dayjs(
- value,
- ['HH:mm', 'hh:mm A', 'h:mm A', 'HH:mm:ss'],
- true
- );
- if (parsed.isValid()) return parsed.format('HH:mm');
- return value;
- }
- const dt = asDate(value);
- if (!dt) return '00:00';
- return dayjs(dt).format('HH:mm');
-};
-
-const toDateString = (value) => {
- const dt = asDate(value);
- if (!dt) return null;
- const year = dt.getFullYear();
- const month = String(dt.getMonth() + 1).padStart(2, '0');
- const day = String(dt.getDate()).padStart(2, '0');
- return `${year}-${month}-${day}`;
-};
-
-const createRoundedDate = (minutesAhead = 0) => {
- const dt = new Date();
- dt.setSeconds(0);
- dt.setMilliseconds(0);
- dt.setMinutes(Math.ceil(dt.getMinutes() / 30) * 30);
- if (minutesAhead) dt.setMinutes(dt.getMinutes() + minutesAhead);
- return dt;
-};
-
-// robust onChange for TimeInput (string or event)
-const timeChange = (setter) => (valOrEvent) => {
- if (typeof valOrEvent === 'string') setter(valOrEvent);
- else if (valOrEvent?.currentTarget) setter(valOrEvent.currentTarget.value);
-};
+import {
+ RECURRING_DAY_OPTIONS,
+ toTimeString,
+} from '../../utils/dateTimeUtils.js';
+import { showNotification } from '../../utils/notificationUtils.js';
+import {
+ buildRecurringPayload,
+ buildSinglePayload,
+ createRecording,
+ createRecurringRule,
+ getChannelsSummary,
+ getRecurringFormDefaults,
+ getSingleFormDefaults,
+ numberedChannelLabel,
+ recurringFormValidators,
+ singleFormValidators,
+ sortedChannelOptions,
+ timeChange,
+ updateRecording,
+} from '../../utils/forms/RecordingUtils.js';
const RecordingModal = ({
recording = null,
@@ -98,117 +52,29 @@ const RecordingModal = ({
const [mode, setMode] = useState('single');
const [submitting, setSubmitting] = useState(false);
- const defaultStart = createRoundedDate();
- const defaultEnd = createRoundedDate(60);
- const defaultDate = new Date();
-
- // One-time form
const singleForm = useForm({
mode: 'controlled',
- initialValues: {
- channel_id: recording
- ? `${recording.channel}`
- : channel
- ? `${channel.id}`
- : '',
- start_time: recording
- ? asDate(recording.start_time) || defaultStart
- : defaultStart,
- end_time: recording
- ? asDate(recording.end_time) || defaultEnd
- : defaultEnd,
- },
- validate: {
- channel_id: isNotEmpty('Select a channel'),
- start_time: isNotEmpty('Select a start time'),
- end_time: (value, values) => {
- const start = asDate(values.start_time);
- const end = asDate(value);
- if (!end) return 'Select an end time';
- if (start && end <= start) return 'End time must be after start time';
- return null;
- },
- },
+ initialValues: getSingleFormDefaults(recording, channel),
+ validate: singleFormValidators,
});
- // Recurring form stores times as "HH:mm" strings for stable editing
const recurringForm = useForm({
mode: 'controlled',
validateInputOnChange: false,
validateInputOnBlur: true,
- initialValues: {
- channel_id: channel ? `${channel.id}` : '',
- days_of_week: [],
- start_time: dayjs(defaultStart).format('HH:mm'),
- end_time: dayjs(defaultEnd).format('HH:mm'),
- rule_name: '',
- start_date: defaultDate,
- end_date: defaultDate,
- },
- validate: {
- channel_id: isNotEmpty('Select a channel'),
- days_of_week: (value) =>
- value && value.length ? null : 'Pick at least one day',
- start_time: (value) => (value ? null : 'Select a start time'),
- end_time: (value, values) => {
- if (!value) return 'Select an end time';
- const start = dayjs(
- values.start_time,
- ['HH:mm', 'hh:mm A', 'h:mm A'],
- true
- );
- const end = dayjs(value, ['HH:mm', 'hh:mm A', 'h:mm A'], true);
- if (
- start.isValid() &&
- end.isValid() &&
- end.diff(start, 'minute') === 0
- ) {
- return 'End time must differ from start time';
- }
- return null;
- },
- end_date: (value, values) => {
- const end = asDate(value);
- const start = asDate(values.start_date);
- if (!end) return 'Select an end date';
- if (start && end < start) return 'End date cannot be before start date';
- return null;
- },
- },
+ initialValues: getRecurringFormDefaults(channel),
+ validate: recurringFormValidators,
});
useEffect(() => {
if (!isOpen) return;
- const freshStart = createRoundedDate();
- const freshEnd = createRoundedDate(60);
- const freshDate = new Date();
-
- if (recording && recording.id) {
+ if (recording?.id) {
setMode('single');
- singleForm.setValues({
- channel_id: `${recording.channel}`,
- start_time: asDate(recording.start_time) || defaultStart,
- end_time: asDate(recording.end_time) || defaultEnd,
- });
+ singleForm.setValues(getSingleFormDefaults(recording, channel));
} else {
- // Reset forms for fresh open
- singleForm.setValues({
- channel_id: channel ? `${channel.id}` : '',
- start_time: freshStart,
- end_time: freshEnd,
- });
-
- const startStr = dayjs(freshStart).format('HH:mm');
- recurringForm.setValues({
- channel_id: channel ? `${channel.id}` : '',
- days_of_week: [],
- start_time: startStr,
- end_time: dayjs(freshEnd).format('HH:mm'),
- rule_name: channel?.name || '',
- start_date: freshDate,
- end_date: freshDate,
- });
+ singleForm.setValues(getSingleFormDefaults(null, channel));
+ recurringForm.setValues(getRecurringFormDefaults(channel));
setMode('single');
}
// eslint-disable-next-line react-hooks/exhaustive-deps
@@ -221,7 +87,7 @@ const RecordingModal = ({
if (!isOpen) return;
try {
setIsChannelsLoading(true);
- const chans = await API.getChannelsSummary();
+ const chans = await getChannelsSummary();
if (cancelled) return;
setAllChannels(Array.isArray(chans) ? chans : []);
} catch (e) {
@@ -238,19 +104,7 @@ const RecordingModal = ({
}, [isOpen]);
const channelOptions = useMemo(() => {
- const list = Array.isArray(allChannels) ? [...allChannels] : [];
- list.sort((a, b) => {
- const aNum = Number(a.channel_number) || 0;
- const bNum = Number(b.channel_number) || 0;
- if (aNum === bNum) return (a.name || '').localeCompare(b.name || '');
- return aNum - bNum;
- });
- return list.map((item) => ({
- value: `${item.id}`,
- label: item.channel_number
- ? `${item.channel_number} - ${item.name || `Channel ${item.id}`}`
- : item.name || `Channel ${item.id}`,
- }));
+ return sortedChannelOptions(allChannels, numberedChannelLabel);
}, [allChannels]);
const resetForms = () => {
@@ -267,25 +121,18 @@ const RecordingModal = ({
const handleSingleSubmit = async (values) => {
try {
setSubmitting(true);
+ const payload = buildSinglePayload(values);
if (recording && recording.id) {
- await API.updateRecording(recording.id, {
- channel: values.channel_id,
- start_time: toIsoIfDate(values.start_time),
- end_time: toIsoIfDate(values.end_time),
- });
- notifications.show({
+ await updateRecording(recording.id, payload);
+ showNotification({
title: 'Recording updated',
message: 'Recording schedule updated successfully',
color: 'green',
autoClose: 2500,
});
} else {
- await API.createRecording({
- channel: values.channel_id,
- start_time: toIsoIfDate(values.start_time),
- end_time: toIsoIfDate(values.end_time),
- });
- notifications.show({
+ await createRecording(payload);
+ showNotification({
title: 'Recording scheduled',
message: 'One-time recording added to DVR queue',
color: 'green',
@@ -304,18 +151,10 @@ const RecordingModal = ({
const handleRecurringSubmit = async (values) => {
try {
setSubmitting(true);
- await API.createRecurringRule({
- channel: values.channel_id,
- days_of_week: (values.days_of_week || []).map((d) => Number(d)),
- start_time: toTimeString(values.start_time),
- end_time: toTimeString(values.end_time),
- start_date: toDateString(values.start_date),
- end_date: toDateString(values.end_date),
- name: values.rule_name?.trim() || '',
- });
+ await createRecurringRule(buildRecurringPayload(values));
await Promise.all([fetchRecurringRules(), fetchRecordings()]);
- notifications.show({
+ showNotification({
title: 'Recurring rule saved',
message: 'Future slots will be scheduled automatically',
color: 'green',
@@ -427,7 +266,10 @@ const RecordingModal = ({
key={recurringForm.key('days_of_week')}
label="Every"
placeholder="Select days"
- data={DAY_OPTIONS}
+ data={RECURRING_DAY_OPTIONS.map((opt) => ({
+ value: String(opt.value),
+ label: opt.label,
+ }))}
searchable
clearable
nothingFoundMessage="No match"
diff --git a/frontend/src/components/forms/RecordingDetailsModal.jsx b/frontend/src/components/forms/RecordingDetailsModal.jsx
index bc8b245f..43351765 100644
--- a/frontend/src/components/forms/RecordingDetailsModal.jsx
+++ b/frontend/src/components/forms/RecordingDetailsModal.jsx
@@ -1,11 +1,13 @@
import useChannelsStore from '../../store/channels.jsx';
-import API from '../../api';
import {
+ format,
+ isAfter,
+ isBefore,
useDateTimeFormat,
useTimeHelpers,
} from '../../utils/dateTimeUtils.js';
-import React from 'react';
-import { Pencil, RefreshCcw, Check, X } from 'lucide-react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import { Check, Pencil, RefreshCcw, X } from 'lucide-react';
import {
ActionIcon,
Badge,
@@ -21,7 +23,6 @@ import {
TextInput,
} from '@mantine/core';
import useVideoStore from '../../store/useVideoStore.jsx';
-import { notifications } from '@mantine/notifications';
import defaultLogo from '../../images/logo.png';
import {
deleteRecordingById,
@@ -33,10 +34,14 @@ import {
runComSkip,
} from '../../utils/cards/RecordingCardUtils.js';
import {
+ getChannel,
getRating,
getStatRows,
getUpcomingEpisodes,
+ refreshArtwork,
+ updateRecordingMetadata,
} from '../../utils/forms/RecordingDetailsModalUtils.js';
+import { showNotification } from '../../utils/notificationUtils.js';
const RecordingDetailsModal = ({
opened,
@@ -51,21 +56,21 @@ const RecordingDetailsModal = ({
}) => {
const allRecordings = useChannelsStore((s) => s.recordings);
// Local channel cache to avoid the global channels map
- const [channelsById, setChannelsById] = React.useState({});
+ const [channelsById, setChannelsById] = useState({});
const { toUserTime, userNow } = useTimeHelpers();
- const [childOpen, setChildOpen] = React.useState(false);
- const [childRec, setChildRec] = React.useState(null);
+ const [childOpen, setChildOpen] = useState(false);
+ const [childRec, setChildRec] = useState(null);
const { timeFormat: timeformat, dateFormat: dateformat } =
useDateTimeFormat();
- const [editing, setEditing] = React.useState(false);
+ const [editing, setEditing] = useState(false);
// Prefer the store version of the recording for live updates
// (e.g., after artwork refresh or metadata edit via WebSocket).
// Preserve _group_count from the categorized prop — the store version
// doesn't carry this client-side field, so without merging it back
// isSeriesGroup would always be false and the episode list hidden.
- const safeRecording = React.useMemo(() => {
+ const safeRecording = useMemo(() => {
if (recording?.id && Array.isArray(allRecordings)) {
const found = allRecordings.find((r) => r.id === recording.id);
if (found) {
@@ -81,7 +86,7 @@ const RecordingDetailsModal = ({
const program = customProps.program || {};
// Derive poster URL from live store data instead of the stale prop snapshot.
- const livePosterUrl = React.useMemo(
+ const livePosterUrl = useMemo(
() =>
getPosterUrl(
customProps.poster_logo_id,
@@ -93,17 +98,17 @@ const RecordingDetailsModal = ({
// Optimistic overrides — show saved values immediately without waiting
// for the WebSocket round-trip to refresh the store.
- const [savedTitle, setSavedTitle] = React.useState(null);
- const [savedDescription, setSavedDescription] = React.useState(null);
+ const [savedTitle, setSavedTitle] = useState(null);
+ const [savedDescription, setSavedDescription] = useState(null);
const recordingName = savedTitle ?? (program.title || 'Custom Recording');
const description =
savedDescription ?? (program.description || customProps.description || '');
- const [editTitle, setEditTitle] = React.useState('');
- const [editDescription, setEditDescription] = React.useState('');
+ const [editTitle, setEditTitle] = useState('');
+ const [editDescription, setEditDescription] = useState('');
// Reset optimistic state when the recording changes
- React.useEffect(() => {
+ useEffect(() => {
setSavedTitle(null);
setSavedDescription(null);
setEditing(false);
@@ -129,7 +134,7 @@ const RecordingDetailsModal = ({
const isSeriesGroup = Boolean(
safeRecording._group_count && safeRecording._group_count > 1
);
- const upcomingEpisodes = React.useMemo(() => {
+ const upcomingEpisodes = useMemo(() => {
return getUpcomingEpisodes(
isSeriesGroup,
allRecordings,
@@ -147,7 +152,7 @@ const RecordingDetailsModal = ({
]);
// Ensure channel is available for a given id
- const loadChannel = React.useCallback(
+ const loadChannel = useCallback(
async (id) => {
if (!id) {
return null;
@@ -159,7 +164,7 @@ const RecordingDetailsModal = ({
}
try {
- const ch = await API.getChannel(id);
+ const ch = await getChannel(id);
if (ch && ch.id === id) {
setChannelsById((prev) => ({ ...prev, [id]: ch }));
return ch;
@@ -177,7 +182,7 @@ const RecordingDetailsModal = ({
);
// When opening a child episode, fetch that episode's channel
- React.useEffect(() => {
+ useEffect(() => {
if (!childOpen || !childRec) return;
loadChannel(childRec.channel);
}, [childOpen, childRec, loadChannel]);
@@ -188,7 +193,7 @@ const RecordingDetailsModal = ({
const s = toUserTime(rec.start_time);
const e = toUserTime(rec.end_time);
- if (now.isAfter(s) && now.isBefore(e)) {
+ if (isAfter(now, s) && isBefore(now, e)) {
const ch =
channelsById[rec.channel] ||
(rec.channel === recording?.channel ? channel : null);
@@ -228,14 +233,11 @@ const RecordingDetailsModal = ({
const saveMetadata = async () => {
try {
- await API.updateRecordingMetadata(recording.id, {
- title: editTitle || 'Custom Recording',
- description: editDescription,
- });
+ await updateRecordingMetadata(recording, editTitle, editDescription);
setSavedTitle(editTitle || 'Custom Recording');
setSavedDescription(editDescription);
setEditing(false);
- notifications.show({
+ showNotification({
title: 'Saved',
message: 'Recording metadata updated',
color: 'green',
@@ -249,8 +251,8 @@ const RecordingDetailsModal = ({
const handleRefreshArtwork = async (e) => {
e.stopPropagation?.();
try {
- await API.refreshArtwork(recording.id);
- notifications.show({
+ await refreshArtwork(recording.id);
+ showNotification({
title: 'Refreshing artwork',
message: 'Poster resolution started',
color: 'blue.5',
@@ -265,7 +267,7 @@ const RecordingDetailsModal = ({
e.stopPropagation?.();
try {
await runComSkip(recording);
- notifications.show({
+ showNotification({
title: 'Removing commercials',
message: 'Queued comskip for this recording',
color: 'blue.5',
@@ -344,8 +346,8 @@ const RecordingDetailsModal = ({
)}
30 14 1 * *
+
+
+ ) : null,
+}));
+
+vi.mock('@mantine/core', async () => ({
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ Flex: ({ children }) => {title}
+
+ {children}
+ {children}
,
+ Button: ({ children, onClick, disabled, loading, color, variant }) => (
+
+ ),
+ Anchor: ({ children, onClick }) => (
+ {children}
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import ProgramRecordingModal from '../ProgramRecordingModal.jsx';
+import { deleteRecordingById, deleteSeriesAndRule } from '../../../utils/cards/RecordingCardUtils.js';
+import { deleteSeriesRuleByTvgId } from '../../../utils/guideUtils.js';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const makeProgram = (overrides = {}) => ({
+ tvg_id: 'tvg-1',
+ title: 'Test Show',
+ ...overrides,
+});
+
+const makeRecording = (overrides = {}) => ({
+ id: 'rec-1',
+ ...overrides,
+});
+
+const defaultProps = (overrides = {}) => ({
+ opened: true,
+ onClose: vi.fn(),
+ program: makeProgram(),
+ recording: null,
+ existingRuleMode: null,
+ existingRule: null,
+ onRecordOne: vi.fn(),
+ onRecordSeriesAll: vi.fn(),
+ onRecordSeriesNew: vi.fn(),
+ onExistingRuleModeChange: vi.fn(),
+ ...overrides,
+});
+
+// ─── ProgramRecordingModal ─────────────────────────────────────────────────────
+
+describe('ProgramRecordingModal', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(deleteRecordingById).mockResolvedValue(undefined);
+ vi.mocked(deleteSeriesAndRule).mockResolvedValue(undefined);
+ vi.mocked(deleteSeriesRuleByTvgId).mockResolvedValue(undefined);
+ });
+
+ // ── Visibility ─────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when opened is true', () => {
+ render(
+ {title}
+ {children}
+
+ ),
+ Button: ({ children, onClick, loading, type }) => (
+
+ ),
+ Group: ({ children }) => {children}
,
+ Loader: ({ size, color }) => ,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ MultiSelect: ({ label, placeholder, ...props }) => (
+ {title}
+
+ {children}
+
+
+
+
+ ),
+ SegmentedControl: ({ value, onChange, data, disabled }) => (
+
+ {data.map((item) => (
+
+ ))}
+
+ ),
+ Select: ({ label, disabled, rightSection, data, ...props }) => (
+
+
+ {rightSection}
+
+
+ ),
+ Stack: ({ children }) => {children}
,
+ TextInput: ({ label, placeholder, ...props }) => (
+
+
+
+
+ ),
+}));
+
+// ── @mantine/dates ─────────────────────────────────────────────────────────────
+vi.mock('@mantine/dates', () => ({
+ DatePickerInput: ({ label, value, onChange }) => (
+
+
+ onChange(e.target.value ? new Date(e.target.value) : null)}
+ />
+
+ ),
+ DateTimePicker: ({ label, ...props }) => (
+
+
+
+
+ ),
+ TimeInput: ({ label, value, onChange, onBlur }) => (
+
+
+
+
+ ),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ CircleAlert: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsStore from '../../../store/channels';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import * as RecordingUtils from '../../../utils/forms/RecordingUtils.js';
+
+const setupStoreMock = () => {
+ const mockFetchRecordings = vi.fn().mockResolvedValue(undefined);
+ const mockFetchRecurringRules = vi.fn().mockResolvedValue(undefined);
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({ fetchRecordings: mockFetchRecordings, fetchRecurringRules: mockFetchRecurringRules })
+ );
+
+ return { mockFetchRecordings, mockFetchRecurringRules };
+};
+
+const makeRecording = (overrides = {}) => ({
+ id: 'rec-1',
+ start_time: '2024-06-01T10:00:00Z',
+ end_time: '2024-06-01T11:00:00Z',
+ custom_properties: { program: { title: 'Test Show' } },
+ ...overrides,
+});
+
+const makeChannel = () => ({ id: 'ch-1', name: 'HBO', channel_number: 501 });
+
+describe('RecordingModal', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(RecordingUtils.getChannelsSummary).mockResolvedValue([
+ { id: 'ch-1', name: 'HBO', channel_number: 501 },
+ ]);
+ vi.mocked(RecordingUtils.createRecording).mockResolvedValue(undefined);
+ vi.mocked(RecordingUtils.updateRecording).mockResolvedValue(undefined);
+ vi.mocked(RecordingUtils.createRecurringRule).mockResolvedValue(undefined);
+ setupStoreMock();
+ });
+
+ // ── Visibility ─────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when isOpen is true', () => {
+ render({children}
+ ),
+ Flex: ({ children }) => {children}
,
+ Group: ({ children }) => {children}
,
+ Image: ({ src, alt, fallbackSrc }) => (
+
+
+ ) : null,
+ Stack: ({ children }) => {title}
+
+ {children}
+ {children}
,
+ Text: ({ children, size, c, fw, style }) => (
+ {children}
+ ),
+ Textarea: ({ label, value, onChange, placeholder, ...props }) => (
+
+
+
+
+ ),
+ TextInput: ({ label, value, onChange, placeholder, ...props }) => (
+
+
+
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import RecordingDetailsModal from '../RecordingDetailsModal';
+import useChannelsStore from '../../../store/channels.jsx';
+import useVideoStore from '../../../store/useVideoStore.jsx';
+import {
+ format,
+ isAfter,
+ isBefore,
+ useDateTimeFormat,
+ useTimeHelpers,
+} from '../../../utils/dateTimeUtils.js';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import * as RecordingCardUtils from '../../../utils/cards/RecordingCardUtils.js';
+import * as RecordingDetailsModalUtils from '../../../utils/forms/RecordingDetailsModalUtils.js';
+import dayjs from 'dayjs';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const PAST = '2020-01-01T10:00:00Z';
+const FUTURE = '2099-01-01T10:00:00Z';
+const NOW = '2024-06-01T12:00:00Z';
+
+const makeMoment = (isoString) => {
+ const d = dayjs(isoString);
+ return {
+ isAfter: (other) => d.isAfter(other?._d ?? other),
+ isBefore: (other) => d.isBefore(other?._d ?? other),
+ format: vi.fn((fmt) => d.format(fmt)),
+ _d: d.toDate(),
+ };
+};
+
+const makeRecording = (overrides = {}) => ({
+ id: 'rec-1',
+ channel: 'ch-1',
+ start_time: PAST,
+ end_time: PAST,
+ _group_count: 1,
+ custom_properties: {
+ status: 'completed',
+ file_url: '/recordings/test.ts',
+ program: {
+ title: 'Test Show',
+ description: 'A test description',
+ sub_title: 'Pilot',
+ },
+ ...overrides.custom_properties,
+ },
+ ...overrides,
+});
+
+const makeChannel = () => ({ id: 'ch-1', name: 'HBO', channel_number: 501 });
+
+const mockShowVideo = vi.fn();
+
+const setupMocks = ({ recording = makeRecording(), now = NOW } = {}) => {
+ const nowMoment = makeMoment(now);
+ const startMoment = makeMoment(recording.start_time);
+ const endMoment = makeMoment(recording.end_time);
+
+ vi.mocked(useTimeHelpers).mockReturnValue({
+ toUserTime: (iso) => {
+ if (iso === recording.start_time) return startMoment;
+ if (iso === recording.end_time) return endMoment;
+ return makeMoment(iso);
+ },
+ userNow: () => nowMoment,
+ });
+
+ vi.mocked(useDateTimeFormat).mockReturnValue({
+ timeFormat: 'HH:mm',
+ dateFormat: 'MM/DD',
+ });
+
+ vi.mocked(format).mockImplementation((moment, fmt) => moment.format(fmt));
+ vi.mocked(isAfter).mockImplementation((a, b) => a.isAfter(b));
+ vi.mocked(isBefore).mockImplementation((a, b) => a.isBefore(b));
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({ recordings: [recording] })
+ );
+
+ mockShowVideo.mockReset();
+ vi.mocked(useVideoStore).mockImplementation((sel) =>
+ sel({ showVideo: mockShowVideo })
+ );
+ useVideoStore.getState = vi.fn(() => ({ showVideo: mockShowVideo }));
+
+ vi.mocked(RecordingCardUtils.getPosterUrl).mockReturnValue('/poster.jpg');
+ vi.mocked(RecordingCardUtils.getChannelLogoUrl).mockReturnValue('/logo.png');
+ vi.mocked(RecordingCardUtils.getRecordingUrl).mockReturnValue('/recordings/test.ts');
+ vi.mocked(RecordingCardUtils.getSeasonLabel).mockReturnValue('');
+ vi.mocked(RecordingCardUtils.getShowVideoUrl).mockReturnValue('/live/ch-1');
+
+ vi.mocked(RecordingDetailsModalUtils.getRating).mockReturnValue(null);
+ vi.mocked(RecordingDetailsModalUtils.getStatRows).mockReturnValue([]);
+ vi.mocked(RecordingDetailsModalUtils.getUpcomingEpisodes).mockReturnValue([]);
+ vi.mocked(RecordingDetailsModalUtils.getChannel).mockResolvedValue(null);
+};
+
+const defaultProps = () => ({
+ opened: true,
+ onClose: vi.fn(),
+ recording: makeRecording(),
+ channel: makeChannel(),
+ posterUrl: '/poster.jpg',
+ onWatchLive: vi.fn(),
+ onWatchRecording: vi.fn(),
+ env_mode: 'production',
+ onEdit: vi.fn(),
+});
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+describe('RecordingDetailsModal', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+ vi.mocked(RecordingDetailsModalUtils.updateRecordingMetadata).mockResolvedValue(undefined);
+ vi.mocked(RecordingDetailsModalUtils.refreshArtwork).mockResolvedValue(undefined);
+ vi.mocked(RecordingCardUtils.runComSkip).mockResolvedValue(undefined);
+ vi.mocked(RecordingCardUtils.deleteRecordingById).mockResolvedValue(undefined);
+ });
+
+ // ── Visibility ───────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when opened is true', () => {
+ render({children}
,
+ Group: ({ children }) => {children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ MultiSelect: ({ label, data, ...props }) => (
+ {title}
+
+ {children}
+
+
+
+
+ ),
+ Select: ({ label, data, ...props }) => (
+
+
+
+
+ ),
+ Stack: ({ children }) => {children}
,
+ Switch: ({ checked, onChange, label, disabled }) => (
+
+ ),
+ Text: ({ children, size, c, fw }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ label, placeholder, ...props }) => (
+
+
+
+
+ ),
+}));
+
+// ── @mantine/dates ─────────────────────────────────────────────────────────────
+vi.mock('@mantine/dates', () => ({
+ DatePickerInput: ({ label, value, onChange }) => (
+
+
+ onChange(e.target.value ? new Date(e.target.value) : null)}
+ />
+
+ ),
+ TimeInput: ({ label, value, onChange }) => (
+
+
+ onChange(e.target.value)}
+ />
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsStore from '../../../store/channels.jsx';
+import {
+ format,
+ toTimeString,
+ useDateTimeFormat,
+ useTimeHelpers,
+} from '../../../utils/dateTimeUtils.js';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import { deleteRecordingById } from '../../../utils/cards/RecordingCardUtils.js';
+import * as RecurringRuleModalUtils from '../../../utils/forms/RecurringRuleModalUtils.js';
+import * as RecordingUtils from '../../../utils/forms/RecordingUtils.js';
+import { useForm } from '@mantine/form';
+import RecurringRuleModal from '../RecurringRuleModal';
+import dayjs from 'dayjs';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const FUTURE = '2099-01-01T10:00:00Z';
+const NOW = '2024-06-01T12:00:00Z';
+
+const makeMoment = (isoString) => {
+ const d = dayjs(isoString);
+ return {
+ isAfter: (other) => d.isAfter(other?._d ?? other),
+ isBefore: (other) => d.isBefore(other?._d ?? other),
+ format: vi.fn((fmt) => `formatted-${fmt}`),
+ _d: d.toDate(),
+ };
+};
+
+const makeRule = (overrides = {}) => ({
+ id: 'rule-1',
+ name: 'Morning News',
+ channel: 'ch-1',
+ channel_id: 'ch-1',
+ days_of_week: ['mon', 'tue'],
+ start_date: new Date('2024-01-01'),
+ end_date: null,
+ start_time: '08:00',
+ end_time: '09:00',
+ enabled: true,
+ ...overrides,
+});
+
+const makeOccurrence = (id = 'occ-1') => ({
+ id,
+ start_time: FUTURE,
+ end_time: FUTURE,
+ custom_properties: { program: { title: 'Episode' } },
+});
+
+const makeChannel = () => ({ id: 'ch-1', name: 'HBO', channel_number: 501 });
+
+const makeRecording = (overrides = {}) => ({
+ id: 'rec-1',
+ start_time: FUTURE,
+ end_time: FUTURE,
+ custom_properties: { program: { title: 'Morning News' } },
+ ...overrides,
+});
+
+const setupMocks = ({ rule = makeRule(), occurrences = [] } = {}) => {
+ const nowMoment = makeMoment(NOW);
+ const mockFetchRecurringRules = vi.fn().mockResolvedValue(undefined);
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({
+ recurringRules: rule ? [rule] : [],
+ fetchRecurringRules: mockFetchRecurringRules,
+ recordings: [],
+ })
+ );
+
+ vi.mocked(useTimeHelpers).mockReturnValue({
+ toUserTime: (iso) => makeMoment(iso),
+ userNow: () => nowMoment,
+ });
+
+ vi.mocked(useDateTimeFormat).mockReturnValue({
+ timeFormat: 'HH:mm',
+ dateFormat: 'MM/DD',
+ });
+
+ vi.mocked(format).mockImplementation((moment, fmt) => `formatted-${fmt}`);
+
+ vi.mocked(RecordingUtils.getRecurringFormDefaults).mockReturnValue({
+ channel_id: '',
+ rule_name: '',
+ days_of_week: [],
+ start_date: new Date('2024-01-01'),
+ end_date: null,
+ start_time: '08:00',
+ end_time: '09:00',
+ enabled: rule?.enabled ?? true,
+ });
+
+ vi.mocked(RecordingUtils.getChannelsSummary).mockResolvedValue([makeChannel()]);
+
+ vi.mocked(RecurringRuleModalUtils.getFormDefaults).mockReturnValue({
+ channel_id: rule?.channel_id ?? '',
+ rule_name: rule?.name ?? '',
+ days_of_week: rule?.days_of_week ?? [],
+ start_date: rule?.start_date ?? new Date('2024-01-01'),
+ end_date: rule?.end_date ?? null,
+ start_time: rule?.start_time ?? '08:00',
+ end_time: rule?.end_time ?? '09:00',
+ enabled: rule?.enabled ?? true,
+ });
+
+ vi.mocked(RecurringRuleModalUtils.getUpcomingOccurrences).mockReturnValue(occurrences);
+ vi.mocked(RecurringRuleModalUtils.updateRecurringRule).mockResolvedValue(undefined);
+ vi.mocked(RecurringRuleModalUtils.updateRecurringRuleEnabled).mockResolvedValue(undefined);
+ vi.mocked(RecurringRuleModalUtils.deleteRecurringRuleById).mockResolvedValue(undefined);
+ vi.mocked(deleteRecordingById).mockResolvedValue(undefined);
+
+ return { mockFetchRecurringRules };
+};
+
+const defaultProps = (overrides = {}) => ({
+ opened: true,
+ onClose: vi.fn(),
+ ruleId: 'rule-1',
+ recording: null,
+ onEditOccurrence: vi.fn(),
+ ...overrides,
+});
+
+// ── Tests ──────────────────────────────────────────────────────────────────────
+describe('RecurringRuleModal', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+ });
+
+ // ── Visibility ───────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when opened is true', () => {
+ render(
+
+
+ {description && {description}}
+ {error && {error}}
+
+ ),
+ NumberInput: ({ label, description, value, onChange, min, disabled }) => (
+
+
+ onChange(Number(e.target.value))}
+ min={min}
+ disabled={disabled}
+ />
+ {description && {description}}
+
+ ),
+ Anchor: ({ children, onClick }) => (
+
+ {children}
+
+ ),
+ Stack: ({ children }) => {children}
,
+ Text: ({ children }) => {children},
+ Code: ({ children }) => {children},
+ Group: ({ children }) => {children}
,
+ Popover: ({ children }) => {children}
,
+ PopoverTarget: ({ children }) => {children}
,
+ PopoverDropdown: ({ children }) => {children}
,
+ ActionIcon: ({ children, onClick }) => (
+
+ ),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ Info: () => ,
+}));
+
+// ── cronUtils ─────────────────────────────────────────────────────────────────
+vi.mock('../../../utils/cronUtils', () => ({
+ validateCronExpression: vi.fn(),
+}));
+
+// ── CronBuilder ────────────────────────────────────────────────────────────────
+vi.mock('../CronBuilder', () => ({
+ default: ({ opened, onClose, onApply, currentValue }) =>
+ opened ? (
+
+ {currentValue}
+
+
+
+ ) : null,
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+import { validateCronExpression } from '../../../utils/cronUtils';
+
+const defaultIntervalProps = () => ({
+ scheduleType: 'interval',
+ onScheduleTypeChange: vi.fn(),
+ intervalValue: 6,
+ onIntervalChange: vi.fn(),
+ cronValue: '',
+ onCronChange: vi.fn(),
+});
+
+const defaultCronProps = () => ({
+ scheduleType: 'cron',
+ onScheduleTypeChange: vi.fn(),
+ cronValue: '0 3 * * *',
+ onCronChange: vi.fn(),
+ intervalValue: 0,
+ onIntervalChange: vi.fn(),
+});
+
+describe('ScheduleInput', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(validateCronExpression).mockReturnValue({ valid: true });
+ });
+
+ // ── Interval mode ────────────────────────────────────────────────────────
+
+ describe('interval mode', () => {
+ it('renders NumberInput in interval mode', () => {
+ render(Custom content
+ Child
+ Child
+
+
+ ) : null,
+ Stack: ({ children }) => {title}
+
+ {children}
+ {children}
,
+ Text: ({ children, size, c, fw }) => (
+
+ {children}
+
+ ),
+ Flex: ({ children }) => {children}
,
+ Group: ({ children }) => {children}
,
+ Button: ({ children, onClick, variant, color, disabled }) => (
+
+ ),
+ Badge: ({ children, color }) => (
+
+ {children}
+
+ ),
+}));
+
+// ── Store ──────────────────────────────────────────────────────────────────────
+vi.mock('../../../store/channels.jsx', () => ({
+ default: { getState: vi.fn() },
+}));
+
+// ── Utils ──────────────────────────────────────────────────────────────────────
+vi.mock('../../../utils/cards/RecordingCardUtils.js', () => ({
+ deleteSeriesAndRule: vi.fn(),
+}));
+
+vi.mock('../../../utils/guideUtils.js', () => ({
+ evaluateSeriesRulesByTvgId: vi.fn(),
+ fetchRules: vi.fn(),
+}));
+
+vi.mock('../../../utils/notificationUtils.js', () => ({
+ showNotification: vi.fn(),
+}));
+
+// ── SeriesRuleEditorModal ──────────────────────────────────────────────────────
+vi.mock('../SeriesRuleEditorModal', () => ({
+ default: ({ opened, onClose, initialRule, onSaved }) =>
+ opened ? (
+
+ {initialRule ? initialRule.title : 'new'}
+
+
+
+ ) : null,
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+import useChannelsStore from '../../../store/channels.jsx';
+import { deleteSeriesAndRule } from '../../../utils/cards/RecordingCardUtils.js';
+import { evaluateSeriesRulesByTvgId, fetchRules } from '../../../utils/guideUtils.js';
+import { showNotification } from '../../../utils/notificationUtils.js';
+
+const makeRule = (overrides = {}) => ({
+ tvg_id: 'tvg-1',
+ title: 'Test Show',
+ mode: 'new',
+ title_mode: 'exact',
+ description: '',
+ channel_id: null,
+ ...overrides,
+});
+
+const defaultProps = (overrides = {}) => ({
+ opened: true,
+ onClose: vi.fn(),
+ rules: [makeRule()],
+ onRulesUpdate: vi.fn(),
+ ...overrides,
+});
+
+const mockFetchRecordings = vi.fn().mockResolvedValue(undefined);
+
+const setupMocks = () => {
+ vi.mocked(useChannelsStore.getState).mockReturnValue({
+ fetchRecordings: mockFetchRecordings,
+ });
+ vi.mocked(fetchRules).mockResolvedValue([makeRule()]);
+ vi.mocked(evaluateSeriesRulesByTvgId).mockResolvedValue(undefined);
+ vi.mocked(deleteSeriesAndRule).mockResolvedValue(undefined);
+};
+
+describe('SeriesRecordingModal', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+ });
+
+ // ── Visibility ─────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders when opened is true', () => {
+ render(
+ {children}
+
+ ),
+ Badge: ({ children, color }) => (
+
+ {children}
+
+ ),
+ Button: ({ children, onClick, disabled, loading, variant }) => (
+
+ ),
+ Divider: () => , + Group: ({ children }) =>
{children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ ScrollAreaAutosize: ({ children }) => {title}
+
+ {children}
+ {children}
,
+ SegmentedControl: ({ data, value, onChange, size }) => (
+
+ {data.map((item) => (
+
+ ))}
+
+ ),
+ Select: ({
+ label,
+ placeholder,
+ data,
+ value,
+ onChange,
+ description,
+ }) => (
+
+
+ {description && (
+ {description}
+ )}
+
+
+ ),
+ Stack: ({ children }) => {children}
,
+ Text: ({ children, size, c, fw }) => (
+
+ {children}
+
+ ),
+ Textarea: ({ label, placeholder, value, onChange, description }) => (
+
+
+ {description && {description}}
+
+
+ ),
+ TextInput: ({ label, placeholder, value, onChange, description }) => (
+
+
+ {description && {description}}
+
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────
+import SeriesRuleEditorModal from '../SeriesRuleEditorModal';
+import useChannelsStore from '../../../store/channels.jsx';
+import useEPGsStore from '../../../store/epgs.jsx';
+import { useDebounce } from '../../../utils.js';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import { getChannelsSummary } from '../../../utils/forms/RecordingUtils.js';
+import { createSeriesRule, evaluateSeriesRulesByTvgId } from '../../../utils/guideUtils.js';
+import {
+ getTvgOptions,
+ previewSeriesRule,
+ formatRange,
+} from '../../../utils/forms/SeriesRuleEditorModalUtils.js';
+
+// ── Shared test data ───────────────────────────────────────────────────────
+const mockTvgs = [
+ { id: 1, tvg_id: 'tvg-1', name: 'Channel One' },
+ { id: 2, tvg_id: 'tvg-2', name: 'Channel Two' },
+];
+
+const mockTvgsById = {
+ 1: { tvg_id: 'tvg-1', name: 'Channel One' },
+ 2: { tvg_id: 'tvg-2', name: 'Channel Two' },
+};
+
+const mockChannels = [
+ { id: 10, name: 'HBO', channel_number: 501, epg_data_id: 1 },
+ { id: 20, name: 'CNN', channel_number: 102, epg_data_id: 2 },
+];
+
+const mockTvgOptions = [
+ { value: 'tvg-1', label: 'Channel One (tvg-1)' },
+ { value: 'tvg-2', label: 'Channel Two (tvg-2)' },
+];
+
+const mockPreviewResponse = {
+ matches: [
+ {
+ id: 'p1',
+ title: 'Match Show',
+ sub_title: 'Episode 1',
+ description: 'A great show',
+ start_time: '2024-01-01T10:00:00Z',
+ end_time: '2024-01-01T11:00:00Z',
+ tvg_id: 'tvg-1',
+ is_new: true,
+ },
+ ],
+ total: 1,
+ epg_found: true,
+};
+
+// ── Setup helper ───────────────────────────────────────────────────────────
+const setupMocks = () => {
+ const mockFetchRecordings = vi.fn().mockResolvedValue(undefined);
+
+ vi.mocked(useEPGsStore).mockImplementation((selector) =>
+ selector({ tvgs: mockTvgs, tvgsById: mockTvgsById })
+ );
+
+ // Mock getState for the imperative call in handleSave
+ useChannelsStore.getState = vi.fn().mockReturnValue({
+ fetchRecordings: mockFetchRecordings,
+ });
+
+ vi.mocked(getTvgOptions).mockReturnValue(mockTvgOptions);
+ vi.mocked(getChannelsSummary).mockResolvedValue(mockChannels);
+ vi.mocked(previewSeriesRule).mockResolvedValue({ matches: [], total: 0, epg_found: true });
+ vi.mocked(createSeriesRule).mockResolvedValue({ id: 'rule-1' });
+ vi.mocked(evaluateSeriesRulesByTvgId).mockResolvedValue(undefined);
+ vi.mocked(useDebounce).mockImplementation((val) => val);
+ vi.mocked(formatRange).mockImplementation((s, e) => `${s} - ${e}`);
+
+ return { mockFetchRecordings };
+};
+
+// ──────────────────────────────────────────────────────────────────────────
+describe('SeriesRuleEditorModal', () => {
+ let defaultProps;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+
+ defaultProps = {
+ opened: true,
+ onClose: vi.fn(),
+ initialRule: null,
+ onSaved: vi.fn(),
+ };
+ });
+
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ // ── Rendering ────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the modal when opened is true', () => {
+ render({children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ Select: ({ label, value, onChange, data, placeholder, error }) => (
+ {title}
+
+ {children}
+
+
+
+ {error && {error}}
+
+ ),
+ TextInput: ({ label, name, value, onChange, error, ...rest }) => (
+
+
+
+ {error && {error}}
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import Stream from '../Stream';
+import useStreamProfilesStore from '../../../store/streamProfiles.jsx';
+import useChannelsStore from '../../../store/channels.jsx';
+import * as StreamUtils from '../../../utils/forms/StreamUtils.js';
+
+// ── Shared test data ───────────────────────────────────────────────────────────
+const mockProfiles = [
+ { id: 1, name: 'Default' },
+ { id: 2, name: 'HD Profile' },
+];
+
+const mockChannelGroups = {
+ 10: { id: 10, name: 'Sports' },
+ 20: { id: 20, name: 'News' },
+};
+
+const makeStream = (overrides = {}) => ({
+ id: 'stream-1',
+ name: 'Test Stream',
+ url: 'http://example.com/stream',
+ channel_group: 10,
+ stream_profile_id: 1,
+ ...overrides,
+});
+
+const setupMocks = () => {
+ vi.mocked(useStreamProfilesStore).mockImplementation((sel) =>
+ sel({ profiles: mockProfiles })
+ );
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({ channelGroups: mockChannelGroups })
+ );
+ vi.mocked(StreamUtils.addStream).mockResolvedValue(undefined);
+ vi.mocked(StreamUtils.updateStream).mockResolvedValue(undefined);
+};
+
+const defaultProps = (overrides = {}) => ({
+ stream: null,
+ isOpen: true,
+ onClose: vi.fn(),
+ ...overrides,
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe('Stream', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ // Reset module-level form state before each test
+ __form.values = {};
+ setupMocks();
+ });
+
+ // ── Visibility ─────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when isOpen is true', () => {
+ render(
+
+ onChange({ currentTarget: { checked: e.target.checked } })}
+ />
+
+ ),
+ Flex: ({ children }) => {children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ Select: ({ label, value, onChange, data, placeholder, error, clearable, disabled, description }) => (
+ {title}
+
+ {children}
+
+
+ {description &&
+ ),
+ Stack: ({ children }) => {description}
}
+
+ {error && {error}}
+ {children}
,
+ Textarea: ({ label, name, value, onChange, error, placeholder, description, disabled, ...rest }) => (
+
+
+ {description &&
+ ),
+ TextInput: ({ label, name, value, onChange, error, disabled, ...rest }) => (
+ {description}
}
+
+ {error && {error}}
+
+
+
+ {error && {error}}
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import StreamProfile from '../StreamProfile';
+import useUserAgentsStore from '../../../store/userAgents';
+import * as StreamProfileUtils from '../../../utils/forms/StreamProfileUtils.js';
+
+// ── Shared test data ───────────────────────────────────────────────────────────
+const mockUserAgents = [
+ { id: 1, name: 'Chrome' },
+ { id: 2, name: 'Firefox' },
+];
+
+const makeProfile = (overrides = {}) => ({
+ id: 'sp-1',
+ name: 'My Profile',
+ command: 'ffmpeg',
+ parameters: '-i {streamUrl}',
+ is_active: true,
+ user_agent: '1',
+ locked: false,
+ ...overrides,
+});
+
+const setupMocks = () => {
+ vi.mocked(useUserAgentsStore).mockImplementation((sel) =>
+ sel({ userAgents: mockUserAgents })
+ );
+ vi.mocked(StreamProfileUtils.addStreamProfile).mockResolvedValue(undefined);
+ vi.mocked(StreamProfileUtils.updateStreamProfile).mockResolvedValue(undefined);
+ vi.mocked(StreamProfileUtils.getResolver).mockReturnValue(undefined);
+ vi.mocked(StreamProfileUtils.toCommandSelection).mockImplementation((cmd) => {
+ const builtins = ['ffmpeg', 'streamlink', 'cvlc', 'yt-dlp'];
+ return builtins.includes(cmd) ? cmd : '__custom__';
+ });
+};
+
+const defaultProps = (overrides = {}) => ({
+ profile: null,
+ isOpen: true,
+ onClose: vi.fn(),
+ ...overrides,
+});
+
+describe('StreamProfile', () => {
+ beforeEach(() => {
+ vi.resetAllMocks();
+ __form.values = {};
+ __form.resetSpy = null;
+ setupMocks();
+ });
+
+ // ── Visibility ──────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders the modal when isOpen is true', () => {
+ render({children}
,
+ Divider: ({ style }) => , + Image: ({ src, alt }) =>
{children}
,
+ Stack: ({ children }) => {children}
,
+ Text: ({ children, size, color, align }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ label, name, value, onChange, required, type }) => (
+
+
+
+
+ ),
+ Title: ({ children, order, align }) => {
+ const Tag = `h${order ?? 1}`;
+ return {children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ MultiSelect: ({ label, onChange }) => (
+ {title}
+
+ {children}
+
+
+ onChange?.(e.target.value ? e.target.value.split(',') : [])}
+ />
+
+ ),
+ NumberInput: ({ label }) => ,
+ PasswordInput: ({ label, disabled }) => (
+
+ ),
+ Select: ({ label, disabled }) => (
+
+ ),
+ Stack: ({ children }) => {children}
,
+ Switch: ({ label }) => ,
+ Tabs: ({ children }) => {children}
,
+ TabsList: ({ children }) => {children}
,
+ TabsPanel: ({ children, value }) => {children}
,
+ TabsTab: ({ children, value }) => ,
+ TagsInput: ({ label }) => ,
+ Text: ({ children }) => {children},
+ TextInput: ({ label, value, disabled, rightSection }) => (
+
+
+
+ {rightSection}
+
+ ),
+ useMantineTheme: () => ({
+ colors: { red: Array(10).fill('#ff0000') },
+ }),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsStore from '../../../store/channels';
+import useOutputProfilesStore from '../../../store/outputProfiles';
+import useAuthStore from '../../../store/auth';
+import * as UserUtils from '../../../utils/forms/UserUtils.js';
+import { copyToClipboard } from '../../../utils';
+import User from '../User';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeAdminUser = (overrides = {}) => ({
+ id: 1,
+ username: 'admin',
+ user_level: 1,
+ api_key: null,
+ ...overrides,
+});
+
+const makeRegularUser = (overrides = {}) => ({
+ id: 2,
+ username: 'user1',
+ user_level: 3,
+ api_key: null,
+ ...overrides,
+});
+
+const setupMocks = ({
+ authUser = makeAdminUser(),
+ profiles = {},
+ outputProfiles = [],
+} = {}) => {
+ const mockSetUser = vi.fn();
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) => sel({ profiles }));
+ vi.mocked(useOutputProfilesStore).mockImplementation((sel) =>
+ sel({ profiles: outputProfiles })
+ );
+ vi.mocked(useAuthStore).mockImplementation((sel) =>
+ sel({ user: authUser, setUser: mockSetUser })
+ );
+
+ // Reset form state
+ mockForm.getValues.mockReturnValue({ user_level: '3' });
+ mockForm.onSubmit.mockImplementation(
+ (fn) => (e) => { e?.preventDefault?.(); return fn(); }
+ );
+
+ return { mockSetUser };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe('User', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(UserUtils.createUser).mockResolvedValue({});
+ vi.mocked(UserUtils.updateUser).mockResolvedValue({});
+ vi.mocked(UserUtils.generateApiKey).mockResolvedValue({ key: 'new-api-key' });
+ vi.mocked(UserUtils.revokeApiKey).mockResolvedValue({ success: true });
+ vi.mocked(UserUtils.formValuesToPayload).mockReturnValue({ user_level: 3 });
+ vi.mocked(UserUtils.getFormInitialValues).mockReturnValue({});
+ vi.mocked(UserUtils.getFormValidators).mockReturnValue({});
+ vi.mocked(UserUtils.userToFormValues).mockReturnValue({});
+ });
+
+ // ── Visibility ───────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders nothing when isOpen is false', () => {
+ setupMocks();
+ render({children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ Space: () => ,
+ TextInput: ({ label, error, ...rest }) => (
+ {title}
+
+ {children}
+
+
+
+ {error && {error}}
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import * as UserAgentUtils from '../../../utils/forms/UserAgentUtils.js';
+import UserAgent from '../UserAgent';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const makeUserAgent = (overrides = {}) => ({
+ id: 1,
+ name: 'Chrome',
+ user_agent: 'Mozilla/5.0',
+ description: 'Chrome browser',
+ is_active: true,
+ ...overrides,
+});
+
+describe('UserAgent', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(UserAgentUtils.addUserAgent).mockResolvedValue({});
+ vi.mocked(UserAgentUtils.updateUserAgent).mockResolvedValue({});
+ vi.mocked(UserAgentUtils.getResolver).mockReturnValue(undefined);
+ });
+
+ // ── Visibility ───────────────────────────────────────────────────────────────
+
+ describe('visibility', () => {
+ it('renders nothing when isOpen is false', () => {
+ render({children}
,
+ Button: ({ children, onClick, disabled, color, variant }) => (
+
+ ),
+ Checkbox: ({ label, checked, onChange, disabled }) => (
+
+ ),
+ Flex: ({ children }) => {children}
,
+ Group: ({ children }) => {children}
,
+ SimpleGrid: ({ children }) => {children}
,
+ Stack: ({ children }) => {children}
,
+ Text: ({ children }) => {children},
+ TextInput: ({ label, value, onChange, placeholder }) => (
+
+ ),
+ SegmentedControl: ({ value, onChange, data }) => (
+
+ {data.map((item) => (
+
+ ))}
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useVODStore from '../../../store/useVODStore';
+import VODCategoryFilter from '../VODCategoryFilter';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const makeCategories = () => [
+ {
+ id: 1,
+ name: 'Action',
+ m3u_accounts: [{ m3u_account: 10, enabled: true }],
+ category_type: 'movies',
+ },
+ { id: 2, name: 'Comedy', m3u_accounts: [{ m3u_account: 10, enabled: false }], category_type: 'movies' },
+ { id: 3, name: 'Drama', m3u_accounts: [{ m3u_account: 10, enabled: true }], category_type: 'movies' },
+ { id: 4, name: 'News', m3u_accounts: [{ m3u_account: 10, enabled: true }], category_type: 'series' },
+];
+
+const makePlaylist = (overrides = {}) => ({ id: 10, name: 'My Playlist', ...overrides });
+
+const categoriesToDict = (arr) =>
+ arr.reduce((acc, cat) => ({ ...acc, [cat.id]: cat }), {});
+
+const setupMocks = ({ categories = makeCategories() } = {}) => {
+ const dict = Array.isArray(categories) ? categoriesToDict(categories) : categories;
+ vi.mocked(useVODStore).mockImplementation((sel) => sel({ categories: dict }));
+};
+
+const defaultProps = (overrides = {}) => {
+ return {
+ playlist: makePlaylist(),
+ categoryStates: [
+ { id: 1, name: 'Action', enabled: true },
+ { id: 2, name: 'Comedy', enabled: false },
+ { id: 3, name: 'Drama', enabled: true },
+ ],
+ setCategoryStates: vi.fn(),
+ type: 'movies',
+ autoEnableNewGroups: true,
+ setAutoEnableNewGroups: vi.fn(),
+ ...overrides,
+ };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe('VODCategoryFilter', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+ });
+
+ // ── Rendering ─────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders without crashing', () => {
+ render({title}
-
+
{children}