Skip to content

Open source personal finance application

test: add tests for replay, form store, signOut, removeAllUserData

Ilya Komichev15dd33c3fef2
diff --git a/app/components/categories/useCategoriesStore.test.ts b/app/components/categories/useCategoriesStore.test.ts
index 1236398d..17028390 100644
--- a/app/components/categories/useCategoriesStore.test.ts
+++ b/app/components/categories/useCategoriesStore.test.ts
@@ -10,6 +10,7 @@ vi.mock('~~/services/convex/api', () => ({
vi.mock('~/components/categories/utils', () => ({
compareCategoriesByParentAndName: () => 0,
+ compareCategoryIds: () => 0,
getTransactibleCategoriesIds: () => [],
}))
diff --git a/app/components/offline/replay.test.ts b/app/components/offline/replay.test.ts
new file mode 100644
index 00000000..f93fead6
--- /dev/null
+++ b/app/components/offline/replay.test.ts
@@ -0,0 +1,253 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+
+import type { OfflineOp } from '~/components/offline/types'
+
+import { OfflineEntityType } from '~/components/offline/types'
+
+// --- Mocks ---
+
+const mockClearOfflineQueue = vi.fn(() => Promise.resolve())
+const mockGetAllOfflineOps = vi.fn((): Promise<OfflineOp[]> => Promise.resolve([]))
+const mockGetQueueUserId = vi.fn((): Promise<string | null> => Promise.resolve(null))
+const mockRemoveOfflineOp = vi.fn(() => Promise.resolve())
+const mockSetOfflineQueueUserId = vi.fn()
+const mockSetQueueUserId = vi.fn(() => Promise.resolve())
+
+vi.mock('~/components/offline/helpers', () => ({
+ clearOfflineQueue: (...args: unknown[]) => mockClearOfflineQueue(...args),
+ getAllOfflineOps: (...args: unknown[]) => mockGetAllOfflineOps(...args),
+ getQueueUserId: (...args: unknown[]) => mockGetQueueUserId(...args),
+ removeOfflineOp: (...args: unknown[]) => mockRemoveOfflineOp(...args),
+ setOfflineQueueUserId: (...args: unknown[]) => mockSetOfflineQueueUserId(...args),
+ setQueueUserId: (...args: unknown[]) => mockSetQueueUserId(...args),
+}))
+
+const mockReplayWalletOps = vi.fn(() => Promise.resolve())
+const mockReplayCategoryOps = vi.fn(() => Promise.resolve())
+const mockReplayTrnOps = vi.fn((): Promise<number> => Promise.resolve(0))
+const mockReplaySettingsOps = vi.fn(() => Promise.resolve())
+const mockGroupOpsByEntity = vi.fn(() => ({
+ categoryOps: [] as OfflineOp[],
+ settingsOps: [] as OfflineOp[],
+ trnOps: [] as OfflineOp[],
+ walletOps: [] as OfflineOp[],
+}))
+
+vi.mock('~/components/offline/replayHelpers', () => ({
+ groupOpsByEntity: (...args: unknown[]) => mockGroupOpsByEntity(...args),
+ replayCategoryOps: (...args: unknown[]) => mockReplayCategoryOps(...args),
+ replaySettingsOps: (...args: unknown[]) => mockReplaySettingsOps(...args),
+ replayTrnOps: (...args: unknown[]) => mockReplayTrnOps(...args),
+ replayWalletOps: (...args: unknown[]) => mockReplayWalletOps(...args),
+}))
+
+let mockUid: string | null = 'user1'
+
+vi.mock('~/components/wallets/useWalletsStore', () => ({
+ useWalletsStore: () => ({ deleteWallet: vi.fn(), items: { w1: {} }, saveWallet: vi.fn() }),
+}))
+
+vi.mock('~/components/categories/useCategoriesStore', () => ({
+ useCategoriesStore: () => ({ deleteCategory: vi.fn(), items: { c1: {} }, saveCategory: vi.fn() }),
+}))
+
+vi.mock('~/components/trns/useTrnsStore', () => ({
+ useTrnsStore: () => ({ deleteTrn: vi.fn(), removeTrnsFromStore: vi.fn(), saveTrn: vi.fn() }),
+}))
+
+vi.mock('~/components/user/useUserStore', () => ({
+ useUserStore: () => ({
+ get uid() { return mockUid },
+ saveUserBaseCurrency: vi.fn(),
+ saveUserLocale: vi.fn(),
+ }),
+}))
+
+const mockShowWarningToast = vi.fn()
+vi.mock('~/composables/useStoreSync', () => ({
+ showWarningToast: (...args: unknown[]) => mockShowWarningToast(...args),
+}))
+
+vi.mock('~/utils/logger', () => ({
+ createLogger: () => ({ error: vi.fn(), log: vi.fn(), warn: vi.fn() }),
+}))
+
+vi.mock('~/utils/convexId', () => ({
+ isLocalId: (id: string) => id.startsWith('local_'),
+}))
+
+function makeOp(entity: OfflineOp['entity'], id: string, type: OfflineOp['type'] = 'create', data?: Record<string, unknown>): OfflineOp {
+ return { data, entity, id, timestamp: Date.now(), type }
+}
+
+// Import once - _isReplaying resets via finally block after each test
+import { isReplaying, replayOfflineQueue } from './replay'
+
+beforeEach(() => {
+ vi.clearAllMocks()
+ mockUid = 'user1'
+ mockGetQueueUserId.mockResolvedValue(null)
+ mockGetAllOfflineOps.mockResolvedValue([])
+ mockReplayTrnOps.mockResolvedValue(0)
+ mockReplayWalletOps.mockResolvedValue(undefined)
+ mockReplayCategoryOps.mockResolvedValue(undefined)
+ mockReplaySettingsOps.mockResolvedValue(undefined)
+ mockGroupOpsByEntity.mockReturnValue({
+ categoryOps: [],
+ settingsOps: [],
+ trnOps: [],
+ walletOps: [],
+ })
+})
+
+describe('replayOfflineQueue', () => {
+ it('does nothing when queue is empty', async () => {
+ await replayOfflineQueue()
+
+ expect(mockGetAllOfflineOps).toHaveBeenCalled()
+ expect(mockReplayWalletOps).not.toHaveBeenCalled()
+ expect(mockReplayCategoryOps).not.toHaveBeenCalled()
+ expect(mockReplayTrnOps).not.toHaveBeenCalled()
+ })
+
+ it('clears queue if it belongs to another user', async () => {
+ mockGetQueueUserId.mockResolvedValue('other-user')
+
+ await replayOfflineQueue()
+
+ expect(mockClearOfflineQueue).toHaveBeenCalled()
+ expect(mockGetAllOfflineOps).not.toHaveBeenCalled()
+ })
+
+ it('sets queue ownership for current user', async () => {
+ await replayOfflineQueue()
+
+ expect(mockSetOfflineQueueUserId).toHaveBeenCalledWith('user1')
+ expect(mockSetQueueUserId).toHaveBeenCalledWith('user1')
+ })
+
+ it('does not set ownership when no current user', async () => {
+ mockUid = null
+
+ await replayOfflineQueue()
+
+ expect(mockSetOfflineQueueUserId).not.toHaveBeenCalled()
+ expect(mockSetQueueUserId).not.toHaveBeenCalled()
+ })
+
+ it('proceeds when queue belongs to current user', async () => {
+ mockGetQueueUserId.mockResolvedValue('user1')
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Wallets, 'w1', 'create'),
+ ])
+
+ await replayOfflineQueue()
+
+ expect(mockReplayWalletOps).toHaveBeenCalled()
+ })
+
+ it('filters out frontend-ID delete ops', async () => {
+ const realOp = makeOp(OfflineEntityType.Wallets, 'real_w2', 'create', { name: 'Cash' })
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Wallets, 'local_w1', 'delete'),
+ realOp,
+ ])
+
+ await replayOfflineQueue()
+
+ expect(mockRemoveOfflineOp).toHaveBeenCalledWith(OfflineEntityType.Wallets, 'local_w1')
+ expect(mockGroupOpsByEntity).toHaveBeenCalledWith([realOp])
+ })
+
+ it('replays phases in order: wallets -> categories -> trns -> settings', async () => {
+ const callOrder: string[] = []
+ mockReplayWalletOps.mockImplementation(async () => { callOrder.push('wallets') })
+ mockReplayCategoryOps.mockImplementation(async () => { callOrder.push('categories') })
+ mockReplayTrnOps.mockImplementation(async () => { callOrder.push('trns'); return 0 })
+ mockReplaySettingsOps.mockImplementation(async () => { callOrder.push('settings') })
+
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Wallets, 'w1', 'create'),
+ ])
+ mockGroupOpsByEntity.mockReturnValue({
+ categoryOps: [makeOp(OfflineEntityType.Categories, 'c1', 'create')],
+ settingsOps: [makeOp(OfflineEntityType.UserSettings, 's1', 'update')],
+ trnOps: [makeOp(OfflineEntityType.Trns, 't1', 'create')],
+ walletOps: [makeOp(OfflineEntityType.Wallets, 'w1', 'create')],
+ })
+
+ await replayOfflineQueue()
+
+ expect(callOrder).toEqual(['wallets', 'categories', 'trns', 'settings'])
+ })
+
+ it('resets isReplaying after success', async () => {
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Wallets, 'w1', 'create'),
+ ])
+
+ await replayOfflineQueue()
+
+ expect(isReplaying()).toBe(false)
+ })
+
+ it('resets isReplaying after error', async () => {
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Wallets, 'w1', 'create'),
+ ])
+ mockReplayWalletOps.mockRejectedValueOnce(new Error('network'))
+
+ await expect(replayOfflineQueue()).rejects.toThrow('network')
+
+ expect(isReplaying()).toBe(false)
+ })
+
+ it('clears queue on ownership check error', async () => {
+ mockGetQueueUserId.mockRejectedValueOnce(new Error('storage error'))
+
+ await replayOfflineQueue()
+
+ expect(mockClearOfflineQueue).toHaveBeenCalled()
+ expect(mockGetAllOfflineOps).not.toHaveBeenCalled()
+ })
+
+ it('shows warning toast when orphaned trns exist', async () => {
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Trns, 't1', 'create'),
+ ])
+ mockGroupOpsByEntity.mockReturnValue({
+ categoryOps: [],
+ settingsOps: [],
+ trnOps: [makeOp(OfflineEntityType.Trns, 't1', 'create')],
+ walletOps: [],
+ })
+ mockReplayTrnOps.mockResolvedValue(3)
+
+ await replayOfflineQueue()
+
+ expect(mockShowWarningToast).toHaveBeenCalledWith('trns.errors.orphanedSkipped', { count: 3 })
+ })
+
+ it('does not show toast when no orphans', async () => {
+ mockGetAllOfflineOps.mockResolvedValue([
+ makeOp(OfflineEntityType.Trns, 't1', 'create'),
+ ])
+ mockGroupOpsByEntity.mockReturnValue({
+ categoryOps: [],
+ settingsOps: [],
+ trnOps: [makeOp(OfflineEntityType.Trns, 't1', 'create')],
+ walletOps: [],
+ })
+ mockReplayTrnOps.mockResolvedValue(0)
+
+ await replayOfflineQueue()
+
+ expect(mockShowWarningToast).not.toHaveBeenCalled()
+ })
+})
+
+describe('isReplaying', () => {
+ it('returns false when not replaying', () => {
+ expect(isReplaying()).toBe(false)
+ })
+})
diff --git a/app/components/stat/statConfig.test.ts b/app/components/stat/statConfig.test.ts
index 84227e49..73ba1bee 100644
--- a/app/components/stat/statConfig.test.ts
+++ b/app/components/stat/statConfig.test.ts
@@ -15,8 +15,11 @@ const defaultConfig: MiniItemConfig = {
isShow: true,
},
catsRound: {
+ isExpanded: false,
isGrouped: false,
isShow: true,
+ isShowFavorites: true,
+ isShowRecent: true,
},
catsView: 'list',
chart: {
diff --git a/app/components/trnForm/useTrnsFormStore.test.ts b/app/components/trnForm/useTrnsFormStore.test.ts
new file mode 100644
index 00000000..a78e05f1
--- /dev/null
+++ b/app/components/trnForm/useTrnsFormStore.test.ts
@@ -0,0 +1,256 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { describe, expect, it, vi, beforeEach } from 'vitest'
+
+import { TrnType } from '~/components/trns/types'
+
+// --- Mocks ---
+
+vi.mock('~/components/categories/useCategoriesStore', () => ({
+ useCategoriesStore: () => ({
+ categoriesIdsForTrnValues: ['c1', 'c2'],
+ items: { c1: { name: 'Food' }, c2: { name: 'Transport' } },
+ }),
+}))
+
+vi.mock('~/components/wallets/useWalletsStore', () => ({
+ useWalletsStore: () => ({
+ items: { w1: { name: 'Cash', currency: 'USD' }, w2: { name: 'Card', currency: 'USD' } },
+ sortedIds: ['w1', 'w2'],
+ }),
+}))
+
+vi.mock('~/components/trns/useTrnsStore', () => ({
+ useTrnsStore: () => ({
+ items: {},
+ lastCreatedTrnItem: null,
+ }),
+}))
+
+vi.mock('~/composables/useStoreSync', () => ({
+ showErrorToast: vi.fn(),
+}))
+
+vi.mock('~~/utils/generateId', () => ({
+ generateId: () => 'generated-id',
+}))
+
+vi.mock('~/components/amount/utils', () => ({
+ formatByCurrency: (amount: number) => String(amount),
+}))
+
+beforeEach(() => {
+ setActivePinia(createPinia())
+})
+
+import { useTrnsFormStore } from './useTrnsFormStore'
+
+describe('useTrnsFormStore', () => {
+ describe('initial state', () => {
+ it('has default values', () => {
+ const store = useTrnsFormStore()
+ expect(store.values.trnType).toBe(TrnType.Expense)
+ expect(store.values.amount).toEqual([0, 0, 0])
+ expect(store.values.categoryId).toBeNull()
+ expect(store.values.walletId).toBeNull()
+ expect(store.ui.isShow).toBe(false)
+ })
+ })
+
+ describe('activeAmountIdx', () => {
+ it('returns 0 for expense', () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Expense
+ expect(store.activeAmountIdx).toBe(0)
+ })
+
+ it('returns 0 for income', () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Income
+ expect(store.activeAmountIdx).toBe(0)
+ })
+
+ it('returns 1 for transfer expense side', () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Transfer
+ store.values.transferType = 'expense'
+ expect(store.activeAmountIdx).toBe(1)
+ })
+
+ it('returns 2 for transfer income side', () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Transfer
+ store.values.transferType = 'income'
+ expect(store.activeAmountIdx).toBe(2)
+ })
+ })
+
+ describe('onChangeTrnType', () => {
+ it('changes trnType', () => {
+ const store = useTrnsFormStore()
+ store.onChangeTrnType(TrnType.Income)
+ expect(store.values.trnType).toBe(TrnType.Income)
+ })
+ })
+
+ describe('onChangeTransferType', () => {
+ it('changes transferType', () => {
+ const store = useTrnsFormStore()
+ store.onChangeTransferType('income')
+ expect(store.values.transferType).toBe('income')
+ })
+ })
+
+ describe('onClear', () => {
+ it('resets amounts and description but keeps category/wallet', () => {
+ const store = useTrnsFormStore()
+ store.values.amount = [100, 200, 300]
+ store.values.desc = 'test'
+ store.values.categoryId = 'c1'
+ store.values.walletId = 'w1'
+
+ store.onClear()
+
+ expect(store.values.amount).toEqual([0, 0, 0])
+ expect(store.values.desc).toBeUndefined()
+ expect(store.values.categoryId).toBe('c1')
+ expect(store.values.walletId).toBe('w1')
+ })
+ })
+
+ describe('$reset', () => {
+ it('resets all values to defaults', () => {
+ const store = useTrnsFormStore()
+ store.values.amount = [100, 200, 300]
+ store.values.categoryId = 'c1'
+ store.values.walletId = 'w1'
+ store.values.trnType = TrnType.Transfer
+ store.ui.isShow = true
+
+ store.$reset()
+
+ expect(store.values.amount).toEqual([0, 0, 0])
+ expect(store.values.categoryId).toBeNull()
+ expect(store.values.walletId).toBeNull()
+ expect(store.values.trnType).toBe(TrnType.Expense)
+ expect(store.ui.isShow).toBe(false)
+ })
+ })
+
+ describe('onClose', () => {
+ it('hides form', () => {
+ const store = useTrnsFormStore()
+ store.ui.isShow = true
+
+ store.onClose()
+
+ expect(store.ui.isShow).toBe(false)
+ })
+
+ it('clears when editing (trnId set)', () => {
+ const store = useTrnsFormStore()
+ store.values.trnId = 'trn1'
+ store.values.amount = [100, 0, 0]
+ store.ui.isShow = true
+
+ store.onClose()
+
+ expect(store.values.amount).toEqual([0, 0, 0])
+ expect(store.values.trnId).toBeNull()
+ expect(store.ui.isShow).toBe(false)
+ })
+ })
+
+ describe('openFormForCreate', () => {
+ it('opens form and sets initial values from wallets/categories', () => {
+ const store = useTrnsFormStore()
+
+ store.openFormForCreate()
+
+ expect(store.ui.isShow).toBe(true)
+ expect(store.values.trnType).toBe(TrnType.Expense)
+ expect(store.values.walletId).toBe('w1')
+ expect(store.values.categoryId).toBe('c1')
+ expect(store.values.incomeWalletId).toBe('w1')
+ expect(store.values.expenseWalletId).toBe('w2')
+ })
+ })
+
+ describe('openFormForEdit', () => {
+ it('does nothing if trn not found', () => {
+ const store = useTrnsFormStore()
+
+ store.openFormForEdit('nonexistent')
+
+ expect(store.ui.isShow).toBe(false)
+ })
+ })
+
+ describe('onSubmit', () => {
+ it('returns error toast when wallet not selected', async () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Expense
+ store.values.walletId = null
+
+ const result = await store.onSubmit()
+
+ expect(result).toBeUndefined()
+ const { showErrorToast } = await import('~/composables/useStoreSync')
+ expect(showErrorToast).toHaveBeenCalledWith('trnForm.errors.selectWallet')
+ })
+
+ it('returns error toast when category not selected', async () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Expense
+ store.values.walletId = 'w1'
+ store.values.categoryId = null
+
+ const result = await store.onSubmit()
+
+ expect(result).toBeUndefined()
+ const { showErrorToast } = await import('~/composables/useStoreSync')
+ expect(showErrorToast).toHaveBeenCalledWith('trnForm.errors.selectCategory')
+ })
+
+ it('returns id and values for valid expense', async () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Expense
+ store.values.walletId = 'w1'
+ store.values.categoryId = 'c1'
+ store.values.amount = [100, 0, 0]
+ store.values.date = 1700000000000
+
+ const result = await store.onSubmit()
+
+ expect(result).toBeDefined()
+ expect(result!.id).toBe('generated-id')
+ expect(result!.values).toBeDefined()
+ })
+
+ it('uses existing trnId when editing', async () => {
+ const store = useTrnsFormStore()
+ store.values.trnType = TrnType.Expense
+ store.values.walletId = 'w1'
+ store.values.categoryId = 'c1'
+ store.values.amount = [100, 0, 0]
+ store.values.date = 1700000000000
+ store.values.trnId = 'existing-trn-id'
+
+ const result = await store.onSubmit()
+
+ expect(result).toBeDefined()
+ expect(result!.id).toBe('existing-trn-id')
+ })
+ })
+
+ describe('modal', () => {
+ it('opens and closes description modal', () => {
+ const store = useTrnsFormStore()
+
+ store.openTrnFormModal('description')
+ expect(store.modal.description).toBe(true)
+
+ store.closeTrnFormModal('description')
+ expect(store.modal.description).toBe(false)
+ })
+ })
+})
diff --git a/app/components/user/useUserStore.test.ts b/app/components/user/useUserStore.test.ts
index c91b824e..5fe197fc 100644
--- a/app/components/user/useUserStore.test.ts
+++ b/app/components/user/useUserStore.test.ts
@@ -8,11 +8,14 @@ import { ref } from 'vue'
const mutationMock = vi.fn(() => Promise.resolve())
const queryMock = vi.fn((): Promise<any> => Promise.resolve(null))
+const actionMock = vi.fn(() => Promise.resolve())
+
vi.stubGlobal('useConvexClientWithApi', () => ({
api: {
- user: { get: 'user.get', upsert: 'user.upsert' },
+ user: { get: 'user.get', removeAllUserData: 'user.removeAllUserData', upsert: 'user.upsert' },
},
client: {
+ action: actionMock,
mutation: mutationMock,
query: queryMock,
},
@@ -26,33 +29,69 @@ vi.stubGlobal('useNuxtApp', () => ({
type SessionUser = { email: string, id: string, image: string | null, name: string }
type SessionData = { data: { user: SessionUser } | null, isPending: boolean }
const useSessionMock = vi.fn(() => ref<SessionData>({ data: null, isPending: false }))
+const authSignOutMock = vi.fn(() => Promise.resolve())
vi.stubGlobal('useAuth', () => ({
- signOut: vi.fn(),
+ signOut: authSignOutMock,
useSession: useSessionMock,
}))
vi.mock('~/components/categories/useCategoriesStore', () => ({
useCategoriesStore: () => ({
- setCategories: vi.fn(),
+ setCategories: (...args: unknown[]) => setCategoriesMock(...args),
}),
}))
vi.mock('~/components/trns/useTrnsStore', () => ({
useTrnsStore: () => ({
- setTrns: vi.fn(),
+ setTrns: (...args: unknown[]) => setTrnsMock(...args),
}),
}))
vi.mock('~/components/wallets/useWalletsStore', () => ({
useWalletsStore: () => ({
- setWallets: vi.fn(),
+ setWallets: (...args: unknown[]) => setWalletsMock(...args),
}),
}))
+vi.mock('~/components/trnForm/useTrnsFormStore', () => ({
+ useTrnsFormStore: () => ({
+ $reset: (...args: unknown[]) => trnFormResetMock(...args),
+ }),
+}))
+
+const clearAuthCookieMock = vi.fn()
+const setSessionInitializedMock = vi.fn()
vi.mock('~/composables/useAuthCookie', () => ({
- clearAuthCookie: vi.fn(),
+ clearAuthCookie: (...args: unknown[]) => clearAuthCookieMock(...args),
+ setSessionInitialized: (...args: unknown[]) => setSessionInitializedMock(...args),
}))
+const blockPersistMock = vi.fn()
+vi.mock('~/composables/useStoreSync', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('~/composables/useStoreSync')>()
+ return {
+ ...actual,
+ blockPersist: (...args: unknown[]) => blockPersistMock(...args),
+ }
+})
+
+const setTrnsMock = vi.fn()
+const setCategoriesMock = vi.fn()
+const setWalletsMock = vi.fn()
+const trnFormResetMock = vi.fn()
+
+const clearOfflineQueueMock = vi.fn(() => Promise.resolve())
+const setOfflineQueueUserIdMock = vi.fn()
+vi.mock('~/components/offline/helpers', () => ({
+ clearOfflineQueue: (...args: unknown[]) => clearOfflineQueueMock(...args),
+ getOfflineOpsByEntity: vi.fn(() => Promise.resolve([])),
+ pushOfflineOp: vi.fn(() => Promise.resolve()),
+ setOfflineQueueUserId: (...args: unknown[]) => setOfflineQueueUserIdMock(...args),
+}))
+
+const useCookieMock = vi.fn(() => ({ value: null }))
+vi.stubGlobal('useCookie', useCookieMock)
+
const { useUserStore } = await import('~/components/user/useUserStore')
// --- Tests ---
@@ -218,4 +257,120 @@ describe('useUserStore', () => {
expect(saved).toEqual({ baseCurrency: 'EUR', locale: 'ru' })
})
})
+
+ describe('signOut', () => {
+ beforeEach(() => {
+ // Mock window.location
+ Object.defineProperty(window, 'location', {
+ configurable: true,
+ value: { href: '/' },
+ writable: true,
+ })
+ })
+
+ it('blocks persist to prevent race conditions', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(blockPersistMock).toHaveBeenCalled()
+ })
+
+ it('resets all stores', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(setTrnsMock).toHaveBeenCalledWith(null)
+ expect(setCategoriesMock).toHaveBeenCalledWith(null)
+ expect(setWalletsMock).toHaveBeenCalledWith(null)
+ expect(trnFormResetMock).toHaveBeenCalled()
+ })
+
+ it('clears auth state', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(clearAuthCookieMock).toHaveBeenCalled()
+ expect(setSessionInitializedMock).toHaveBeenCalledWith(false)
+ })
+
+ it('clears localforage', async () => {
+ await localforage.setItem('testKey', 'testValue')
+ const store = useUserStore()
+ await store.signOut()
+
+ const value = await localforage.getItem('testKey')
+ expect(value).toBeNull()
+ })
+
+ it('calls authClient.signOut', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(authSignOutMock).toHaveBeenCalled()
+ })
+
+ it('redirects to /login', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(window.location.href).toBe('/login')
+ })
+
+ it('resets isSigningOut after completion', async () => {
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(store.isSigningOut).toBe(false)
+ })
+
+ it('resets isSigningOut on error', async () => {
+ authSignOutMock.mockRejectedValueOnce(new Error('network'))
+ const store = useUserStore()
+ await store.signOut()
+
+ expect(store.isSigningOut).toBe(false)
+ })
+ })
+
+ describe('removeAllUserData', () => {
+ it('blocks persist', async () => {
+ useSessionMock.mockReturnValue(ref({ data: { user: { email: '[email protected]', id: 'u1', image: null, name: 'A' } }, isPending: false }))
+ setActivePinia(createPinia())
+ const store = useUserStore()
+ await store.removeAllUserData()
+
+ expect(blockPersistMock).toHaveBeenCalled()
+ })
+
+ it('resets all stores', async () => {
+ useSessionMock.mockReturnValue(ref({ data: { user: { email: '[email protected]', id: 'u1', image: null, name: 'A' } }, isPending: false }))
+ setActivePinia(createPinia())
+ const store = useUserStore()
+ await store.removeAllUserData()
+
+ expect(setTrnsMock).toHaveBeenCalledWith(null)
+ expect(setCategoriesMock).toHaveBeenCalledWith(null)
+ expect(setWalletsMock).toHaveBeenCalledWith(null)
+ expect(trnFormResetMock).toHaveBeenCalled()
+ })
+
+ it('clears offline queue and restores userId', async () => {
+ useSessionMock.mockReturnValue(ref({ data: { user: { email: '[email protected]', id: 'u1', image: null, name: 'A' } }, isPending: false }))
+ setActivePinia(createPinia())
+ const store = useUserStore()
+ await store.removeAllUserData()
+
+ expect(clearOfflineQueueMock).toHaveBeenCalled()
+ expect(setOfflineQueueUserIdMock).toHaveBeenCalledWith('u1')
+ })
+
+ it('calls Convex removeAllUserData action', async () => {
+ useSessionMock.mockReturnValue(ref({ data: { user: { email: '[email protected]', id: 'u1', image: null, name: 'A' } }, isPending: false }))
+ setActivePinia(createPinia())
+ const store = useUserStore()
+ await store.removeAllUserData()
+
+ expect(actionMock).toHaveBeenCalledWith('user.removeAllUserData', {})
+ })
+ })
})
diff --git a/app/test-utils/setup-store.ts b/app/test-utils/setup-store.ts
index 057b1a37..d1154a5e 100644
--- a/app/test-utils/setup-store.ts
+++ b/app/test-utils/setup-store.ts
@@ -9,9 +9,10 @@
*/
import { defineStore } from 'pinia'
import { vi } from 'vitest'
-import { computed, ref, shallowRef, watch } from 'vue'
+import { computed, reactive, ref, shallowRef, watch } from 'vue'
vi.stubGlobal('computed', computed)
+vi.stubGlobal('reactive', reactive)
vi.stubGlobal('ref', ref)
vi.stubGlobal('shallowRef', shallowRef)
vi.stubGlobal('watch', watch)