expeditaea 1.0.0

package/packages/utils/test/resolve.posix.test.js

@@ -0,0 +1,85 @@
+import consola from 'consola'
+
+import {
+  startsWithAlias, startsWithSrcAlias, wp, wChunk,
+  relativeTo, defineAlias, isIndexFileAndFolder, getMainModule
+} from '../src/resolve'
+
+describe.posix('util: resolve', () => {
+  test('should check if path starts with alias', () => {
+    expect(startsWithAlias(['/var'])('/var/nuxt/src')).toEqual(true)
+  })
+
+  test('should check if path starts with root alias', () => {
+    expect(startsWithSrcAlias('@/assets')).toEqual(true)
+    expect(startsWithSrcAlias('~/pages')).toEqual(true)
+  })
+
+  test('should check if path starts with src alias', () => {
+    expect(startsWithSrcAlias('@@/src/assets')).toEqual(true)
+    expect(startsWithSrcAlias('~~/src/pages')).toEqual(true)
+  })
+
+  test('should return same path in linux', () => {
+    expect(wp('/var/nuxt\\ src/')).toEqual('/var/nuxt\\ src/')
+  })
+
+  test('should return same path in linux', () => {
+    expect(wChunk('nuxt/layout/test')).toEqual('nuxt/layout/test')
+  })
+
+  test('should define alias', () => {
+    const nuxt = {}
+    const server = {
+      name: 'nuxt',
+      bound: () => 'bound fn',
+      test: () => 'test defineAlias'
+    }
+
+    defineAlias(nuxt, server, ['name', 'bound'])
+    defineAlias(nuxt, server, ['test'], { bind: false, warn: true })
+
+    expect(nuxt.name).toEqual(server.name)
+    expect(nuxt.bound).not.toBe(server.bound)
+    expect(nuxt.bound()).toEqual('bound fn')
+    expect(nuxt.test).toBe(server.test)
+    expect(nuxt.test()).toEqual('test defineAlias')
+    expect(consola.warn).toBeCalledTimes(1)
+    expect(consola.warn).toBeCalledWith({
+      message: '\'test\' is deprecated\'',
+      additional: expect.any(String)
+    })
+  })
+
+  test('should check if given argument is index file or folder', () => {
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test'])).toEqual(false)
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test/index.js'])).toEqual(false)
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test', '/var/nuxt/plugins/test/index.js'])).toEqual(true)
+  })
+
+  test('should return main module', () => {
+    expect(getMainModule()).toHaveProperty('children', 'exports', 'filename', 'path')
+  })
+
+  describe('relativeTo', () => {
+    const path1 = '@/foo'
+    const path2 = '@/bar'
+
+    test('should resolve alias path', () => {
+      expect(relativeTo(path1, path2)).toBe('@/bar')
+    })
+
+    test('should keep webpack inline loaders prepended', () => {
+      expect(relativeTo(path1, `loader1!loader2!${path2}`))
+        .toEqual('loader1!loader2!@/bar')
+    })
+
+    test('should check path which is not started with alias', () => {
+      expect(relativeTo('/var/nuxt/foo/bar', '/var/nuxt/foo/baz')).toBe('../baz')
+    })
+
+    test('should check path which is not started with alias ', () => {
+      expect(relativeTo('/var/nuxt/foo', '/var/nuxt/foo/bar')).toBe('./bar')
+    })
+  })
+})

package/packages/utils/test/resolve.win.test.js

