Raise test coverage on stores, lib utilities, and the activity-log controller

Excludes pure-wiring files from coverage measurement (backend NestJS
modules and main.ts; frontend ShadCN UI primitives, the test harness,
*.d.ts files, and config files) so the numbers reflect actual business
logic rather than DI boilerplate. Adds the missing
activity-log.controller spec, fills the encryption service round-trip
branch, and lifts the frontend stores from ~70% to ~99% by covering
auth.initialize and onAuthStateChange, optimistic reorderAccounts,
transactions.updateTransaction and fetchAllTransactions,
advisor.startConversation/sendMessage error and period-forwarding paths,
aggregations.fetchCashFlow, and the previously-untested activity store.
Also new lib tests for the auth-aware fetch wrapper, date helpers, and
account-type predicate.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

tehriehlbudget-backend/package.json

@@ -86,7 +86,9 @@
     ],
     "coveragePathIgnorePatterns": [
       "/node_modules/",
-      "/generated/"
+      "/generated/",
+      ".*\\.module\\.ts$",
+      "src/main\\.ts$"
     ],
     "coverageDirectory": "coverage",
     "testEnvironment": "node",

tehriehlbudget-backend/src/activity-log/activity-log.controller.spec.ts

@@ -0,0 +1,72 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ActivityLogController } from './activity-log.controller';
+import { ActivityLogService } from './activity-log.service';
+import { AuthGuard } from '../auth/auth.guard';
+
+jest.mock('@prisma/client', () => ({
+  PrismaClient: class {},
+  EntityType: {
+    TRANSACTION: 'TRANSACTION',
+    ACCOUNT: 'ACCOUNT',
+    ACCOUNT_VALUATION: 'ACCOUNT_VALUATION',
+  },
+  ActivityAction: { CREATE: 'CREATE', UPDATE: 'UPDATE', DELETE: 'DELETE' },
+}));
+
+describe('ActivityLogController', () => {
+  let controller: ActivityLogController;
+
+  const mockUser = { id: 'user-123' } as any;
+
+  const mockService = {
+    findAll: jest.fn().mockResolvedValue({
+      data: [
+        {
+          id: 'log-1',
+          entityType: 'TRANSACTION',
+          action: 'CREATE',
+          summary: '$50.00 EXPENSE — Coffee',
+        },
+      ],
+      total: 1,
+      page: 1,
+      limit: 20,
+    }),
+  };
+
+  beforeEach(async () => {
+    jest.clearAllMocks();
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [ActivityLogController],
+      providers: [{ provide: ActivityLogService, useValue: mockService }],
+    })
+      .overrideGuard(AuthGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    controller = module.get<ActivityLogController>(ActivityLogController);
+  });
+
+  it('forwards the user id and raw query filters to the service', async () => {
+    const filters = {
+      entityType: 'TRANSACTION' as const,
+      action: 'DELETE' as const,
+      accountId: 'acc-1',
+      startDate: '2026-04-01',
+      endDate: '2026-04-30',
+      page: 2,
+      limit: 50,
+    };
+
+    const result = await controller.findAll(mockUser, filters);
+
+    expect(mockService.findAll).toHaveBeenCalledWith('user-123', filters);
+    expect(result.data).toHaveLength(1);
+    expect(result.total).toBe(1);
+  });
+
+  it('passes through an empty filter object when no query params are sent', async () => {
+    await controller.findAll(mockUser, {});
+    expect(mockService.findAll).toHaveBeenCalledWith('user-123', {});
+  });
+});

tehriehlbudget-backend/src/encryption/encryption.service.spec.ts

@@ -76,5 +76,16 @@ describe('EncryptionService', () => {
     it('should return null when encrypting undefined', () => {
       expect(service.encryptField(undefined)).toBeNull();
     });
+
+    it('encryptField round-trips a non-null value through decryptField', () => {
+      const encrypted = service.encryptField('account-1234-5678');
+      expect(encrypted).not.toBeNull();
+      expect(encrypted).not.toBe('account-1234-5678');
+      expect(service.decryptField(encrypted)).toBe('account-1234-5678');
+    });
+
+    it('should return null when decrypting undefined', () => {
+      expect(service.decryptField(undefined)).toBeNull();
+    });
   });
 });

