lucia-frontend/tests/stores/files.test.js

// The Lucia project.
// Copyright 2026-2026 DSP, inc.  All rights reserved.
// Authors:
//   imacat.yang@dsp.im (imacat), 2026/03/06

import { describe, it, expect, beforeEach, vi } from 'vitest';
import { setActivePinia, createPinia } from 'pinia';

// Mock modules that have deep import chains (router, Swal, pinia, toast)
vi.mock('@/module/apiError.js', () => ({
  default: vi.fn(),
}));
vi.mock('@/module/alertModal.js', () => ({
  uploadFailedFirst: vi.fn(),
  uploadFailedSecond: vi.fn(),
  uploadloader: vi.fn(),
  uploadSuccess: vi.fn(),
  deleteSuccess: vi.fn(),
}));
vi.mock('sweetalert2', () => ({
  default: { close: vi.fn(), fire: vi.fn() },
}));
// Prevent module-level store init in cytoscapeMap.js (loaded via router → Map.vue)
vi.mock('@/module/cytoscapeMap.js', () => ({}));
vi.mock('@/router/index.ts', () => ({
  default: { push: vi.fn(), currentRoute: { value: { path: '/' } } },
}));

const { mockGet, mockPost, mockPut, mockDelete } = vi.hoisted(() => ({
  mockGet: vi.fn(), mockPost: vi.fn(), mockPut: vi.fn(), mockDelete: vi.fn(),
}));
vi.mock('@/api/client.js', () => ({
  default: { get: mockGet, post: mockPost, put: mockPut, delete: mockDelete },
}));

import { useFilesStore } from '@/stores/files';

