feat: Implement basic general folder support (#2051)

- Related: #1748
2025-05-21 19:59:21 -07:00
parent 2eb0d9e35e
commit c6a4c8aea2
350 changed files with 12837 additions and 4509 deletions
@@ -0,0 +1,172 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { FoldersExecutor } from '../../../src/card-controller/folders/executor';
+import { HAFoldersEngine } from '../../../src/card-controller/folders/ha/engine';
+import { FolderQuery } from '../../../src/card-controller/folders/types';
+import { FolderConfig } from '../../../src/config/schema/folders';
+import { Endpoint } from '../../../src/types';
+import { ViewFolder } from '../../../src/view/item';
+import { createFolder, createHASS, TestViewMedia } from '../../test-utils';
+
+vi.mock('../../../src/card-controller/folders/ha/engine');
+vi.mock('../../../../src/utils/ha/download');
+
+describe('FoldersExecutor', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getItemCapabilities', () => {
+    it('should not get capabilities for non-folder media', () => {
+      const item = new TestViewMedia({ folder: null });
+      const executor = new FoldersExecutor();
+
+      expect(executor.getItemCapabilities(item)).toBeNull();
+    });
+
+    it('should not get capabilities for non-existent folder engine', () => {
+      const folder: FolderConfig = {
+        type: 'UNKNOWN',
+      } as unknown as FolderConfig;
+      const item = new TestViewMedia({ folder });
+      const executor = new FoldersExecutor();
+
+      expect(executor.getItemCapabilities(item)).toBeNull();
+    });
+
+    it('should get capabilities for HA folder engine', () => {
+      const folder = createFolder();
+      const item = new TestViewMedia({ folder });
+
+      const capabilities = {
+        canFavorite: false,
+        canDownload: true,
+      };
+      const haFolderEngine = mock<HAFoldersEngine>();
+      haFolderEngine.getItemCapabilities.mockReturnValue(capabilities);
+
+      const executor = new FoldersExecutor({
+        ha: haFolderEngine,
+      });
+
+      expect(executor.getItemCapabilities(item)).toEqual(capabilities);
+    });
+  });
+
+  describe('getDownloadPath', () => {
+    it('should not get download path for non-existent folder engine', async () => {
+      const folder: FolderConfig = {
+        type: 'UNKNOWN',
+      } as unknown as FolderConfig;
+      const item = new TestViewMedia({ folder });
+      const executor = new FoldersExecutor();
+
+      expect(await executor.getDownloadPath(createHASS(), item)).toBeNull();
+    });
+
+    it('should get download path for HA folder engine', async () => {
+      const endpoint: Endpoint = { endpoint: '/media', sign: false };
+      const haFolderEngine = mock<HAFoldersEngine>();
+      haFolderEngine.getDownloadPath.mockResolvedValue(endpoint);
+
+      const executor = new FoldersExecutor({
+        ha: haFolderEngine,
+      });
+      const item = new TestViewMedia({ folder: createFolder() });
+      expect(await executor.getDownloadPath(createHASS(), item)).toEqual(endpoint);
+    });
+  });
+
+  describe('favorite', () => {
+    it('should not favorite non-existent folder engine', async () => {
+      const folder: FolderConfig = {
+        type: 'UNKNOWN',
+      } as unknown as FolderConfig;
+      const item = new TestViewMedia({ folder });
+      const executor = new FoldersExecutor();
+
+      await executor.favorite(createHASS(), item, true);
+
+      // No observable effect.
+    });
+
+    it('should favorite', async () => {
+      const haFolderEngine = mock<HAFoldersEngine>();
+      const executor = new FoldersExecutor({
+        ha: haFolderEngine,
+      });
+
+      const hass = createHASS();
+      const item = new TestViewMedia({ folder: createFolder() });
+
+      await executor.favorite(hass, item, true);
+
+      expect(haFolderEngine.favorite).toBeCalledWith(hass, item, true);
+    });
+  });
+
+  describe('generateDefaultFolderQuery', () => {
+    it('should generate default folder query', () => {
+      const folder: FolderConfig = createFolder();
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      const haFolderEngine = mock<HAFoldersEngine>();
+      haFolderEngine.generateDefaultFolderQuery.mockReturnValue(query);
+      const executor = new FoldersExecutor({ ha: haFolderEngine });
+
+      expect(executor.generateDefaultFolderQuery(folder)).toEqual(query);
+    });
+
+    it('should return null for non-existent folder engine', () => {
+      const folder: FolderConfig = {
+        type: 'UNKNOWN',
+      } as unknown as FolderConfig;
+      const executor = new FoldersExecutor();
+
+      expect(executor.generateDefaultFolderQuery(folder)).toBeNull();
+    });
+  });
+
+  describe('expandFolder', () => {
+    it('should reject folders of the wrong type', async () => {
+      const query = {
+        folder: { type: 'UNKNOWN' },
+      } as unknown as FolderQuery;
+
+      const executor = new FoldersExecutor();
+
+      expect(await executor.expandFolder(createHASS(), query)).toBeNull();
+    });
+
+    it('should expand folder', async () => {
+      const folder = createFolder();
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      const mediaItem = new TestViewMedia({
+        folder,
+        startTime: new Date('2023-04-29T14:27'),
+      });
+      const folderItem = new ViewFolder(folder);
+
+      const haFolderEngine = mock<HAFoldersEngine>();
+      haFolderEngine.expandFolder.mockResolvedValue([folderItem, mediaItem, folderItem]);
+
+      const executor = new FoldersExecutor({
+        ha: haFolderEngine,
+      });
+      const hass = createHASS();
+      const results = await executor.expandFolder(hass, query);
+      expect(results).toEqual([
+        // Folder will have been sorted to the front and de-duped.
+        folderItem,
+        mediaItem,
+      ]);
+    });
+  });
+});
@@ -0,0 +1,370 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { HAFoldersEngine } from '../../../../src/card-controller/folders/ha/engine';
+import { FolderQuery } from '../../../../src/card-controller/folders/types';
+import { FolderConfig } from '../../../../src/config/schema/folders';
+import { getMediaDownloadPath } from '../../../../src/ha/download';
+import { homeAssistantWSRequest } from '../../../../src/ha/ws-request';
+import { Endpoint } from '../../../../src/types';
+import { ViewFolder, ViewMedia } from '../../../../src/view/item';
+import {
+  createBrowseMedia,
+  createFolder,
+  createHASS,
+  TestViewMedia,
+} from '../../../test-utils';
+
+vi.mock('../../../../src/ha/download');
+vi.mock('../../../../src/ha/ws-request');
+
+describe('HAFoldersEngine', () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('getItemCapabilities', () => {
+    it('should not be able to download a folder', () => {
+      const item = new ViewFolder(createFolder());
+      const engine = new HAFoldersEngine();
+
+      expect(engine.getItemCapabilities(item)).toEqual({
+        canFavorite: false,
+        canDownload: false,
+      });
+    });
+
+    it('should be able to download a media item', () => {
+      const item = new TestViewMedia({ folder: createFolder() });
+      const engine = new HAFoldersEngine();
+
+      expect(engine.getItemCapabilities(item)).toEqual({
+        canFavorite: false,
+        canDownload: true,
+      });
+    });
+  });
+
+  describe('getDownloadPath', () => {
+    it('should return null if item is not a media item', async () => {
+      const item = new ViewFolder(createFolder());
+      const engine = new HAFoldersEngine();
+      expect(await engine.getDownloadPath(createHASS(), item)).toBeNull();
+    });
+
+    it('should return a download path for a media item', async () => {
+      const item = new TestViewMedia({ folder: createFolder() });
+      const engine = new HAFoldersEngine();
+
+      const endpoint: Endpoint = { endpoint: '/media', sign: false };
+      vi.mocked(getMediaDownloadPath).mockResolvedValue(endpoint);
+
+      expect(await engine.getDownloadPath(createHASS(), item)).toEqual(endpoint);
+    });
+  });
+
+  describe('favorite', () => {
+    it('should favorite', async () => {
+      const engine = new HAFoldersEngine();
+      const item = new TestViewMedia({ folder: createFolder() });
+
+      await engine.favorite(createHASS(), item, true);
+
+      // No observable effect.
+    });
+  });
+
+  describe('expandFolder', () => {
+    it('should reject folders of the wrong type', async () => {
+      const query = {
+        folder: { type: 'UNKNOWN' },
+      } as unknown as FolderQuery;
+      const engine = new HAFoldersEngine();
+
+      expect(await engine.expandFolder(createHASS(), query)).toBeNull();
+    });
+  });
+
+  describe('should generate default folder query', () => {
+    it('should generate default folder query', () => {
+      const folder: FolderConfig = { type: 'ha' };
+      const engine = new HAFoldersEngine();
+
+      const query = engine.generateDefaultFolderQuery(folder);
+      expect(query).toEqual({
+        folder,
+        path: [{ id: 'media-source://', ha: { id: 'media-source://' } }],
+      });
+    });
+
+    it('should reject folders of the wrong type', async () => {
+      const folder = createFolder({ type: 'UNKNOWN' } as unknown as FolderConfig);
+      const engine = new HAFoldersEngine();
+
+      expect(engine.generateDefaultFolderQuery(folder)).toBeNull();
+    });
+
+    it('should respect path_url as a priority', async () => {
+      const folder = createFolder({
+        ha: {
+          url: [{ id: 'media-source://1' }],
+          path: [{ id: 'media-source://2' }],
+        },
+      });
+      const engine = new HAFoldersEngine();
+      expect(engine.generateDefaultFolderQuery(folder)).toEqual({
+        folder,
+        path: [
+          { id: 'media-source://1', ha: { id: 'media-source://1' } },
+          { id: 'media-source://2', ha: { id: 'media-source://2' } },
+        ],
+      });
+    });
+
+    it('should respect configured url', async () => {
+      const folder = createFolder({ ha: { url: [{ id: 'media-source://' }] } });
+      const engine = new HAFoldersEngine();
+      expect(engine.generateDefaultFolderQuery(folder)).toEqual({
+        folder,
+        path: [{ id: 'media-source://', ha: { id: 'media-source://' } }],
+      });
+    });
+
+    it('should add default media root as necessary', async () => {
+      const folder = createFolder({ ha: { path: [{ title: 'Frigate' }] } });
+      const engine = new HAFoldersEngine();
+      expect(engine.generateDefaultFolderQuery(folder)).toEqual({
+        folder,
+        path: [
+          { id: 'media-source://', ha: { id: 'media-source://' } },
+          { id: undefined, ha: { title: 'Frigate' } },
+        ],
+      });
+    });
+  });
+
+  describe('should expand folder', () => {
+    it('should expand folder with cache by default', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        path: [{ id: 'media-source://id' }],
+      };
+
+      vi.mocked(homeAssistantWSRequest).mockResolvedValueOnce(
+        createBrowseMedia({
+          media_content_id: 'media-source://id',
+          can_expand: true,
+          children: [
+            createBrowseMedia({
+              media_content_id: 'media-source://media-item',
+              title: 'Media Item',
+            }),
+            createBrowseMedia({
+              media_content_id: 'media-source://frigate',
+              title: 'Frigate',
+              can_expand: true,
+            }),
+          ],
+        }),
+      );
+
+      const engine = new HAFoldersEngine();
+      const results = await engine.expandFolder(createHASS(), query);
+      expect(results?.length).toBe(2);
+      expect(results?.[0]).toBeInstanceOf(ViewMedia);
+      expect(results?.[1]).toBeInstanceOf(ViewFolder);
+
+      expect(homeAssistantWSRequest).toBeCalledTimes(1);
+
+      // Expanding the folder again should use the cache.
+      await engine.expandFolder(createHASS(), query);
+      expect(homeAssistantWSRequest).toBeCalledTimes(1);
+    });
+
+    it('should expand folder without cache when requested', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        path: [{ id: 'media-source://id' }],
+      };
+
+      vi.mocked(homeAssistantWSRequest)
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://id',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://media-item',
+                title: 'Media Item',
+              }),
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate',
+                title: 'Frigate',
+                can_expand: true,
+              }),
+            ],
+          }),
+        )
+        .mockResolvedValueOnce([]);
+
+      const engine = new HAFoldersEngine();
+      const results = await engine.expandFolder(createHASS(), query, {
+        useCache: false,
+      });
+      expect(results?.length).toBe(2);
+      expect(results?.[0]).toBeInstanceOf(ViewMedia);
+      expect(results?.[1]).toBeInstanceOf(ViewFolder);
+
+      expect(homeAssistantWSRequest).toBeCalledTimes(1);
+
+      // Expanding the folder again should use the cache.
+      await engine.expandFolder(createHASS(), query);
+      expect(homeAssistantWSRequest).toBeCalledTimes(2);
+    });
+
+    it('should not expand without a folder with an id', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        // There's no component in the query with an id to start from.
+        path: [{ ha: { title: 'Frigate' } }],
+      };
+      const engine = new HAFoldersEngine();
+      expect(await engine.expandFolder(createHASS(), query)).toBeNull();
+    });
+
+    it('should expand folder with title based query', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        path: [{ id: 'media-source://' }, { ha: { title: 'Frigate' } }],
+      };
+
+      vi.mocked(homeAssistantWSRequest)
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate',
+                title: 'Frigate',
+                can_expand: true,
+              }),
+            ],
+          }),
+        )
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://frigate',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate/result',
+                title: 'Result',
+              }),
+            ],
+          }),
+        );
+
+      const engine = new HAFoldersEngine();
+      const results = await engine.expandFolder(createHASS(), query);
+      expect(results?.length).toBe(1);
+      expect(results?.[0]).toBeInstanceOf(ViewMedia);
+      expect(results?.[0].getID()).toBe('media-source://frigate/result');
+    });
+
+    it('should expand folder with title_re based query', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        path: [{ id: 'media-source://' }, { ha: { title_re: 'Fri.*' } }],
+      };
+
+      vi.mocked(homeAssistantWSRequest)
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate',
+                title: 'Frigate',
+                can_expand: true,
+              }),
+            ],
+          }),
+        )
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://frigate',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate/result',
+                title: 'Result',
+              }),
+            ],
+          }),
+        );
+
+      const engine = new HAFoldersEngine();
+      const results = await engine.expandFolder(createHASS(), query);
+      expect(results?.length).toBe(1);
+      expect(results?.[0]).toBeInstanceOf(ViewMedia);
+      expect(results?.[0].getID()).toBe('media-source://frigate/result');
+    });
+
+    it('should expand folder with ha id based query', async () => {
+      const query: FolderQuery = {
+        folder: { type: 'ha' },
+        path: [
+          { id: 'media-source://' },
+          { ha: { title: 'Frigate' } },
+          { id: 'media-source://frigate/subdir' },
+        ],
+      };
+
+      vi.mocked(homeAssistantWSRequest)
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate',
+                title: 'Frigate',
+                can_expand: true,
+              }),
+            ],
+          }),
+        )
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://frigate',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate/subdir',
+                can_expand: true,
+              }),
+            ],
+          }),
+        )
+        .mockResolvedValueOnce(
+          createBrowseMedia({
+            media_content_id: 'media-source://frigate/subdir',
+            can_expand: true,
+            children: [
+              createBrowseMedia({
+                media_content_id: 'media-source://frigate/subdir/result',
+                title: 'Result',
+              }),
+            ],
+          }),
+        );
+
+      const engine = new HAFoldersEngine();
+      const results = await engine.expandFolder(createHASS(), query);
+      expect(results?.length).toBe(1);
+      expect(results?.[0]).toBeInstanceOf(ViewMedia);
+      expect(results?.[0].getID()).toBe('media-source://frigate/subdir/result');
+    });
+  });
+});
@@ -0,0 +1,266 @@
+import { describe, expect, it, vi } from 'vitest';
+import { mock } from 'vitest-mock-extended';
+import { FoldersExecutor } from '../../../src/card-controller/folders/executor';
+import { FoldersManager } from '../../../src/card-controller/folders/manager';
+import { FolderQuery } from '../../../src/card-controller/folders/types';
+import { FolderConfig } from '../../../src/config/schema/folders';
+import { ResolvedMediaCache } from '../../../src/ha/resolved-media';
+import { Endpoint } from '../../../src/types';
+import { ViewItemCapabilities } from '../../../src/view/types';
+import {
+  createCardAPI,
+  createFolder,
+  createHASS,
+  TestViewMedia,
+} from '../../test-utils';
+
+describe('FoldersManager', () => {
+  it('should initialize with no folders', () => {
+    const api = createCardAPI();
+    const manager = new FoldersManager(api);
+    expect(manager.getFolderCount()).toBe(0);
+  });
+
+  describe('should add folders', () => {
+    it('should add a folder correctly without a title', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder = createFolder({ id: 'folder-1' });
+
+      manager.addFolders([folder]);
+      expect(manager.getFolderCount()).toBe(1);
+      expect(manager.getFolder('folder-1')).toEqual({
+        ...folder,
+        title: 'Folder 0',
+      });
+    });
+
+    it('should add a folder correctly with a title', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder = createFolder({ id: 'folder-1', title: 'Original Title' });
+
+      manager.addFolders([folder]);
+      expect(manager.getFolderCount()).toBe(1);
+      expect(manager.getFolder('folder-1')).toEqual(folder);
+    });
+
+    it('should add a folder without an id', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder = createFolder({ title: 'Title' });
+
+      manager.addFolders([folder]);
+      expect(manager.getFolderCount()).toBe(1);
+      expect(manager.getFolder('folder/0')).toEqual({
+        ...folder,
+        id: 'folder/0',
+      });
+    });
+
+    it('should reject duplicate folder IDs', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder_1 = createFolder({ id: 'DUP' });
+      const folder_2 = createFolder({ id: 'DUP' });
+
+      expect(() => manager.addFolders([folder_1, folder_2])).toThrowError(
+        /Duplicate folder id/,
+      );
+    });
+
+    it('should preserve previous folders', () => {
+      const manager = new FoldersManager(createCardAPI());
+
+      const folder_original = createFolder();
+      manager.addFolders([folder_original]);
+
+      const folder_new = createFolder({ id: 'DUP' });
+      manager.addFolders([folder_new]);
+
+      expect(manager.getFolderCount()).toBe(2);
+    });
+  });
+
+  it('should delete folders', () => {
+    const manager = new FoldersManager(createCardAPI());
+    const folder_1 = createFolder({ id: 'id-1' });
+    const folder_2 = createFolder({ id: 'id-2' });
+
+    manager.addFolders([folder_1, folder_2]);
+    expect(manager.getFolderCount()).toBe(2);
+
+    manager.deleteFolders();
+    expect(manager.getFolderCount()).toBe(0);
+  });
+
+  describe('should get folders', () => {
+    it('should get default folder', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder = createFolder({ id: 'id', title: 'Title' });
+      manager.addFolders([folder]);
+
+      expect(manager.getFolder()).toEqual(folder);
+    });
+
+    it('should get default folders when there are none', () => {
+      const manager = new FoldersManager(createCardAPI());
+      expect(manager.getFolder()).toBeNull();
+    });
+
+    it('should get all folders', () => {
+      const manager = new FoldersManager(createCardAPI());
+      const folder_1 = createFolder({ id: 'id-1', title: 'Title' });
+      const folder_2 = createFolder({ id: 'id-2', title: 'Title' });
+
+      manager.addFolders([folder_1, folder_2]);
+
+      expect([...manager.getFolders()]).toEqual([
+        ['id-1', folder_1],
+        ['id-2', folder_2],
+      ]);
+    });
+
+    it('should get non-existent folder', () => {
+      const manager = new FoldersManager(createCardAPI());
+      expect(manager.getFolder('NON-EXISTENT')).toBeNull();
+    });
+  });
+
+  describe('generateDefaultFolderQuery', () => {
+    it('should generate default folder query with implicit folder', () => {
+      const folder: FolderConfig = createFolder();
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      const executor = mock<FoldersExecutor>();
+      vi.mocked(executor.generateDefaultFolderQuery).mockReturnValue(query);
+
+      const manager = new FoldersManager(createCardAPI(), executor);
+      manager.addFolders([folder]);
+
+      expect(manager.generateDefaultFolderQuery()).toEqual(query);
+    });
+
+    it('should generate default folder query without any folder', () => {
+      const folder: FolderConfig = createFolder();
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      const executor = mock<FoldersExecutor>();
+      vi.mocked(executor.generateDefaultFolderQuery).mockReturnValue(query);
+
+      const manager = new FoldersManager(createCardAPI(), executor);
+      // Folder is not added to the manager.
+
+      expect(manager.generateDefaultFolderQuery()).toBeNull();
+    });
+
+    it('should generate default folder query with explicit folder', () => {
+      const folder: FolderConfig = createFolder();
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      const executor = mock<FoldersExecutor>();
+      vi.mocked(executor.generateDefaultFolderQuery).mockReturnValue(query);
+
+      const manager = new FoldersManager(createCardAPI(), executor);
+
+      expect(manager.generateDefaultFolderQuery(folder)).toEqual(query);
+    });
+  });
+
+  describe('should expand folder', () => {
+    it('should expand folder with hass', async () => {
+      const hass = createHASS();
+      const api = createCardAPI();
+      vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
+
+      const media = new TestViewMedia();
+      const executor = mock<FoldersExecutor>();
+      executor.expandFolder.mockResolvedValue([media]);
+
+      const manager = new FoldersManager(api, executor);
+
+      const folder = createFolder({ id: 'folder-1' });
+      const engineOptions = {};
+      const query: FolderQuery = {
+        folder,
+        path: ['media-source://'],
+      };
+
+      expect(await manager.expandFolder(query, engineOptions)).toEqual([media]);
+
+      expect(executor.expandFolder).toBeCalledWith(hass, query, engineOptions);
+    });
+
+    it('should not expand folder with hass', async () => {
+      const api = createCardAPI();
+      const executor = mock<FoldersExecutor>();
+      const manager = new FoldersManager(api, executor);
+      const folder = createFolder({ id: 'folder-1' });
+
+      expect(
+        await manager.expandFolder({ folder, path: ['media-source://'] }),
+      ).toBeNull();
+
+      expect(executor.expandFolder).not.toBeCalled();
+    });
+  });
+
+  describe('should get item capabilities', () => {
+    it('should get item capabilities', () => {
+      const api = createCardAPI();
+      const executor = mock<FoldersExecutor>();
+      const capabilities: ViewItemCapabilities = {
+        canFavorite: true,
+        canDownload: true,
+      };
+      executor.getItemCapabilities.mockReturnValue(capabilities);
+      const item = new TestViewMedia();
+
+      const manager = new FoldersManager(api, executor);
+
+      expect(manager.getItemCapabilities(item)).toEqual(capabilities);
+      expect(executor.getItemCapabilities).toBeCalledWith(item);
+    });
+  });
+
+  describe('should get download path', () => {
+    it('should get download path', async () => {
+      const api = createCardAPI();
+      const hass = createHASS();
+      vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
+      const cache = new ResolvedMediaCache();
+      vi.mocked(api.getResolvedMediaCache).mockReturnValue(cache);
+
+      const executor = mock<FoldersExecutor>();
+      const item = new TestViewMedia();
+      const endpoint: Endpoint = { endpoint: 'endpoint' };
+      executor.getDownloadPath.mockResolvedValue(endpoint);
+
+      const manager = new FoldersManager(api, executor);
+      expect(await manager.getDownloadPath(item)).toEqual(endpoint);
+      expect(executor.getDownloadPath).toBeCalledWith(hass, item, {
+        resolvedMediaCache: cache,
+      });
+    });
+  });
+
+  describe('should favorite item', () => {
+    it('should favorite item', async () => {
+      const api = createCardAPI();
+      const hass = createHASS();
+      vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);
+
+      const executor = mock<FoldersExecutor>();
+      const item = new TestViewMedia();
+
+      const manager = new FoldersManager(api, executor);
+      await manager.favorite(item, true);
+      expect(executor.favorite).toBeCalledWith(hass, item, true);
+    });
+  });
+});