unit tests

Author: yyx990803

package.json

@@ -21,6 +21,7 @@
     "build": "rollup -c && uglifyjs dist/vue-router.js -c -m -o dist/vue-router.min.js",
     "lint": "eslint src examples",
     "test": "npm run lint && flow check && npm run test:e2e",
+    "test:unit": "jasmine JASMINE_CONFIG_PATH=test/unit/jasmine.json",
     "test:e2e": "node test/e2e/runner.js"
   },
   "devDependencies": {
@@ -40,6 +41,7 @@
     "express": "^4.14.0",
     "express-urlrewrite": "^1.2.0",
     "flow-bin": "^0.29.0",
+    "jasmine": "^2.4.1",
     "nightwatch": "^0.9.5",
     "nightwatch-helpers": "^1.0.0",
     "path-to-regexp": "^1.5.3",

src/util/location.js

@@ -14,9 +14,14 @@ export function normalizeLocation (
   }
 
   const parsedPath = parsePath(next.path || '')
-  const path = resolvePath(parsedPath.path, current && current.path, append)
+  const path = parsedPath.path
+    ? resolvePath(parsedPath.path, current && current.path, append)
+    : (current && current.path) || '/'
   const query = resolveQuery(parsedPath.query, next.query)
-  const hash = parsedPath.hash
+  let hash = next.hash || parsedPath.hash
+  if (hash && hash.charAt(0) !== '#') {
+    hash = `#${hash}`
+  }
 
   return {
     _normalized: true,

src/util/path.js

@@ -9,7 +9,7 @@ export function resolvePath (
     return relative
   }
 
-  if (relative.charAt(0) === '?') {
+  if (relative.charAt(0) === '?' || relative.charAt(0) === '#') {
     return base + relative
   }
 
@@ -44,9 +44,9 @@ export function resolvePath (
 }
 
 export function parsePath (path: string): {
-  path: string,
-  query: string,
-  hash: string
+  path: string;
+  query: string;
+  hash: string;
 } {
   let hash = ''
   let query = ''

src/util/query.js

@@ -1,5 +1,7 @@
 /* @flow */
 
+import { warn } from './warn'
+
 const encode = encodeURIComponent
 const decode = decodeURIComponent
 
@@ -12,7 +14,7 @@ export function resolveQuery (
     try {
       parsedQuery = parseQuery(query)
     } catch (e) {
-      console.error(e)
+      warn(false, e.message)
       parsedQuery = {}
     }
     for (const key in extraQuery) {

test/unit/jasmine.json

@@ -0,0 +1,9 @@
+{
+  "spec_dir": "test/unit/specs",
+  "spec_files": [
+    "*.spec.js"
+  ],
+  "helpers": [
+    "../../../node_modules/babel-register/lib/node.js"
+  ]
+}

test/unit/specs/async.spec.js

@@ -0,0 +1,17 @@
+import { runQueue } from '../../../src/util/async'
+
+describe('Async utils', () => {
+  describe('runQueue', () => {
+    it('should work', done => {
+      const calls = []
+      const queue = [1, 2, 3, 4, 5].map(i => next => {
+        calls.push(i)
+        setTimeout(done, 0)
+      })
+      runQueue(queue, (fn, next) => fn(next), () => {
+        expect(calls).toEqual([1, 2, 3, 4, 5])
+        done()
+      })
+    })
+  })
+})

test/unit/specs/location.spec.js

@@ -0,0 +1,81 @@
+import { normalizeLocation } from '../../../src/util/location'
+
+describe('Location utils', () => {
+  describe('normalizeLocation', () => {
+    it('string', () => {
+      const loc = normalizeLocation('/abc?foo=bar&baz=qux#hello')
+      expect(loc._normalized).toBe(true)
+      expect(loc.path).toBe('/abc')
+      expect(loc.hash).toBe('#hello')
+      expect(JSON.stringify(loc.query)).toBe(JSON.stringify({
+        foo: 'bar',
+        baz: 'qux'
+      }))
+    })
+
+    it('relative', () => {
+      const loc = normalizeLocation('abc?foo=bar&baz=qux#hello', {
+        path: '/root/next'
+      })
+      expect(loc._normalized).toBe(true)
+      expect(loc.path).toBe('/root/abc')
+      expect(loc.hash).toBe('#hello')
+      expect(JSON.stringify(loc.query)).toBe(JSON.stringify({
+        foo: 'bar',
+        baz: 'qux'
+      }))
+    })
+
+    it('relative append', () => {
+      const loc = normalizeLocation('abc?foo=bar&baz=qux#hello', {
+        path: '/root/next'
+      }, true)
+      expect(loc._normalized).toBe(true)
+      expect(loc.path).toBe('/root/next/abc')
+      expect(loc.hash).toBe('#hello')
+      expect(JSON.stringify(loc.query)).toBe(JSON.stringify({
+        foo: 'bar',
+        baz: 'qux'
+      }))
+    })
+
+    it('relative query & hash', () => {
+      const loc = normalizeLocation('?foo=bar&baz=qux#hello', {
+        path: '/root/next'
+      })
+      expect(loc._normalized).toBe(true)
+      expect(loc.path).toBe('/root/next')
+      expect(loc.hash).toBe('#hello')
+      expect(JSON.stringify(loc.query)).toBe(JSON.stringify({
+        foo: 'bar',
+        baz: 'qux'
+      }))
+    })
+
+    it('object', () => {
+      const loc = normalizeLocation({
+        path: '/abc?foo=bar#hello',
+        query: { baz: 'qux' },
+        hash: 'lol'
+      })
+      expect(loc._normalized).toBe(true)
+      expect(loc.path).toBe('/abc')
+      expect(loc.hash).toBe('#lol')
+      expect(JSON.stringify(loc.query)).toBe(JSON.stringify({
+        foo: 'bar',
+        baz: 'qux'
+      }))
+    })
+
+    it('skip normalized', () => {
+      const loc1 = {
+        _normalized: true,
+        path: '/abc?foo=bar#hello',
+        query: { baz: 'qux' },
+        hash: 'lol'
+      }
+      const loc2 = normalizeLocation(loc1)
+      expect(loc1).toBe(loc2)
+    })
+  })
+})

test/unit/specs/path.spec.js

@@ -0,0 +1,77 @@
+import { resolvePath, parsePath, cleanPath } from '../../../src/util/path'
+
+describe('Path utils', () => {
+  describe('resolvePath', () => {
+    it('absolute', () => {
+      const path = resolvePath('/a', '/b')
+      expect(path).toBe('/a')
+    })
+
+    it('relative', () => {
+      const path = resolvePath('c/d', '/b')
+      expect(path).toBe('/c/d')
+    })
+
+    it('relative with append', () => {
+      const path = resolvePath('c/d', '/b', true)
+      expect(path).toBe('/b/c/d')
+    })
+
+    it('relative parent', () => {
+      const path = resolvePath('../d', '/a/b/c')
+      expect(path).toBe('/a/d')
+    })
+
+    it('relative parent with append', () => {
+      const path = resolvePath('../d', '/a/b/c', true)
+      expect(path).toBe('/a/b/d')
+    })
+
+    it('relative query', () => {
+      const path = resolvePath('?foo=bar', '/a/b')
+      expect(path).toBe('/a/b?foo=bar')
+    })
+
+    it('relative hash', () => {
+      const path = resolvePath('#hi', '/a/b')
+      expect(path).toBe('/a/b#hi')
+    })
+  })
+
+  describe('parsePath', () => {
+    it('plain', () => {
+      const res = parsePath('/a')
+      expect(res.path).toBe('/a')
+      expect(res.hash).toBe('')
+      expect(res.query).toBe('')
+    })
+
+    it('query', () => {
+      const res = parsePath('/a?foo=bar???')
+      expect(res.path).toBe('/a')
+      expect(res.hash).toBe('')
+      expect(res.query).toBe('foo=bar???')
+    })
+
+    it('hash', () => {
+      const res = parsePath('/a#haha#hoho')
+      expect(res.path).toBe('/a')
+      expect(res.hash).toBe('#haha#hoho')
+      expect(res.query).toBe('')
+    })
+
+    it('both', () => {
+      const res = parsePath('/a?foo=bar#ok?baz=qux')
+      expect(res.path).toBe('/a')
+      expect(res.hash).toBe('#ok?baz=qux')
+      expect(res.query).toBe('foo=bar')
+    })
+  })
+
+  describe('cleanPath', () => {
+    it('should work', () => {
+      const path = cleanPath('//a//b//d/')
+      expect(path).toBe('/a/b/d/')
+    })
+  })
+})

test/unit/specs/query.spec.js

@@ -0,0 +1,23 @@
+import { resolveQuery, stringifyQuery } from '../../../src/util/query'
+
+describe('Query utils', () => {
+  describe('resolveQuery', () => {
+    it('should work', () => {
+      const query = resolveQuery('foo=bar&foo=k', { baz: 'qux' })
+      expect(JSON.stringify(query)).toBe(JSON.stringify({
+        foo: ['bar', 'k'],
+        baz: 'qux'
+      }))
+    })
+  })
+
+  describe('stringifyQuery', () => {
+    it('should work', () => {
+      expect(stringifyQuery({
+        foo: 'bar',
+        baz: 'qux',
+        arr: [1, 2]
+      })).toBe('?arr=1&arr=2&baz=qux&foo=bar') // sorted alphabetically
+    })
+  })
+})

test/unit/specs/route.spec.js

@@ -0,0 +1,76 @@
+import { isSameRoute, isIncludedRoute } from '../../../src/util/route'
+
+describe('Route utils', () => {
+  describe('isSameRoute', () => {
+    it('path', () => {
+      const a = {
+        path: '/a',
+        hash: '#hi',
+        query: { foo: 'bar', arr: [1, 2] }
+      }
+      const b = {
+        path: '/a',
+        hash: '#hi',
+        query: { arr: ['1', '2'], foo: 'bar' }
+      }
+      expect(isSameRoute(a, b)).toBe(true)
+    })
+
+    it('name', () => {
+      const a = {
+        path: '/abc',
+        name: 'a',
+        hash: '#hi',
+        query: { foo: 'bar', arr: [1, 2] }
+      }
+      const b = {
+        name: 'a',
+        hash: '#hi',
+        query: { arr: ['1', '2'], foo: 'bar' }
+      }
+      expect(isSameRoute(a, b)).toBe(true)
+    })
+  })
+
+  describe('isIncludedRoute', () => {
+    it('path', () => {
+      const a = { path: '/a/b' }
+      const b = { path: '/a' }
+      const c = { path: '/a/b/c' }
+      expect(isIncludedRoute(a, b)).toBe(true)
+      expect(isIncludedRoute(a, c)).toBe(false)
+    })
+
+    it('with hash', () => {
+      const a = { path: '/a/b', hash: '#a' }
+      const b = { path: '/a' }
+      const c = { path: '/a', hash: '#a' }
+      const d = { path: '/a', hash: '#b' }
+      expect(isIncludedRoute(a, b)).toBe(true)
+      expect(isIncludedRoute(a, c)).toBe(true)
+      expect(isIncludedRoute(a, d)).toBe(false)
+    })
+
+    it('with query', () => {
+      const a = { path: '/a/b', query: { foo: 'bar', baz: 'qux' }}
+      const b = { path: '/a', query: {}}
+      const c = { path: '/a', query: { foo: 'bar' }}
+      const d = { path: '/a', query: { foo: 'bar', a: 'b' }}
+      expect(isIncludedRoute(a, b)).toBe(true)
+      expect(isIncludedRoute(a, c)).toBe(true)
+      expect(isIncludedRoute(a, d)).toBe(false)
+    })
+
+    it('with both', () => {
+      const a = { path: '/a/b', query: { foo: 'bar', baz: 'qux' }, hash: '#a' }
+      const b = { path: '/a', query: {}}
+      const c = { path: '/a', query: { foo: 'bar' }}
+      const d = { path: '/a', query: { foo: 'bar' }, hash: '#b' }
+      const e = { path: '/a', query: { a: 'b' }, hash: '#a' }
+      expect(isIncludedRoute(a, b)).toBe(true)
+      expect(isIncludedRoute(a, c)).toBe(true)
+      expect(isIncludedRoute(a, d)).toBe(false)
+      expect(isIncludedRoute(a, e)).toBe(false)
+    })
+  })
+})