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

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

vi.mock('@/module/apiError.js', () => ({
  default: vi.fn(),
}));

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

import useAllMapDataStore from '@/stores/allMapData.js';

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

  beforeEach(() => {
    setActivePinia(createPinia());
    store = useAllMapDataStore();
    vi.clearAllMocks();
  });

  it('has correct default state', () => {
    expect(store.logId).toBeNull();
    expect(store.allProcessMap).toEqual({});
    expect(store.allTrace).toEqual([]);
  });

  describe('getAllMapData', () => {
    it('fetches log discover data', async () => {
      store.logId = 1;
      const mockData = {
        process_map: { nodes: [] },
        bpmn: { nodes: [] },
        stats: { cases: 10 },
        insights: {},
      };
      mockGet.mockResolvedValue({ data: mockData });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith(
        '/api/logs/1/discover',
      );
      expect(store.allProcessMap).toEqual({ nodes: [] });
      expect(store.allStats).toEqual({ cases: 10 });
    });

    it('fetches temp filter discover data when set', async () => {
      store.logId = 1;
      store.tempFilterId = 5;
      mockGet.mockResolvedValue({
        data: {
          process_map: {},
          bpmn: {},
          stats: {},
          insights: {},
        },
      });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith(
        '/api/temp-filters/5/discover',
      );
    });

    it('fetches created filter discover data', async () => {
      store.logId = 1;
      store.createFilterId = 3;
      mockGet.mockResolvedValue({
        data: {
          process_map: {},
          bpmn: {},
          stats: {},
          insights: {},
        },
      });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith(
        '/api/filters/3/discover',
      );
    });

    it('does not throw on API failure', async () => {
      store.logId = 1;
      mockGet.mockRejectedValue(new Error('fail'));

      await expect(store.getAllMapData())
        .resolves.not.toThrow();
    });
  });

  describe('getFilterParams', () => {
    it('fetches filter params and transforms timeframe', async () => {
      store.logId = 1;
      const mockData = {
        tasks: ['A', 'B'],
        sources: ['A'],
        sinks: ['B'],
        timeframe: {
          x_axis: {
            min: '2023-01-01T00:00:00Z',
            max: '2023-12-31T00:00:00Z',
          },
        },
        trace: [],
        attrs: [],
      };
      mockGet.mockResolvedValue({ data: mockData });

      await store.getFilterParams();

      expect(mockGet).toHaveBeenCalledWith(
        '/api/filters/params?log_id=1',
      );
      expect(store.allFilterTask).toEqual(['A', 'B']);
      // Check that min_base and max_base are stored
      expect(store.allFilterTimeframe.x_axis.min_base)
        .toBe('2023-01-01T00:00:00Z');
    });
  });

  describe('checkHasResult', () => {
    it('posts rule data and stores result', async () => {
      store.logId = 1;
      store.postRuleData = [{ type: 'task' }];
      mockPost.mockResolvedValue({
        data: { result: true },
      });

      await store.checkHasResult();

      expect(mockPost).toHaveBeenCalledWith(
        '/api/filters/has-result?log_id=1',
        [{ type: 'task' }],
      );
      expect(store.hasResultRule).toBe(true);
    });
  });

  describe('addTempFilterId', () => {
    it('creates temp filter and stores id', async () => {
      store.logId = 1;
      store.postRuleData = [];
      mockPost.mockResolvedValue({ data: { id: 77 } });

      await store.addTempFilterId();

      expect(store.tempFilterId).toBe(77);
    });
  });

  describe('addFilterId', () => {
    it('creates filter and clears temp id', async () => {
      store.logId = 1;
      store.tempFilterId = 77;
      store.postRuleData = [{ type: 'rule' }];
      mockPost.mockResolvedValue({ data: { id: 88 } });

      await store.addFilterId('myFilter');

      expect(mockPost).toHaveBeenCalledWith(
        '/api/filters?log_id=1',
        { name: 'myFilter', rules: [{ type: 'rule' }] },
      );
      expect(store.createFilterId).toBe(88);
      expect(store.tempFilterId).toBeNull();
    });
  });

  describe('updateFilter', () => {
    it('updates filter and clears temp id', async () => {
      store.createFilterId = 88;
      store.tempFilterId = 77;
      store.postRuleData = [{ type: 'updated' }];
      mockPut.mockResolvedValue({ status: 200 });

      await store.updateFilter();

      expect(mockPut).toHaveBeenCalledWith(
        '/api/filters/88',
        [{ type: 'updated' }],
      );
      expect(store.isUpdateFilter).toBe(true);
      expect(store.tempFilterId).toBeNull();
    });
  });

  describe('getAllTrace', () => {
    it('does not crash when baseLogId is falsy', async () => {
      store.logId = 1;
      store.baseLogId = null;
      mockGet.mockResolvedValue({ data: [{ id: 1 }] });

      await store.getAllTrace();

      expect(store.allTrace).toEqual([{ id: 1 }]);
      // allBaseTrace should not be set when baseLogId is falsy
      expect(store.allBaseTrace).toEqual([]);
    });
  });

  describe('getters', () => {
    it('traces getter sorts by id', () => {
      store.allTrace = [
        { id: 3, name: 'C' },
        { id: 1, name: 'A' },
        { id: 2, name: 'B' },
      ];
      expect(store.traces.map(t => t.id)).toEqual([1, 2, 3]);
    });

    it('processMap getter returns state', () => {
      store.allProcessMap = { nodes: [1, 2] };
      expect(store.processMap).toEqual({ nodes: [1, 2] });
    });
  });
});