cloudron-box/src/test/apptask-test.js

/* global it:false */
/* global describe:false */
/* global before:false */
/* global after:false */

'use strict';

var appdb = require('../appdb.js'),
    apps = require('../apps.js'),
    apptask = require('../apptask.js'),
    async = require('async'),
    blobs = require('../blobs.js'),
    database = require('../database.js'),
    domains = require('../domains.js'),
    expect = require('expect.js'),
    fs = require('fs'),
    paths = require('../paths.js'),
    settings = require('../settings.js'),
    userdb = require('../userdb.js'),
    _ = require('underscore');

var MANIFEST = {
    'id': 'io.cloudron.test',
    'author': 'The Presidents Of the United States Of America',
    'title': 'test title',
    'description': 'test description',
    'tagline': 'test rocks',
    'website': 'http://test.cloudron.io',
    'contactEmail': 'test@cloudron.io',
    'version': '0.1.0',
    'manifestVersion': 1,
    'dockerImage': 'cloudron/test:25.2.0',
    'healthCheckPath': '/',
    'httpPort': 7777,
    'tcpPorts': {
        'ECHO_SERVER_PORT': {
            'title': 'Echo Server Port',
            'description': 'Echo server',
            'containerPort': 7778
        }
    },
    'addons': {
        'oauth': { },
        'redis': { },
        'mysql': { },
        'postgresql': { }
    }
};

const DOMAIN_0 = {
    domain: 'example.com',
    zoneName: 'example.com',
    provider: 'route53',
    config: {
        accessKeyId: 'accessKeyId',
        secretAccessKey: 'secretAccessKey',
        endpoint: 'http://localhost:5353'
    },
    fallbackCertificate: null,
    tlsConfig: { provider: 'letsencrypt-staging' },
    wellKnown: null
};

let AUDIT_SOURCE = { ip: '1.2.3.4' };

var ADMIN = {
    id: 'admin123',
    username: 'admin123',
    password: 'secret',
    email: 'admin@me.com',
    fallbackEmail: 'admin@me.com',
    salt: 'morton',
    createdAt: 'sometime back',
    resetToken: '',
    displayName: '',
    role: 'owner',
    source: ''
};

var APP = {
    id: 'appid',
    appStoreId: 'appStoreId',
    installationState: apps.ISTATE_PENDING_INSTALL,
    runState: 'running',
    location: 'applocation',
    domain: DOMAIN_0.domain,
    fqdn: DOMAIN_0.domain + '.' + 'applocation',
    manifest: MANIFEST,
    containerId: 'someid',
    portBindings: null,
    accessRestriction: null,
    memoryLimit: 0,
    mailboxDomain: DOMAIN_0.domain,
    alternateDomains: [],
    aliasDomains: []
};

describe('apptask', function () {
    before(function (done) {
        async.series([
            database.initialize,
            database._clear,
            blobs.initSecrets,
            settings.setDashboardLocation.bind(null, DOMAIN_0.domain, 'my.' + DOMAIN_0.domain),
            domains.add.bind(null, DOMAIN_0.domain, DOMAIN_0, AUDIT_SOURCE),
            userdb.add.bind(null, ADMIN.id, ADMIN),
            appdb.add.bind(null, APP.id, APP.appStoreId, APP.manifest, APP.location, APP.domain, APP.portBindings, APP)
        ], done);
    });

    after(function (done) {
        async.series([
            database._clear,
            database.uninitialize
        ], done);
    });

    it('configure nginx correctly', function (done) {
        apptask._configureReverseProxy(APP, function (error) {
            expect(fs.existsSync(paths.NGINX_APPCONFIG_DIR + '/' + APP.id + '.conf'));
            expect(error).to.be(null);
            done();
        });
    });

    it('unconfigure nginx', function (done) {
        apptask._unconfigureReverseProxy(APP, function (error) {
            expect(!fs.existsSync(paths.NGINX_APPCONFIG_DIR + '/' + APP.id + '.conf'));
            expect(error).to.be(null);
            done();
        });
    });

    it('create volume', function (done) {
        apptask._createAppDir(APP, function (error) {
            expect(fs.existsSync(paths.APPS_DATA_DIR + '/' + APP.id)).to.be(true);
            expect(fs.existsSync(paths.APPS_DATA_DIR + '/' + APP.id + '/data')).to.be(false);
            expect(error).to.be(null);
            done();
        });
    });

    it('delete volume - removeDirectory (false) ', function (done) {
        apptask._deleteAppDir(APP, { removeDirectory: false }, function (error) {
            expect(fs.existsSync(paths.APPS_DATA_DIR + '/' + APP.id)).to.be(true);
            expect(fs.readdirSync(paths.APPS_DATA_DIR + '/' + APP.id).length).to.be(0); // empty
            expect(error).to.be(null);
            done();
        });
    });

    it('delete volume - removeDirectory (true) ', function (done) {
        apptask._deleteAppDir(APP, { removeDirectory: true }, function (error) {
            expect(!fs.existsSync(paths.APPS_DATA_DIR + '/' + APP.id)).to.be(true);
            expect(error).to.be(null);
            done();
        });
    });

    it('barfs on empty manifest', function (done) {
        var badApp = _.extend({ }, APP);
        badApp.manifest = { };

        apptask._verifyManifest(badApp.manifest, function (error) {
            expect(error).to.be.ok();
            done();
        });
    });

    it('fails on bad manifest', function (done) {
        var badApp = _.extend({ }, APP);
        badApp.manifest = _.extend({ }, APP.manifest);
        delete badApp.manifest.httpPort;

        apptask._verifyManifest(badApp.manifest, function (error) {
            expect(error).to.be.ok();
            done();
        });
    });

    it('barfs on incompatible manifest', function (done) {
        var badApp = _.extend({ }, APP);
        badApp.manifest = _.extend({ }, APP.manifest);
        badApp.manifest.maxBoxVersion = '0.0.0'; // max box version is too small

        apptask._verifyManifest(badApp.manifest, function (error) {
            expect(error).to.be.ok();
            done();
        });
    });

    it('verifies manifest', function (done) {
        var goodApp = _.extend({ }, APP);

        apptask._verifyManifest(goodApp.manifest, function (error) {
            expect(error).to.be(null);
            done();
        });
    });
});