fix the backup tests

src/test/backuptask-test.js

@@ -0,0 +1,151 @@
+/* jslint node:true */
+/* global it:false */
+/* global describe:false */
+/* global before:false */
+/* global after:false */
+
+'use strict';
+
+const backups = require('../backups.js'),
+    backuptask = require('../backuptask.js'),
+    common = require('./common.js'),
+    DataLayout = require('../datalayout.js'),
+    delay = require('delay'),
+    expect = require('expect.js'),
+    fs = require('fs'),
+    os = require('os'),
+    path = require('path'),
+    safe = require('safetydance'),
+    settings = require('../settings.js'),
+    tasks = require('../tasks.js');
+
+describe('backuptask', function () {
+    const { setup, cleanup, createTree } = common;
+
+    before(setup);
+    after(cleanup);
+
+    describe('fs meta data', function () {
+        let tmpdir;
+        before(function () {
+            tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'backups-test'));
+        });
+        after(function () {
+            fs.rmSync(tmpdir, { recursive: true, force: true });
+        });
+
+        it('saves special files', async function () {
+            createTree(tmpdir, { 'data': { 'subdir': { 'emptydir': { } } }, 'dir2': { 'file': 'stuff' } });
+            fs.chmodSync(path.join(tmpdir, 'dir2/file'), parseInt('0755', 8));
+
+            let dataLayout = new DataLayout(tmpdir, []);
+
+            await backuptask._saveFsMetadata(dataLayout, `${dataLayout.localRoot()}/fsmetadata.json`);
+
+            const emptyDirs = JSON.parse(fs.readFileSync(path.join(tmpdir, 'fsmetadata.json'), 'utf8')).emptyDirs;
+            expect(emptyDirs).to.eql(['./data/subdir/emptydir']);
+
+            const execFiles = JSON.parse(fs.readFileSync(path.join(tmpdir, 'fsmetadata.json'), 'utf8')).execFiles;
+            expect(execFiles).to.eql(['./dir2/file']);
+        });
+
+        it('restores special files', async function () {
+            fs.rmSync(path.join(tmpdir, 'data'), { recursive: true, force: true });
+
+            expect(fs.existsSync(path.join(tmpdir, 'data/subdir/emptydir'))).to.be(false); // just make sure rimraf worked
+
+            let dataLayout = new DataLayout(tmpdir, []);
+
+            await backuptask._restoreFsMetadata(dataLayout, `${dataLayout.localRoot()}/fsmetadata.json`);
+
+            expect(fs.existsSync(path.join(tmpdir, 'data/subdir/emptydir'))).to.be(true);
+            const mode = fs.statSync(path.join(tmpdir, 'dir2/file')).mode;
+            expect(mode & ~fs.constants.S_IFREG).to.be(parseInt('0755', 8));
+        });
+    });
+
+
+    describe('backupBoxAndApps', function () {
+        let backupInfo1;
+
+        const backupConfig = {
+            provider: 'filesystem',
+            backupFolder: path.join(os.tmpdir(), 'backupstask-test-filesystem'),
+            format: 'tgz',
+            retentionPolicy: { keepWithinSecs: 10000 },
+            schedulePattern: '00 00 23 * * *'
+        };
+
+        before(function (done) {
+            fs.rmSync(backupConfig.backupFolder,  { recursive: true, force: true });
+
+            settings.setBackupConfig(backupConfig, done);
+        });
+
+        after(function () {
+            fs.rmSync(backupConfig.backupFolder,  { recursive: true, force: true });
+        });
+
+        function createBackup(callback) {
+            backups.startBackupTask({ username: 'test' }, async function (error, taskId) { // this call does not wait for the backup!
+                if (error) return callback(error);
+
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    await delay(1000);
+
+                    const p = await tasks.get(taskId);
+
+                    if (p.percent !== 100) continue;
+                    if (p.error) return callback(new Error(`backup failed: ${p.error.message}`));
+                    if (!p.result) return callback(new Error('backup has no result:' + p));
+
+                    const [error, result] = await safe(backups.getByIdentifierAndStatePaged(backups.BACKUP_IDENTIFIER_BOX, backups.BACKUP_STATE_NORMAL, 1, 1));
+
+                    if (error) return callback(error);
+                    if (result.length !== 1) return callback(new Error('result is not of length 1'));
+
+                    // the task progress and the db entry is set in the worker. wait for 2 seconds for backup lock to get released in parent process
+                    await delay(2000);
+
+                    callback(null, result[0]);
+                }
+            });
+        }
+
+        it('can backup', function (done) {
+            // arch only has maria db which lacks some mysqldump options we need, this is only here to allow running the tests :-/
+            if (require('child_process').execSync('/usr/bin/mysqldump --version').toString().indexOf('MariaDB') !== -1) {
+                console.log('test skipped because of MariaDB');
+                return done();
+            }
+
+            createBackup(function (error, result) {
+                expect(error).to.be(null);
+                expect(fs.statSync(path.join(backupConfig.backupFolder, 'snapshot/box.tar.gz')).nlink).to.be(2); // hard linked to a rotated backup
+                expect(fs.statSync(path.join(backupConfig.backupFolder, `${result.id}.tar.gz`)).nlink).to.be(2);
+
+                backupInfo1 = result;
+
+                done();
+            });
+        });
+
+        it('can take another backup', function (done) {
+            // arch only has maria db which lacks some mysqldump options we need, this is only here to allow running the tests :-/
+            if (require('child_process').execSync('/usr/bin/mysqldump --version').toString().indexOf('MariaDB') !== -1) {
+                console.log('test skipped because of MariaDB');
+                return done();
+            }
+
+            createBackup(function (error, result) {
+                expect(error).to.be(null);
+                expect(fs.statSync(path.join(backupConfig.backupFolder, 'snapshot/box.tar.gz')).nlink).to.be(2); // hard linked to a rotated backup
+                expect(fs.statSync(path.join(backupConfig.backupFolder, `${result.id}.tar.gz`)).nlink).to.be(2); // hard linked to new backup
+                expect(fs.statSync(path.join(backupConfig.backupFolder, `${backupInfo1.id}.tar.gz`)).nlink).to.be(1); // not hard linked anymore
+
+                done();
+            });
+        });
+    });
+});