add tests for storage backends

src/test/backups-test.js

@@ -15,9 +15,80 @@ var async = require('async'),
     expect = require('expect.js'),
     fs = require('fs'),
     os = require('os'),
+    mkdirp = require('mkdirp'),
+    readdirp = require('readdirp'),
     path = require('path'),
+    progress = require('../progress.js'),
     rimraf = require('rimraf'),
-    settings = require('../settings.js');
+    settings = require('../settings.js'),
+    SettingsError = require('../settings.js').SettingsError;
+
+function compareDirectories(one, two, callback) {
+    readdirp({ root: one }, function (error, treeOne) {
+        if (error) return callback(error);
+
+        readdirp({ root: two }, function (error, treeTwo) {
+            if (error) return callback(error);
+
+            var mismatch = [];
+
+            function compareDirs(a, b) {
+                a.forEach(function (tmpA) {
+                    var found = b.find(function (tmpB) {
+                        return tmpA.path === tmpB.path;
+                    });
+
+                    if (!found) mismatch.push(tmpA);
+                });
+            }
+
+            function compareFiles(a, b) {
+                a.forEach(function (tmpA) {
+                    var found = b.find(function (tmpB) {
+                        // TODO check file or symbolic link
+                        return tmpA.path === tmpB.path && tmpA.mode === tmpB.mode;
+                    });
+
+                    if (!found) mismatch.push(tmpA);
+                });
+            }
+
+            compareDirs(treeOne.directories, treeTwo.directories);
+            compareDirs(treeTwo.directories, treeOne.directories);
+            compareFiles(treeOne.files, treeTwo.files);
+            compareFiles(treeTwo.files, treeOne.files);
+
+            if (mismatch.length) {
+                console.error('Files not found in both: %j', mismatch);
+                return callback(new Error('file mismatch'));
+            }
+
+            callback(null);
+        });
+    });
+}
+
+function createBackup(callback) {
+    backups.backup({ username: 'test' }, function (error) { // this call does not wait for the backup!
+        if (error) return callback(error);
+
+        function waitForBackup() {
+            var p = progress.getAll();
+            if (p.backup.percent !== 100) return setTimeout(waitForBackup, 1000);
+
+            if (p.backup.message) return callback(new Error('backup failed:' + p.backup.message));
+
+            backups.getByStatePaged(backupdb.BACKUP_STATE_NORMAL, 1, 1, function (error, result) {
+                if (error) return callback(error);
+                if (result.length !== 1) return callback(new Error('result is not of length 1'));
+
+                callback(null, result[0]);
+            });
+        }
+
+        setTimeout(waitForBackup, 1000);
+    });
+}
 
 describe('backups', function () {
     before(function (done) {
@@ -209,4 +280,72 @@ describe('backups', function () {
             });
         });
     });
+
+    describe('filesystem', function () {
+        var backupInfo1;
+
+        var gBackupConfig = {
+            provider: 'filesystem',
+            backupFolder: path.join(os.tmpdir(), 'backups-test-filesystem'),
+            format: 'tgz'
+        };
+
+        before(function (done) {
+            rimraf.sync(gBackupConfig.backupFolder);
+
+            done();
+        });
+
+        after(function (done) {
+            rimraf.sync(gBackupConfig.backupFolder);
+            progress.clear(progress.BACKUP);
+            done();
+        });
+
+        it('fails to set backup config for non-existing folder', function (done) {
+            settings.setBackupConfig(gBackupConfig, function (error) {
+                expect(error).to.be.a(SettingsError);
+                expect(error.reason).to.equal(SettingsError.BAD_FIELD);
+
+                done();
+            });
+        });
+
+        it('succeeds to set backup config', function (done) {
+            mkdirp.sync(gBackupConfig.backupFolder);
+
+            settings.setBackupConfig(gBackupConfig, function (error) {
+                expect(error).to.be(null);
+
+                done();
+            });
+        });
+
+        it('can backup', function (done) {
+            this.timeout(6000);
+
+            createBackup(function (error, result) {
+                expect(error).to.be(null);
+                expect(fs.statSync(path.join(gBackupConfig.backupFolder, 'snapshot/box.tar.gz')).nlink).to.be(2); // hard linked to a rotated backup
+                expect(fs.statSync(path.join(gBackupConfig.backupFolder, `${result.id}.tar.gz`)).nlink).to.be(2);
+
+                backupInfo1 = result;
+
+                done();
+            });
+        });
+
+        it('can take another backup', function (done) {
+            this.timeout(6000);
+
+            createBackup(function (error, result) {
+                expect(error).to.be(null);
+                expect(fs.statSync(path.join(gBackupConfig.backupFolder, 'snapshot/box.tar.gz')).nlink).to.be(2); // hard linked to a rotated backup
+                expect(fs.statSync(path.join(gBackupConfig.backupFolder, `${result.id}.tar.gz`)).nlink).to.be(2); // hard linked to new backup
+                expect(fs.statSync(path.join(gBackupConfig.backupFolder, `${backupInfo1.id}.tar.gz`)).nlink).to.be(1); // not hard linked anymore
+
+                done();
+            });
+        });
+    });
 });