advanced-camera-card/tests/card-controller/folders/manager.test.ts

import { describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';

import type { FoldersExecutor } from '../../../src/card-controller/folders/executor';
import { FoldersManager } from '../../../src/card-controller/folders/manager';
import type { FolderQuery } from '../../../src/card-controller/folders/types';
import type {
  FolderConfig,
  FolderConfigWithoutID,
} from '../../../src/config/schema/folders';
import { ResolvedMediaCache } from '../../../src/ha/resolved-media';
import { QuerySource } from '../../../src/query-source';
import type { Endpoint } from '../../../src/types';
import { ViewFolder } from '../../../src/view/item';
import type { ViewItemCapabilities } from '../../../src/view/types';
import { createCardAPI, createFolder, createHASS } from '../../test-utils';
import { TestViewMedia } from '../../view/test-utils';

describe('FoldersManager', () => {
  it('should initialize with no folders', () => {
    const api = createCardAPI();
    const manager = new FoldersManager(api);
    expect(manager.getFolderCount()).toBe(0);
    expect(manager.hasFolders()).toBe(false);
  });

  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',
      });
      expect(manager.hasFolders()).toBe(true);
    });

    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: FolderConfigWithoutID = {
        type: 'ha' as const,
        title: 'Title',
        ha: {
          path: [{ id: 'media-source://' }],
        },
      };

      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])).toThrow(
        /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('getDefaultQueryParameters', () => {
    it('should return null with no folder provided and no internal folders', () => {
      const manager = new FoldersManager(createCardAPI());
      expect(manager.getDefaultQueryParameters()).toBeNull();
    });

    it('should use provided folder', () => {
      const folder = createFolder();
      const executor = mock<FoldersExecutor>();
      const manager = new FoldersManager(createCardAPI(), executor);
      const query: FolderQuery = { source: QuerySource.Folder, folder, path: [{}] };

      executor.getDefaultQueryParameters.mockReturnValue(query);

      expect(manager.getDefaultQueryParameters(folder)).toEqual(query);
      expect(executor.getDefaultQueryParameters).toHaveBeenCalledWith(folder);
    });

    it('should fallback to default folder if none provided', () => {
      const folder = createFolder();
      const executor = mock<FoldersExecutor>();
      const manager = new FoldersManager(createCardAPI(), executor);

      const query: FolderQuery = { source: QuerySource.Folder, folder, path: [{}] };

      manager.addFolders([folder]);
      executor.getDefaultQueryParameters.mockReturnValue(query);

      expect(manager.getDefaultQueryParameters()).toEqual(query);
      expect(executor.getDefaultQueryParameters).toHaveBeenCalledWith(
        manager.getFolder(),
      );
    });
  });

  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('generateChildFolderQuery', () => {
    it('should generate child folder query', () => {
      const folder: FolderConfig = createFolder();
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
      };
      const viewFolder = new ViewFolder(folder, []);

      const executor = mock<FoldersExecutor>();
      vi.mocked(executor.generateChildFolderQuery).mockReturnValue(query);

      const manager = new FoldersManager(createCardAPI(), executor);

      expect(manager.generateChildFolderQuery(query, viewFolder)).toEqual(query);
      expect(executor.generateChildFolderQuery).toHaveBeenCalledWith(query, viewFolder);
    });
  });

  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 conditionState = {};
      const engineOptions = {};
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
      };

      expect(await manager.expandFolder(query, conditionState, engineOptions)).toEqual([
        media,
      ]);

      expect(executor.expandFolder).toHaveBeenCalledWith(
        hass,
        query,
        conditionState,
        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({
          source: QuerySource.Folder,
          folder,
          path: [{ ha: { id: 'media-source://' } }],
        }),
      ).toBeNull();

      expect(executor.expandFolder).not.toHaveBeenCalled();
    });

    it('should return null for query with unsupported filters', async () => {
      const hass = createHASS();
      const api = createCardAPI();
      vi.mocked(api.getHASSManager().getHASS).mockReturnValue(hass);

      const executor = mock<FoldersExecutor>();
      const manager = new FoldersManager(api, executor);

      const folder = createFolder({ id: 'folder-1' });
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
        favorite: true,
      };

      expect(await manager.expandFolder(query)).toBeNull();
      expect(executor.expandFolder).not.toHaveBeenCalled();
    });
  });

  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).toHaveBeenCalledWith(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).toHaveBeenCalledWith(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).toHaveBeenCalledWith(hass, item, true);
    });
  });

  describe('areResultsFresh', () => {
    it('should delegate freshness check to executor', () => {
      const api = createCardAPI();
      const executor = mock<FoldersExecutor>();
      const manager = new FoldersManager(api, executor);
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder: createFolder(),
        path: [{}],
      };
      const timestamp = new Date();

      executor.areResultsFresh.mockReturnValue(true);

      expect(manager.areResultsFresh(timestamp, query)).toBe(true);
      expect(executor.areResultsFresh).toHaveBeenCalledWith(timestamp, query);
    });
  });
});