diff --git a/src/routes/test/branding-test.js b/src/routes/test/branding-test.js
index b8cb601f2..5ab6ce688 100644
--- a/src/routes/test/branding-test.js
+++ b/src/routes/test/branding-test.js
@@ -5,234 +5,165 @@
 /* global before:false */
 /* global after:false */
 
-var async = require('async'),
-    constants = require('../../constants.js'),
-    database = require('../../database.js'),
+const common = require('./common.js'),
     expect = require('expect.js'),
     fs = require('fs'),
     paths = require('../../paths.js'),
-    server = require('../../server.js'),
     superagent = require('superagent');
 
-var SERVER_URL = 'http://localhost:' + constants.PORT;
-
-var USERNAME = 'superadmin', PASSWORD = 'Foobar?1337', EMAIL ='silly@me.com';
-var token = null;
-
-function setup(done) {
-    async.series([
-        server.start.bind(null),
-        database._clear.bind(null),
-
-        function createAdmin(callback) {
-            superagent.post(SERVER_URL + '/api/v1/cloudron/activate')
-                .query({ setupToken: 'somesetuptoken' })
-                .send({ username: USERNAME, password: PASSWORD, email: EMAIL })
-                .end(function (error, result) {
-                    expect(result).to.be.ok();
-                    expect(result.statusCode).to.eql(201);
-
-                    // stash token for further use
-                    token = result.body.token;
-
-                    callback();
-                });
-        }
-    ], done);
-}
-
-function cleanup(done) {
-    database._clear(function (error) {
-        expect(!error).to.be.ok();
-
-        server.stop(done);
-    });
-}
-
 describe('Branding API', function () {
+    const { setup, cleanup, serverUrl, owner } = common;
+
     before(setup);
     after(cleanup);
 
     describe('cloudron_name', function () {
-        var name = 'foobar';
+        let name = 'foobar';
 
-        it('get default succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/cloudron_name')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.name).to.be.ok();
-                    done();
-                });
+        it('get default succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/cloudron_name`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.name).to.be.ok();
         });
 
-        it('cannot set without name', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/cloudron_name')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+        it('cannot set without name', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/cloudron_name`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set empty name', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/cloudron_name')
-                .query({ access_token: token })
+        it('cannot set empty name', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/cloudron_name`)
+                .query({ access_token: owner.token })
                 .send({ name: '' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('set succeeds', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/cloudron_name')
-                .query({ access_token: token })
-                .send({ name: name })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
-                    done();
-                });
+        it('set succeeds', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/cloudron_name`)
+                .query({ access_token: owner.token })
+                .send({ name: name });
+
+            expect(response.statusCode).to.equal(202);
         });
 
-        it('get succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/cloudron_name')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.name).to.eql(name);
-                    done();
-                });
+        it('get succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/cloudron_name`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.name).to.eql(name);
         });
     });
 
     describe('cloudron_avatar', function () {
-        it('get default succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/cloudron_avatar')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body).to.be.a(Buffer);
-                    done();
-                });
+        it('get default succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/cloudron_avatar`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body).to.be.a(Buffer);
         });
 
-        it('cannot set without data', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/cloudron_avatar')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+        it('cannot set without data', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/cloudron_avatar`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('set succeeds', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/cloudron_avatar')
-                .query({ access_token: token })
-                .attach('avatar', paths.CLOUDRON_DEFAULT_AVATAR_FILE)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
-                    done();
-                });
+        it('set succeeds', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/cloudron_avatar`)
+                .query({ access_token: owner.token })
+                .attach('avatar', paths.CLOUDRON_DEFAULT_AVATAR_FILE);
+
+            expect(response.statusCode).to.equal(202);
         });
 
-        it('get succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/cloudron_avatar')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.toString()).to.eql(fs.readFileSync(paths.CLOUDRON_DEFAULT_AVATAR_FILE, 'utf-8'));
-                    done(err);
-                });
+        it('get succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/cloudron_avatar`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.toString()).to.eql(fs.readFileSync(paths.CLOUDRON_DEFAULT_AVATAR_FILE, 'utf-8'));
         });
     });
 
     describe('appstore listing config', function () {
-        it('get default succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.whitelist).to.eql(null);
-                    expect(res.body.blacklist).to.eql([]);
+        it('get default succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token });
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.whitelist).to.eql(null);
+            expect(response.body.blacklist).to.eql([]);
         });
 
-        it('cannot set with no bl or wl', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+        it('cannot set with no bl or wl', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set bad bl', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
+        it('cannot set bad bl', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token })
                 .send({ blacklist: [ 1 ] })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set bad wl', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
+        it('cannot set bad wl', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token })
                 .send({ whitelist: 4 })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('set bl succeeds', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .send({ blacklist: [ 'id1', 'id2' ] })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
-                    done();
-                });
+        it('set bl succeeds', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token })
+                .send({ blacklist: [ 'id1', 'id2' ] });
+
+            expect(response.statusCode).to.equal(202);
         });
 
