@kevairy/template 0.1.3 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/template/.env +2 -2
- package/template/.env.production +6 -0
- package/template/src/adapters/auth/index.ts +1 -1
- package/template/src/adapters/auth/types.ts +6 -1
- package/template/src/api/auth.ts +3 -2
- package/template/src/components/core/layouts/art-guide/index.vue +9 -1
- package/template/src/components/core/layouts/art-page-content/index.vue +8 -1
- package/template/src/config/index.ts +4 -0
- package/template/src/directives/core/access.ts +125 -0
- package/template/src/directives/core/auth.ts +7 -62
- package/template/src/directives/core/roles.ts +5 -83
- package/template/src/env.d.ts +1 -0
- package/template/src/hooks/core/useAuth.ts +2 -74
- package/template/src/hooks/core/useGuide.ts +6 -0
- package/template/src/hooks/core/usePermission.ts +41 -0
- package/template/src/hooks/index.ts +1 -0
- package/template/src/locales/langs/en.json +11 -1
- package/template/src/locales/langs/zh.json +11 -1
- package/template/src/main.ts +18 -10
- package/template/src/router/core/IframeRouteManager.ts +4 -2
- package/template/src/router/core/MenuProcessor.ts +5 -40
- package/template/src/router/core/RoutePermissionValidator.ts +6 -149
- package/template/src/router/core/access.ts +79 -0
- package/template/src/router/guards/afterEach.ts +6 -10
- package/template/src/router/guards/beforeEach.ts +143 -100
- package/template/src/router/guards/error.ts +42 -0
- package/template/src/router/index.ts +2 -0
- package/template/src/router/modules/examples.ts +4 -3
- package/template/src/router/routes/staticRoutes.ts +5 -3
- package/template/src/services/auth.ts +32 -10
- package/template/src/services/permission.ts +21 -0
- package/template/src/store/modules/menu.ts +28 -8
- package/template/src/store/modules/user.ts +72 -35
- package/template/src/store/modules/worktab.ts +1 -1
- package/template/src/types/api/api.d.ts +4 -1
- package/template/src/types/config/index.ts +5 -0
- package/template/src/types/directive/directive.d.ts +1 -0
- package/template/src/types/router/index.ts +6 -0
- package/template/src/utils/http/contract.ts +51 -19
- package/template/src/utils/http/error.ts +73 -26
- package/template/src/utils/http/index.ts +160 -167
- package/template/src/utils/http/request-manager.ts +124 -0
- package/template/src/utils/http/status.ts +1 -0
- package/template/src/utils/permission/index.ts +66 -0
- package/template/src/utils/session.ts +24 -0
- package/template/src/utils/storage/storage-config.ts +15 -0
- package/template/src/utils/storage/storage.ts +5 -3
- package/template/src/utils/sys/diagnostics.ts +180 -0
- package/template/src/utils/sys/error-handle.ts +56 -126
- package/template/src/utils/sys/recovery.ts +31 -0
- package/template/src/views/examples/permissions/index.vue +69 -13
- package/template/src/views/exception/403/index.vue +33 -0
- package/template/src/views/exception/500/index.vue +52 -10
- package/template/tests/e2e/permissions.spec.ts +53 -0
- package/template/tests/e2e/session-recovery.spec.ts +49 -0
- package/template/tests/unit/diagnostics/diagnostics.spec.ts +132 -0
- package/template/tests/unit/diagnostics/router.spec.ts +84 -0
- package/template/tests/unit/http/auth-lifecycle.spec.ts +203 -0
- package/template/tests/unit/http/contract.spec.ts +46 -0
- package/template/tests/unit/http/request.spec.ts +487 -0
- package/template/tests/unit/permissions/guard.spec.ts +261 -0
- package/template/tests/unit/permissions/guide.spec.ts +30 -0
- package/template/tests/unit/permissions/rules.spec.ts +106 -0
- package/template/tests/unit/permissions/state-and-directives.spec.ts +176 -0
- package/template/tests/unit/router/examples.spec.ts +5 -1
- package/template/vite.config.ts +5 -2
|
@@ -0,0 +1,261 @@
|
|
|
1
|
+
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
2
|
+
import { createPinia, setActivePinia } from 'pinia'
|
|
3
|
+
import { effectScope, nextTick, type EffectScope } from 'vue'
|
|
4
|
+
import { flushPromises } from '@vue/test-utils'
|
|
5
|
+
import type { AppRouteRecord } from '@/types/router'
|
|
6
|
+
|
|
7
|
+
const fixtures = vi.hoisted(() => ({
|
|
8
|
+
frontend: true,
|
|
9
|
+
routes: [] as AppRouteRecord[],
|
|
10
|
+
getInfo: vi.fn(),
|
|
11
|
+
getMenus: vi.fn()
|
|
12
|
+
}))
|
|
13
|
+
vi.mock('@/api/auth', () => ({ fetchGetUserInfo: fixtures.getInfo }))
|
|
14
|
+
vi.mock('@/adapters/navigation', () => ({ navigationAdapter: { getMenuList: fixtures.getMenus } }))
|
|
15
|
+
vi.mock('@/router/routes/asyncRoutes', () => ({ asyncRoutes: fixtures.routes }))
|
|
16
|
+
vi.mock('@/hooks/core/useAppMode', () => ({
|
|
17
|
+
useAppMode: () => ({ isFrontendMode: { value: fixtures.frontend } })
|
|
18
|
+
}))
|
|
19
|
+
vi.mock('nprogress', () => ({ default: { start: vi.fn(), done: vi.fn(), remove: vi.fn() } }))
|
|
20
|
+
vi.mock('@/utils/navigation', () => ({ setWorktab: vi.fn() }))
|
|
21
|
+
vi.mock('@/utils/router', () => ({
|
|
22
|
+
setPageTitle: vi.fn(),
|
|
23
|
+
formatMenuTitle: (title: string) => title,
|
|
24
|
+
configureNProgress: vi.fn()
|
|
25
|
+
}))
|
|
26
|
+
vi.mock('@/utils/ui', () => ({ loadingService: { showLoading: vi.fn(), hideLoading: vi.fn() } }))
|
|
27
|
+
vi.mock('@/router/core/ComponentLoader', () => ({
|
|
28
|
+
ComponentLoader: class {
|
|
29
|
+
load() {
|
|
30
|
+
return async () => ({ render: () => null })
|
|
31
|
+
}
|
|
32
|
+
loadLayout() {
|
|
33
|
+
return this.load()
|
|
34
|
+
}
|
|
35
|
+
loadIframe() {
|
|
36
|
+
return this.load()
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
}))
|
|
40
|
+
vi.mock('@/router', async () => {
|
|
41
|
+
const { createRouter, createMemoryHistory } = await import('vue-router')
|
|
42
|
+
const View = { render: () => null }
|
|
43
|
+
const routes = [
|
|
44
|
+
{ path: '/auth/login', name: 'Login', component: View },
|
|
45
|
+
{ path: '/403', name: 'Exception403', component: View },
|
|
46
|
+
{ path: '/500', name: 'Exception500', component: View },
|
|
47
|
+
{
|
|
48
|
+
path: '/outside/iframe/:path',
|
|
49
|
+
name: 'Iframe',
|
|
50
|
+
component: View,
|
|
51
|
+
meta: { requiresAuth: true }
|
|
52
|
+
},
|
|
53
|
+
{ path: '/:pathMatch(.*)*', name: 'Exception404', component: View }
|
|
54
|
+
]
|
|
55
|
+
return {
|
|
56
|
+
router: createRouter({ history: createMemoryHistory(), routes }),
|
|
57
|
+
HOME_PAGE_PATH: '/secure/list'
|
|
58
|
+
}
|
|
59
|
+
})
|
|
60
|
+
|
|
61
|
+
let scope: EffectScope
|
|
62
|
+
let teardown: (() => void) | undefined
|
|
63
|
+
const info = (roles: string[] = [], permissions: string[] = []): Api.Auth.UserInfo => ({
|
|
64
|
+
userId: 'test',
|
|
65
|
+
userName: 'Test',
|
|
66
|
+
email: '',
|
|
67
|
+
roles,
|
|
68
|
+
permissions
|
|
69
|
+
})
|
|
70
|
+
beforeEach(() => {
|
|
71
|
+
vi.resetModules()
|
|
72
|
+
setActivePinia(createPinia())
|
|
73
|
+
fixtures.frontend = true
|
|
74
|
+
fixtures.routes.splice(0, fixtures.routes.length, {
|
|
75
|
+
path: '/secure',
|
|
76
|
+
name: 'Secure',
|
|
77
|
+
component: '/index/index',
|
|
78
|
+
meta: { title: 'Secure', roles: ['admin'] },
|
|
79
|
+
children: [
|
|
80
|
+
{ path: 'list', name: 'List', component: '/list', meta: { title: 'List' } },
|
|
81
|
+
{
|
|
82
|
+
path: 'detail/:id',
|
|
83
|
+
name: 'Detail',
|
|
84
|
+
component: '/detail',
|
|
85
|
+
meta: { title: 'Detail', isHide: true, permissions: ['resource:read'] }
|
|
86
|
+
}
|
|
87
|
+
]
|
|
88
|
+
})
|
|
89
|
+
fixtures.getInfo.mockReset().mockResolvedValue(info())
|
|
90
|
+
fixtures.getMenus.mockReset().mockResolvedValue([])
|
|
91
|
+
scope = effectScope()
|
|
92
|
+
})
|
|
93
|
+
afterEach(async () => {
|
|
94
|
+
teardown?.()
|
|
95
|
+
scope.stop()
|
|
96
|
+
const { resetRouterState } = await import('@/router/guards/beforeEach')
|
|
97
|
+
resetRouterState(0)
|
|
98
|
+
})
|
|
99
|
+
|
|
100
|
+
async function setup(login = true) {
|
|
101
|
+
const { router } = await import('@/router')
|
|
102
|
+
const { useUserStore } = await import('@/store/modules/user')
|
|
103
|
+
const { setupBeforeEachGuard } = await import('@/router/guards/beforeEach')
|
|
104
|
+
const user = useUserStore()
|
|
105
|
+
if (login) user.establishSession('test-token')
|
|
106
|
+
await router.push('/auth/login')
|
|
107
|
+
scope.run(() => {
|
|
108
|
+
teardown = setupBeforeEachGuard(router)
|
|
109
|
+
})
|
|
110
|
+
return { router, user }
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
describe('authorization navigation', () => {
|
|
114
|
+
it('recovers from initialization failure after an explicit router reset', async () => {
|
|
115
|
+
vi.spyOn(console, 'error').mockImplementation(() => {})
|
|
116
|
+
fixtures.getInfo.mockRejectedValueOnce(new Error('Service unavailable'))
|
|
117
|
+
const { router } = await setup()
|
|
118
|
+
await router.push('/secure/list')
|
|
119
|
+
expect(router.currentRoute.value.path).toBe('/500')
|
|
120
|
+
const { resetRouterState, getRouteInitFailed } = await import('@/router/guards/beforeEach')
|
|
121
|
+
expect(getRouteInitFailed()).toBe(true)
|
|
122
|
+
fixtures.getInfo.mockResolvedValue(info(['admin']))
|
|
123
|
+
resetRouterState(0)
|
|
124
|
+
await router.push('/')
|
|
125
|
+
expect(router.currentRoute.value.path).toBe('/secure/list')
|
|
126
|
+
expect(getRouteInitFailed()).toBe(false)
|
|
127
|
+
vi.restoreAllMocks()
|
|
128
|
+
})
|
|
129
|
+
|
|
130
|
+
it('discards old user info that arrives after a new login initializes', async () => {
|
|
131
|
+
let complete!: (value: Api.Auth.UserInfo) => void
|
|
132
|
+
fixtures.getInfo.mockImplementationOnce(
|
|
133
|
+
() =>
|
|
134
|
+
new Promise((resolve) => {
|
|
135
|
+
complete = resolve
|
|
136
|
+
})
|
|
137
|
+
)
|
|
138
|
+
const { router, user } = await setup()
|
|
139
|
+
const old = router.push('/secure/list?session=old')
|
|
140
|
+
await flushPromises()
|
|
141
|
+
user.establishSession('new-token')
|
|
142
|
+
fixtures.getInfo.mockResolvedValue({ ...info(['admin']), userId: 'new' })
|
|
143
|
+
await router.push('/secure/list?session=new')
|
|
144
|
+
complete({ ...info(), userId: 'old' })
|
|
145
|
+
await old
|
|
146
|
+
expect(user.info.userId).toBe('new')
|
|
147
|
+
expect(router.currentRoute.value.fullPath).toBe('/secure/list?session=new')
|
|
148
|
+
const { getRouteInitFailed } = await import('@/router/guards/beforeEach')
|
|
149
|
+
expect(getRouteInitFailed()).toBe(false)
|
|
150
|
+
})
|
|
151
|
+
|
|
152
|
+
it('does not let old menu failures poison a newer session', async () => {
|
|
153
|
+
fixtures.frontend = false
|
|
154
|
+
let fail!: (error: Error) => void
|
|
155
|
+
fixtures.getMenus.mockImplementationOnce(
|
|
156
|
+
() =>
|
|
157
|
+
new Promise((_, reject) => {
|
|
158
|
+
fail = reject
|
|
159
|
+
})
|
|
160
|
+
)
|
|
161
|
+
const { router, user } = await setup()
|
|
162
|
+
const old = router.push('/old')
|
|
163
|
+
await flushPromises()
|
|
164
|
+
user.establishSession('new-token')
|
|
165
|
+
fixtures.getMenus.mockResolvedValue([
|
|
166
|
+
{ path: '/new', name: 'New', component: '/new', meta: { title: 'New' } }
|
|
167
|
+
])
|
|
168
|
+
await router.push('/new')
|
|
169
|
+
fail(new Error('Old menu failed'))
|
|
170
|
+
await old
|
|
171
|
+
const { useMenuStore } = await import('@/store/modules/menu')
|
|
172
|
+
const { getRouteInitFailed } = await import('@/router/guards/beforeEach')
|
|
173
|
+
expect(getRouteInitFailed()).toBe(false)
|
|
174
|
+
expect(useMenuStore().routeList[0].path).toBe('/new')
|
|
175
|
+
expect(router.currentRoute.value.path).toBe('/new')
|
|
176
|
+
})
|
|
177
|
+
|
|
178
|
+
it('ignores a stale permission refresh and permits retry after a canceled initialization', async () => {
|
|
179
|
+
fixtures.getInfo.mockResolvedValue(info(['admin']))
|
|
180
|
+
const { router, user } = await setup()
|
|
181
|
+
await router.push('/secure/list')
|
|
182
|
+
let complete!: (value: Api.Auth.UserInfo) => void
|
|
183
|
+
fixtures.getInfo.mockImplementationOnce(
|
|
184
|
+
() =>
|
|
185
|
+
new Promise((resolve) => {
|
|
186
|
+
complete = resolve
|
|
187
|
+
})
|
|
188
|
+
)
|
|
189
|
+
const { refreshAccess } = await import('@/services/permission')
|
|
190
|
+
const refresh = refreshAccess()
|
|
191
|
+
user.establishSession('new-token')
|
|
192
|
+
user.setUserInfo({ ...info(['admin']), userId: 'new' })
|
|
193
|
+
complete({ ...info(), userId: 'old' })
|
|
194
|
+
await refresh
|
|
195
|
+
expect(user.info.userId).toBe('new')
|
|
196
|
+
user.permissionsReady = false
|
|
197
|
+
fixtures.getInfo.mockRejectedValueOnce(new DOMException('Canceled', 'AbortError'))
|
|
198
|
+
await router.push('/secure/list?retry=1')
|
|
199
|
+
const { getRouteInitFailed } = await import('@/router/guards/beforeEach')
|
|
200
|
+
expect(getRouteInitFailed()).toBe(false)
|
|
201
|
+
await router.push('/secure/list?retry=2')
|
|
202
|
+
expect(router.currentRoute.value.name).toBe('List')
|
|
203
|
+
})
|
|
204
|
+
|
|
205
|
+
it('keeps an authenticated empty-role user signed in and restores or revokes detail access', async () => {
|
|
206
|
+
const { router, user } = await setup()
|
|
207
|
+
await router.push('/secure/detail/42')
|
|
208
|
+
expect(router.currentRoute.value.path).toBe('/403')
|
|
209
|
+
expect(user.isLogin).toBe(true)
|
|
210
|
+
expect(user.accessToken).toBe('test-token')
|
|
211
|
+
expect(user.permissionsReady).toBe(true)
|
|
212
|
+
user.setUserInfo(info(['admin'], ['resource:read']))
|
|
213
|
+
await nextTick()
|
|
214
|
+
await router.push('/secure/detail/42')
|
|
215
|
+
expect(router.currentRoute.value.name).toBe('Detail')
|
|
216
|
+
user.setUserInfo(info(['admin'], []))
|
|
217
|
+
await nextTick()
|
|
218
|
+
await flushPromises()
|
|
219
|
+
expect(router.currentRoute.value.path).toBe('/403')
|
|
220
|
+
expect(user.isLogin).toBe(true)
|
|
221
|
+
await router.push('/secure/list')
|
|
222
|
+
expect(router.currentRoute.value.name).toBe('List')
|
|
223
|
+
await router.push('/secure/detail/42')
|
|
224
|
+
expect(router.currentRoute.value.path).toBe('/403')
|
|
225
|
+
})
|
|
226
|
+
|
|
227
|
+
it('treats a successful empty backend menu as ready and recovers after explicit refresh', async () => {
|
|
228
|
+
fixtures.frontend = false
|
|
229
|
+
const { router, user } = await setup()
|
|
230
|
+
await router.push('/')
|
|
231
|
+
expect(router.currentRoute.value.path).toBe('/403')
|
|
232
|
+
await router.push('/')
|
|
233
|
+
expect(fixtures.getMenus).toHaveBeenCalledOnce()
|
|
234
|
+
expect(fixtures.getInfo).toHaveBeenCalledOnce()
|
|
235
|
+
expect(user.isLogin).toBe(true)
|
|
236
|
+
fixtures.getMenus.mockResolvedValue([
|
|
237
|
+
{ path: '/allowed', name: 'Allowed', component: '/allowed', meta: { title: 'Allowed' } }
|
|
238
|
+
])
|
|
239
|
+
const { refreshAccess } = await import('@/services/permission')
|
|
240
|
+
await refreshAccess()
|
|
241
|
+
expect(router.currentRoute.value.path).toBe('/allowed')
|
|
242
|
+
})
|
|
243
|
+
|
|
244
|
+
it('separates unknown paths from declared forbidden pages and checks hidden-page permissions on deep links', async () => {
|
|
245
|
+
fixtures.getInfo.mockResolvedValue(info(['admin']))
|
|
246
|
+
const { router } = await setup()
|
|
247
|
+
await router.push('/secure/detail/12')
|
|
248
|
+
expect(router.currentRoute.value.path).toBe('/403')
|
|
249
|
+
await router.push('/secure/list')
|
|
250
|
+
await router.push('/secure/arbitrary-child')
|
|
251
|
+
expect(router.currentRoute.value.name).toBe('Exception404')
|
|
252
|
+
})
|
|
253
|
+
|
|
254
|
+
it('redirects anonymous visits to protected static routes to login', async () => {
|
|
255
|
+
const { router } = await setup(false)
|
|
256
|
+
await router.push('/outside/iframe/test')
|
|
257
|
+
expect(router.currentRoute.value.name).toBe('Login')
|
|
258
|
+
expect(router.currentRoute.value.query.redirect).toBe('/outside/iframe/test')
|
|
259
|
+
expect(fixtures.getInfo).not.toHaveBeenCalled()
|
|
260
|
+
})
|
|
261
|
+
})
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import { describe, expect, it, vi } from 'vitest'
|
|
2
|
+
import { useGuide } from '@/hooks/core/useGuide'
|
|
3
|
+
|
|
4
|
+
const fixtures = vi.hoisted(() => ({
|
|
5
|
+
completeGuide: vi.fn(),
|
|
6
|
+
destroy: vi.fn(),
|
|
7
|
+
config: {} as { onDestroyStarted?: () => void }
|
|
8
|
+
}))
|
|
9
|
+
vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
|
|
10
|
+
vi.mock('@/store/modules/setting', () => ({
|
|
11
|
+
useSettingStore: () => ({ completeGuide: fixtures.completeGuide })
|
|
12
|
+
}))
|
|
13
|
+
vi.mock('driver.js', () => ({
|
|
14
|
+
driver: (config: typeof fixtures.config) => {
|
|
15
|
+
fixtures.config = config
|
|
16
|
+
return { drive: vi.fn(), destroy: fixtures.destroy }
|
|
17
|
+
}
|
|
18
|
+
}))
|
|
19
|
+
|
|
20
|
+
describe('onboarding completion', () => {
|
|
21
|
+
it('records an early close even when the driver does not invoke onDestroyed', () => {
|
|
22
|
+
const guide = useGuide()
|
|
23
|
+
guide.start()
|
|
24
|
+
fixtures.config.onDestroyStarted?.()
|
|
25
|
+
expect(fixtures.completeGuide).toHaveBeenCalledOnce()
|
|
26
|
+
expect(fixtures.destroy).toHaveBeenCalledOnce()
|
|
27
|
+
guide.destroy()
|
|
28
|
+
expect(fixtures.destroy).toHaveBeenCalledOnce()
|
|
29
|
+
})
|
|
30
|
+
})
|
|
@@ -0,0 +1,106 @@
|
|
|
1
|
+
import { describe, expect, it } from 'vitest'
|
|
2
|
+
import {
|
|
3
|
+
canAccessMeta,
|
|
4
|
+
matchesGrants,
|
|
5
|
+
normalizeGrants,
|
|
6
|
+
type AccessContext
|
|
7
|
+
} from '@/utils/permission'
|
|
8
|
+
import { canAccessRoute, filterAccessibleRoutes, resolveRouteChain } from '@/router/core/access'
|
|
9
|
+
import type { AppRouteRecord } from '@/types/router'
|
|
10
|
+
|
|
11
|
+
const access: AccessContext = {
|
|
12
|
+
ready: true,
|
|
13
|
+
permissions: ['resource:read'],
|
|
14
|
+
roles: [],
|
|
15
|
+
wildcard: '*:*:*'
|
|
16
|
+
}
|
|
17
|
+
const routes: AppRouteRecord[] = [
|
|
18
|
+
{
|
|
19
|
+
name: 'Resources',
|
|
20
|
+
path: '/resources',
|
|
21
|
+
component: '/index/index',
|
|
22
|
+
meta: { title: '资源' },
|
|
23
|
+
children: [
|
|
24
|
+
{ name: 'List', path: '/resources/list', component: '/list', meta: { title: '列表' } },
|
|
25
|
+
{
|
|
26
|
+
name: 'Detail',
|
|
27
|
+
path: '/resources/detail/:id(\\d+)',
|
|
28
|
+
component: '/detail',
|
|
29
|
+
meta: { title: '详情', isHide: true, permissions: ['resource:read'] }
|
|
30
|
+
},
|
|
31
|
+
{
|
|
32
|
+
name: 'Restricted',
|
|
33
|
+
path: '/resources/admin',
|
|
34
|
+
component: '/admin',
|
|
35
|
+
meta: { title: '管理', roles: ['admin'] }
|
|
36
|
+
}
|
|
37
|
+
]
|
|
38
|
+
}
|
|
39
|
+
]
|
|
40
|
+
|
|
41
|
+
describe('permission rules', () => {
|
|
42
|
+
it.each(['', ' ', [], [''], ['read', ''], undefined, null])(
|
|
43
|
+
'rejects invalid requirements, including for super permissions: %j',
|
|
44
|
+
(required) => {
|
|
45
|
+
expect(matchesGrants(['*:*:*'], required, 'any', '*:*:*')).toBe(false)
|
|
46
|
+
expect(matchesGrants([], required, 'all')).toBe(false)
|
|
47
|
+
}
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
it('supports any/all and an explicit configurable global wildcard', () => {
|
|
51
|
+
expect(matchesGrants([], 'read')).toBe(false)
|
|
52
|
+
expect(matchesGrants(['read'], ['read', 'write'])).toBe(true)
|
|
53
|
+
expect(matchesGrants(['read'], ['read', 'write'], 'all')).toBe(false)
|
|
54
|
+
expect(matchesGrants(['read', 'write'], ['read', 'write'], 'all')).toBe(true)
|
|
55
|
+
expect(matchesGrants(['*:*:*'], 'write', 'any', '*:*:*')).toBe(true)
|
|
56
|
+
expect(matchesGrants(['*:*:*'], 'write')).toBe(false)
|
|
57
|
+
expect(matchesGrants(['resource:*'], 'resource:read', 'any', '*:*:*')).toBe(false)
|
|
58
|
+
expect(matchesGrants(['root'], 'write', 'any', 'root')).toBe(true)
|
|
59
|
+
expect(normalizeGrants(['read', '', ' read ', null])).toEqual(['read'])
|
|
60
|
+
})
|
|
61
|
+
|
|
62
|
+
it('distinguishes unloaded access, unrestricted pages and explicit empty restrictions', () => {
|
|
63
|
+
expect(canAccessMeta({}, { ...access, ready: false })).toBe(false)
|
|
64
|
+
expect(canAccessMeta({}, access)).toBe(true)
|
|
65
|
+
expect(canAccessMeta({ roles: ['admin'] }, access)).toBe(false)
|
|
66
|
+
expect(canAccessMeta({ roles: [] }, access)).toBe(false)
|
|
67
|
+
expect(canAccessMeta({ permissions: [] }, access)).toBe(false)
|
|
68
|
+
expect(canAccessMeta({ permissions: ['resource:write', 'resource:read'] }, access)).toBe(true)
|
|
69
|
+
expect(
|
|
70
|
+
canAccessMeta(
|
|
71
|
+
{ permissions: ['resource:write', 'resource:read'], permissionMode: 'all' },
|
|
72
|
+
access
|
|
73
|
+
)
|
|
74
|
+
).toBe(false)
|
|
75
|
+
})
|
|
76
|
+
|
|
77
|
+
it('filters restricted routes for empty roles, preserves hidden detail and prunes empty directories', () => {
|
|
78
|
+
const filtered = filterAccessibleRoutes(routes, access)
|
|
79
|
+
expect(filtered[0].children?.map((item) => item.name)).toEqual(['List', 'Detail'])
|
|
80
|
+
const restrictedDirectory: AppRouteRecord[] = [
|
|
81
|
+
{ ...routes[0], children: [routes[0].children![2]] }
|
|
82
|
+
]
|
|
83
|
+
expect(filterAccessibleRoutes(restrictedDirectory, access)).toEqual([])
|
|
84
|
+
expect(filterAccessibleRoutes(routes, { ...access, ready: false })).toEqual([])
|
|
85
|
+
})
|
|
86
|
+
|
|
87
|
+
it('matches complete declared routes and inherits all ancestor restrictions', () => {
|
|
88
|
+
expect(canAccessRoute('/resources/detail/42', routes, access)).toBe(true)
|
|
89
|
+
expect(canAccessRoute('/resources/detail/42', routes, { ...access, permissions: [] })).toBe(
|
|
90
|
+
false
|
|
91
|
+
)
|
|
92
|
+
expect(resolveRouteChain('/resources/detail/abc', routes)).toHaveLength(0)
|
|
93
|
+
expect(resolveRouteChain('/resources/unknown', routes)).toHaveLength(0)
|
|
94
|
+
expect(resolveRouteChain('/resources/list/extra', routes)).toHaveLength(0)
|
|
95
|
+
const parentRestricted = [{ ...routes[0], meta: { title: '资源', roles: ['admin'] } }]
|
|
96
|
+
expect(canAccessRoute('/resources/detail/42', parentRestricted, access)).toBe(false)
|
|
97
|
+
expect(
|
|
98
|
+
canAccessRoute('/resources/detail/42', parentRestricted, { ...access, roles: ['admin'] })
|
|
99
|
+
).toBe(true)
|
|
100
|
+
})
|
|
101
|
+
|
|
102
|
+
it('replaces a denied default redirect with an accessible landing page', () => {
|
|
103
|
+
const tree = [{ ...routes[0], redirect: '/resources/admin' }]
|
|
104
|
+
expect(filterAccessibleRoutes(tree, access)[0].redirect).toBe('/resources/list')
|
|
105
|
+
})
|
|
106
|
+
})
|
|
@@ -0,0 +1,176 @@
|
|
|
1
|
+
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
|
2
|
+
import { createPinia, setActivePinia } from 'pinia'
|
|
3
|
+
import { defineComponent, h, nextTick, ref, withDirectives } from 'vue'
|
|
4
|
+
import { mount } from '@vue/test-utils'
|
|
5
|
+
import { ElButton } from 'element-plus'
|
|
6
|
+
import { useUserStore } from '@/store/modules/user'
|
|
7
|
+
import { useMenuStore } from '@/store/modules/menu'
|
|
8
|
+
import { usePermission } from '@/hooks/core/usePermission'
|
|
9
|
+
import { useAuth } from '@/hooks/core/useAuth'
|
|
10
|
+
import { createAccessDirective } from '@/directives/core/access'
|
|
11
|
+
|
|
12
|
+
vi.mock('@/router', async () => {
|
|
13
|
+
const { createRouter, createMemoryHistory } = await import('vue-router')
|
|
14
|
+
return {
|
|
15
|
+
router: createRouter({ history: createMemoryHistory(), routes: [] }),
|
|
16
|
+
HOME_PAGE_PATH: '/dashboard/console'
|
|
17
|
+
}
|
|
18
|
+
})
|
|
19
|
+
vi.mock('@/router/guards/beforeEach', () => ({ resetRouterState: vi.fn() }))
|
|
20
|
+
|
|
21
|
+
const userInfo = (extra: Partial<Api.Auth.UserInfo> = {}): Api.Auth.UserInfo => ({
|
|
22
|
+
userId: 'tester',
|
|
23
|
+
userName: 'Tester',
|
|
24
|
+
email: '',
|
|
25
|
+
roles: [],
|
|
26
|
+
...extra
|
|
27
|
+
})
|
|
28
|
+
const wrappers: Array<ReturnType<typeof mount>> = []
|
|
29
|
+
beforeEach(() => setActivePinia(createPinia()))
|
|
30
|
+
afterEach(() => wrappers.splice(0).forEach((wrapper) => wrapper.unmount()))
|
|
31
|
+
|
|
32
|
+
describe('permission state and compatibility', () => {
|
|
33
|
+
it('starts unloaded, normalizes legacy grants and denies again for a new session or sign-out', () => {
|
|
34
|
+
const user = useUserStore()
|
|
35
|
+
const permission = usePermission()
|
|
36
|
+
const legacy = useAuth()
|
|
37
|
+
expect(permission.ready.value).toBe(false)
|
|
38
|
+
expect(permission.hasPermission('read')).toBe(false)
|
|
39
|
+
user.setUserInfo(userInfo({ buttons: ['read'] }))
|
|
40
|
+
expect(user.permissions).toEqual(['read'])
|
|
41
|
+
expect(permission.hasPermission('read')).toBe(true)
|
|
42
|
+
expect(legacy.hasAuth('read')).toBe(true)
|
|
43
|
+
user.setUserInfo(userInfo({ permissions: [], buttons: ['*:*:*'] }))
|
|
44
|
+
expect(permission.ready.value).toBe(true)
|
|
45
|
+
expect(permission.hasPermission('read')).toBe(false)
|
|
46
|
+
user.setUserInfo(userInfo({ permissions: ['*:*:*'], roles: ['admin'] }))
|
|
47
|
+
expect(permission.hasPermission('read')).toBe(true)
|
|
48
|
+
expect(permission.hasRole('admin')).toBe(true)
|
|
49
|
+
user.establishSession('new-token')
|
|
50
|
+
expect(permission.ready.value).toBe(false)
|
|
51
|
+
expect(permission.permissions.value).toEqual([])
|
|
52
|
+
user.setUserInfo(userInfo({ permissions: ['read'] }))
|
|
53
|
+
user.clearAuthState(false)
|
|
54
|
+
expect(permission.ready.value).toBe(false)
|
|
55
|
+
expect(permission.hasPermission('read')).toBe(false)
|
|
56
|
+
})
|
|
57
|
+
|
|
58
|
+
it('recalculates menus and home when empty roles gain and lose a restriction', () => {
|
|
59
|
+
const user = useUserStore()
|
|
60
|
+
const menus = useMenuStore()
|
|
61
|
+
menus.setMenuList([
|
|
62
|
+
{
|
|
63
|
+
path: '/admin',
|
|
64
|
+
name: 'Admin',
|
|
65
|
+
component: '/admin',
|
|
66
|
+
meta: { title: 'Admin', roles: ['admin'] }
|
|
67
|
+
},
|
|
68
|
+
{ path: '/public', name: 'Public', component: '/public', meta: { title: 'Public' } }
|
|
69
|
+
])
|
|
70
|
+
expect(menus.menuList).toEqual([])
|
|
71
|
+
user.setUserInfo(userInfo())
|
|
72
|
+
expect(menus.menuList.map((route) => route.path)).toEqual(['/public'])
|
|
73
|
+
expect(menus.homePath).toBe('/public')
|
|
74
|
+
user.setUserInfo(userInfo({ roles: ['admin'] }))
|
|
75
|
+
expect(menus.menuList).toHaveLength(2)
|
|
76
|
+
user.setUserInfo(userInfo())
|
|
77
|
+
expect(menus.menuList).toHaveLength(1)
|
|
78
|
+
menus.setMenuList([])
|
|
79
|
+
expect(menus.homePath).toBe('/403')
|
|
80
|
+
})
|
|
81
|
+
})
|
|
82
|
+
|
|
83
|
+
describe('reactive access directives', () => {
|
|
84
|
+
it('hides before mounting and restores the same node when store permissions change', async () => {
|
|
85
|
+
const user = useUserStore()
|
|
86
|
+
const directive = createAccessDirective()
|
|
87
|
+
const clicked = vi.fn()
|
|
88
|
+
const wrapper = mount(
|
|
89
|
+
defineComponent({
|
|
90
|
+
render: () =>
|
|
91
|
+
withDirectives(h('button', { onClick: clicked }, 'Action'), [[directive, 'read']])
|
|
92
|
+
}),
|
|
93
|
+
{ attachTo: document.body }
|
|
94
|
+
)
|
|
95
|
+
wrappers.push(wrapper)
|
|
96
|
+
const button = wrapper.get('button').element as HTMLButtonElement
|
|
97
|
+
expect(button.style.display).toBe('none')
|
|
98
|
+
button.click()
|
|
99
|
+
expect(clicked).not.toHaveBeenCalled()
|
|
100
|
+
user.setUserInfo(userInfo({ permissions: ['read'] }))
|
|
101
|
+
await nextTick()
|
|
102
|
+
expect(wrapper.get('button').element).toBe(button)
|
|
103
|
+
expect(button.style.display).toBe('')
|
|
104
|
+
button.click()
|
|
105
|
+
expect(clicked).toHaveBeenCalledOnce()
|
|
106
|
+
user.setUserInfo(userInfo({ permissions: [] }))
|
|
107
|
+
await nextTick()
|
|
108
|
+
expect(button.style.display).toBe('none')
|
|
109
|
+
})
|
|
110
|
+
|
|
111
|
+
it('restores disabled state without enabling a business-disabled button', async () => {
|
|
112
|
+
const user = useUserStore()
|
|
113
|
+
const businessDisabled = ref(false)
|
|
114
|
+
const directive = createAccessDirective()
|
|
115
|
+
const wrapper = mount(
|
|
116
|
+
defineComponent({
|
|
117
|
+
render: () =>
|
|
118
|
+
withDirectives(
|
|
119
|
+
h(ElButton, { disabled: businessDisabled.value }, () => 'Action'),
|
|
120
|
+
[[directive, 'read', undefined, { disabled: true }]]
|
|
121
|
+
)
|
|
122
|
+
})
|
|
123
|
+
)
|
|
124
|
+
wrappers.push(wrapper)
|
|
125
|
+
const button = wrapper.get('button').element as HTMLButtonElement
|
|
126
|
+
expect(button.disabled).toBe(true)
|
|
127
|
+
businessDisabled.value = true
|
|
128
|
+
await nextTick()
|
|
129
|
+
user.setUserInfo(userInfo({ permissions: ['read'] }))
|
|
130
|
+
await nextTick()
|
|
131
|
+
expect(button.disabled).toBe(true)
|
|
132
|
+
businessDisabled.value = false
|
|
133
|
+
await nextTick()
|
|
134
|
+
expect(button.disabled).toBe(false)
|
|
135
|
+
user.setUserInfo(userInfo({ permissions: [] }))
|
|
136
|
+
await nextTick()
|
|
137
|
+
expect(button.disabled).toBe(true)
|
|
138
|
+
user.setUserInfo(userInfo({ permissions: ['read'] }))
|
|
139
|
+
await nextTick()
|
|
140
|
+
expect(button.disabled).toBe(false)
|
|
141
|
+
expect(button.hasAttribute('aria-disabled')).toBe(false)
|
|
142
|
+
})
|
|
143
|
+
|
|
144
|
+
it('responds to binding changes, all matching, roles and unmount cleanup', async () => {
|
|
145
|
+
const user = useUserStore()
|
|
146
|
+
user.setUserInfo(userInfo({ permissions: ['read'], roles: [] }))
|
|
147
|
+
const required = ref(['read'])
|
|
148
|
+
const permission = createAccessDirective()
|
|
149
|
+
const role = createAccessDirective(true)
|
|
150
|
+
const wrapper = mount(
|
|
151
|
+
defineComponent({
|
|
152
|
+
render: () =>
|
|
153
|
+
h('div', [
|
|
154
|
+
withDirectives(h('button', 'Permissions'), [
|
|
155
|
+
[permission, required.value, undefined, { all: true }]
|
|
156
|
+
]),
|
|
157
|
+
withDirectives(h('article', 'Admin'), [[role, 'admin']])
|
|
158
|
+
])
|
|
159
|
+
})
|
|
160
|
+
)
|
|
161
|
+
wrappers.push(wrapper)
|
|
162
|
+
required.value = ['read', 'write']
|
|
163
|
+
await nextTick()
|
|
164
|
+
expect((wrapper.get('button').element as HTMLElement).style.display).toBe('none')
|
|
165
|
+
user.setUserInfo(userInfo({ permissions: ['read', 'write'], roles: ['admin'] }))
|
|
166
|
+
await nextTick()
|
|
167
|
+
const button = wrapper.get('button').element as HTMLElement
|
|
168
|
+
expect(button.style.display).toBe('')
|
|
169
|
+
expect((wrapper.get('article').element as HTMLElement).style.display).toBe('')
|
|
170
|
+
wrapper.unmount()
|
|
171
|
+
user.setUserInfo(userInfo())
|
|
172
|
+
await nextTick()
|
|
173
|
+
expect(button.style.display).toBe('')
|
|
174
|
+
wrappers.pop()
|
|
175
|
+
})
|
|
176
|
+
})
|
|
@@ -47,6 +47,10 @@ describe('examples routes', () => {
|
|
|
47
47
|
(item) => item.name === 'PermissionPlaygroundExample'
|
|
48
48
|
)
|
|
49
49
|
|
|
50
|
-
expect(route?.meta.authList?.map((item) => item.authMark)).toEqual([
|
|
50
|
+
expect(route?.meta.authList?.map((item) => item.authMark)).toEqual([
|
|
51
|
+
'example:resource:create',
|
|
52
|
+
'example:resource:edit',
|
|
53
|
+
'example:resource:export'
|
|
54
|
+
])
|
|
51
55
|
})
|
|
52
56
|
})
|
package/template/vite.config.ts
CHANGED
|
@@ -28,7 +28,8 @@ export default ({ mode }: { mode: string }) => {
|
|
|
28
28
|
|
|
29
29
|
return defineConfig({
|
|
30
30
|
define: {
|
|
31
|
-
__APP_VERSION__: JSON.stringify(VITE_VERSION)
|
|
31
|
+
__APP_VERSION__: JSON.stringify(VITE_VERSION),
|
|
32
|
+
__BUILD_ID__: JSON.stringify(env.VITE_BUILD_ID || new Date().toISOString())
|
|
32
33
|
},
|
|
33
34
|
base: VITE_BASE_URL,
|
|
34
35
|
server: {
|
|
@@ -49,6 +50,7 @@ export default ({ mode }: { mode: string }) => {
|
|
|
49
50
|
}
|
|
50
51
|
},
|
|
51
52
|
build: {
|
|
53
|
+
sourcemap: env.VITE_BUILD_SOURCEMAP === 'true' ? 'hidden' : false,
|
|
52
54
|
target: 'es2015',
|
|
53
55
|
outDir: 'dist',
|
|
54
56
|
chunkSizeWarningLimit: 700,
|
|
@@ -108,7 +110,8 @@ export default ({ mode }: { mode: string }) => {
|
|
|
108
110
|
esbuild:
|
|
109
111
|
mode === 'production'
|
|
110
112
|
? {
|
|
111
|
-
drop: ['
|
|
113
|
+
drop: ['debugger'],
|
|
114
|
+
pure: ['console.log', 'console.debug', 'console.info']
|
|
112
115
|
}
|
|
113
116
|
: undefined,
|
|
114
117
|
css: {
|