98 lines
3.4 KiB
JavaScript
98 lines
3.4 KiB
JavaScript
const fs = require('fs-extra')
|
|
const path = require('path')
|
|
const yaml = require('js-yaml')
|
|
const glob = require('glob')
|
|
const u = require('../src/utils')
|
|
const a = require('../src/assert')
|
|
const ergogen = require('../src/ergogen')
|
|
require('./helpers/mock_footprints').inject(ergogen)
|
|
|
|
let what = process.env.npm_config_what
|
|
let dump = process.env.npm_config_dump
|
|
|
|
// Unit tests
|
|
// the --what switch supports each unit individually
|
|
// the --dump switch does nothing here
|
|
|
|
what = what ? what.split(',') : false
|
|
for (const unit of glob.sync(path.join(__dirname, 'unit', '*.js'))) {
|
|
const base = path.basename(unit, '.js')
|
|
if (what && !what.includes(base)) continue
|
|
require(`./unit/${base}.js`)
|
|
}
|
|
|
|
// Integration tests
|
|
// the --what switch supports categories (like `points` and `outlines`)
|
|
// as well as individual tests using slash-notation (like `points/000`)
|
|
// the --dump switch can output actual results for easier reference creation
|
|
// by default, json output is generated of the whole `actual`, but a raw,
|
|
// type-specific representation can be written if a deep path is specified
|
|
|
|
const cap = s => s.charAt(0).toUpperCase() + s.slice(1)
|
|
|
|
const test = function(input_path) {
|
|
this.timeout(120000)
|
|
title = path.basename(input_path, '.yaml').split('_').join(' ')
|
|
it(title, async function() {
|
|
const input = yaml.load(fs.readFileSync(input_path).toString())
|
|
const actual = await ergogen.process(input, true)
|
|
|
|
// if we're just creating the reference, we can dump the current output
|
|
if (dump) {
|
|
const out = path.join(
|
|
path.dirname(input_path),
|
|
path.basename(input_path, '.yaml') + '___ref_candidate'
|
|
)
|
|
// whole dump
|
|
if (dump === true) {
|
|
fs.writeJSONSync(out + '.json', actual, {spaces: 4})
|
|
// partial, type-specific dump
|
|
} else {
|
|
const part = u.deep(actual, dump)
|
|
if (a.type(part)() == 'string') {
|
|
fs.writeFileSync(out + '.txt', part)
|
|
} else {
|
|
fs.writeJSONSync(out + '.json', part, {spaces: 4})
|
|
}
|
|
}
|
|
}
|
|
|
|
// compare actual vs. reference
|
|
const base = path.join(path.dirname(input_path), path.basename(input_path, '.yaml'))
|
|
for (const expected_path of glob.sync(base + '___*')) {
|
|
let expected = fs.readFileSync(expected_path).toString()
|
|
if (expected_path.endsWith('.json')) {
|
|
expected = JSON.parse(expected)
|
|
}
|
|
const comp_path = expected_path.split('___')[1].split('.')[0].split('_').join('.')
|
|
u.deep(actual, comp_path).should.deep.equal(expected)
|
|
}
|
|
})
|
|
}
|
|
|
|
if (what) {
|
|
for (const w of what) {
|
|
let regex
|
|
let title
|
|
if (w.includes('/')) {
|
|
title = cap(w.split('/')[0]) + ' (partial)'
|
|
regex = path.join(__dirname, w + '*.yaml')
|
|
} else {
|
|
title = cap(w)
|
|
regex = path.join(__dirname, w, '*.yaml')
|
|
}
|
|
describe(title, function() {
|
|
for (const i of glob.sync(regex)) {
|
|
test.call(this, i)
|
|
}
|
|
})
|
|
}
|
|
} else {
|
|
for (const part of ['points', 'outlines', 'cases', 'pcbs']) {
|
|
describe(cap(part), function() {
|
|
for (const i of glob.sync(path.join(__dirname, part, '*.yaml'))) {
|
|
test.call(this, i)
|
|
}
|
|
})
|
|
}
|
|
}
|