tehriehlbudget-frontend/src/lib/accountTypes.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { isMarketValue, MARKET_VALUE_TYPES } from './accountTypes';
+
+describe('isMarketValue', () => {
+  it('returns true for STOCK, INVESTMENT, and RETIREMENT', () => {
+    for (const t of MARKET_VALUE_TYPES) {
+      expect(isMarketValue(t)).toBe(true);
+    }
+  });
+
+  it.each(['CHECKING', 'SAVINGS', 'CREDIT', 'LOAN', 'CASH'])(
+    'returns false for transaction-driven type %s',
+    (t) => {
+      expect(isMarketValue(t)).toBe(false);
+    },
+  );
+
+  it('returns false for unknown types', () => {
+    expect(isMarketValue('NONEXISTENT')).toBe(false);
+  });
+});

tehriehlbudget-frontend/src/lib/api.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+const { mockGetSession } = vi.hoisted(() => ({
+  mockGetSession: vi.fn(),
+}));
+
+vi.mock('./supabase', () => ({
+  supabase: { auth: { getSession: mockGetSession } },
+}));
+
+import { api } from './api';
+
+const originalFetch = global.fetch;
+
+describe('api', () => {
+  beforeEach(() => {
+    mockGetSession.mockReset();
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it('attaches a Bearer token when a Supabase session is present', async () => {
+    mockGetSession.mockResolvedValue({
+      data: { session: { access_token: 'tok-abc' } },
+    });
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ ok: true }),
+    });
+
+    await api.get('/anything');
+
+    const [, init] = (global.fetch as any).mock.calls[0];
+    expect(init.headers.Authorization).toBe('Bearer tok-abc');
+  });
+
+  it('omits the Authorization header when there is no session', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({}),
+    });
+
+    await api.get('/anything');
+
+    const [, init] = (global.fetch as any).mock.calls[0];
+    expect(init.headers.Authorization).toBeUndefined();
+  });
+
+  it('returns parsed JSON on success', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ id: 1 }),
+    });
+
+    const result = await api.get<{ id: number }>('/x');
+    expect(result).toEqual({ id: 1 });
+  });
+
+  it('returns undefined for a 204 No Content response', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      status: 204,
+      json: async () => {
+        throw new Error('would not be called');
+      },
+    });
+
+    const result = await api.delete<void>('/x');
+    expect(result).toBeUndefined();
+  });
+
+  it('throws with the server-supplied message on a JSON error response', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: false,
+      status: 400,
+      statusText: 'Bad Request',
+      json: async () => ({ message: 'Invalid input' }),
+    });
+
+    await expect(api.post('/x', {})).rejects.toThrow('Invalid input');
+  });
+
+  it('falls back to statusText when the error body is not JSON', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      json: async () => {
+        throw new Error('not json');
+      },
+    });
+
+    await expect(api.patch('/x', {})).rejects.toThrow('Internal Server Error');
+  });
+
+  it('JSON-stringifies the body on POST/PATCH', async () => {
+    mockGetSession.mockResolvedValue({ data: { session: null } });
+    (global.fetch as any).mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({}),
+    });
+
+    await api.post('/x', { name: 'kevin' });
+
+    const [, init] = (global.fetch as any).mock.calls[0];
+    expect(init.method).toBe('POST');
+    expect(init.body).toBe(JSON.stringify({ name: 'kevin' }));
+  });
+});

