test: refactor next usage

Author: posva

packages/router/__tests__/errors.spec.ts

@@ -86,9 +86,9 @@ describe('Errors & Navigation failures', () => {
 
   it('next("/location") triggers afterEach', async () => {
     await testNavigation(
-      ((to, from, next) => {
-        if (to.path === '/location') next()
-        else next('/location')
+      ((to, from) => {
+        if (to.path === '/location') return
+        else return '/location'
       }) as NavigationGuard,
       undefined
     )
@@ -109,10 +109,13 @@ describe('Errors & Navigation failures', () => {
   it('triggers afterEach if a new navigation happens', async () => {
     const { router } = createRouter()
     const [promise, resolve] = fakePromise()
-    router.beforeEach((to, from, next) => {
+    router.beforeEach(async (to, from) => {
       // let it hang otherwise
-      if (to.path === '/') next()
-      else promise.then(() => next())
+      if (to.path === '/') return
+      else {
+        await promise
+        return
+      }
     })
 
     let from = router.currentRoute.value
@@ -236,9 +239,9 @@ describe('Errors & Navigation failures', () => {
 
     it('next("/location") triggers afterEach with history.back', async () => {
       await testHistoryNavigation(
-        ((to, from, next) => {
-          if (to.path === '/location') next()
-          else next('/location')
+        ((to, from) => {
+          if (to.path === '/location') return
+          else return '/location'
         }) as NavigationGuard,
         undefined
       )

packages/router/__tests__/guards/beforeEach.spec.ts

@@ -87,10 +87,10 @@ describe('router.beforeEach', () => {
     const spy = vi.fn()
     const router = createRouter({ routes })
     await router.push('/foo')
-    spy.mockImplementation((to, from, next) => {
+    spy.mockImplementation((to, from) => {
       // only allow going to /other
-      if (to.fullPath !== '/other') next('/other')
-      else next()
+      if (to.fullPath !== '/other') return '/other'
+      else return
     })
     router.beforeEach(spy)
     expect(spy).not.toHaveBeenCalled()
@@ -160,11 +160,11 @@ describe('router.beforeEach', () => {
     const spy = vi.fn()
     const router = createRouter({ routes })
     await router.push('/')
-    spy.mockImplementation((to, from, next) => {
+    spy.mockImplementation((to, from) => {
       // only allow going to /other
       const i = Number(to.params.i)
-      if (i >= 3) next()
-      else next(redirectFn(String(i + 1)))
+      if (i >= 3) return
+      else return redirectFn(String(i + 1))
     })
     router.beforeEach(spy)
     expect(spy).not.toHaveBeenCalled()
@@ -210,9 +210,9 @@ describe('router.beforeEach', () => {
   it('waits before navigating', async () => {
     const [promise, resolve] = fakePromise()
     const router = createRouter({ routes })
-    router.beforeEach(async (to, from, next) => {
+    router.beforeEach(async (to, from) => {
       await promise
-      next()
+      return
     })
     const p = router.push('/foo')
     expect(router.currentRoute.value.fullPath).toBe('/')
@@ -227,17 +227,17 @@ describe('router.beforeEach', () => {
     const router = createRouter({ routes })
     const guard1 = vi.fn()
     let order = 0
-    guard1.mockImplementationOnce(async (to, from, next) => {
+    guard1.mockImplementationOnce(async (to, from) => {
       expect(order++).toBe(0)
       await p1
-      next()
+      return
     })
     router.beforeEach(guard1)
     const guard2 = vi.fn()
-    guard2.mockImplementationOnce(async (to, from, next) => {
+    guard2.mockImplementationOnce(async (to, from) => {
       expect(order++).toBe(1)
       await p2
-      next()
+      return
     })
     router.beforeEach(guard2)
     let navigation = router.push('/foo')

packages/router/__tests__/guards/beforeEnter.spec.ts

@@ -157,9 +157,9 @@ describe('beforeEnter', () => {
   it('waits before navigating', async () => {
     const [promise, resolve] = fakePromise()
     const router = createRouter({ routes })
-    beforeEnter.mockImplementationOnce(async (to, from, next) => {
+    beforeEnter.mockImplementationOnce(async (to, from) => {
       await promise
-      next()
+      return
     })
     const p = router.push('/foo')
     expect(router.currentRoute.value.fullPath).toBe('/')
@@ -172,13 +172,13 @@ describe('beforeEnter', () => {
     const [p1, r1] = fakePromise()
     const [p2, r2] = fakePromise()
     const router = createRouter({ routes })
-    beforeEnters[0].mockImplementationOnce(async (to, from, next) => {
+    beforeEnters[0].mockImplementationOnce(async (to, from) => {
       await p1
-      next()
+      return
     })
-    beforeEnters[1].mockImplementationOnce(async (to, from, next) => {
+    beforeEnters[1].mockImplementationOnce(async (to, from) => {
       await p2
-      next()
+      return
     })
     const p = router.push('/multiple')
     expect(router.currentRoute.value.fullPath).toBe('/')

packages/router/__tests__/guards/beforeRouteEnter.spec.ts

@@ -111,9 +111,9 @@ describe('beforeRouteEnter', () => {
 
   it('calls beforeRouteEnter guards on navigation', async () => {
     const router = createRouter({ routes })
-    beforeRouteEnter.mockImplementationOnce((to, from, next) => {
-      if (to.params.n !== 'valid') return next(false)
-      next()
+    beforeRouteEnter.mockImplementationOnce((to, from) => {
+      if (to.params.n !== 'valid') return false
+      return
     })
     await router.push('/guard/valid')
     expect(beforeRouteEnter).toHaveBeenCalledTimes(1)
@@ -183,8 +183,8 @@ describe('beforeRouteEnter', () => {
 
   it('aborts navigation if one of the named views aborts', async () => {
     const router = createRouter({ routes })
-    named.default.mockImplementationOnce((to, from, next) => {
-      next(false)
+    named.default.mockImplementationOnce((to, from) => {
+      return false
     })
     named.other.mockImplementationOnce(noGuard)
     await router.push('/named').catch(err => {}) // catch abort
@@ -204,9 +204,9 @@ describe('beforeRouteEnter', () => {
   it('waits before navigating', async () => {
     const [promise, resolve] = fakePromise()
     const router = createRouter({ routes })
-    beforeRouteEnter.mockImplementationOnce(async (to, from, next) => {
+    beforeRouteEnter.mockImplementationOnce(async (to, from) => {
       await promise
-      next()
+      return
     })
     const p = router.push('/foo')
     expect(router.currentRoute.value.fullPath).toBe('/')

packages/router/__tests__/guards/beforeRouteLeave.spec.ts

@@ -94,9 +94,9 @@ describe('beforeRouteLeave', () => {
 
   it('calls beforeRouteLeave guard on navigation', async () => {
     const router = createRouter({ routes })
-    beforeRouteLeave.mockImplementationOnce((to, from, next) => {
-      if (to.path === 'foo') next(false)
-      else next()
+    beforeRouteLeave.mockImplementationOnce((to, from) => {
+      if (to.path === 'foo') return false
+      else return
     })
     await router.push('/guard')
     expect(beforeRouteLeave).not.toHaveBeenCalled()
@@ -110,8 +110,8 @@ describe('beforeRouteLeave', () => {
 
   it('does not call beforeRouteLeave guard if the view is not mounted', async () => {
     const router = createRouter({ routes })
-    beforeRouteLeave.mockImplementationOnce((to, from, next) => {
-      next()
+    beforeRouteLeave.mockImplementationOnce((to, from) => {
+      return
     })
     await router.push('/guard')
     expect(beforeRouteLeave).not.toHaveBeenCalled()
@@ -158,17 +158,17 @@ describe('beforeRouteLeave', () => {
     await router.push({ name: 'nested-nested-foo' })
     resetMocks()
     let count = 0
-    nested.nestedNestedFoo.mockImplementation((to, from, next) => {
+    nested.nestedNestedFoo.mockImplementation((to, from) => {
       expect(count++).toBe(0)
-      next()
+      return
     })
-    nested.nestedNested.mockImplementation((to, from, next) => {
+    nested.nestedNested.mockImplementation((to, from) => {
       expect(count++).toBe(1)
-      next()
+      return
     })
-    nested.parent.mockImplementation((to, from, next) => {
+    nested.parent.mockImplementation((to, from) => {
       expect(count++).toBe(2)
-      next()
+      return
     })
 
     // simulate a mounted route component
@@ -184,8 +184,8 @@ describe('beforeRouteLeave', () => {
 
   it('can cancel navigation', async () => {
     const router = createRouter({ routes })
-    beforeRouteLeave.mockImplementationOnce(async (to, from, next) => {
-      next(false)
+    beforeRouteLeave.mockImplementationOnce(async (to, from) => {
+      return false
     })
     await router.push('/guard')
     const p = router.push('/')

packages/router/__tests__/guards/beforeRouteUpdate.spec.ts

@@ -68,9 +68,9 @@ describe('beforeRouteUpdate', () => {
   it('waits before navigating', async () => {
     const [promise, resolve] = fakePromise()
     const router = createRouter({ routes })
-    beforeRouteUpdate.mockImplementationOnce(async (to, from, next) => {
+    beforeRouteUpdate.mockImplementationOnce(async (to, from) => {
       await promise
-      next()
+      return
     })
     await router.push('/guard/one')
     const p = router.push('/guard/foo')

packages/router/__tests__/guards/extractComponentsGuards.spec.ts

@@ -40,8 +40,8 @@ const ErrorLazyLoad: RouteRecordRaw = {
 
 beforeEach(() => {
   beforeRouteEnter.mockReset()
-  beforeRouteEnter.mockImplementation((to, from, next) => {
-    next()
+  beforeRouteEnter.mockImplementation((to, from) => {
+    return
   })
 })
 

packages/router/__tests__/initialNavigation.spec.ts

@@ -19,8 +19,8 @@ const routes: RouteRecordRaw[] = [
   {
     path: '/home-before',
     component,
-    beforeEnter: (to, from, next) => {
-      next('/')
+    beforeEnter: (to, from) => {
+      return '/'
     },
   },
   { path: '/bar', component },

packages/router/__tests__/lazyLoading.spec.ts

@@ -159,7 +159,7 @@ describe('Lazy Loading', () => {
 
   it('avoid fetching async component if navigation is cancelled through beforeEnter', async () => {
     const { component, resolve } = createLazyComponent()
-    const spy = vi.fn((to, from, next) => next(false))
+    const spy = vi.fn((to, from) => false)
     const { router } = newRouter({
       routes: [
         {
@@ -187,7 +187,7 @@ describe('Lazy Loading', () => {
       ],
     })
 
-    const spy = vi.fn((to, from, next) => next(false))
+    const spy = vi.fn((to, from) => false)
 
     router.beforeEach(spy)
 
@@ -199,7 +199,7 @@ describe('Lazy Loading', () => {
 
   it('invokes beforeRouteEnter after lazy loading the component', async () => {
     const { promise, resolve } = createLazyComponent()
-    const spy = vi.fn((to, from, next) => next())
+    const spy = vi.fn((to, from) => {})
     const component = vi.fn(() =>
       promise.then(() => ({ beforeRouteEnter: spy }))
     )
@@ -215,7 +215,7 @@ describe('Lazy Loading', () => {
 
   it('beforeRouteLeave works on a lazy loaded component', async () => {
     const { promise, resolve } = createLazyComponent()
-    const spy = vi.fn((to, from, next) => next())
+    const spy = vi.fn((to, from) => {})
     const component = vi.fn(() =>
       promise.then(() => ({ beforeRouteLeave: spy }))
     )
@@ -240,7 +240,7 @@ describe('Lazy Loading', () => {
 
   it('beforeRouteUpdate works on a lazy loaded component', async () => {
     const { promise, resolve } = createLazyComponent()
-    const spy = vi.fn((to, from, next) => next())
+    const spy = vi.fn((to, from) => {})
     const component = vi.fn(() =>
       promise.then(() => ({ beforeRouteUpdate: spy }))
     )

packages/router/__tests__/multipleApps.spec.ts

@@ -34,8 +34,8 @@ describe('Multiple apps', () => {
   it('does not listen to url changes before being ready', async () => {
     const { router, history } = newRouter()
 
-    const spy = vi.fn((to, from, next) => {
-      next()
+    const spy = vi.fn((to, from) => {
+      return
     })
     router.beforeEach(spy)