-        it('get bl succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.blacklist).to.eql([ 'id1', 'id2' ]);
-                    expect(res.body.whitelist).to.be(undefined);
+        it('get bl succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token });
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.blacklist).to.eql([ 'id1', 'id2' ]);
+            expect(response.body.whitelist).to.be(undefined);
         });
 
-        it('set wl succeeds', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .send({ whitelist: [ 'id1', 'id2' ] })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
-                    done();
-                });
+        it('set wl succeeds', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token })
+                .send({ whitelist: [ 'id1', 'id2' ] });
+
+            expect(response.statusCode).to.equal(202);
         });
 
-        it('get wl succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/branding/appstore_listing_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.whitelist).to.eql([ 'id1', 'id2' ]);
-                    expect(res.body.blacklist).to.be(undefined);
+        it('get wl succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/branding/appstore_listing_config`)
+                .query({ access_token: owner.token });
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.whitelist).to.eql([ 'id1', 'id2' ]);
+            expect(response.body.blacklist).to.be(undefined);
         });
-
     });
-
 });
diff --git a/src/routes/test/common.js b/src/routes/test/common.js
index af5795b17..76e032ce8 100644
--- a/src/routes/test/common.js
+++ b/src/routes/test/common.js
@@ -5,9 +5,12 @@ const async = require('async'),
     database = require('../../database.js'),
     delay = require('delay'),
     expect = require('expect.js'),
+    fs = require('fs'),
     mailer = require('../../mailer.js'),
+    safe = require('safetydance'),
     server = require('../../server.js'),
     settings = require('../../settings.js'),
+    support = require('../../support.js'),
     superagent = require('superagent'),
     tokens = require('../../tokens.js');
 
@@ -33,9 +36,10 @@ exports = module.exports = {
         token: null
     },
 
-    MOCK_API_SERVER_ORIGIN: 'http://localhost:6060',
+    mockApiServerOrigin: 'http://localhost:6060',
     dashboardDomain: 'test.example.com',
     dashboardFqdn: 'my.test.example.com',
+    appstoreToken: 'toktok',
 
     serverUrl: `http://localhost:${constants.PORT}`,
 };