@@ -0,0 +1,90 @@
+import consola from 'consola'
+
+import {
+  wp, wChunk, r, relativeTo,
+  startsWithAlias, startsWithSrcAlias,
+  defineAlias, isIndexFileAndFolder, getMainModule
+} from '../src/resolve'
+
+describe.win('util: resolve windows', () => {
+  test('should format windows separator', () => {
+    expect(wp('c:\\nuxt\\src')).toEqual('c:\\\\nuxt\\\\src')
+  })
+
+  test('should format windows path', () => {
+    expect(wChunk('nuxt/layout/test')).toEqual('nuxt/layout/test')
+  })
+
+  test('should resolve alias path', () => {
+    expect(r('@\\layout\\test')).toEqual('@\\\\layout\\\\test')
+  })
+
+  test('should check if path starts with alias', () => {
+    expect(startsWithAlias(['#'])('#layout/test')).toEqual(true)
+  })
+
+  test('should check if path starts with root alias', () => {
+    expect(startsWithSrcAlias('@/assets')).toEqual(true)
+    expect(startsWithSrcAlias('~/pages')).toEqual(true)
+  })
+
+  test('should check if path starts with src alias', () => {
+    expect(startsWithSrcAlias('@@/src/assets')).toEqual(true)
+    expect(startsWithSrcAlias('~~/src/pages')).toEqual(true)
+  })
+
+  test('should define alias', () => {
+    const nuxt = {}
+    const server = {
+      name: 'nuxt',
+      bound: () => 'bound fn',
+      test: () => 'test defineAlias'
+    }
+
+    defineAlias(nuxt, server, ['name', 'bound'])
+    defineAlias(nuxt, server, ['test'], { bind: false, warn: true })
+
+    expect(nuxt.name).toEqual(server.name)
+    expect(nuxt.bound).not.toBe(server.bound)
+    expect(nuxt.bound()).toEqual('bound fn')
+    expect(nuxt.test).toBe(server.test)
+    expect(nuxt.test()).toEqual('test defineAlias')
+    expect(consola.warn).toBeCalledTimes(1)
+    expect(consola.warn).toBeCalledWith({
+      message: '\'test\' is deprecated\'',
+      additional: expect.any(String)
+    })
+  })
+
+  test('should check if given argument is index file or folder', () => {
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test'])).toEqual(false)
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test/index.js'])).toEqual(false)
+    expect(isIndexFileAndFolder(['/var/nuxt/plugins/test', '/var/nuxt/plugins/test/index.js'])).toEqual(true)
+  })
+
+  test('should return main module', () => {
+    expect(getMainModule()).toHaveProperty('children', 'exports', 'filename', 'path')
+  })
+
+  describe('relativeTo', () => {
+    const path1 = '@\\foo'
+    const path2 = '@\\bar'
+
+    test('should resolve alias path', () => {
+      expect(relativeTo(path1, path2)).toBe('@\\\\bar')
+    })
+
+    test('should keep webpack inline loaders prepended', () => {
+      expect(relativeTo(path1, `loader1!loader2!${path2}`))
+        .toBe('loader1!loader2!@\\\\bar')
+    })
+
+    test('should check path which is not started with alias', () => {
+      expect(relativeTo('c:\\foo\\bar', 'c:\\foo\\baz')).toBe('..\\\\baz')
+    })
+
+    test('should check path which is not started with alias ', () => {
+      expect(relativeTo('c:\\foo', 'c:\\foo\\baz')).toBe('.\\\\baz')
+    })
+  })
+})

package/packages/utils/test/route.test.js