describe('filesStore', () => {
  let store;

  beforeEach(() => {
    setActivePinia(createPinia());
    store = useFilesStore();
    store.$router = { push: vi.fn() };
    vi.clearAllMocks();
  });

  it('has correct default state', () => {
    expect(store.filesTag).toBe('ALL');
    expect(store.httpStatus).toBe(200);
    expect(store.uploadId).toBeNull();
  });

  describe('allFiles getter', () => {
    it('filters files by current filesTag', () => {
      store.allEventFiles = [
        { fileType: 'Log', name: 'a.xes' },
        { fileType: 'Filter', name: 'b' },
        { fileType: 'Design', name: 'c' },
      ];

      store.filesTag = 'COMPARE';
      expect(store.allFiles.map((f) => f.name)).toEqual(['a.xes', 'b']);

      store.filesTag = 'ALL';
      expect(store.allFiles).toHaveLength(3);
    });
  });

  describe('fetchAllFiles', () => {
    it('fetches and transforms file data', async () => {
      mockGet.mockResolvedValue({
        data: [
          {
            type: 'log',
            name: 'test.xes',
            owner: { name: 'Alice' },
            updated_at: '2024-01-15T10:00:00Z',
            accessed_at: '2024-01-15T11:00:00Z',
          },
          {
            type: 'filter',
            name: 'filter1',
            parent: { name: 'test.xes' },
            owner: { name: 'Bob' },
            updated_at: '2024-01-16T10:00:00Z',
            accessed_at: null,
          },
        ],
      });

      await store.fetchAllFiles();

      expect(mockGet).toHaveBeenCalledWith('/api/files');
      expect(store.allEventFiles).toHaveLength(2);
      expect(store.allEventFiles[0].fileType).toBe('Log');
      expect(store.allEventFiles[0].icon).toBe('work_history');
      expect(store.allEventFiles[0].ownerName).toBe('Alice');
      expect(store.allEventFiles[1].fileType).toBe('Filter');
      expect(store.allEventFiles[1].parentLog).toBe('test.xes');
      expect(store.allEventFiles[1].accessed_at).toBeNull();
    });

    it('does not throw on API failure', async () => {
      mockGet.mockRejectedValue(new Error('Network error'));
      await expect(store.fetchAllFiles()).resolves.toBeUndefined();
    });

    it('maps design files without leaking metadata from previous file items', async () => {
      mockGet.mockResolvedValue({
        data: [
          {
            type: 'log',
            name: 'order-log',
            owner: { name: 'Alice' },
            updated_at: '2024-01-15T10:00:00Z',
            accessed_at: null,
          },
          {
            type: 'design',
            name: 'diagram-a',
            owner: { name: 'Bob' },
            updated_at: '2024-01-16T10:00:00Z',
            accessed_at: null,
          },
        ],
      });

      await store.fetchAllFiles();

      expect(store.allEventFiles[1].icon).toBe('shape_line');
      expect(store.allEventFiles[1].fileType).toBe('Design');
      expect(store.allEventFiles[1].parentLog).toBe('diagram-a');
    });
  });

  describe('upload', () => {
    it('uploads file and navigates to Upload page', async () => {
      mockPost.mockResolvedValue({ data: { id: 42 } });
      const formData = new FormData();

      await store.upload(formData);

      expect(mockPost).toHaveBeenCalledWith(
        '/api/logs/csv-uploads',
        formData,
        expect.objectContaining({
          headers: { 'Content-Type': 'multipart/form-data' },
        }),
      );
      expect(store.uploadId).toBe(42);
      expect(store.$router.push).toHaveBeenCalledWith({ name: 'Upload' });
    });
  });

  describe('getUploadDetail', () => {
    it('fetches upload preview', async () => {
      store.uploadId = 10;
      mockGet.mockResolvedValue({
        data: { preview: { columns: ['a', 'b'] } },
      });

      await store.getUploadDetail();

      expect(mockGet).toHaveBeenCalledWith('/api/logs/csv-uploads/10');
      expect(store.allUploadDetail).toEqual({ columns: ['a', 'b'] });
    });
  });

  describe('rename', () => {
    it('renames a log file', async () => {
      mockPut.mockResolvedValue({});
      mockGet.mockResolvedValue({ data: [] });

      await store.rename('log', 5, 'new-name');

      expect(mockPut).toHaveBeenCalledWith('/api/logs/5/name', {
        name: 'new-name',
      });
    });
  });

  describe('getDependents', () => {
    it('fetches dependents for a log', async () => {
      mockGet.mockResolvedValue({ data: [{ id: 1 }, { id: 2 }] });

      await store.getDependents('log', 7);

      expect(mockGet).toHaveBeenCalledWith('/api/logs/7/dependents');
      expect(store.allDependentsData).toEqual([{ id: 1 }, { id: 2 }]);
    });
  });

  describe('deleteFile', () => {
    it('calls mockDelete before fetchAllFiles', async () => {
      const callOrder = [];
      mockDelete.mockImplementation(async () => {
        callOrder.push('delete');
        return {};
      });
      mockGet.mockImplementation(async () => {
        callOrder.push('get');
        return { data: [] };
      });

      await store.deleteFile('log', 1);

      expect(mockDelete).toHaveBeenCalledWith('/api/logs/1');
      expect(callOrder.indexOf('delete')).toBeLessThan(
        callOrder.indexOf('get'),
      );
    });

    it('returns early for invalid id without throwing', async () => {
      await expect(
        store.deleteFile('log', null),
      ).resolves.toBeUndefined();

      expect(mockDelete).not.toHaveBeenCalled();
    });
  });

  describe('deletionRecord', () => {
    it('deletes a deletion record', async () => {
      mockDelete.mockResolvedValue({});

      await store.deletionRecord(5);

      expect(mockDelete).toHaveBeenCalledWith('/api/deletion/5');
    });
  });

  describe('downloadFileCSV', () => {
    it('downloads CSV for a log', async () => {
      mockGet.mockResolvedValue({ data: 'col1,col2\na,b' });

      window.URL.createObjectURL = vi.fn().mockReturnValue('blob:test');
      window.URL.revokeObjectURL = vi.fn();

      await store.downloadFileCSV('log', 3, 'my-file');

      expect(mockGet).toHaveBeenCalledWith('/api/logs/3/csv');
      expect(window.URL.revokeObjectURL).toHaveBeenCalledWith('blob:test');
    });

    it('returns early for unsupported type', async () => {
      await store.downloadFileCSV('log-check', 3, 'file');

      expect(mockGet).not.toHaveBeenCalled();
    });
  });
});