tehriehlbudget-frontend/src/lib/dates.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { formatDate, toDateInputValue, todayInputValue } from './dates';
+
+describe('formatDate', () => {
+  it('renders a yyyy-mm-dd string as a local calendar date', () => {
+    // Locale-agnostic check: just confirm the date components show up
+    // somewhere in the output.
+    const out = formatDate('2026-04-15');
+    expect(out).toMatch(/2026/);
+    expect(out).toMatch(/15/);
+  });
+
+  it('does not roll a midnight-UTC date to the previous day in negative timezones', () => {
+    // Regression: parsing "2026-04-15T00:00:00Z" with `new Date(...)` lands
+    // on 2026-04-14 in timezones west of UTC. formatDate should pull the
+    // calendar components out of the string directly and avoid that.
+    const out = formatDate('2026-04-15T00:00:00.000Z');
+    expect(out).toMatch(/15/);
+    expect(out).not.toMatch(/14/);
+  });
+
+  it('accepts a Date instance', () => {
+    const out = formatDate(new Date('2026-04-15T12:00:00.000Z'));
+    expect(out).toMatch(/2026/);
+    expect(out).toMatch(/15/);
+  });
+
+  it('returns an empty string for an unparseable input', () => {
+    expect(formatDate('not-a-date')).toBe('');
+  });
+});
+
+describe('toDateInputValue', () => {
+  it('returns the leading yyyy-mm-dd of a string ISO', () => {
+    expect(toDateInputValue('2026-04-15T12:00:00.000Z')).toBe('2026-04-15');
+  });
+
+  it('passes through an already-truncated yyyy-mm-dd', () => {
+    expect(toDateInputValue('2026-04-15')).toBe('2026-04-15');
+  });
+
+  it('formats a Date instance', () => {
+    expect(toDateInputValue(new Date('2026-04-15T12:00:00.000Z'))).toBe('2026-04-15');
+  });
+});
+
+describe('todayInputValue', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ['Date'] });
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns today using local-timezone components, padded', () => {
+    vi.setSystemTime(new Date(2026, 3, 5, 23, 30)); // April 5, 2026 local
+    expect(todayInputValue()).toBe('2026-04-05');
+  });
+});

tehriehlbudget-frontend/src/stores/accounts.test.ts

@@ -79,4 +79,69 @@ describe('useAccountsStore', () => {
       expect(useAccountsStore.getState().accounts[0].id).toBe('2');
     });
   });
+
+  describe('reorderAccounts', () => {
+    it('reorders optimistically and then replaces state with the server response', async () => {
+      useAccountsStore.setState({
+        accounts: [
+          { id: '1', name: 'Checking' } as any,
+          { id: '2', name: 'Savings' } as any,
+          { id: '3', name: 'Credit' } as any,
+        ],
+      });
+
+      let resolvePatch: (value: any) => void;
+      mockApi.patch.mockReturnValue(
+        new Promise((res) => {
+          resolvePatch = res;
+        }),
+      );
+
+      const promise = useAccountsStore
+        .getState()
+        .reorderAccounts(['3', '1', '2']);
+
+      // Optimistic state landed before the server replied
+      expect(
+        useAccountsStore.getState().accounts.map((a) => a.id),
+      ).toEqual(['3', '1', '2']);
+
+      // Server confirms with potentially-different objects (e.g. updated sortOrder)
+      resolvePatch!([
+        { id: '3', name: 'Credit', sortOrder: 0 },
+        { id: '1', name: 'Checking', sortOrder: 1 },
+        { id: '2', name: 'Savings', sortOrder: 2 },
+      ]);
+      await promise;
+
+      expect(mockApi.patch).toHaveBeenCalledWith('/accounts/reorder', {
+        orderedIds: ['3', '1', '2'],
+      });
+      expect(useAccountsStore.getState().accounts[0].sortOrder).toBe(0);
+    });
+
+    it('drops ids that no longer exist locally during the optimistic pass', async () => {
+      useAccountsStore.setState({
+        accounts: [
+          { id: '1', name: 'Checking' } as any,
+          { id: '2', name: 'Savings' } as any,
+        ],
+      });
+      mockApi.patch.mockResolvedValue([
+        { id: '1' },
+        { id: '2' },
+      ]);
+
+      await useAccountsStore
+        .getState()
+        .reorderAccounts(['2', 'nonexistent', '1']);
+
+      // Server response wins after the await; check the optimistic
+      // intermediate state via a fresh call without resolving the promise.
+      // Here we just confirm the call was made with the requested order.
+      expect(mockApi.patch).toHaveBeenCalledWith('/accounts/reorder', {
+        orderedIds: ['2', 'nonexistent', '1'],
+      });
+    });
+  });
 });

