97 lines
3.2 KiB
TypeScript
97 lines
3.2 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from 'vitest';
|
|
|
|
import { ResolvedMediaCache, resolveMedia } from '../../src/ha/resolved-media';
|
|
import { resolvedMediaSchema, type ResolvedMedia } from '../../src/ha/types';
|
|
import { homeAssistantWSRequest } from '../../src/ha/ws-request';
|
|
import { errorToConsole } from '../../src/utils/basic';
|
|
import type * as UtilsBasic from '../../src/utils/basic';
|
|
import { createHASS } from '../test-utils';
|
|
|
|
vi.mock('../../src/ha/ws-request', () => ({
|
|
homeAssistantWSRequest: vi.fn(),
|
|
}));
|
|
vi.mock('../../src/utils/basic', async (importOriginal) => ({
|
|
...(await importOriginal<typeof UtilsBasic>()),
|
|
errorToConsole: vi.fn(),
|
|
}));
|
|
|
|
describe('ResolvedMediaCache', () => {
|
|
it('should store and retrieve values', () => {
|
|
const cache = new ResolvedMediaCache();
|
|
const key = 'media-id';
|
|
const resolvedMedia = {
|
|
id: key,
|
|
title: 'Test Media',
|
|
mime_type: 'video/mp4',
|
|
url: 'http://media',
|
|
media_content_type: 'video',
|
|
media_content_id: key,
|
|
};
|
|
cache.set(key, resolvedMedia);
|
|
expect(cache.get(key)).toBe(resolvedMedia);
|
|
});
|
|
});
|
|
|
|
describe('resolveMedia', () => {
|
|
const mediaContentID = 'media-123';
|
|
const resolvedMedia: ResolvedMedia = {
|
|
mime_type: 'video/mp4',
|
|
url: 'http://media',
|
|
};
|
|
|
|
beforeEach(() => {
|
|
vi.clearAllMocks();
|
|
});
|
|
|
|
it('returns cached value if present', async () => {
|
|
const cache = new ResolvedMediaCache();
|
|
cache.set(mediaContentID, resolvedMedia);
|
|
const result = await resolveMedia(createHASS(), mediaContentID, cache);
|
|
expect(result).toBe(resolvedMedia);
|
|
expect(homeAssistantWSRequest).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('fetches and caches value if not present in cache', async () => {
|
|
vi.mocked(homeAssistantWSRequest).mockResolvedValueOnce(resolvedMedia);
|
|
|
|
const hass = createHASS();
|
|
const cache = new ResolvedMediaCache();
|
|
const result = await resolveMedia(hass, mediaContentID, cache);
|
|
|
|
expect(homeAssistantWSRequest).toHaveBeenCalledWith(
|
|
hass,
|
|
resolvedMediaSchema,
|
|
expect.objectContaining({
|
|
type: 'media_source/resolve_media',
|
|
media_content_id: mediaContentID,
|
|
}),
|
|
);
|
|
expect(result).toEqual(resolvedMedia);
|
|
expect(cache.get(mediaContentID)).toEqual(resolvedMedia);
|
|
});
|
|
|
|
it('returns null and logs error if request fails', async () => {
|
|
const error = new Error('fail');
|
|
vi.mocked(homeAssistantWSRequest).mockRejectedValueOnce(error);
|
|
|
|
const cache = new ResolvedMediaCache();
|
|
const result = await resolveMedia(createHASS(), mediaContentID, cache);
|
|
expect(result).toBeNull();
|
|
expect(errorToConsole).toHaveBeenCalledWith(error);
|
|
});
|
|
|
|
it('does not cache null results', async () => {
|
|
vi.mocked(homeAssistantWSRequest).mockResolvedValueOnce(null);
|
|
const cache = new ResolvedMediaCache();
|
|
const result = await resolveMedia(createHASS(), mediaContentID, cache);
|
|
expect(result).toBeNull();
|
|
expect(cache.get(mediaContentID)).toBeNull();
|
|
});
|
|
|
|
it('works without cache argument', async () => {
|
|
vi.mocked(homeAssistantWSRequest).mockResolvedValueOnce(resolvedMedia);
|
|
const result = await resolveMedia(createHASS(), mediaContentID);
|
|
expect(result).toEqual(resolvedMedia);
|
|
});
|
|
});
|