@@ -0,0 +1,240 @@
+import { flatRoutes, createRoutes, guardDir, promisifyRoute } from '../src/route'
+
+describe('util: route', () => {
+  test('should flat route with path', () => {
+    const routes = flatRoutes([
+      { name: 'login', path: '/login' },
+      { name: 'about', path: '/about' },
+      {
+        name: 'posts',
+        path: '',
+        children: [
+          { name: 'posts-list', path: '' },
+          { name: 'posts-create', path: 'post' }
+        ]
+      }
+    ])
+    expect(routes).toEqual(['/login', '/about', '/', '/post'])
+  })
+
+  test('should ignore route with * and :', () => {
+    const routes = flatRoutes([
+      { name: 'login', path: '/login' },
+      { name: 'foo', path: '/foo/:id' },
+      { name: 'bar', path: '/bar/*' }
+    ])
+    expect(routes).toEqual(['/login'])
+  })
+
+  test('should resolve route with /', () => {
+    const routes = flatRoutes([
+      {
+        name: 'foo',
+        path: '/',
+        children: [
+          { name: 'foo-bar', path: 'foo/bar' },
+          { name: 'foo-baz', path: 'foo/baz' }
+        ]
+      }
+    ])
+    expect(routes).toEqual(['/', '/foo/bar', '/foo/baz'])
+  })
+
+  test('should flat absolute routes', () => {
+    const routes = flatRoutes([
+      {
+        name: 'foo',
+        path: '/foo',
+        children: [
+          { name: 'foo-bar', path: '/foo/bar' },
+          { name: 'foo-baz', path: '/foo/baz' }
+        ]
+      }
+    ])
+
+    expect(routes).toEqual(['/foo', '/foo/bar', '/foo/baz'])
+  })
+
+  test('should flat absolute routes with empty path', () => {
+    const routes = flatRoutes([
+      {
+        name: 'foo',
+        path: '/foo',
+        children: [
+          { name: 'foo-root', path: '' },
+          { name: 'foo-bar', path: '/foo/bar' },
+          { name: 'foo-baz', path: '/foo/baz' }
+        ]
+      }
+    ])
+
+    expect(routes).toEqual(['/foo', '/foo/bar', '/foo/baz'])
+  })
+
+  describe('util: route guard', () => {
+    test('should guard parent dir', () => {
+      expect(() => {
+        guardDir({ dir1: '/root/parent', dir2: '/root' }, 'dir1', 'dir2')
+      }).toThrow()
+    })
+
+    test('should guard same dir', () => {
+      expect(() => {
+        guardDir({ dir1: '/root/parent', dir2: '/root/parent' }, 'dir1', 'dir2')
+      }).toThrow()
+    })
+
+    test('should not guard same level dir', () => {
+      expect(() => {
+        guardDir({ dir1: '/root/parent-next', dir2: '/root/parent' }, 'dir1', 'dir2')
+      }).not.toThrow()
+    })
+
+    test('should not guard same level dir - 2', () => {
+      expect(() => {
+        guardDir({ dir1: '/root/parent', dir2: '/root/parent-next' }, 'dir1', 'dir2')
+      }).not.toThrow()
+    })
+
+    test('should not guard child dir', () => {
+      expect(() => {
+        guardDir({ dir1: '/root/parent', dir2: '/root/parent/child' }, 'dir1', 'dir2')
+      }).not.toThrow()
+    })
+  })
+
+  describe('util: route promisifyRoute', () => {
+    test('should promisify array routes', () => {
+      const array = [1]
+      const promise = promisifyRoute(array)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res).toBe(array)
+      })
+    })
+
+    test('should promisify functional routes', () => {
+      const array = [1, 2]
+      const fn = function () {
+        return array
+      }
+      const promise = promisifyRoute(fn)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res).toBe(array)
+      })
+    })
+
+    test('should promisify promisable functional routes', () => {
+      const array = [1, 2, 3]
+      const fn = function () {
+        return new Promise((resolve) => {
+          resolve(array)
+        })
+      }
+      const promise = promisifyRoute(fn)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res).toBe(array)
+      })
+    })
+
+    test('should promisify promisable functional routes with arguments', () => {
+      const fn = function (array) {
+        return new Promise((resolve) => {
+          resolve(array)
+        })
+      }
+      const array = [1, 2, 3]
+      const promise = promisifyRoute(fn, array)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res).toBe(array)
+      })
+    })
+
+    test('should promisify functional routes with error', () => {
+      const fn = function (cb) {
+        cb(new Error('Error here'))
+      }
+      const promise = promisifyRoute(fn)
+      expect(typeof promise).toBe('object')
+      return promise.catch((e) => {
+        expect(e.message).toBe('Error here')
+      })
+    })
+
+    test('should promisify functional routes with arguments and error', () => {
+      const fn = function (cb, array) {
+        cb(new Error('Error here: ' + array.join()))
+      }
+      const array = [1, 2, 3, 4]
+      const promise = promisifyRoute(fn, array)
+      expect(typeof promise).toBe('object')
+      return promise.catch((e) => {
+        expect(e.message).toBe('Error here: ' + array.join())
+      })
+    })
+
+    test('should promisify functional routes with result', () => {
+      const array = [1, 2, 3, 4]
+      const fn = function (cb) {
+        cb(null, array)
+      }
+      const promise = promisifyRoute(fn)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res).toBe(array)
+      })
+    })
+
+    test('should promisify functional routes with arguments and result', () => {
+      const fn = function (cb, array, object) {
+        cb(null, { array, object })
+      }
+      const array = [1, 2, 3, 4]
+      const object = { a: 1 }
+      const promise = promisifyRoute(fn, array, object)
+      expect(typeof promise).toBe('object')
+      return promise.then((res) => {
+        expect(res.array).toBe(array)
+        expect(res.object).toBe(object)
+      })
+    })
+  })
+
+  describe('util: route create', () => {
+    const files = [
+      'pages/index.vue',
+      'pages/_param.vue',
+      'pages/subpage/_param.vue',
+      'pages/snake_case_route.vue',
+      'pages/another_route/_id.vue',
+      'pages/parent/index.vue',
+      'pages/parent/child/index.vue',
+      'pages/parent/child/test.vue'
+    ]
+    const srcDir = '/some/nuxt/app'
+    const pagesDir = 'pages'
+
+    test.posix('createRoutes should allow snake case routes in posix system', () => {
+      const routesResult = createRoutes({ files, srcDir, pagesDir })
+      expect(routesResult).toMatchSnapshot()
+    })
+
+    test.win('createRoutes should allow snake case routes in windows system', () => {
+      const routesResult = createRoutes({ files, srcDir, pagesDir })
+      expect(routesResult).toMatchSnapshot()
+    })
+
+    test.posix('createRoutes should enforce trailing slashes when configured to', () => {
+      const routesResult = createRoutes({ files, srcDir, pagesDir, trailingSlash: true })
+      expect(routesResult).toMatchSnapshot()
+    })
+
+    test.posix('createRoutes should remove trailing slashes when configured to', () => {
+      const routesResult = createRoutes({ files, srcDir, pagesDir, trailingSlash: false })
+      expect(routesResult).toMatchSnapshot()
+    })
+  })
+})

