TheThing
/
service-core
1
0
Fork 0
Code Issues Pull Requests Projects Releases 22 Wiki Activity

Application almost done
continuous-integration/appveyor/branch AppVeyor build failed Details

master
Jonatan Nilsson 2022-01-27 18:25:33 +00:00
parent a16a04a91f
commit f008af597d
11 changed files with 536 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -108,6 +108,4 @@ db.json
package-lock.json
daemon
app/*
manage/*
dev/public/main.js

111
core/application.mjs
View File

@ -13,6 +13,7 @@ export default class Application extends EventEmitter {
Object.assign(this, {
setInterval: opts.setInterval || setInterval,
fs: opts.fs || fs,
})
this.db.addApplication(name)
@ -35,6 +36,7 @@ export default class Application extends EventEmitter {
updateLog(message) {
this.db.data.core[this.name].updater += message
this.db.log.info(message)
return message
}
async update() {
@ -42,28 +44,127 @@ export default class Application extends EventEmitter {
this.updating = true
this.db.data.core[this.name].updater = ''
let cleanup = true
let folder = ''
let log = ''
let latest = null
try {
this.updateLog(`Checking for latest version at ${new Date().toISOString().replace('T', ' ').split('.')[0]}. `)
log += this.updateLog(`Checking for latest version at ${new Date().toISOString().replace('T', ' ').split('.')[0]}. `) + '\n'
let latest = await this.provider.getLatestVersion()
latest = await this.provider.getLatestVersion()
this.updateLog(`Found ${latest.version}. `)
log += this.updateLog(`Found ${latest.version}. `) + '\n'
if (this.db.data.core[this.name].latestInstalled === latest.version) {
this.updateLog('Already up to date, nothing to do. ')
this.updating = false
return
}
latest.id = latest.version
var found = this.db.get(this.db.data.core[this.name].versions, latest.id)
if (found) {
Object.keys(latest).forEach(function(key) {
found[key] = latest[key]
})
latest = found
log = latest.log + log
} else {
this.db.upsert(this.db.data.core[this.name].versions, latest)
}
if (latest.failtodownload && latest.failtodownload > 3) {
this.updateLog('Version failed to download too many times, skipping this version. ')
this.updating = false
return
}
if (latest.failtoinstall && latest.failtoinstall > 3) {
this.updateLog('Version failed to install too many times, skipping this version. ')
this.updating = false
return
}
let target = this.util.getPathFromRoot(`./${this.name}/${latest.version}/file${this.util.getExtension(latest.filename)}`)
folder = this.util.getPathFromRoot(`./${this.name}/${latest.version}`)
await fs.mkdir(this.util.getPathFromRoot(`./${this.name}/${latest.version}`), { recursive: true })
await this.fs.mkdir(folder, { recursive: true })
this.updateLog(`Downloading ${latest.link} to ${target}. `)
log += this.updateLog(`Downloading ${latest.link} to ${target}. `) + '\n'
await this.provider.downloadVersion(latest, target)
.catch(function(err) {
latest.failtodownload = (latest.failtodownload || 0) + 1
return Promise.reject(err)
})
log += '\n' + this.updateLog(`Extracting ${target}. `) + '\n'
await this.util.extractFile(target, function(msg) {
log += msg
}).catch(function(err) {
latest.failtodownload = (latest.failtodownload || 0) + 1
return Promise.reject(err)
})
if (!log.endsWith('\n')) {
log += '\n'
}
if (!log.endsWith('\n\n')) {
log += '\n'
}
await this.fs.stat(this.util.getPathFromRoot(`./${this.name}/${latest.version}/index.mjs`))
.catch((err) => {
latest.failtodownload = (latest.failtodownload || 0) + 1
log += this.updateLog('Version did not include or was missing index.mjs. ') + '\n'
return Promise.reject(err)
})
cleanup = false
let packageStat = await this.fs.stat(this.util.getPathFromRoot(`./${this.name}/${latest.version}/package.json`))
.catch(function() { return null })
if (packageStat) {
log += this.updateLog(`running npm install --production. `) + '\n'
await this.util.runCommand(
'npm.cmd',
['install', '--production', '--no-optional', '--no-package-lock', '--no-audit', '--loglevel=notice'],
folder,
function(msg) {
log += msg
}
).catch(function(err) {
latest.failtoinstall = (latest.failtoinstall || 0) + 1
return Promise.reject(err)
})
if (!log.endsWith('\n')) {
log += '\n'
}
if (!log.endsWith('\n\n')) {
log += '\n'
}
} else {
log += this.updateLog('Release did not contain package.json, skipping npm install. ') + '\n'
}
} catch (err) {
this.updating = false
log += this.updateLog(`Error: ${err.message}. `) + '\n'
if (folder && cleanup) {
await this.fs.rm(folder, { force: true, recursive: true }).catch((err) => {
this.updateLog(`Error while cleaning up: ${err.message}. `)
})
}
if (latest) {
latest.log = log
}
return Promise.reject(err)
}
log += this.updateLog(`Finished updating ${this.name} to version ${latest.version}.`) + '\n'
this.db.data.core[this.name].latestInstalled = latest.version
latest.log = log
this.updating = false
}
}

3
core/db.mjs
View File

@ -48,8 +48,9 @@ export default function GetDB(config, log, orgFilename = 'db.json') {
col[i] = item
return
}
} else {
item[db.id] = db.createId(col)
}
item[db.id] = db.createId(col)
col.push(item)
}

1
core/providers/git.mjs
View File

@ -32,6 +32,7 @@ export default class GitProvider {
version: item.name,
link: asset.browser_download_url,
filename: asset.name,
description: item.body,
log: '',
}
}

14
core/util.mjs
View File

@ -70,19 +70,25 @@ export default class Util {
runCommand(command, options = [], folder = null, stream = function() {}) {
return new Promise(function(res, rej) {
stream(`[Command] ${folder ? folder : ''}${command} ${options.join(' ')}\n`)
let fullcommand = path.join(folder ? folder : '', command)
if (command.indexOf('/') >= 0 || command.indexOf('\\') >= 0) {
fullcommand = command
}
stream(`[Command] ${fullcommand} ${options.join(' ')}\n`)
let processor = spawn(command, options, {
shell: true,
cwd: folder,
})
let timeOuter = setInterval(function() {
processor.stdin.write('n\n')
try {
processor.stdin.write('n\n')
} catch {}
}, 250)
processor.stdout.on('data', function(data) {
stream(data.toString())
stream(data.toString().replace(/\r\n/g, '\n'))
})
processor.stderr.on('data', function(data) {
stream(data.toString())
stream(data.toString().replace(/\r\n/g, '\n'))
})
processor.on('error', function(err) {
clearInterval(timeOuter)

1
package.json
View File

@ -13,6 +13,7 @@
"patterns": [
"{core,test}/*"
],
"ignore": "test/testapp",
"extensions": "js,mjs",
"quiet": true,
"inherit": true

46
test/application.integration.test.mjs Normal file
View File

@ -0,0 +1,46 @@
import { Eltro as t, assert, stub } from 'eltro'
import fs from 'fs/promises'
import lowdb from '../core/db.mjs'
import Application from '../core/application.mjs'
import GitProvider from '../core/providers/git.mjs'
import Util from '../core/util.mjs'
const util = new Util(import.meta.url)
const logger = {
info: stub(),
warn: stub(),
error: stub(),
}
t.timeout(10000).describe('Application update integration test', function() {
let db
let app
let provider
t.before(function() {
return lowdb({ test: { } }, logger, util.getPathFromRoot('./db_test.json')).then(function(res) {
db = res
provider = new GitProvider({ url: 'https://git.nfp.is/api/v1/repos/thething/sc-helloworld/releases' })
app = new Application(util, db, provider, 'testapp')
return provider.getLatestVersion()
}).then(function(version) {
return fs.rm(`./test/testapp/${version.version}`, { force: true, recursive: true })
})
})
t.after(function() {
if (db.data.core.testapp.versions.length) {
return fs.rm(`./test/testapp/${db.data.core.testapp.versions[0].id}`, { force: true, recursive: true })
}
})
t.test('should run update and install correctly', async function(){
await app.update()
assert.ok(db.data.core.testapp.latestInstalled)
await fs.stat(util.getPathFromRoot(`./testapp/${db.data.core.testapp.latestInstalled}/index.mjs`))
await fs.stat(util.getPathFromRoot(`./testapp/${db.data.core.testapp.latestInstalled}/package.json`))
await fs.stat(util.getPathFromRoot(`./testapp/${db.data.core.testapp.latestInstalled}/node_modules`))
})
})

365
test/application.test.mjs
View File

@ -7,7 +7,7 @@ import Util from '../core/util.mjs'
const util = new Util(import.meta.url)
var logger = {
const logger = {
info: stub(),
warn: stub(),
error: stub(),
@ -163,12 +163,36 @@ t.timeout(250).describe('#update()', function() {
let db
let app
let provider
let stubExtract
let stubRunCommand
let stubWrite
let stubFsMkdir
let stubFsRm
let stubFsStat
t.beforeEach(function() {
util.extractFile = stubExtract = stub()
util.runCommand = stubRunCommand = stub()
stubExtract.resolves()
stubRunCommand.resolves()
return lowdb({ test: { } }, logger, null).then(function(res) {
db = res
db.write = stubWrite = stub()
provider = createProvider()
app = new Application(util, db, provider, 'testapp')
app = new Application(util, db, provider, 'testapp', {
fs: {
mkdir: stubFsMkdir = stub(),
rm: stubFsRm = stub(),
stat: stubFsStat = stub(),
},
})
stubFsMkdir.resolves()
stubFsRm.resolves()
stubFsStat.resolves({})
provider.downloadVersion.resolves()
provider.getLatestVersion.resolves({ version: '123456789', link: 'httplinkhere', filename: 'test.7z' })
})
})
@ -203,12 +227,13 @@ t.timeout(250).describe('#update()', function() {
db.data.core.testapp.updater = ''
let err = await assert.isRejected(app.update())
assert.strictEqual(err, assertError)
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.match(db.data.core.testapp.updater, /check/i)
assert.match(db.data.core.testapp.updater, /version/i)
assert.match(db.data.core.testapp.updater, new RegExp(new Date().toISOString().split('T')[0]))
assert.match(db.data.core.testapp.updater, new RegExp(assertError.message))
})
t.test('should call provider download latest correctly if new 7zip version', async function() {
@ -216,17 +241,16 @@ t.timeout(250).describe('#update()', function() {
const assertLink = 'All of you'
const assertVersion = { version: '123456789', link: assertLink, filename: 'test.7z' }
const assertTarget = util.getPathFromRoot('./testapp/123456789/file.7z')
await assert.isRejected(fs.stat('./test/testapp/123456789'))
assert.strictEqual(db.data.core.testapp.versions.length, 0)
provider.getLatestVersion.resolves(assertVersion)
provider.downloadVersion.rejects(assertError)
db.data.core.testapp.updater = ''
let err = await assert.isRejected(app.update())
assert.strictEqual(err, assertError)
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.match(db.data.core.testapp.updater, /found/i)
assert.match(db.data.core.testapp.updater, new RegExp(assertVersion.version))
assert.match(db.data.core.testapp.updater, /downloading/i)
@ -234,8 +258,29 @@ t.timeout(250).describe('#update()', function() {
assert.match(db.data.core.testapp.updater, new RegExp(assertTarget.replace(/\\/g, '\\\\')))
assert.strictEqual(provider.downloadVersion.firstCall[0], assertVersion)
assert.strictEqual(provider.downloadVersion.firstCall[1], assertTarget)
assert.match(db.data.core.testapp.updater, new RegExp(assertError.message))
await fs.stat('./test/testapp/123456789')
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.ok(assertVersion.log)
assert.match(assertVersion.log, /\. \n/)
assert.match(assertVersion.log, new RegExp(assertError.message))
assert.ok(assertVersion.log.endsWith('\n'))
assert.strictEqual(assertVersion.failtodownload, 1)
assert.ok(stubFsMkdir.called)
assert.match(stubFsMkdir.firstCall[0], /123456789/)
assert.ok(stubFsMkdir.firstCall[1]?.recursive)
// Test if subsequent calls increment counter
err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.strictEqual(assertVersion.failtodownload, 2)
})
t.test('should call provider download latest correctly if new 7zip version', async function() {
@ -243,17 +288,16 @@ t.timeout(250).describe('#update()', function() {
const assertLink = 'All of you'
const assertVersion = { version: '123456789', link: assertLink, filename: 'test.7z' }
const assertTarget = util.getPathFromRoot('./testapp/123456789/file.7z')
await assert.isRejected(fs.stat('./test/testapp/123456789'))
assert.strictEqual(db.data.core.testapp.versions.length, 0)
provider.getLatestVersion.resolves(assertVersion)
provider.downloadVersion.rejects(assertError)
db.data.core.testapp.updater = ''
let err = await assert.isRejected(app.update())
assert.strictEqual(err, assertError)
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.match(db.data.core.testapp.updater, /found/i)
assert.match(db.data.core.testapp.updater, new RegExp(assertVersion.version))
assert.match(db.data.core.testapp.updater, /downloading/i)
@ -261,8 +305,265 @@ t.timeout(250).describe('#update()', function() {
assert.match(db.data.core.testapp.updater, new RegExp(assertTarget.replace(/\\/g, '\\\\')))
assert.strictEqual(provider.downloadVersion.firstCall[0], assertVersion)
assert.strictEqual(provider.downloadVersion.firstCall[1], assertTarget)
assert.match(db.data.core.testapp.updater, new RegExp(assertError.message))
await fs.stat('./test/testapp/123456789')
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.ok(assertVersion.log)
assert.match(assertVersion.log, /\. \n/)
assert.match(assertVersion.log, new RegExp(assertError.message))
assert.ok(assertVersion.log.endsWith('\n'))
assert.strictEqual(assertVersion.failtodownload, 1)
assert.ok(stubFsRm.called)
assert.match(stubFsRm.firstCall[0], /123456789/)
assert.ok(stubFsRm.firstCall[1]?.recursive)
assert.ok(stubFsRm.firstCall[1]?.force)
// Test if subsequent calls increment counter
err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.strictEqual(assertVersion.failtodownload, 2)
})
t.test('should call extract on util correctly', async function() {
const assertExtractText = 'Reverdations of Success'
const assertError = new Error('Dai Gekisen')
const assertTarget = util.getPathFromRoot('./testapp/123456789/file.7z')
stubExtract.returnWith(function(target, stream) {
stream(assertExtractText)
return Promise.reject(assertError)
})
assert.strictEqual(db.data.core.testapp.versions.length, 0)
let err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(app.updating, false)
assert.strictEqual(stubExtract.firstCall[0], assertTarget)
assert.notOk(stubWrite.called)
assert.match(db.data.core.testapp.updater, new RegExp('extracting[^.]+file\.7z', 'i'))
assert.match(db.data.core.testapp.updater, new RegExp(assertError.message))
assert.ok(stubFsRm.called)
assert.match(stubFsRm.firstCall[0], /123456789/)
assert.ok(stubFsRm.firstCall[1]?.recursive)
assert.ok(stubFsRm.firstCall[1]?.force)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
let version = db.data.core.testapp.versions[0]
assert.ok(version.log)
assert.match(version.log, /\. \n/)
assert.match(version.log, new RegExp('extracting[^.]+file\.7z', 'i'))
assert.match(version.log, new RegExp(assertError.message))
assert.match(version.log, new RegExp(assertExtractText))
assert.ok(version.log.endsWith('\n'))
assert.strictEqual(version.failtodownload, 1)
// Test if subsequent calls increment counter
err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], version)
assert.strictEqual(version.failtodownload, 2)
})
t.test('should not call npm install if stat fails to find index.mjs', async function() {
const assertError = new Error('File not found')
const assertTarget = util.getPathFromRoot('./testapp/123456789/index.mjs')
stubRunCommand.rejects(new Error('should not be seen'))
stubFsStat.rejects(assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 0)
let err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.ok(stubExtract.called)
assert.strictEqual(err, assertError)
assert.strictEqual(stubFsStat.firstCall[0], assertTarget)
assert.match(db.data.core.testapp.updater, /index\.mjs/i)
assert.match(db.data.core.testapp.updater, /missing/i)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
let version = db.data.core.testapp.versions[0]
assert.ok(version.log)
assert.match(version.log, /index\.mjs/i)
assert.match(version.log, /missing/i)
assert.ok(version.log.endsWith('\n'))
assert.strictEqual(version.failtodownload, 1)
// Test if subsequent calls increment counter
err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], version)
assert.strictEqual(version.failtodownload, 2)
})
t.test('should not call npm install if package.json is missing but shuld pass', async function() {
const assertError = new Error('File not found')
const assertTarget = util.getPathFromRoot('./testapp/123456789/package.json')
stubRunCommand.rejects(new Error('should not be seen'))
stubFsStat.returnWith(function(path) {
if (path.endsWith('package.json')) {
return Promise.reject(assertError)
}
return Promise.resolve({})
})
assert.strictEqual(db.data.core.testapp.versions.length, 0)
await app.update()
assert.strictEqual(app.updating, false)
assert.strictEqual(stubFsStat.callCount, 2)
assert.strictEqual(stubFsStat.secondCall[0], assertTarget)
assert.ok(stubExtract.called)
assert.notOk(stubRunCommand.called)
assert.match(db.data.core.testapp.updater, /package\.json/i)
assert.match(db.data.core.testapp.updater, /contain/i)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
let version = db.data.core.testapp.versions[0]
assert.ok(version.log)
assert.match(version.log, /package\.json/i)
assert.match(version.log, /contain/i)
assert.ok(version.log.endsWith('\n'))
assert.ok(db.data.core.testapp.latestInstalled)
assert.match(version.log, /finished/i)
assert.match(version.log, /updating/i)
// Test if subsequent calls do nothing
provider.downloadVersion.reset()
await app.update()
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.notOk(provider.downloadVersion.called)
assert.match(db.data.core.testapp.updater, /already/i)
assert.match(db.data.core.testapp.updater, /nothing/i)
})
t.test('should otherwise call npm install correctly', async function() {
const assertExtractText = 'Egao no Hikair ni Tsutsumarete'
const assertNpmText = 'Dadadadash'
const assertVersion = { version: '123456789', link: 'somelinkhere', filename: 'test.7z' }
const assertError = new Error('Nagisa')
const assertTarget = util.getPathFromRoot('./testapp/123456789')
provider.getLatestVersion.resolves(assertVersion)
assert.strictEqual(db.data.core.testapp.versions.length, 0)
assert.notOk(stubWrite.called)
stubExtract.returnWith(function(target, stream) {
stream(assertExtractText)
return Promise.resolve()
})
stubRunCommand.returnWith(function(command, options, folder, stream) {
stream(assertNpmText)
return Promise.reject(assertError)
})
let err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(stubRunCommand.firstCall[0], 'npm.cmd')
assert.ok(stubRunCommand.firstCall[1])
assert.strictEqual(stubRunCommand.firstCall[1][0], 'install')
assert.ok(stubRunCommand.firstCall[1].includes('--production'), 'should have --production')
assert.ok(stubRunCommand.firstCall[1].includes('--no-optional'), 'should have --no-optional')
assert.ok(stubRunCommand.firstCall[1].includes('--no-package-lock'), 'should have --no-package-lock')
assert.ok(stubRunCommand.firstCall[1].includes('--no-audit'), 'should have --no-audit')
assert.strictEqual(stubRunCommand.firstCall[2], assertTarget)
assert.notOk(stubFsRm.called)
assert.match(db.data.core.testapp.updater, /npm/i)
assert.match(db.data.core.testapp.updater, /install/i)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.ok(assertVersion.log)
assert.match(assertVersion.log, /\. \n/)
assert.match(assertVersion.log, new RegExp(assertExtractText))
assert.match(assertVersion.log, new RegExp(assertNpmText))
assert.match(assertVersion.log, new RegExp(assertError.message))
assert.match(assertVersion.log, /npm/i)
assert.match(assertVersion.log, /install/i)
assert.ok(assertVersion.log.endsWith('\n'))
assert.strictEqual(assertVersion.failtoinstall, 1)
// Test if subsequent calls increment counter
err = await assert.isRejected(app.update())
assert.strictEqual(app.updating, false)
assert.strictEqual(err, assertError)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.strictEqual(assertVersion.failtoinstall, 2)
})
t.test('should update latest installed correctly', async function() {
const assertVersion = { version: '123456789', link: 'httplinkhere', filename: 'test.7z' }
provider.getLatestVersion.resolves(assertVersion)
assert.notStrictEqual(db.data.core.testapp.latestInstalled, assertVersion.version)
assert.strictEqual(db.data.core.testapp.versions.length, 0)
await app.update()
assert.strictEqual(app.updating, false)
assert.strictEqual(db.data.core.testapp.latestInstalled, assertVersion.version)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.ok(assertVersion.log)
assert.match(assertVersion.log, /found/i)
assert.match(assertVersion.log, new RegExp(assertVersion.version))
assert.match(assertVersion.log, /downloading/i)
assert.match(assertVersion.log, new RegExp('extracting[^.]+file\.7z', 'i'))
assert.match(assertVersion.log, /finished/i)
assert.match(assertVersion.log, /updating/i)
})
t.test('should update existing version if found', async function() {
const assertNewLink = 'THE last pain'
const assertNewFilename = 'The place of hope.7z'
const oldLog = 'The Smell of Sea\n'
const assertVersion = { version: '123456789', link: 'httplinkhere', filename: 'test.7z', log: oldLog }
assertVersion.id = assertVersion.version
db.upsert(db.data.core.testapp.versions, assertVersion)
provider.getLatestVersion.resolves({ version: assertVersion.version, link: assertNewLink, filename: assertNewFilename })
assert.strictEqual(db.data.core.testapp.versions.length, 1)
await app.update()
assert.strictEqual(app.updating, false)
assert.strictEqual(db.data.core.testapp.versions.length, 1)
assert.strictEqual(db.data.core.testapp.versions[0], assertVersion)
assert.ok(assertVersion.log)
assert.ok(assertVersion.log.startsWith(oldLog))
assert.match(assertVersion.log, /found/i)
assert.match(assertVersion.log, new RegExp(assertVersion.version))
assert.match(assertVersion.log, /downloading/i)
assert.match(assertVersion.log, new RegExp('extracting[^.]+file\.7z', 'i'))
assert.match(assertVersion.log, /finished/i)
assert.match(assertVersion.log, /updating/i)
})
t.test('should do nothing if latestInstalled matches version', async function() {
@ -274,8 +575,44 @@ t.timeout(250).describe('#update()', function() {
db.data.core.testapp.latestInstalled = assertVersion.version
await app.update()
assert.strictEqual(app.updating, false)
assert.notOk(provider.downloadVersion.called)
assert.match(db.data.core.testapp.updater, /already/i)
assert.match(db.data.core.testapp.updater, /nothing/i)
})
t.test('should do nothing it exists and failtodownload is higher than 3', async function() {
const assertError = new Error('should not be seen')
const assertVersion = { version: '999.888.777.666', filename: 'test.7z' }
provider.getLatestVersion.resolves(assertVersion)
provider.downloadVersion.rejects(assertError)
db.data.core.testapp.updater = ''
db.upsert(db.data.core.testapp.versions, { id: '999.888.777.666', version: '999.888.777.666', link: 'httplinkhere', filename: 'test.7z', failtodownload: 4 })
await app.update()
assert.strictEqual(app.updating, false)
assert.notOk(provider.downloadVersion.called)
assert.match(db.data.core.testapp.updater, /many/i)
assert.match(db.data.core.testapp.updater, /fail/i)
assert.match(db.data.core.testapp.updater, /skip/i)
})
t.test('should do nothing it exists and failtoinstall is higher than 3', async function() {
const assertError = new Error('should not be seen')
const assertVersion = { version: '999.888.777.666', filename: 'test.7z' }
provider.getLatestVersion.resolves(assertVersion)
provider.downloadVersion.rejects(assertError)
db.data.core.testapp.updater = ''
db.upsert(db.data.core.testapp.versions, { id: '999.888.777.666', version: '999.888.777.666', link: 'httplinkhere', filename: 'test.7z', failtoinstall: 4 })
await app.update()
assert.strictEqual(app.updating, false)
assert.notOk(provider.downloadVersion.called)
assert.match(db.data.core.testapp.updater, /many/i)
assert.match(db.data.core.testapp.updater, /fail/i)
assert.match(db.data.core.testapp.updater, /skip/i)
})
})

14
test/db.test.mjs
View File

@ -271,3 +271,17 @@ t.test('should have basic database-like functions with string-like name of colle
assert.strictEqual(dbSec.data.myarr.length, 1)
assert.strictEqual(dbSec.get('myarr', assertItem1.id), null)
})
t.test('#upsert() should work properly', async function() {
let db = await lowdb({}, logger, null)
db.data.test = {
items: []
}
db.upsert(db.data.test.items, { id: '1234', text: '1' })
db.upsert(db.data.test.items, { id: '1234', text: '2' })
assert.strictEqual(db.data.test.items.length, 1)
assert.strictEqual(db.data.test.items[0].id, '1234')
assert.strictEqual(db.data.test.items[0].text, '2')
})

1
test/providers/git.integration.test.mjs
View File

@ -15,6 +15,7 @@ t.timeout(5000).describe('Git integration', function() {
let version = await provider.getLatestVersion()
assert.ok(version)
assert.ok(version.version)
assert.ok(version.description)
assert.ok(version.link)
assert.match(version.link, /\/attachments\//)
})

5
test/util.test.mjs
View File

@ -233,6 +233,9 @@ t.describe('#extractFile()', function() {
t.test('should stream the process of extracting', async function() {
let output = ''
await util.extractFile(util.getPathFromRoot('./testapp/example.tar.gz'), function(msg) { output += msg + '\n' })
console.log(output)
assert.match(output, /Extracting archive\:.+example.tar.gz/)
assert.match(output, /1 file, 123 bytes/)
assert.strictEqual(output.indexOf('\r\n'), -1)
})
})