Add store tests with mocked axios and apiError

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/stores/allMapData.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { setActivePinia, createPinia } from 'pinia';
+
+vi.mock('@/module/apiError.js', () => ({
+  default: vi.fn(),
+}));
+
+import useAllMapDataStore from '@/stores/allMapData.js';
+
+describe('allMapDataStore', () => {
+  let store;
+  const mockAxios = {
+    get: vi.fn(),
+    post: vi.fn(),
+    put: vi.fn(),
+  };
+
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    store = useAllMapDataStore();
+    store.$axios = mockAxios;
+    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: {},
+      };
+      mockAxios.get.mockResolvedValue({ data: mockData });
+
+      await store.getAllMapData();
+
+      expect(mockAxios.get).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;
+      mockAxios.get.mockResolvedValue({
+        data: {
+          process_map: {},
+          bpmn: {},
+          stats: {},
+          insights: {},
+        },
+      });
+
+      await store.getAllMapData();
+
+      expect(mockAxios.get).toHaveBeenCalledWith(
+        '/api/temp-filters/5/discover',
+      );
+    });
+
+    it('fetches created filter discover data', async () => {
+      store.logId = 1;
+      store.createFilterId = 3;
+      mockAxios.get.mockResolvedValue({
+        data: {
+          process_map: {},
+          bpmn: {},
+          stats: {},
+          insights: {},
+        },
+      });
+
+      await store.getAllMapData();
+
+      expect(mockAxios.get).toHaveBeenCalledWith(
+        '/api/filters/3/discover',
+      );
+    });
+
+    it('does not throw on API failure', async () => {
+      store.logId = 1;
+      mockAxios.get.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: [],
+      };
+      mockAxios.get.mockResolvedValue({ data: mockData });
+
+      await store.getFilterParams();
+
+      expect(mockAxios.get).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' }];
+      mockAxios.post.mockResolvedValue({
+        data: { result: true },
+      });
+
+      await store.checkHasResult();
+
+      expect(mockAxios.post).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 = [];
+      mockAxios.post.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' }];
+      mockAxios.post.mockResolvedValue({ data: { id: 88 } });
+
+      await store.addFilterId('myFilter');
+
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        '/api/filters?log_id=1',
+        { name: 'myFilter', rules: [{ type: 'rule' }] },
+      );
+      expect(store.createFilterId).toBe(88);
+      expect(store.tempFilterId).toBeNull();
+    });
+  });
+
+  describe('updataFilter', () => {
+    it('updates filter and clears temp id', async () => {
+      store.createFilterId = 88;
+      store.tempFilterId = 77;
+      store.postRuleData = [{ type: 'updated' }];
+      mockAxios.put.mockResolvedValue({ status: 200 });
+
+      await store.updataFilter();
+
+      expect(mockAxios.put).toHaveBeenCalledWith(
+        '/api/filters/88',
+        [{ type: 'updated' }],
+      );
+      expect(store.isUpdataFilter).toBe(true);
+      expect(store.tempFilterId).toBeNull();
+    });
+  });
+
+  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] });
+    });
+  });
+});