@@ -47,7 +51,11 @@ function setup(done) {
         server.start.bind(null),
         database._clear.bind(null),
 
-        settings._setApiServerOrigin.bind(null, exports.MOCK_API_SERVER_ORIGIN),
+        async () => await safe(fs.promises.unlink(support._sshInfo().filePath)),
+
+        settings._setApiServerOrigin.bind(null, exports.mockApiServerOrigin),
+
+        settings.setCloudronToken.bind(null, exports.appstoreToken),
 
         function setup(callback) {
             superagent.post(`${serverUrl}/api/v1/cloudron/setup`)
diff --git a/src/routes/test/domains-test.js b/src/routes/test/domains-test.js
index 079f4db24..8c235199c 100644
--- a/src/routes/test/domains-test.js
+++ b/src/routes/test/domains-test.js
@@ -5,27 +5,17 @@
 /* global before:false */
 /* global after:false */
 
-var async = require('async'),
-    child_process = require('child_process'),
-    constants = require('../../constants.js'),
-    database = require('../../database.js'),
-    domaindb = require('../../domaindb.js'),
+const child_process = require('child_process'),
+    common = require('./common.js'),
     expect = require('expect.js'),
     fs = require('fs'),
     path = require('path'),
     paths = require('../../paths.js'),
-    superagent = require('superagent'),
-    server = require('../../server.js'),
-    _ = require('underscore');
+    superagent = require('superagent');
 
-var SERVER_URL = 'http://localhost:' + constants.PORT;
-
-var USERNAME = 'superadmin', PASSWORD = 'Foobar?1337', EMAIL ='silly@me.com';
-var token = null;
-
-var DOMAIN_0 = {
-    domain: 'cloudron.com',
-    zoneName: 'cloudron.com',
+const DOMAIN_0 = {
+    domain: 'domain0.com',
+    zoneName: 'domain0.com',
     provider: 'noop',
     config: { },
     tlsConfig: {
@@ -33,8 +23,8 @@ var DOMAIN_0 = {
     }
 };
 
-var DOMAIN_1 = {
-    domain: 'foobar.com',
+const DOMAIN_1 = {
+    domain: 'domain1.com',
     provider: 'noop',
     config: { },
     tlsConfig: {
@@ -43,209 +33,130 @@ var DOMAIN_1 = {
 };
 
 describe('Domains API', function () {
-    before(function (done) {
-        async.series([
-            server.start.bind(null),
-            database._clear.bind(null),
+    const { setup, cleanup, serverUrl, owner, dashboardDomain } = common;
 
-            function (callback) {
-                superagent.post(SERVER_URL + '/api/v1/cloudron/activate')
-                    .query({ setupToken: 'somesetuptoken' })
-                    .send({ username: USERNAME, password: PASSWORD, email: EMAIL })
-                    .end(function (error, result) {
-                        expect(result).to.be.ok();
-                        expect(result.statusCode).to.equal(201);
-
-                        // stash token for further use
-                        token = result.body.token;
-
-                        callback();
-                    });
-            },
-        ], done);
-    });
-
-    after(function (done) {
-        async.series([
-            database._clear.bind(null),
-            server.stop.bind(null)
-        ], done);
-    });
+    before(setup);
+    after(cleanup);
 
     describe('add', function () {
-        it('fails with missing domain', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('fails with missing domain', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send({})
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with invalid domain', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('fails with invalid domain', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send({ domain: 'abc' })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with unknown provider', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('fails with unknown provider', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send({ domain: 'cloudron.com', provider: 'doesnotexist', config: { }})
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with invalid tlsConfig', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('fails with invalid tlsConfig', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send({ domain: 'cloudron.com', provider: 'noop', config: { }, tlsConfig: 'foobar' })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with unknown tls provider', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('fails with unknown tls provider', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send({ domain: 'cloudron.com', provider: 'noop', config: { }, tlsConfig: { provider: 'hello' }})
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails without token', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
+        it('fails without token', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
                 .query({ })
                 .send(DOMAIN_0)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(401);
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(401);
         });
 
-        it('succeeds', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
+        it('succeeds', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
+                .send(DOMAIN_0);
+
+            expect(response.statusCode).to.equal(201);
+        });
+
+        it('succeeds for second domain without zoneName', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
+                .send(DOMAIN_1);
+
+            expect(response.statusCode).to.equal(201);
+        });
+
+        it('fails for already added domain', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token })
                 .send(DOMAIN_0)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(201);
+                .ok(() => true);
 
-                    done();
-                });
-        });
-
-        it('succeeds for second domain without zoneName', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
-                .send(DOMAIN_1)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(201);
-
-                    done();
-                });
-        });
-
-        it('fails for already added domain', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
-                .send(DOMAIN_0)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(409);
-
-                    done();
-                });
+            expect(response.statusCode).to.equal(409);
         });
     });
 
     describe('list', function () {
-        it('succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(200);
-                    expect(result.body.domains).to.be.an(Array);
-                    expect(result.body.domains.length).to.equal(2);
+        it('succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/domains`)
+                .query({ access_token: owner.token });
 
-                    expect(result.body.domains[0].domain).to.equal(DOMAIN_0.domain);
-                    expect(result.body.domains[1].domain).to.equal(DOMAIN_1.domain);
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.domains).to.be.an(Array);
+            expect(response.body.domains.length).to.equal(3);
 
-                    done();
-                });
+            expect(response.body.domains[0].domain).to.equal(DOMAIN_0.domain);
+            expect(response.body.domains[1].domain).to.equal(DOMAIN_1.domain);
+            expect(response.body.domains[2].domain).to.equal(dashboardDomain);
         });
     });
 
     describe('get', function () {
-        it('fails for non-existing domain', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/domains/' + DOMAIN_0.domain + DOMAIN_0.domain)
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(404);
+        it('fails for non-existing domain', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/domains/random`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
 
-                    done();
-                });
+            expect(response.statusCode).to.equal(404);
         });
 
-        it('succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/domains/' + DOMAIN_0.domain)
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(200);
-                    expect(result.body.domain).to.equal(DOMAIN_0.domain);
+        it('succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token });
 
-                    done();
-                });
-        });
-    });
-
-    describe('delete', function () {
-        it('fails for non-existing domain', function (done) {
-            superagent.delete(SERVER_URL + '/api/v1/domains/' + DOMAIN_0.domain + DOMAIN_0.domain)
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(404);
-
-                    done();
-                });
-        });
-
-        it('succeeds', function (done) {
-            superagent.delete(SERVER_URL + '/api/v1/domains/' + DOMAIN_0.domain)
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(204);
-
-                    superagent.get(SERVER_URL + '/api/v1/domains/' + DOMAIN_0.domain)
-                        .query({ access_token: token })
-                        .end(function (error, result) {
-                            expect(result.statusCode).to.equal(404);
-
-                            done();
-                        });
-                });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.domain).to.equal(DOMAIN_0.domain);
         });
     });
 
     describe('Certificates API', function () {
-        var validCert0, validKey0, // example.com
+        let validCert0, validKey0, // example.com
             validCert1, validKey1; // *.example.com
 
-        before(function (done) {
+        before(async function () {
             child_process.execSync(`openssl req -subj "/CN=${DOMAIN_0.domain}/O=My Company Name LTD./C=US" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /tmp/server.key -out /tmp/server.crt`);
             validKey0 = fs.readFileSync('/tmp/server.key', 'utf8');
             validCert0 = fs.readFileSync('/tmp/server.crt', 'utf8');
@@ -253,103 +164,108 @@ describe('Domains API', function () {
             child_process.execSync(`openssl req -subj "/CN=*.${DOMAIN_0.domain}/O=My Company Name LTD./C=US" -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout /tmp/server.key -out /tmp/server.crt`);
             validKey1 = fs.readFileSync('/tmp/server.key', 'utf8');
             validCert1 = fs.readFileSync('/tmp/server.crt', 'utf8');
-
-            superagent.post(SERVER_URL + '/api/v1/domains')
-                .query({ access_token: token })
-                .send(DOMAIN_0)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(201);
-
-                    done();
-                });
         });
 
-        it('cannot set certificate without certificate', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('cannot set certificate without certificate', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { key: validKey1 };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
                 .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set certificate without key', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('cannot set certificate without key', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { cert: validCert1 };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
                 .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set certificate with cert not being a string', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('cannot set certificate with cert not being a string', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { cert: 1234, key: validKey1 };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
                 .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set certificate with key not being a string', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('cannot set certificate with key not being a string', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { cert: validCert1, key: true };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
                 .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set non-fallback certificate', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('cannot set non-fallback certificate', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { cert: validCert0, key: validKey0 };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
                 .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('can set fallback certificate', function (done) {
-            var d = _.extend({}, DOMAIN_0);
+        it('can set fallback certificate', async function () {
+            let d = Object.assign({}, DOMAIN_0);
             d.fallbackCertificate = { cert: validCert1, key: validKey1 };
 
-            superagent.put(`${SERVER_URL}/api/v1/domains/${DOMAIN_0.domain}`)
-                .query({ access_token: token })
-                .send(d)
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(204);
-                    done();
-                });
+            const response = await superagent.put(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
+                .send(d);
+
+            expect(response.statusCode).to.equal(204);
         });
 
-        it('did set the certificate', function (done) {
-            var cert = fs.readFileSync(path.join(paths.NGINX_CERT_DIR, `${DOMAIN_0.domain}.host.cert`), 'utf-8');
+        it('did set the certificate', async function () {
+            const cert = fs.readFileSync(path.join(paths.NGINX_CERT_DIR, `${DOMAIN_0.domain}.host.cert`), 'utf-8');
             expect(cert).to.eql(validCert1);
 
-            var key = fs.readFileSync(path.join(paths.NGINX_CERT_DIR, `${DOMAIN_0.domain}.host.key`), 'utf-8');
+            const key = fs.readFileSync(path.join(paths.NGINX_CERT_DIR, `${DOMAIN_0.domain}.host.key`), 'utf-8');
             expect(key).to.eql(validKey1);
+        });
+    });
 
-            done();
+    describe('delete', function () {
+        it('fails for non-existing domain', async function () {
+            const response = await superagent.del(`${serverUrl}/api/v1/domains/random`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(404);
+        });
+
+        it('succeeds', async function () {
+            const response = await superagent.del(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(204);
+
+            const response2 = await superagent.get(`${serverUrl}/api/v1/domains/${DOMAIN_0.domain}`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response2.statusCode).to.equal(404);
         });
     });
 });
diff --git a/src/routes/test/settings-test.js b/src/routes/test/settings-test.js
index 77b18498a..8be86fa37 100644
--- a/src/routes/test/settings-test.js
+++ b/src/routes/test/settings-test.js
@@ -5,139 +5,77 @@
 /* global before:false */
 /* global after:false */
 
-var async = require('async'),
+const common = require('./common.js'),
     constants = require('../../constants.js'),
-    database = require('../../database.js'),
     expect = require('expect.js'),
-    fs = require('fs'),
-    rimraf = require('rimraf'),
-    server = require('../../server.js'),
     superagent = require('superagent');
 
-var SERVER_URL = 'http://localhost:' + constants.PORT;
-var USERNAME = 'superadmin', PASSWORD = 'Foobar?1337', EMAIL ='silly@me.com';
-var BACKUP_FOLDER = '/tmp/backup_test';
-
-var token = null;
-
-function setup(done) {
-    fs.mkdirSync(BACKUP_FOLDER, { recursive: true });
-
-    async.series([
-        server.start.bind(null),
-        database._clear.bind(null),
-
-        function createAdmin(callback) {
-            superagent.post(SERVER_URL + '/api/v1/cloudron/activate')
-                .query({ setupToken: 'somesetuptoken' })
-                .send({ username: USERNAME, password: PASSWORD, email: EMAIL })
-                .end(function (error, result) {
-                    expect(result).to.be.ok();
-                    expect(result.statusCode).to.eql(201);
-
-                    // stash token for further use
-                    token = result.body.token;
-
-                    callback();
-                });
-        }
-    ], done);
-}
-
-function cleanup(done) {
-    rimraf.sync(BACKUP_FOLDER);
-
-    database._clear(function (error) {
-        expect(!error).to.be.ok();
-
-        server.stop(done);
-    });
-}
+const BACKUP_FOLDER = '/tmp/backup_test';
 
 describe('Settings API', function () {
+    const { setup, cleanup, serverUrl, owner } = common;
+
     before(setup);
     after(cleanup);
 
     describe('autoupdate_pattern', function () {
-        it('can get app auto update pattern (default)', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.pattern).to.be.ok();
-                    done();
-                });
+        it('can get app auto update pattern (default)', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.pattern).to.be.ok();
         });
 
-        it('cannot set autoupdate_pattern without pattern', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+        it('cannot set autoupdate_pattern without pattern', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token })
+                .ok(() => true);
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('can set autoupdate_pattern', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .send({ pattern: '00 30 11 * * 1-5' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    done();
-                });
+        it('can set autoupdate_pattern', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token })
+                .send({ pattern: '00 30 11 * * 1-5' });
+            expect(response.statusCode).to.equal(200);
         });
 
-        it('can get auto update pattern', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.pattern).to.be('00 30 11 * * 1-5');
-                    done();
-                });
+        it('can get auto update pattern', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.pattern).to.be('00 30 11 * * 1-5');
         });
 
-        it('can set autoupdate_pattern to never', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .send({ pattern: constants.AUTOUPDATE_PATTERN_NEVER })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    done();
-                });
+        it('can set autoupdate_pattern to never', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token })
+                .send({ pattern: constants.AUTOUPDATE_PATTERN_NEVER });
+            expect(response.statusCode).to.equal(200);
         });
 
-        it('can get auto update pattern', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.pattern).to.be(constants.AUTOUPDATE_PATTERN_NEVER);
-                    done();
-                });
+        it('can get auto update pattern', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.pattern).to.be(constants.AUTOUPDATE_PATTERN_NEVER);
         });
 
-        it('cannot set invalid autoupdate_pattern', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/autoupdate_pattern')
-                .query({ access_token: token })
+        it('cannot set invalid autoupdate_pattern', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/autoupdate_pattern`)
+                .query({ access_token: owner.token })
                 .send({ pattern: '1 3 x 5 6' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+            expect(response.statusCode).to.equal(400);
         });
     });
 
     describe('time_zone', function () {
-        it('succeeds', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/time_zone')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.timeZone).to.be('America/Los_Angeles');
-                    done();
-                });
+        it('succeeds', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/time_zone`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.timeZone).to.be('America/Los_Angeles');
         });
     });
 
@@ -152,286 +90,257 @@ describe('Settings API', function () {
             schedulePattern: '00 00 23 * * *' // every day at 11pm
         };
 
-        it('can get backup_config (default)', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body).to.eql(defaultConfig);
-                    done();
-                });
+        it('can get backup_config (default)', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body).to.eql(defaultConfig);
         });
 
-        it('cannot set backup_config without provider', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config without provider', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             delete tmp.provider;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid provider', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid provider', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.provider = 'invalid provider';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config without schedulePattern', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config without schedulePattern', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             delete tmp.schedulePattern;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid schedulePattern', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid schedulePattern', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.schedulePattern = 'not a pattern';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config without format', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config without format', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             delete tmp.format;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid format', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid format', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.format = 'invalid format';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config without retentionPolicy', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config without retentionPolicy', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             delete tmp.retentionPolicy;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid retentionPolicy', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid retentionPolicy', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.retentionPolicy = 'not an object';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with empty retentionPolicy', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with empty retentionPolicy', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.retentionPolicy = {};
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with retentionPolicy missing properties', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with retentionPolicy missing properties', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.retentionPolicy = { foo: 'bar' };
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with retentionPolicy with invalid keepWithinSecs', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with retentionPolicy with invalid keepWithinSecs', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.retentionPolicy = { keepWithinSecs: 'not a number' };
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid password', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid password', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.password = 1234;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid syncConcurrency', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid syncConcurrency', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.syncConcurrency = 'not a number';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid syncConcurrency', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid syncConcurrency', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.syncConcurrency = 0;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set backup_config with invalid acceptSelfSignedCerts', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('cannot set backup_config with invalid acceptSelfSignedCerts', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.acceptSelfSignedCerts = 'not a boolean';
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
                 .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('can set backup_config', function (done) {
-            var tmp = JSON.parse(JSON.stringify(defaultConfig));
+        it('can set backup_config', async function () {
+            let tmp = JSON.parse(JSON.stringify(defaultConfig));
             tmp.format = 'rsync';
             tmp.backupFolder = BACKUP_FOLDER;
 
-            superagent.post(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
-                .send(tmp)
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    done();
-                });
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token })
+                .send(tmp);
+
+            expect(response.statusCode).to.equal(200);
         });
 
-        it('can get backup_config', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/backup_config')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.format).to.equal('rsync');
-                    expect(res.body.backupFolder).to.equal(BACKUP_FOLDER);
-                    done();
-                });
+        it('can get backup_config', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/backup_config`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.format).to.equal('rsync');
+            expect(response.body.backupFolder).to.equal(BACKUP_FOLDER);
         });
     });
 
     describe('language', function () {
-        it('can get default language', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/language')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.language).to.equal('en');
-                    done();
-                });
+        it('can get default language', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/language`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.language).to.equal('en');
         });
 
-        it('cannot set language with missing language', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/language')
-                .query({ access_token: token })
+        it('cannot set language with missing language', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/language`)
+                .query({ access_token: owner.token })
                 .send({ foo: 'bar' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(400);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('cannot set language with invalid language', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/language')
-                .query({ access_token: token })
+        it('cannot set language with invalid language', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/language`)
+                .query({ access_token: owner.token })
                 .send({ language: 'doesnotexist' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(404);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(404);
         });
 
-        it('can set language', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/settings/language')
-                .query({ access_token: token })
-                .send({ language: 'de' })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    done();
-                });
+        it('can set language', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/settings/language`)
+                .query({ access_token: owner.token })
+                .send({ language: 'de' });
+
+            expect(response.statusCode).to.equal(200);
         });
 
-        it('can get language', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/settings/language')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.language).to.equal('de');
-                    done();
-                });
+        it('can get language', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/settings/language`)
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.language).to.equal('de');
         });
     });
 });
diff --git a/src/routes/test/support-test.js b/src/routes/test/support-test.js
index 7d19a2063..6684d7b16 100644
--- a/src/routes/test/support-test.js
+++ b/src/routes/test/support-test.js
@@ -5,256 +5,182 @@
 
 'use strict';
 
-var async = require('async'),
-    constants = require('../../constants.js'),
-    database = require('../../database.js'),
+const common = require('./common.js'),
     expect = require('expect.js'),
+    fs = require('fs'),
     nock = require('nock'),
-    path = require('path'),
-    paths = require('../../paths.js'),
-    safe = require('safetydance'),
-    settings = require('../../settings.js'),
-    settingsdb = require('../../settingsdb.js'),
-    superagent = require('superagent'),
-    server = require('../../server.js');
-
-var SERVER_URL = 'http://localhost:' + constants.PORT;
-
-var USERNAME = 'superadmin', PASSWORD = 'Foobar?1337', EMAIL ='silly@me.com';
-var AUTHORIZED_KEYS_FILE = path.join(paths.baseDir(), 'authorized_keys');
-var token = null;
-
-function setup(done) {
-    nock.cleanAll();
-    safe.fs.unlinkSync(AUTHORIZED_KEYS_FILE);
-
-    async.series([
-        server.start.bind(server),
-
-        database._clear,
-
-        function createAdmin(callback) {
-            superagent.post(SERVER_URL + '/api/v1/cloudron/activate')
-                .query({ setupToken: 'somesetuptoken' })
-                .send({ username: USERNAME, password: PASSWORD, email: EMAIL })
-                .end(function (error, result) {
-                    expect(result).to.be.ok();
-                    expect(result.statusCode).to.eql(201);
-
-                    // stash token for further use
-                    token = result.body.token;
-
-                    callback();
-                });
-        },
-
-        settingsdb.set.bind(null, settings.CLOUDRON_TOKEN_KEY, 'CLOUDRON_TOKEN')
-    ], done);
-}
-
-function cleanup(done) {
-    database._clear(function (error) {
-        expect(error).to.not.be.ok();
-
-        server.stop(done);
-    });
-}
+    support = require('../../support.js'),
+    superagent = require('superagent');
 
 describe('Support API', function () {
+    const { setup, cleanup, serverUrl, owner, mockApiServerOrigin, appstoreToken } = common;
+
+    before(setup);
+    after(cleanup);
+
+    const authorizedKeysFile = support._sshInfo().filePath;
+
     describe('remote support', function () {
-        before(setup);
-        after(cleanup);
-
-        it('get remote support', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.enabled).to.be(false);
-                    done();
-                });
+        it('get remote support', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.enabled).to.be(false);
         });
 
-        it('enable remote support', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .send({ enable: true })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
+        it('enable remote support', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token })
+                .send({ enable: true });
 
-                    let data = safe.fs.readFileSync(AUTHORIZED_KEYS_FILE, 'utf8');
-                    let count = (data.match(/support@cloudron.io/g) || []).length;
-                    expect(count).to.be(1);
-                    done();
-                });
+            expect(response.statusCode).to.equal(202);
+
+            let data = await fs.promises.readFile(authorizedKeysFile, 'utf8');
+            let count = (data.match(/support@cloudron.io/g) || []).length;
+            expect(count).to.be(1);
         });
 
-        it('returns true when remote support enabled', function (done) {
-            superagent.get(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(200);
-                    expect(res.body.enabled).to.be(true);
-                    done();
-                });
+        it('returns true when remote support enabled', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token });
+            expect(response.statusCode).to.equal(200);
+            expect(response.body.enabled).to.be(true);
         });
 
-        it('enable remote support (again)', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .send({ enable: true })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
+        it('enable remote support (again)', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token })
+                .send({ enable: true });
+            expect(response.statusCode).to.equal(202);
 
-                    let data = safe.fs.readFileSync(AUTHORIZED_KEYS_FILE, 'utf8');
-                    let count = (data.match(/support@cloudron.io/g) || []).length;
-                    expect(count).to.be(1);
-                    done();
-                });
+            let data = await fs.promises.readFile(authorizedKeysFile, 'utf8');
+            let count = (data.match(/support@cloudron.io/g) || []).length;
+            expect(count).to.be(1);
         });
 
-        it('disable remote support', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .send({ enable: false })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
+        it('disable remote support', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token })
+                .send({ enable: false });
 
-                    let data = safe.fs.readFileSync(AUTHORIZED_KEYS_FILE, 'utf8');
-                    let count = (data.match(/support@cloudron.io/g) || []).length;
-                    expect(count).to.be(0);
-                    done();
-                });
+            expect(response.statusCode).to.equal(202);
+
+            let data = await fs.promises.readFile(authorizedKeysFile, 'utf8');
+            let count = (data.match(/support@cloudron.io/g) || []).length;
+            expect(count).to.be(0);
         });
 
-        it('disable remote support (again)', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/remote_support')
-                .query({ access_token: token })
-                .send({ enable: false })
-                .end(function (err, res) {
-                    expect(res.statusCode).to.equal(202);
+        it('disable remote support (again)', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/remote_support`)
+                .query({ access_token: owner.token })
+                .send({ enable: false });
 
-                    let data = safe.fs.readFileSync(AUTHORIZED_KEYS_FILE, 'utf8');
-                    let count = (data.match(/support@cloudron.io/g) || []).length;
-                    expect(count).to.be(0);
-                    done();
-                });
+            expect(response.statusCode).to.equal(202);
+
+            const data = await fs.promises.readFile(authorizedKeysFile, 'utf8');
+            const count = (data.match(/support@cloudron.io/g) || []).length;
+            expect(count).to.be(0);
         });
     });
 
     describe('ticket', function () {
-        before(setup);
-        after(cleanup);
-
-        it('fails without token', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails without token', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', subject: 'some subject', description: 'some description' })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(401);
-                    done();
-                });
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(401);
         });
 
