chore: import upstream snapshot with attribution

test/providers/video/utils.test.ts

@@ -0,0 +1,101 @@
+import fsPromises from 'fs/promises';
+import path from 'path';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  getCacheMappingPath,
+  readCacheMapping,
+  storeCacheMapping,
+} from '../../../src/providers/video/utils';
+import { getConfigDirectoryPath } from '../../../src/util/config/manage';
+
+vi.mock('fs/promises', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('fs/promises')>();
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      mkdir: vi.fn(),
+      readFile: vi.fn(),
+      writeFile: vi.fn(),
+    },
+    mkdir: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+  };
+});
+
+vi.mock('../../../src/util/config/manage', () => ({
+  getConfigDirectoryPath: vi.fn(),
+}));
+
+vi.mock('../../../src/logger', () => ({
+  default: {
+    debug: vi.fn(),
+  },
+}));
+
+describe('video cache utilities', () => {
+  const expectedMappingPath = path.join(
+    '/tmp/test-config',
+    'media',
+    'video',
+    '_cache',
+    'cache-key.json',
+  );
+  const expectedCacheDir = path.dirname(expectedMappingPath);
+
+  beforeEach(() => {
+    vi.mocked(getConfigDirectoryPath).mockReset();
+    vi.mocked(fsPromises.mkdir).mockReset();
+    vi.mocked(fsPromises.readFile).mockReset();
+    vi.mocked(fsPromises.writeFile).mockReset();
+
+    vi.mocked(getConfigDirectoryPath).mockReturnValue('/tmp/test-config');
+    vi.mocked(fsPromises.mkdir).mockResolvedValue(undefined);
+    vi.mocked(fsPromises.writeFile).mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('reads cache mappings with fs/promises', async () => {
+    vi.mocked(fsPromises.readFile).mockResolvedValue(
+      JSON.stringify({
+        videoKey: 'video/abc.mp4',
+        thumbnailKey: 'video/abc.webp',
+        createdAt: '2026-04-28T00:00:00.000Z',
+      }),
+    );
+
+    await expect(readCacheMapping('cache-key')).resolves.toEqual({
+      videoKey: 'video/abc.mp4',
+      thumbnailKey: 'video/abc.webp',
+      createdAt: '2026-04-28T00:00:00.000Z',
+    });
+    expect(fsPromises.readFile).toHaveBeenCalledWith(expectedMappingPath, 'utf8');
+  });
+
+  it('returns null when a cache mapping does not exist', async () => {
+    vi.mocked(fsPromises.readFile).mockRejectedValue(
+      Object.assign(new Error('ENOENT'), { code: 'ENOENT' }),
+    );
+
+    await expect(readCacheMapping('missing-key')).resolves.toBeNull();
+  });
+
+  it('creates the cache directory before writing mappings', async () => {
+    await storeCacheMapping('cache-key', 'video/abc.mp4', 'video/abc.webp');
+
+    expect(getCacheMappingPath('cache-key')).toBe(expectedMappingPath);
+    expect(fsPromises.mkdir).toHaveBeenCalledWith(expectedCacheDir, {
+      recursive: true,
+    });
+    expect(fsPromises.writeFile).toHaveBeenCalledWith(
+      expectedMappingPath,
+      expect.stringContaining('"videoKey": "video/abc.mp4"'),
+      'utf8',
+    );
+  });
+});