package/packages/utils/test/serialize.test.input.js

@@ -0,0 +1,41 @@
+// NOTE: This file is excluded from being transformed by babel-jest and needs to use the CommonJS syntax.
+
+module.exports = {
+  arrow: {
+  // eslint-disable-next-line arrow-parens
+    fn1: foobar => {},
+    fn2: foobar => 1,
+    // eslint-disable-next-line arrow-parens
+    fn3: foobar => {
+      return 3
+    },
+    // eslint-disable-next-line arrow-parens
+    fn4: arg1 =>
+      2 * arg1,
+    fn5: () => {},
+    // eslint-disable-next-line arrow-parens
+    fn6: foobar => (foobar ? 1 : 0)
+  },
+  normal: {
+    fn: function () {} // eslint-disable-line object-shorthand
+  },
+  shorthand: {
+    fn () {},
+    // eslint-disable-next-line space-before-function-paren
+    $fn() {},
+    // eslint-disable-next-line no-unused-vars
+    fn_arrow () { const _ = rule => rule },
+    fn_script () {
+      return 'function xyz(){};a=false?true:xyz();'
+    },
+    fn_internal (arg) {
+      if (arg) {
+        return {
+          title () {
+            return 'test'
+          }
+        }
+      }
+    }
+  }
+}

package/packages/utils/test/serialize.test.js

@@ -0,0 +1,69 @@
+import { serializeFunction, normalizeFunctions } from '../src/serialize'
+import data from './serialize.test.input'
+
+const RE_LINE_BREAKS = /[\r\n]+/g
+
+describe('util: serialize', () => {
+  test('should normalize arrow functions', () => {
+    const normalized = normalizeFunctions(Object.assign({}, data.arrow))
+    expect(normalized.fn1.toString()).toEqual('function anonymous(foobar\n) {\n\n}')
+    expect(normalized.fn2.toString()).toEqual('function anonymous(foobar\n) {\nreturn 1\n}')
+    expect(normalized.fn3.toString()).toEqual('function anonymous(foobar\n) {\nreturn 3\n}')
+    expect(normalized.fn4.toString()).toEqual('function anonymous(arg1\n) {\nreturn 2 * arg1\n}')
+  })
+
+  test('should serialize normal function', () => {
+    const obj = Object.assign({}, data.normal)
+    expect(serializeFunction(obj.fn)).toEqual('function () {}')
+  })
+
+  test('should serialize shorthand function', () => {
+    const obj = Object.assign({}, data.shorthand)
+    expect(serializeFunction(obj.fn)).toEqual('function() {}')
+    expect(serializeFunction(obj.$fn)).toEqual('function() {}')
+    expect(serializeFunction(obj.fn_arrow)).toEqual('function() { const _ = rule => rule }')
+  })
+
+  test('should serialize arrow function', () => {
+    const obj = Object.assign({}, data.arrow)
+    expect(serializeFunction(obj.fn5)).toEqual('() => {}')
+  })
+
+  test('should serialize arrow function with ternary in parens', () => {
+    const obj = Object.assign({}, data.arrow)
+    expect(serializeFunction(obj.fn6)).toEqual('foobar => (foobar ? 1 : 0)')
+  })
+
+  test('should serialize arrow function with single parameter', () => {
+    const obj = Object.assign({}, data.arrow)
+    expect(serializeFunction(obj.fn1)).toEqual('foobar => {}')
+    expect(serializeFunction(obj.fn2)).toEqual('foobar => 1')
+    expect(serializeFunction(obj.fn3).replace(RE_LINE_BREAKS, '\n')).toEqual(`foobar => {
+      return 3
+    }`)
+    expect(serializeFunction(obj.fn4).replace(RE_LINE_BREAKS, '\n')).toEqual(`arg1 =>
+      2 * arg1`)
+  })
+
+  test('should not replace custom scripts', () => {
+    const obj = Object.assign({}, data.shorthand)
+
+    expect(serializeFunction(obj.fn_script).replace(RE_LINE_BREAKS, '\n')).toEqual(`function() {
+      return 'function xyz(){};a=false?true:xyz();'
+    }`)
+  })
+
+  test('should serialize internal function', () => {
+    const obj = Object.assign({}, data.shorthand)
+
+    expect(serializeFunction(obj.fn_internal).replace(RE_LINE_BREAKS, '\n')).toEqual(`function(arg) {
+      if (arg) {
+        return {
+          title: function () {
+            return 'test'
+          }
+        }
+      }
+    }`)
+  })
+})