-        it('fails without type', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails without type', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ subject: 'some subject', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with empty type', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails with empty type', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: '', subject: 'some subject', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with unknown type', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails with unknown type', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'foobar', subject: 'some subject', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails without description', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails without description', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', subject: 'some subject' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with empty subject', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails with empty subject', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', subject: '', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails with empty description', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails with empty description', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', subject: 'some subject', description: '' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('fails without subject', function (done) {
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+        it('fails without subject', async function () {
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(400);
-                    done();
-                });
+                .query({ access_token: owner.token })
+                .ok(() => true);
+
+            expect(response.statusCode).to.equal(400);
         });
 
-        it('succeeds with ticket type', function (done) {
-            var scope2 = nock(settings.apiServerOrigin())
+        it('succeeds with ticket type', async function () {
+            const scope2 = nock(mockApiServerOrigin)
                 .filteringRequestBody(function (/* unusedBody */) { return ''; }) // strip out body
-                .post('/api/v1/ticket?accessToken=CLOUDRON_TOKEN')
+                .post(`/api/v1/ticket?accessToken=${appstoreToken}`)
                 .reply(201, { });
 
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'ticket', subject: 'some subject', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(201);
-                    expect(scope2.isDone()).to.be.ok();
-                    done();
-                });
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(201);
+            expect(scope2.isDone()).to.be.ok();
         });
 
-        it('succeeds with app type', function (done) {
-            var scope2 = nock(settings.apiServerOrigin())
+        it('succeeds with app type', async function () {
+            const scope2 = nock(mockApiServerOrigin)
                 .filteringRequestBody(function (/* unusedBody */) { return ''; }) // strip out body
-                .post('/api/v1/ticket?accessToken=CLOUDRON_TOKEN')
+                .post(`/api/v1/ticket?accessToken=${appstoreToken}`)
                 .reply(201, { });
 
-            superagent.post(SERVER_URL + '/api/v1/support/ticket')
+            const response = await superagent.post(`${serverUrl}/api/v1/support/ticket`)
                 .send({ type: 'app_missing', subject: 'some subject', description: 'some description' })
-                .query({ access_token: token })
-                .end(function (error, result) {
-                    expect(result.statusCode).to.equal(201);
-                    expect(scope2.isDone()).to.be.ok();
-                    done();
-                });
+                .query({ access_token: owner.token });
+
+            expect(response.statusCode).to.equal(201);
+            expect(scope2.isDone()).to.be.ok();
         });
     });
 });
diff --git a/src/support.js b/src/support.js
index ee3c5c569..4d2e1ab5a 100644
--- a/src/support.js
+++ b/src/support.js
@@ -2,10 +2,12 @@
 
 exports = module.exports = {
     getRemoteSupport,
-    enableRemoteSupport
+    enableRemoteSupport,
+
+    _sshInfo: sshInfo
 };
 
-let assert = require('assert'),
+const assert = require('assert'),
     BoxError = require('./boxerror.js'),
     constants = require('./constants.js'),
     eventlog = require('./eventlog.js'),
@@ -54,7 +56,7 @@ function enableRemoteSupport(enable, auditSource, callback) {
     assert.strictEqual(typeof auditSource, 'object');
     assert.strictEqual(typeof callback, 'function');
 
-    let si = sshInfo();
+    const si = sshInfo();
     shell.sudo('support', [ AUTHORIZED_KEYS_CMD, enable ? 'enable' : 'disable', si.filePath, si.user ], {}, function (error) {
         if (error) callback(new BoxError(BoxError.FS_ERROR, error));