tehriehlbudget-frontend/src/stores/activity.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const { mockApi } = vi.hoisted(() => ({
+  mockApi: { get: vi.fn(), post: vi.fn(), patch: vi.fn(), delete: vi.fn() },
+}));
+
+vi.mock('@/lib/api', () => ({ api: mockApi }));
+
+import { useActivityStore } from './activity';
+
+describe('useActivityStore', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useActivityStore.setState({
+      activities: [],
+      total: 0,
+      page: 1,
+      loading: false,
+    });
+  });
+
+  it('starts with no activities and page 1', () => {
+    const state = useActivityStore.getState();
+    expect(state.activities).toEqual([]);
+    expect(state.total).toBe(0);
+    expect(state.page).toBe(1);
+    expect(state.loading).toBe(false);
+  });
+
+  it('fetches activities and writes them into the store', async () => {
+    const entry = {
+      id: 'log-1',
+      userId: 'u1',
+      entityType: 'TRANSACTION',
+      entityId: 'tx-1',
+      action: 'CREATE',
+      accountId: 'acc-1',
+      destinationAccountId: null,
+      summary: '$50.00 EXPENSE — Coffee',
+      snapshot: { amount: 50 },
+      createdAt: '2026-04-15T12:00:00.000Z',
+    };
+    mockApi.get.mockResolvedValue({
+      data: [entry],
+      total: 1,
+      page: 1,
+      limit: 20,
+    });
+
+    await useActivityStore.getState().fetchActivities();
+
+    const state = useActivityStore.getState();
+    expect(state.activities).toEqual([entry]);
+    expect(state.total).toBe(1);
+    expect(state.page).toBe(1);
+    expect(state.loading).toBe(false);
+  });
+
+  it('passes filters and page through as query params', async () => {
+    mockApi.get.mockResolvedValue({ data: [], total: 0, page: 3, limit: 20 });
+
+    await useActivityStore.getState().fetchActivities(
+      {
+        entityType: 'ACCOUNT',
+        action: 'DELETE',
+        accountId: 'acc-1',
+        startDate: '2026-04-01',
+        endDate: '2026-04-30',
+      },
+      3,
+    );
+
+    const url = mockApi.get.mock.calls[0][0] as string;
+    expect(url).toMatch(/^\/activity\?/);
+    expect(url).toContain('page=3');
+    expect(url).toContain('limit=20');
+    expect(url).toContain('entityType=ACCOUNT');
+    expect(url).toContain('action=DELETE');
+    expect(url).toContain('accountId=acc-1');
+    expect(url).toContain('startDate=2026-04-01');
+    expect(url).toContain('endDate=2026-04-30');
+  });
+
+  it('skips empty filter values', async () => {
+    mockApi.get.mockResolvedValue({ data: [], total: 0, page: 1, limit: 20 });
+
+    await useActivityStore.getState().fetchActivities({
+      entityType: undefined,
+      action: undefined,
+      accountId: '',
+    });
+
+    const url = mockApi.get.mock.calls[0][0] as string;
+    expect(url).not.toContain('entityType=');
+    expect(url).not.toContain('action=');
+    expect(url).not.toContain('accountId=');
+  });
+});

tehriehlbudget-frontend/src/stores/advisor.test.ts

@@ -74,4 +74,58 @@ describe('useAdvisorStore', () => {
     expect(useAdvisorStore.getState().messages).toEqual([]);
     expect(useAdvisorStore.getState().generatedAt).toBeNull();
   });
