mirror of https://github.com/curbengh/hexo-yam
1155 lines
29 KiB
JavaScript
1155 lines
29 KiB
JavaScript
/* eslint-env jest */
|
|
'use strict'
|
|
|
|
const { promisify } = require('util')
|
|
const Hexo = require('hexo')
|
|
const hexo = new Hexo(__dirname)
|
|
global.hexo = hexo
|
|
|
|
describe('html', () => {
|
|
const { htmlDefault } = require('../index')
|
|
const h = require('../lib/filter').minifyHtml.bind(hexo)
|
|
const Htmlminifier = require('html-minifier').minify
|
|
const input = '<p id="">foo</p>'
|
|
const path = 'index.html'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.html = Object.assign({}, htmlDefault)
|
|
})
|
|
|
|
test('default', () => {
|
|
const result = h(input, { path })
|
|
const expected = Htmlminifier(input, hexo.config.minify.html)
|
|
|
|
expect(result).toBe(expected)
|
|
})
|
|
|
|
test('disable', () => {
|
|
hexo.config.minify.html.enable = false
|
|
|
|
const result = h(input, { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', () => {
|
|
const result = h('', { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('option', () => {
|
|
const customOpt = { removeEmptyAttributes: false }
|
|
hexo.config.minify.html = customOpt
|
|
|
|
const result = h(input, { path })
|
|
const expected = Htmlminifier(input, customOpt)
|
|
|
|
expect(result).toBe(input)
|
|
expect(result).toBe(expected)
|
|
})
|
|
|
|
test('option - verbose', () => {
|
|
hexo.config.minify.html.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
h(input, { path })
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`html: ${path}`)
|
|
})
|
|
|
|
test('exclude', () => {
|
|
const exclude = '*.min.html'
|
|
hexo.config.minify.html.exclude = exclude
|
|
|
|
const result = h(input, { path: 'foo/bar.min.html' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - slash in pattern', () => {
|
|
const exclude = '**/lectus/**/*.html'
|
|
hexo.config.minify.html.exclude = exclude
|
|
|
|
const result = h(input, { path: 'eleifend/lectus/nullam/dapibus/netus.html' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - basename is true + slash', () => {
|
|
const exclude = ['**/lectus/**/*.html', 'bar.html']
|
|
const globOptions = { basename: true }
|
|
hexo.config.minify.html.exclude = exclude
|
|
hexo.config.minify.html.globOptions = globOptions
|
|
|
|
const result = h(input, { path: 'foo/bar.html' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - basename is false + slash', () => {
|
|
const exclude = ['**/lectus/**/*.html', 'bar.html']
|
|
const globOptions = { basename: false }
|
|
hexo.config.minify.html.exclude = exclude
|
|
hexo.config.minify.html.globOptions = globOptions
|
|
|
|
const result = h(input, { path: 'foo/bar.html' })
|
|
const expected = Htmlminifier(input, hexo.config.minify.html)
|
|
|
|
expect(result).toBe(expected)
|
|
})
|
|
|
|
test('null', () => {
|
|
hexo.config.minify.html.exclude = null
|
|
hexo.config.minify.html.globOptions = null
|
|
|
|
const result = h(input, { path: null })
|
|
const expected = Htmlminifier(input, hexo.config.minify.html)
|
|
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
|
|
describe('css', () => {
|
|
const { cssDefault } = require('../index')
|
|
const c = require('../lib/filter').minifyCss.bind(hexo)
|
|
const CleanCSS = require('clean-css')
|
|
const input = 'foo { bar: baz; } foo { aaa: bbb; }'
|
|
const path = 'foo.css'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.css = Object.assign({}, cssDefault)
|
|
})
|
|
|
|
test('default', async () => {
|
|
const result = await c(input, { path })
|
|
const { styles } = await new CleanCSS(hexo.config.minify.css).minify(input)
|
|
|
|
expect(result).toBe(styles)
|
|
})
|
|
|
|
test('disable', async () => {
|
|
hexo.config.minify.css.enable = false
|
|
const result = await c(input, { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', async () => {
|
|
const result = await c('', { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('option', async () => {
|
|
const customOpt = {
|
|
level: {
|
|
1: {
|
|
mergeAdjacentRules: false
|
|
}
|
|
}
|
|
}
|
|
hexo.config.minify.css = customOpt
|
|
|
|
const result = await c(input, { path })
|
|
const { styles } = await new CleanCSS(customOpt).minify(input)
|
|
|
|
expect(result).toBe(styles)
|
|
})
|
|
|
|
test('option - verbose', async () => {
|
|
hexo.config.minify.css.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
await c(input, { path })
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`css: ${path}`)
|
|
})
|
|
|
|
test('option - invalid', async () => {
|
|
const customOpt = {
|
|
level: 9000
|
|
}
|
|
hexo.config.minify.css = customOpt
|
|
|
|
let result, expected
|
|
|
|
try {
|
|
await c(input, { path })
|
|
} catch (err) {
|
|
result = err.message
|
|
}
|
|
try {
|
|
await new CleanCSS(customOpt).minify(input)
|
|
} catch (err) {
|
|
expected = err.message
|
|
}
|
|
|
|
expect(result).toContain(expected)
|
|
})
|
|
|
|
test('exclude - *.min.css', async () => {
|
|
const result = await c(input, { path: 'foo/bar.min.css' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - basename', async () => {
|
|
const exclude = '*baz.css'
|
|
hexo.config.minify.css.exclude = exclude
|
|
const result = await c(input, { path: 'foo/barbaz.css' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - slash in pattern', async () => {
|
|
const exclude = '**/lectus/**/*.css'
|
|
hexo.config.minify.css.exclude = exclude
|
|
const result = await c(input, { path: 'eleifend/lectus/nullam/dapibus/netus.css' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
|
|
describe('js', () => {
|
|
const { jsDefault } = require('../index')
|
|
const j = require('../lib/filter').minifyJs.bind(hexo)
|
|
const Terser = require('terser')
|
|
const input = 'var o = { "foo": 1, bar: 3 };'
|
|
const path = 'foo.js'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.js = Object.assign({}, jsDefault)
|
|
})
|
|
|
|
test('default', () => {
|
|
const result = j(input, { path })
|
|
const { code } = Terser.minify(input, { mangle: jsDefault.mangle })
|
|
|
|
expect(result).toBeDefined()
|
|
expect(code).toBeDefined()
|
|
expect(result).toBe(code)
|
|
})
|
|
|
|
test('disable', () => {
|
|
hexo.config.minify.js.enable = false
|
|
|
|
const result = j(input, { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', () => {
|
|
const result = j('', { path })
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('option', () => {
|
|
const customOpt = {
|
|
mangle: {
|
|
properties: true
|
|
}
|
|
}
|
|
hexo.config.minify.js = customOpt
|
|
|
|
const result = j(input, { path })
|
|
const { code } = Terser.minify(input, customOpt)
|
|
|
|
expect(result).toBe(code)
|
|
})
|
|
|
|
test('option - verbose', () => {
|
|
hexo.config.minify.js.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
j(input, { path })
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`js: ${path}`)
|
|
})
|
|
|
|
test('option - invalid', () => {
|
|
const customOpt = {
|
|
mangle: {
|
|
foo: 'bar'
|
|
}
|
|
}
|
|
hexo.config.minify.js = customOpt
|
|
|
|
const { error } = Terser.minify(input, customOpt)
|
|
try {
|
|
j(input, { path })
|
|
} catch (err) {
|
|
expect(err.message).toContain(error.message)
|
|
}
|
|
})
|
|
|
|
test('exclude - *.min.js', () => {
|
|
const result = j(input, { path: 'foo/bar.min.js' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - basename', () => {
|
|
const exclude = '*baz.js'
|
|
hexo.config.minify.js.exclude = exclude
|
|
const result = j(input, { path: 'foo/barbaz.js' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
|
|
test('exclude - slash in pattern', () => {
|
|
const exclude = '**/lectus/**/*.js'
|
|
hexo.config.minify.js.exclude = exclude
|
|
const result = j(input, { path: 'eleifend/lectus/nullam/dapibus/netus.js' })
|
|
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
|
|
describe('svg', () => {
|
|
const { svgDefault } = require('../index')
|
|
const s = require('../lib/filter').minifySvg.bind(hexo)
|
|
const Svgo = require('svgo')
|
|
const input = '<svg><rect x="1" y="2" width="3" height="4" id="a"/></svg>'
|
|
const path = 'foo.svg'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.svg = Object.assign({}, svgDefault)
|
|
hexo.route.set(path, input)
|
|
})
|
|
|
|
afterEach(() => {
|
|
const routeList = hexo.route.list()
|
|
routeList.forEach((path) => hexo.route.remove(path))
|
|
})
|
|
|
|
test('default', async () => {
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
})
|
|
})
|
|
|
|
test('disable', async () => {
|
|
hexo.config.minify.svg.enable = false
|
|
const result = await s()
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', async () => {
|
|
hexo.route.set(path, '')
|
|
const result = await s()
|
|
|
|
// empty file resolves to an array of undefined
|
|
expect(result).toBeDefined()
|
|
expect(result[0]).toBeUndefined()
|
|
})
|
|
|
|
test('option', async () => {
|
|
const customOpt = [{ cleanupIDs: false }]
|
|
hexo.config.minify.svg.plugins = customOpt
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
expect(result).toContain('id="a"')
|
|
})
|
|
})
|
|
|
|
test('option - verbose', async () => {
|
|
hexo.config.minify.svg.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
await s()
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`svg: ${path}`)
|
|
})
|
|
|
|
test('invalid svg', async () => {
|
|
const input = '{}'
|
|
hexo.route.set(path, input)
|
|
let expected
|
|
try {
|
|
await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
} catch (err) {
|
|
expected = err
|
|
}
|
|
try {
|
|
await s()
|
|
} catch (err) {
|
|
expect(err.message).toContain(expected)
|
|
}
|
|
})
|
|
|
|
test('include - exclude *.min.svg by default', async () => {
|
|
const path = 'foo.min.svg'
|
|
hexo.route.set(path, input)
|
|
await s()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
|
|
test('include - basename', async () => {
|
|
hexo.config.minify.svg.include = 'bar.svg'
|
|
const path = 'foo/bar.svg'
|
|
hexo.route.set(path, input)
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
})
|
|
})
|
|
|
|
test('include - slash in pattern', async () => {
|
|
hexo.config.minify.svg.include = '**/lectus/**/*.svg'
|
|
const path = 'eleifend/lectus/nullam/dapibus/netus.svg'
|
|
hexo.route.set(path, input)
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
})
|
|
})
|
|
|
|
test('include - basename + slash', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.svg',
|
|
'gravida/sociis/erat/ante.svg',
|
|
'aptent/elementum.svg',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.svg.include = [
|
|
'dolor.svg',
|
|
'**/sociis/**/*.svg'
|
|
]
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
const minPaths = paths.slice(0, 2)
|
|
const unminPaths = paths.slice(2)
|
|
|
|
minPaths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
})
|
|
})
|
|
|
|
unminPaths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
})
|
|
|
|
test('include - reverse pattern + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.svg',
|
|
'gravida/sociis/erat/ante.svg',
|
|
'aptent/elementum.svg',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.svg.include = [
|
|
'!dolor.svg'
|
|
]
|
|
hexo.config.minify.svg.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await s()
|
|
const { data } = await new Svgo(hexo.config.minify.svg).optimize(input)
|
|
|
|
paths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(data)
|
|
})
|
|
})
|
|
})
|
|
|
|
test('include - empty route', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const result = await s()
|
|
expect(result.length).toBe(0)
|
|
})
|
|
})
|
|
|
|
describe('gzip', () => {
|
|
const { gzipDefault } = require('../index')
|
|
const g = require('../lib/filter').gzipFn.bind(hexo)
|
|
const zlib = require('zlib')
|
|
const gzip = promisify(zlib.gzip)
|
|
const unzip = promisify(zlib.unzip)
|
|
const path = 'foo.txt'
|
|
const input = 'Lorem ipsum dolor sit amet consectetur adipiscing elit fusce'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.gzip = Object.assign({}, gzipDefault)
|
|
hexo.route.set(path, input)
|
|
})
|
|
|
|
afterEach(() => {
|
|
const routeList = hexo.route.list()
|
|
routeList.forEach((path) => hexo.route.remove(path))
|
|
})
|
|
|
|
test('default', async () => {
|
|
await g()
|
|
|
|
const output = hexo.route.get(path.concat('.gz'))
|
|
const buf = []
|
|
output.on('data', (chunk) => (buf.push(chunk)))
|
|
output.on('end', async () => {
|
|
const result = Buffer.concat(buf)
|
|
const expected = await gzip(input, { level: zlib.constants.Z_BEST_COMPRESSION })
|
|
const resultUnzip = await unzip(result)
|
|
const expectedUnzip = await unzip(expected)
|
|
|
|
expect(result.equals(expected)).toBe(true)
|
|
expect(resultUnzip.toString()).toBe(input)
|
|
expect(expectedUnzip.toString()).toBe(input)
|
|
})
|
|
})
|
|
|
|
test('disable', async () => {
|
|
hexo.config.minify.gzip.enable = false
|
|
const result = await g()
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', async () => {
|
|
hexo.route.set(path, '')
|
|
|
|
const routeList = hexo.route.list()
|
|
expect(routeList).not.toContain(path.concat('.gz'))
|
|
|
|
const result = await g()
|
|
// empty file resolves to an array of undefined
|
|
expect(result).toBeDefined()
|
|
expect(result[0]).toBeUndefined()
|
|
})
|
|
|
|
test('option', async () => {
|
|
const customOpt = {
|
|
level: 1
|
|
}
|
|
hexo.config.minify.gzip.level = customOpt.level
|
|
await g()
|
|
|
|
const output = hexo.route.get(path.concat('.gz'))
|
|
const buf = []
|
|
output.on('data', (chunk) => (buf.push(chunk)))
|
|
output.on('end', async () => {
|
|
const result = Buffer.concat(buf)
|
|
const expected = await gzip(input, customOpt)
|
|
|
|
expect(result.equals(expected)).toBe(true)
|
|
})
|
|
})
|
|
|
|
test('option - verbose', async () => {
|
|
hexo.config.minify.gzip.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
await g()
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`gzip: ${path}`)
|
|
})
|
|
|
|
test('option - invalid', async () => {
|
|
const customOpt = {
|
|
level: 9000
|
|
}
|
|
hexo.config.minify.gzip.level = customOpt.level
|
|
|
|
let expected
|
|
try {
|
|
await gzip(input, customOpt)
|
|
} catch (err) {
|
|
expected = err.message
|
|
}
|
|
try {
|
|
await g()
|
|
} catch (err) {
|
|
expect(err.message).toContain(expected)
|
|
}
|
|
})
|
|
|
|
test('include - exclude non-text file by default', async () => {
|
|
const path = 'foo.jpg'
|
|
hexo.route.set(path, input)
|
|
await g()
|
|
|
|
const result = hexo.route.get(path.concat('.gz'))
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('include - basename', async () => {
|
|
hexo.config.minify.gzip.include = 'bar.txt'
|
|
const path = 'foo/bar.txt'
|
|
hexo.route.set(path, input)
|
|
await g()
|
|
|
|
const result = hexo.route.get(path.concat('.gz'))
|
|
|
|
expect(result).toBeDefined()
|
|
})
|
|
|
|
test('include - slash in pattern', async () => {
|
|
hexo.config.minify.gzip.include = '**/lectus/**/*.txt'
|
|
const path = 'eleifend/lectus/nullam/dapibus/netus.txt'
|
|
hexo.route.set(path, input)
|
|
await g()
|
|
|
|
const result = hexo.route.get(path.concat('.gz'))
|
|
|
|
expect(result).toBeDefined()
|
|
})
|
|
|
|
test('include - basename + slash + basename enabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.gzip.include = [
|
|
'*.html',
|
|
'**/sociis/**/*.css'
|
|
]
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await g()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = [
|
|
'lorem/ipsum/dolor.html.gz',
|
|
'gravida/sociis/erat/ante.css.gz'
|
|
]
|
|
const notExpected = [
|
|
'aptent/elementum.js.gz',
|
|
'felis/blandit/cursus.svg.gz'
|
|
]
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
expect(routeList).toEqual(expect.not.arrayContaining(notExpected))
|
|
})
|
|
|
|
test('include - basename + slash + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.gzip.include = [
|
|
'*.html',
|
|
'**/sociis/**/*.css'
|
|
]
|
|
hexo.config.minify.gzip.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await g()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = [
|
|
'gravida/sociis/erat/ante.css.gz'
|
|
]
|
|
const notExpected = [
|
|
'lorem/ipsum/dolor.html.gz',
|
|
'aptent/elementum.js.gz',
|
|
'felis/blandit/cursus.svg.gz'
|
|
]
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
expect(routeList).toEqual(expect.not.arrayContaining(notExpected))
|
|
})
|
|
|
|
test('include - reverse pattern + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.gzip.include = [
|
|
'!dolor.html'
|
|
]
|
|
hexo.config.minify.gzip.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await g()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = paths.map((path) => path.concat('.gz'))
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
})
|
|
})
|
|
|
|
describe('brotli', () => {
|
|
const { brotliDefault } = require('../index')
|
|
const b = require('../lib/filter').brotliFn.bind(hexo)
|
|
const zlib = require('zlib')
|
|
const brotli = promisify(zlib.brotliCompress)
|
|
const unbrotli = promisify(zlib.brotliDecompress)
|
|
const path = 'foo.txt'
|
|
const input = 'Lorem ipsum dolor sit amet consectetur adipiscing elit fusce'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.brotli = Object.assign({}, brotliDefault)
|
|
hexo.route.set(path, input)
|
|
})
|
|
|
|
afterEach(() => {
|
|
const routeList = hexo.route.list()
|
|
routeList.forEach((path) => hexo.route.remove(path))
|
|
})
|
|
|
|
test('default', async () => {
|
|
await b()
|
|
|
|
const output = hexo.route.get(path.concat('.br'))
|
|
const buf = []
|
|
output.on('data', (chunk) => (buf.push(chunk)))
|
|
output.on('end', async () => {
|
|
const result = Buffer.concat(buf)
|
|
const expected = await brotli(input)
|
|
const resultUnbr = await unbrotli(result)
|
|
const expectedUnbr = await unbrotli(expected)
|
|
|
|
expect(result.equals(expected)).toBe(true)
|
|
expect(resultUnbr.toString()).toBe(input)
|
|
expect(expectedUnbr.toString()).toBe(input)
|
|
})
|
|
})
|
|
|
|
test('disable', async () => {
|
|
hexo.config.minify.brotli.enable = false
|
|
const result = await b()
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('empty file', async () => {
|
|
hexo.route.set(path, '')
|
|
|
|
const routeList = hexo.route.list()
|
|
expect(routeList).not.toContain(path.concat('.br'))
|
|
|
|
const result = await b()
|
|
expect(result).toBeDefined()
|
|
expect(result[0]).toBeUndefined()
|
|
})
|
|
|
|
test('option', async () => {
|
|
const level = 1
|
|
hexo.config.minify.brotli.level = level
|
|
await b()
|
|
|
|
const output = hexo.route.get(path.concat('.br'))
|
|
const buf = []
|
|
output.on('data', (chunk) => (buf.push(chunk)))
|
|
output.on('end', async () => {
|
|
const result = Buffer.concat(buf)
|
|
const expected = await brotli(input, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: level } })
|
|
|
|
expect(result.equals(expected)).toBe(true)
|
|
})
|
|
})
|
|
|
|
test('option - verbose', async () => {
|
|
hexo.config.minify.brotli.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
await b()
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`brotli: ${path}`)
|
|
})
|
|
|
|
test('option - level is string', async () => {
|
|
const level = 'foo'
|
|
hexo.config.minify.brotli.level = level
|
|
await b()
|
|
|
|
const output = hexo.route.get(path.concat('.br'))
|
|
const buf = []
|
|
output.on('data', (chunk) => (buf.push(chunk)))
|
|
output.on('end', async () => {
|
|
const result = Buffer.concat(buf)
|
|
const expected = await brotli(input, { params: { [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY } })
|
|
|
|
expect(result.equals(expected)).toBe(true)
|
|
})
|
|
})
|
|
|
|
test('include - exclude non-text file by default', async () => {
|
|
const path = 'foo.jpg'
|
|
hexo.route.set(path, input)
|
|
await b()
|
|
|
|
const result = hexo.route.get(path.concat('.br'))
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('include - basename', async () => {
|
|
hexo.config.minify.brotli.include = 'bar.txt'
|
|
const path = 'foo/bar.txt'
|
|
hexo.route.set(path, input)
|
|
await b()
|
|
|
|
const result = hexo.route.get(path.concat('.br'))
|
|
|
|
expect(result).toBeDefined()
|
|
})
|
|
|
|
test('include - slash in pattern', async () => {
|
|
hexo.config.minify.brotli.include = '**/lectus/**/*.txt'
|
|
const path = 'eleifend/lectus/nullam/dapibus/netus.txt'
|
|
hexo.route.set(path, input)
|
|
await b()
|
|
|
|
const result = hexo.route.get(path.concat('.br'))
|
|
|
|
expect(result).toBeDefined()
|
|
})
|
|
|
|
test('include - basename + slash + basename enabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.brotli.include = [
|
|
'*.html',
|
|
'**/sociis/**/*.css'
|
|
]
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await b()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = [
|
|
'lorem/ipsum/dolor.html.br',
|
|
'gravida/sociis/erat/ante.css.br'
|
|
]
|
|
const notExpected = [
|
|
'aptent/elementum.js.br',
|
|
'felis/blandit/cursus.svg.br'
|
|
]
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
expect(routeList).toEqual(expect.not.arrayContaining(notExpected))
|
|
})
|
|
|
|
test('include - basename + slash + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.brotli.include = [
|
|
'*.html',
|
|
'**/sociis/**/*.css'
|
|
]
|
|
hexo.config.minify.brotli.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await b()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = [
|
|
'gravida/sociis/erat/ante.css.br'
|
|
]
|
|
const notExpected = [
|
|
'lorem/ipsum/dolor.html.br',
|
|
'aptent/elementum.js.br',
|
|
'felis/blandit/cursus.svg.br'
|
|
]
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
expect(routeList).toEqual(expect.not.arrayContaining(notExpected))
|
|
})
|
|
|
|
test('include - reverse pattern + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.html',
|
|
'gravida/sociis/erat/ante.css',
|
|
'aptent/elementum.js',
|
|
'felis/blandit/cursus.svg'
|
|
]
|
|
hexo.config.minify.brotli.include = [
|
|
'!dolor.html'
|
|
]
|
|
hexo.config.minify.brotli.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await b()
|
|
|
|
const routeList = hexo.route.list()
|
|
const expected = paths.map((path) => path.concat('.br'))
|
|
|
|
expect(routeList).toEqual(expect.arrayContaining(expected))
|
|
})
|
|
})
|
|
|
|
describe('xml', () => {
|
|
const { xmlDefault } = require('../index')
|
|
const x = require('../lib/filter').minifyXml.bind(hexo)
|
|
const path = 'foo.xml'
|
|
const input = '<?xml version="1.0" encoding="utf-8"?>\n<feed xmlns="http://www.w3.org/2005/Atom">\n <!-- foo bar -->\n <title>foo</title>\n</feed>'
|
|
const expected = '<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom"><title>foo</title></feed>'
|
|
|
|
beforeEach(() => {
|
|
hexo.config.minify.xml = Object.assign({}, xmlDefault)
|
|
// plugin is disabled by default
|
|
hexo.config.minify.xml.enable = true
|
|
hexo.route.set(path, input)
|
|
})
|
|
|
|
afterEach(() => {
|
|
const routeList = hexo.route.list()
|
|
routeList.forEach((path) => hexo.route.remove(path))
|
|
})
|
|
|
|
test('default', async () => {
|
|
await x()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
|
|
test('disable', async () => {
|
|
hexo.config.minify.xml.enable = false
|
|
const result = await x()
|
|
|
|
expect(result).toBeUndefined()
|
|
})
|
|
|
|
test('option - removeComments', async () => {
|
|
hexo.config.minify.xml.removeComments = false
|
|
|
|
await x()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toContain('<!-- foo bar -->')
|
|
})
|
|
})
|
|
|
|
test('option - verbose', async () => {
|
|
hexo.config.minify.xml.verbose = true
|
|
hexo.log.log = jest.fn()
|
|
await x()
|
|
|
|
expect(hexo.log.log.mock.calls[0][0]).toContain(`xml: ${path}`)
|
|
})
|
|
|
|
test('empty file', async () => {
|
|
hexo.route.set(path, '')
|
|
const result = await x()
|
|
|
|
expect(result).toBeDefined()
|
|
expect(result[0]).toBeUndefined()
|
|
})
|
|
|
|
test('include - exclude *.min.xml by default', async () => {
|
|
const path = 'foo.min.xml'
|
|
hexo.route.set(path, input)
|
|
await x()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
|
|
test('include - basename', async () => {
|
|
hexo.config.minify.xml.include = 'bar.xml'
|
|
const path = 'foo/bar.xml'
|
|
hexo.route.set(path, input)
|
|
await x()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
|
|
test('include - slash in pattern', async () => {
|
|
hexo.config.minify.xml.include = '**/lectus/**/*.xml'
|
|
const path = 'eleifend/lectus/nullam/dapibus/netus.xml'
|
|
hexo.route.set(path, input)
|
|
await x()
|
|
|
|
const output = hexo.route.get(path)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
|
|
test('include - basename + slash', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.xml',
|
|
'gravida/sociis/erat/ante.xml',
|
|
'aptent/elementum.xml',
|
|
'felis/blandit/cursus.xml'
|
|
]
|
|
hexo.config.minify.xml.include = [
|
|
'dolor.xml',
|
|
'**/sociis/**/*.xml'
|
|
]
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await x()
|
|
|
|
const minPaths = paths.slice(0, 2)
|
|
const unminPaths = paths.slice(2)
|
|
|
|
minPaths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
|
|
unminPaths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(input)
|
|
})
|
|
})
|
|
})
|
|
|
|
test('include - reverse pattern + basename disabled', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const paths = [
|
|
'lorem/ipsum/dolor.xml',
|
|
'gravida/sociis/erat/ante.xml',
|
|
'aptent/elementum.xml',
|
|
'felis/blandit/cursus.xml'
|
|
]
|
|
hexo.config.minify.xml.include = [
|
|
'!dolor.xml'
|
|
]
|
|
hexo.config.minify.xml.globOptions = {
|
|
basename: false
|
|
}
|
|
|
|
paths.forEach((inpath) => {
|
|
hexo.route.set(inpath, input)
|
|
})
|
|
await x()
|
|
|
|
paths.forEach((inpath) => {
|
|
const output = hexo.route.get(inpath)
|
|
let result = ''
|
|
output.on('data', (chunk) => (result += chunk))
|
|
output.on('end', () => {
|
|
expect(result).toBe(expected)
|
|
})
|
|
})
|
|
})
|
|
|
|
test('include - empty route', async () => {
|
|
hexo.route.remove(path)
|
|
|
|
const result = await x()
|
|
expect(result.length).toBe(0)
|
|
})
|
|
})
|