👕 refactor(test): switch to jest

Author: kazupon

test/directive.test.js

@@ -1,8 +1,9 @@
-const Vue = require('vue')
 const VueI18n = require('vue-i18n')
+const { createLocalVue } = require('@vue/test-utils')
 const { createRenderer } = require('vue-server-renderer')
 const { directive } = require('../src/index')
 
+const Vue = createLocalVue()
 Vue.use(VueI18n)
 
 const options = {

test/module.test.js

@@ -1,11 +1,9 @@
-/*
-import test from 'ava'
-import sinon from 'sinon'
-import Vue from 'vue'
-import VueI18n from 'vue-i18n'
-import { compile } from 'vue-template-compiler'
-import { module } from '../src/index'
+const VueI18n = require('vue-i18n')
+const { createLocalVue } = require('@vue/test-utils')
+const { compile } = require('vue-template-compiler')
+const I18nModule = require('../src/index').module
 
+const Vue = createLocalVue()
 Vue.use(VueI18n)
 
 const options = {
@@ -23,58 +21,62 @@ const options = {
 }
 
 const i18n = new VueI18n(options)
-const i18nModule = module(i18n)
+const i18nModule = I18nModule(i18n)
 
-test('transform with static string literal', t => {
+it('transform with static string literal', () => {
   const { ast, render, errors } = compile(`<p v-t="'hello'"></p>`, { modules: [i18nModule] })
-  t.is(ast.i18n, 'hello')
-  t.is(render, `with(this){return _c('p',{domProps:{"textContent":_s("hello")}})}`)
-  t.deepEqual(errors, [])
+  expect(ast.i18n).toEqual('hello')
+  expect(render).toEqual(`with(this){return _c('p',{domProps:{"textContent":_s("hello")}})}`)
+  expect(errors).toEqual([])
 })
 
-test('transform with static object literal', t => {
+it('transform with static object literal', () => {
   const { ast, render, errors } = compile(`<p v-t="{ path: 'named', locale: 'ja', args: { name: 'kazupon' } }"></p>`, { modules: [i18nModule] })
-  t.is(ast.i18n, 'やあ、kazupon！')
-  t.is(render, `with(this){return _c('p',{domProps:{"textContent":_s("やあ、kazupon！")}})}`)
-  t.deepEqual(errors, [])
+  expect(ast.i18n).toEqual('やあ、kazupon！')
+  expect(render).toEqual(`with(this){return _c('p',{domProps:{"textContent":_s("やあ、kazupon！")}})}`)
+  expect(errors).toEqual([])
 })
 
-test('not transform with dynamic params', t => {
-  const spy = sinon.spy(console, 'warn')
+it('not transform with dynamic params', () => {
+  const spy = jest.spyOn(global.console, 'warn')
+  spy.mockImplementation(x => x)
   const { ast, render, errors } = compile(`<p v-t="hello"></p>`, { modules: [i18nModule] })
-  t.falsy(ast.i18n)
-  t.is(render, `with(this){return _c('p',{directives:[{name:"t",rawName:"v-t",value:(hello),expression:"hello"}]})}`)
-  t.deepEqual(errors, [])
-  t.truthy(spy.withArgs('[vue-i18n-extensions] pre-localization with v-t support only static params').calledOnce)
-  spy.restore()
+  expect(ast.i18n).toBeFalsy()
+  expect(render).toEqual(`with(this){return _c('p',{directives:[{name:"t",rawName:"v-t",value:(hello),expression:"hello"}]})}`)
+  expect(errors).toEqual([])
+  expect(spy.mock.calls[0][0]).toEqual('[vue-i18n-extensions] pre-localization with v-t support only static params')
+  spy.mockReset()
+  spy.mockRestore()
 })
 
-test('not support value warning', t => {
-  const spy = sinon.spy(console, 'warn')
+it('not support value warning', () => {
+  const spy = jest.spyOn(global.console, 'warn')
+  spy.mockImplementation(x => x)
   const { ast, render, errors } = compile(`<p v-t="[1]"></p>`, { modules: [i18nModule] })
-  t.falsy(ast.i18n)
-  t.is(render, `with(this){return _c('p',{directives:[{name:"t",rawName:"v-t",value:([1]),expression:"[1]"}]})}`)
-  t.deepEqual(errors, [])
-  t.truthy(spy.withArgs('[vue-i18n-extensions] not support value type').calledOnce)
-  spy.restore()
+  expect(ast.i18n).toBeFalsy()
+  expect(render).toEqual(`with(this){return _c('p',{directives:[{name:"t",rawName:"v-t",value:([1]),expression:"[1]"}]})}`)
+  expect(errors).toEqual([])
+  expect(spy.mock.calls[0][0]).toEqual('[vue-i18n-extensions] not support value type')
+  spy.mockReset()
+  spy.mockRestore()
 })
 
-test('detect missing translation', t => {
+it('detect missing translation', done => {
   i18n.missing = (locale, key, vm) => {
-    t.is(locale, 'en')
-    t.is(key, 'foo.bar')
-    t.is(vm, null)
+    expect(locale).toEqual('en')
+    expect(key).toEqual('foo.bar')
+    expect(vm).toBeNull()
+    done()
   }
   const { ast, render, errors } = compile(`<p v-t="'foo.bar'"></p>`, { modules: [i18nModule] })
-  t.is(ast.i18n, 'foo.bar')
-  t.is(render, `with(this){return _c(\'p\',{domProps:{"textContent":_s("foo.bar")}})}`)
-  t.deepEqual(errors, [])
+  expect(ast.i18n).toEqual('foo.bar')
+  expect(render).toEqual(`with(this){return _c(\'p\',{domProps:{"textContent":_s("foo.bar")}})}`)
+  expect(errors).toEqual([])
 })
 
-test('fallback custom directive', t => {
+it('fallback custom directive', () => {
   const { ast, render, errors } = compile(`<p v-t="'foo.bar'"></p>`)
-  t.falsy(ast.i18n)
-  t.deepEqual(ast.directives[0], { name: 't', rawName: 'v-t', value: '\'foo.bar\'', arg: null, modifiers: undefined })
-  t.deepEqual(errors, [])
-})
-*/
+  expect(ast.i18n).toBeFalsy()
+  expect(ast.directives[0]).toEqual({ name: 't', rawName: 'v-t', value: '\'foo.bar\'', arg: null, modifiers: undefined })
+  expect(errors).toEqual([])
+})