cloudron-box/src/routes/test/backuptargets-test.js

/* global it, describe, before, after */

'use strict';

const backupTargets = require('../../backuptargets.js'),
    common = require('./common.js'),
    expect = require('expect.js'),
    superagent = require('@cloudron/superagent');

describe('Backups API', function () {
    const { setup, cleanup, waitForTask, serverUrl, owner, admin, getDefaultBackupTarget } = common;

    before(setup);
    after(cleanup);

    const newTarget = {
        provider: 'filesystem',
        label: 'NewTarget',
        config: { backupFolder: '/tmp/boxtest-newtarget' },
        format: 'tgz',
        retention: { keepWithinSecs: 60 * 60 },
        schedule:  '00 01 * * * *'
    };

    const encryptedTarget = {
        provider: 'filesystem',
        label: 'EncryptedTarget',
        config: { backupFolder: '/tmp/boxtest-enctarget' },
        format: 'rsync',
        retention: { keepMonthly: 60 },
        schedule:  '* 1 * * * *',
    };

    describe('add', function () {
        it('fails as admin', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets`)
                .query({ access_token: admin.token })
                .send(newTarget)
                .ok(() => true);

            expect(response.status).to.equal(403);
        });

        it('succeeds as owner', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets`)
                .query({ access_token: owner.token })
                .send(newTarget)
                .ok(() => true);

            expect(response.status).to.equal(200);
            newTarget.id = response.body.id;
        });

        it('succeeds with password', async function () {
            const tmp = Object.assign({}, encryptedTarget, { encryptionPassword: 'deutsch-a1', encryptedFilenames: true });

            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets`)
                .query({ access_token: owner.token })
                .send(tmp)
                .ok(() => true);

            expect(response.status).to.equal(200);
            encryptedTarget.id = response.body.id;
        });
    });

    describe('list', function () {
        it('succeeds as admin', async function () {
            const response = await superagent.get(`${serverUrl}/api/v1/backup_targets`)
                .query({ access_token: admin.token });
            expect(response.status).to.equal(200);
            expect(response.body.backupTargets.length).to.be(3);
            const tmp = response.body.backupTargets.find(t => t.id === newTarget.id);
            expect(tmp.provider).to.be(newTarget.provider);
            expect(tmp.config).to.be.ok();
            expect(tmp.format).to.be(newTarget.format);
            expect(tmp.label).to.be(newTarget.label);
            expect(tmp.primary).to.be(false);
        });
    });

    describe('get', function () {
        it('succeeds as admin', async function () {
            const response = await superagent.get(`${serverUrl}/api/v1/backup_targets/${newTarget.id}`)
                .query({ access_token: admin.token });
            expect(response.status).to.equal(200);
            expect(response.body.provider).to.be(newTarget.provider);
            expect(response.body.config).to.be.ok();
            expect(response.body.format).to.be(newTarget.format);
            expect(response.body.label).to.be(newTarget.label);
            expect(response.body.primary).to.be(false);
        });

        it('succeeds as admin (encrypted)', async function () {
            const response = await superagent.get(`${serverUrl}/api/v1/backup_targets/${encryptedTarget.id}`)
                .query({ access_token: admin.token });
            expect(response.status).to.equal(200);
            expect(response.body.provider).to.be(encryptedTarget.provider);
            expect(response.body.config).to.be.ok();
            expect(response.body.format).to.be(encryptedTarget.format);
            expect(response.body.label).to.be(encryptedTarget.label);
            expect(response.body.primary).to.be(false);
            expect(response.body.encrypted).to.be(true);
            expect(response.body.encryptedFilenames).to.be(true);
        });
    });

    describe('schedule', function () {
        it('cannot set without schedule', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/schedule`)
                .query({ access_token: owner.token })
                .send({})
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('cannot set invalid schedule', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/schedule`)
                .query({ access_token: owner.token })
                .send({ schedule: 'whatever' })
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('can set "never" schedule', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/schedule`)
                .query({ access_token: owner.token })
                .send({ schedule: 'never' })
                .ok(() => true);

            expect(response.status).to.equal(200);

            const result = await backupTargets.get(newTarget.id);
            expect(result.schedule).to.be('never');
        });

        it('can set valid schedule', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/schedule`)
                .query({ access_token: owner.token })
                .send({ schedule: '00 00 3 * * *' })
                .ok(() => true);

            expect(response.status).to.equal(200);
            const result = await backupTargets.get(newTarget.id);
            expect(result.schedule).to.be('00 00 3 * * *');
        });
    });

    describe('retention', function () {
        it('cannot set without retention', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/retention`)
                .query({ access_token: owner.token })
                .send({})
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('cannot set invalid retention', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/retention`)
                .query({ access_token: owner.token })
                .send({ retention: 'whatever' })
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('cannot set backup_policy with retention with invalid keepWithinSecs', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/retention`)
                .query({ access_token: owner.token })
                .send({ retention: { keepWithinSecs: 'not a number' } })
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('can set valid retention', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/retention`)
                .query({ access_token: owner.token })
                .send({ retention: { keepWithinSecs: 2 * 24 * 60 * 60 } })
                .ok(() => true);

            expect(response.status).to.equal(200);
            const result = await backupTargets.get(newTarget.id);
            expect(result.retention).to.eql({ keepWithinSecs: 2 * 24 * 60 * 60 });
        });
    });

    describe('limits', function () {
        it('cannot set invalid limits', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/limits`)
                .query({ access_token: owner.token })
                .send({ limits: 2 })
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('can set valid limits', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/limits`)
                .query({ access_token: owner.token })
                .send({ limits: { syncConcurrency: 34 } })
                .ok(() => true);

            expect(response.status).to.equal(200);
            const result = await backupTargets.get(newTarget.id);
            expect(result.limits).to.eql({ syncConcurrency: 34 });
        });
    });

    describe('primary', function () {
        it('cannot set invalid id', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}xx/configure/primary`)
                .query({ access_token: owner.token })
                .send({})
                .ok(() => true);

            expect(response.status).to.equal(404);
        });

        it('can set valid primary', async function () {
            const oldDefault = await getDefaultBackupTarget();

            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/primary`)
                .query({ access_token: owner.token })
                .send({})
                .ok(() => true);

            expect(response.status).to.equal(200);
            const result = await backupTargets.get(newTarget.id);
            expect(result.primary).to.be(true);

            const result2 = await backupTargets.get(oldDefault.id);
            expect(result2.primary).to.be(false);
        });
    });

    // at this point , newTarget is the primary and the default one is not
    describe('del', function () {
        it('cannot delete invalid id', async function () {
            const response = await superagent.del(`${serverUrl}/api/v1/backup_targets/${newTarget.id}xx`)
                .query({ access_token: owner.token })
                .ok(() => true);

            expect(response.status).to.equal(404);
        });

        it('cannot delete primary', async function () {
            const response = await superagent.del(`${serverUrl}/api/v1/backup_targets/${newTarget.id}`)
                .query({ access_token: owner.token })
                .ok(() => true);

            expect(response.status).to.equal(409);
        });

        it('can delete non-primary', async function () {
            const result2 = (await backupTargets.list(1, 10)).pop();
            const response = await superagent.del(`${serverUrl}/api/v1/backup_targets/${result2.id}`)
                .query({ access_token: owner.token })
                .ok(() => true);

            expect(response.status).to.equal(204);
        });
    });

    describe('config', function () {
        const someConfig = {
            backupFolder: '/tmp/boxtest-someconfig',
        };

        it('cannot set invalid config', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/config`)
                .query({ access_token: owner.token })
                .send({ config: 32 })
                .ok(() => true);

            expect(response.status).to.equal(400);
        });

        it('can set valid config', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/configure/config`)
                .query({ access_token: owner.token })
                .send({ config: someConfig })
                .ok(() => true);

            expect(response.status).to.equal(200);
            const result = await backupTargets.get(newTarget.id);
            expect(result.config.backupFolder).to.be(someConfig.backupFolder);
        });
    });

    describe('mounting', function () {
        it('mount status', async function () {
            const response = await superagent.get(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/mount_status`)
                .query({ access_token: owner.token });
            expect(response.status).to.equal(200);
            expect(response.body.state).to.be('active');
            expect(response.body.message).to.be('Mounted');
        });

        it('remount', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/remount`)
                .query({ access_token: owner.token })
                .send({});
            expect(response.status).to.equal(202);
        });
    });

    describe('create', function () {
        it('succeeds', async function () {
            const response = await superagent.post(`${serverUrl}/api/v1/backup_targets/${newTarget.id}/create_backup`)
                .query({ access_token: admin.token });
            expect(response.status).to.equal(202);
            expect(response.body.taskId).to.be.a('string');
            await waitForTask(response.body.taskId);
        });
    });
});