+
+  it('startConversation forwards the dashboard period when provided', async () => {
+    mockApi.post.mockResolvedValue({ role: 'assistant', content: 'hi' });
+
+    await useAdvisorStore.getState().startConversation({
+      startDate: '2026-04-02',
+      endDate: '2026-05-01',
+      label: 'Last 30 days',
+    });
+
+    expect(mockApi.post).toHaveBeenCalledWith('/advisor/chat', {
+      messages: [],
+      period: {
+        startDate: '2026-04-02',
+        endDate: '2026-05-01',
+        label: 'Last 30 days',
+      },
+    });
+  });
+
+  it('sendMessage forwards the dashboard period when provided', async () => {
+    mockApi.post.mockResolvedValue({ role: 'assistant', content: 'sure' });
+
+    await useAdvisorStore.getState().sendMessage('And dining?', {
+      startDate: '2026-02-01',
+      endDate: '2026-05-01',
+      label: 'Last 90 days',
+    });
+
+    const body = mockApi.post.mock.calls[0][1];
+    expect(body.period.label).toBe('Last 90 days');
+    expect(body.messages[body.messages.length - 1]).toEqual({
+      role: 'user',
+      content: 'And dining?',
+    });
+  });
+
+  it('startConversation clears the loading flag and rethrows on API failure', async () => {
+    mockApi.post.mockRejectedValue(new Error('network down'));
+
+    await expect(useAdvisorStore.getState().startConversation()).rejects.toThrow(
+      'network down',
+    );
+    expect(useAdvisorStore.getState().loading).toBe(false);
+  });
+
+  it('sendMessage clears the loading flag and rethrows on API failure', async () => {
+    mockApi.post.mockRejectedValue(new Error('boom'));
+
+    await expect(
+      useAdvisorStore.getState().sendMessage('hi'),
+    ).rejects.toThrow('boom');
+    expect(useAdvisorStore.getState().loading).toBe(false);
+  });
 });

tehriehlbudget-frontend/src/stores/aggregations.test.ts

@@ -40,4 +40,18 @@ describe('useAggregationsStore', () => {
 
     expect(useAggregationsStore.getState().spendingByCategory).toEqual(mockData);
   });
+
+  it('should fetch cash flow', async () => {
+    const cashFlow = { inflows: 5000, outflows: 3000, net: 2000 };
+    mockApi.get.mockResolvedValue(cashFlow);
+
+    await useAggregationsStore
+      .getState()
+      .fetchCashFlow('2026-04-01', '2026-04-30');
+
+    expect(mockApi.get).toHaveBeenCalledWith(
+      '/aggregations/cash-flow?startDate=2026-04-01&endDate=2026-04-30',
+    );
+    expect(useAggregationsStore.getState().cashFlow).toEqual(cashFlow);
+  });
 });

tehriehlbudget-frontend/src/stores/auth.test.ts

@@ -110,4 +110,70 @@ describe('useAuthStore', () => {
       expect(state.session).toBeNull();
     });
   });
+
+  describe('initialize', () => {
+    it('hydrates user/session from the existing supabase session', async () => {
+      const mockSession = {
+        access_token: 'tok',
+        user: { id: 'u1', email: 'a@b.com' },
+      };
+      mockSupabase.auth.getSession.mockResolvedValue({
+        data: { session: mockSession },
+      });
+
+      await useAuthStore.getState().initialize();
+
+      const state = useAuthStore.getState();
+      expect(state.user).toEqual(mockSession.user);
+      expect(state.session).toEqual(mockSession);
+      expect(state.loading).toBe(false);
+      expect(mockSupabase.auth.onAuthStateChange).toHaveBeenCalledTimes(1);
+    });
+
+    it('clears user/session when there is no active session', async () => {
+      mockSupabase.auth.getSession.mockResolvedValue({
+        data: { session: null },
+      });
+
+      await useAuthStore.getState().initialize();
+
+      const state = useAuthStore.getState();
+      expect(state.user).toBeNull();
+      expect(state.session).toBeNull();
+      expect(state.loading).toBe(false);
+    });
+
+    it('updates state on auth state changes (e.g. token refresh, sign-out from another tab)', async () => {
+      mockSupabase.auth.getSession.mockResolvedValue({
+        data: { session: null },
+      });
+      let listener: ((event: string, session: any) => void) | null = null;
+      mockSupabase.auth.onAuthStateChange.mockImplementation((cb: any) => {
+        listener = cb;
+        return { data: { subscription: { unsubscribe: vi.fn() } } };
+      });
+
+      await useAuthStore.getState().initialize();
+
+      const refreshed = {
+        access_token: 'tok2',
+        user: { id: 'u2', email: 'c@d.com' },
+      };
+      listener!('TOKEN_REFRESHED', refreshed);
+
+      const state = useAuthStore.getState();
+      expect(state.user).toEqual(refreshed.user);
+      expect(state.session).toEqual(refreshed);
+    });
+  });
+
+  describe('setStayLoggedIn', () => {
+    it('persists the preference and updates store state', () => {
+      useAuthStore.getState().setStayLoggedIn(false);
+      expect(useAuthStore.getState().stayLoggedIn).toBe(false);
+
+      useAuthStore.getState().setStayLoggedIn(true);
+      expect(useAuthStore.getState().stayLoggedIn).toBe(true);
+    });
+  });
 });