package/packages/utils/test/task.test.js

@@ -0,0 +1,117 @@
+import consola from 'consola'
+import { sequence, parallel, chainFn } from '../src/task'
+
+describe('util: task', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should call fn in sequence', async () => {
+    const fn = jest.fn(consola.log)
+    await sequence([1, 2, 3, 4], fn)
+
+    expect(fn).toBeCalledTimes(4)
+    expect(consola.log).toBeCalledTimes(4)
+    expect(consola.log).nthCalledWith(1, 1)
+    expect(consola.log).nthCalledWith(2, 2)
+    expect(consola.log).nthCalledWith(3, 3)
+    expect(consola.log).nthCalledWith(4, 4)
+  })
+
+  test('should call fn in parallel', async () => {
+    jest.spyOn(Promise, 'all')
+    jest.spyOn(Promise, 'resolve')
+
+    await parallel([1, 2, 3, 4], (num, index) => [num, index])
+
+    expect(Promise.all).toBeCalledTimes(1)
+    expect(Promise.resolve).toBeCalledTimes(4)
+    expect(Promise.resolve).nthCalledWith(1, [1, 0])
+    expect(Promise.resolve).nthCalledWith(2, [2, 1])
+    expect(Promise.resolve).nthCalledWith(3, [3, 2])
+    expect(Promise.resolve).nthCalledWith(4, [4, 3])
+
+    Promise.all.mockRestore()
+    Promise.resolve.mockRestore()
+  })
+
+  test('chainFn (mutate, mutate)', () => {
+    // Pass more than one argument to test that they're actually taken into account
+    const firstFn = function (obj, count) {
+      obj.foo = count + 1
+    }
+    const secondFn = function (obj, count) {
+      obj.bar = count + 2
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn({}, 10)).toEqual({ foo: 11, bar: 12 })
+  })
+
+  test('chainFn (mutate, return)', () => {
+    const firstFn = function (obj, count) {
+      obj.foo = count + 1
+    }
+    const secondFn = function (obj, count) {
+      return Object.assign({}, obj, { bar: count + 2 })
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn({}, 10)).toEqual({ foo: 11, bar: 12 })
+  })
+
+  test('chainFn (return, mutate)', () => {
+    const firstFn = function (obj, count) {
+      return Object.assign({}, obj, { foo: count + 1 })
+    }
+    const secondFn = function (obj, count) {
+      obj.bar = count + 2
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn({}, 10)).toEqual({ foo: 11, bar: 12 })
+  })
+
+  test('chainFn (return, return)', () => {
+    const firstFn = function (obj, count) {
+      return Object.assign({}, obj, { foo: count + 1 })
+    }
+    const secondFn = function (obj, count) {
+      return Object.assign({}, obj, { bar: count + 2 })
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn({}, 10)).toEqual({ foo: 11, bar: 12 })
+  })
+
+  test('chainFn (return, non-function)', () => {
+    const firstFn = function (obj, count) {
+      return Object.assign({}, obj, { foo: count + 1 })
+    }
+    const secondFn = ''
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn).toBe(firstFn)
+  })
+
+  test('chainFn (non-function, return)', () => {
+    const firstFn = ''
+    const secondFn = function (obj, count) {
+      return Object.assign({}, obj, { bar: count + 2 })
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(chainedFn({}, 10)).toEqual({ bar: 12 })
+  })
+
+  test('chainFn (promise)', async () => {
+    const firstFn = () => Promise.resolve({ foo: 1 })
+    const secondFn = function (obj) {
+      obj.foo++
+      return Promise.resolve()
+    }
+
+    const chainedFn = chainFn(firstFn, secondFn)
+    expect(await chainedFn()).toEqual({ foo: 2 })
+  })
+})