tehriehlbudget-frontend/src/stores/transactions.test.ts

@@ -74,5 +74,68 @@ describe('useTransactionsStore', () => {
     await useTransactionsStore.getState().deleteTransaction('1');
 
     expect(useTransactionsStore.getState().transactions).toHaveLength(1);
+    expect(useTransactionsStore.getState().total).toBe(1);
+  });
+
+  it('should update a transaction in place', async () => {
+    useTransactionsStore.setState({
+      transactions: [
+        { id: '1', description: 'old' } as any,
+        { id: '2', description: 'other' } as any,
+      ],
+    });
+    mockApi.patch.mockResolvedValue({ id: '1', description: 'new' });
+
+    await useTransactionsStore
+      .getState()
+      .updateTransaction('1', { description: 'new' });
+
+    expect(mockApi.patch).toHaveBeenCalledWith(
+      '/transactions/1',
+      expect.objectContaining({ description: 'new' }),
+    );
+    const txns = useTransactionsStore.getState().transactions;
+    expect(txns[0]).toEqual({ id: '1', description: 'new' });
+    expect(txns[1]).toEqual({ id: '2', description: 'other' });
+  });
+
+  describe('fetchAllTransactions', () => {
+    it('hits /transactions?all=true and returns the data array directly without writing to store', async () => {
+      const data = [{ id: '1' }, { id: '2' }];
+      mockApi.get.mockResolvedValue({ data });
+
+      // Pre-existing store state must NOT be overwritten by this read.
+      useTransactionsStore.setState({
+        transactions: [{ id: 'preserved' } as any],
+        total: 1,
+      });
+
+      const result = await useTransactionsStore
+        .getState()
+        .fetchAllTransactions({
+          accountId: 'acc-1',
+          startDate: '2026-04-01',
+        });
+
+      expect(result).toEqual(data);
+      const url = mockApi.get.mock.calls[0][0] as string;
+      expect(url).toContain('all=true');
+      expect(url).toContain('accountId=acc-1');
+      expect(url).toContain('startDate=2026-04-01');
+      expect(useTransactionsStore.getState().transactions).toEqual([
+        { id: 'preserved' },
+      ]);
+    });
+
+    it('omits empty filter values from the query string', async () => {
+      mockApi.get.mockResolvedValue({ data: [] });
+      await useTransactionsStore
+        .getState()
+        .fetchAllTransactions({ accountId: '', categoryId: undefined });
+
+      const url = mockApi.get.mock.calls[0][0] as string;
+      expect(url).not.toContain('accountId=');
+      expect(url).not.toContain('categoryId=');
+    });
   });
 });

tehriehlbudget-frontend/vitest.config.ts

@@ -17,6 +17,15 @@ export default defineConfig({
     coverage: {
       provider: "v8",
       reporter: ["text", "lcov"],
+      include: ["src/**/*.{ts,tsx}"],
+      exclude: [
+        "src/components/ui/**",
+        "src/test/**",
+        "src/main.tsx",
+        "src/vite-env.d.ts",
+        "src/**/*.d.ts",
+        "**/*.config.*",
+      ],
       thresholds: {
         statements: 90,
         branches: 90,