system: add tests for fs usage route

src/routes/test/common.js

@@ -6,12 +6,10 @@ const apps = require('../../apps.js'),
     constants = require('../../constants.js'),
     database = require('../../database.js'),
     expect = require('expect.js'),
-    fs = require('fs'),
     mailer = require('../../mailer.js'),
     nock = require('nock'),
     oidcClients = require('../../oidcclients.js'),
     oidcServer = require('../../oidcserver.js'),
-    safe = require('safetydance'),
     server = require('../../server.js'),
     settings = require('../../settings.js'),
     superagent = require('@cloudron/superagent'),
@@ -54,6 +52,7 @@ exports = module.exports = {
     clearMailQueue,
     checkMails,
     waitForTask,
+    waitForAsyncTask,
 
     owner: {
         id: null,
@@ -179,6 +178,7 @@ async function cleanup() {
     debug('Cleaning up');
     await server.stop();
     await oidcServer.stop();
+    if (!nock.isActive()) nock.activate();
     debug('Cleaned up');
 }
 
@@ -207,3 +207,25 @@ async function waitForTask(taskId) {
     }
     throw new Error(`Task ${taskId} never finished`);
 }
+
+async function waitForAsyncTask(es) {
+    return new Promise((resolve, reject) => {
+        const messages = [];
+        es.addEventListener('message', function (message) {
+            debug(`waitForAsyncTask: ${message.data}`);
+            messages.push(JSON.parse(message.data));
+            if (messages[messages.length-1].type === 'done') {
+                debug('waitForAsyncTask: finished');
+                es.close();
+                resolve(messages);
+            }
+        });
+        es.addEventListener('error', function (error) {
+            debug('waitForAsyncTask: errored', error);
+            es.close();
+            const e = new Error(error.message);
+            e.code = error.code;
+            reject(e);
+        });
+    });
+}

src/routes/test/system-test.js

@@ -7,18 +7,26 @@
 
 const constants = require('../../constants.js'),
     common = require('./common.js'),
+    { EventSource } = require('eventsource'),
     expect = require('expect.js'),
     fs = require('fs'),
     http = require('http'),
+    nock = require('nock'),
     os = require('os'),
     paths = require('../../paths.js'),
+    safe = require('safetydance'),
     superagent = require('@cloudron/superagent');
 
 describe('System', function () {
-    const { setup, cleanup, serverUrl, owner, user, waitForTask } = common;
+    const { setup, cleanup, serverUrl, owner, user, waitForAsyncTask } = common;
 
-    before(setup);
-    after(cleanup);
+    before(async function () {
+        await setup();
+        if (nock.isActive()) nock.restore(); // the docker df call does not go through otherwise
+    });
+    after(async function () {
+        await cleanup();
+    });
 
     describe('cpus', function () {
         it('succeeds', async function () {
@@ -127,41 +135,31 @@ describe('System', function () {
         });
     });
 
-    describe('disk usage', function () {
-        it('get succeeds with no cache', async function () {
-            const response = await superagent.get(`${serverUrl}/api/v1/system/disk_usage`)
+    describe('filesystem', function () {
+        let rootFs;
+
+        it('get filesystems', async function () {
+            const response = await superagent.get(`${serverUrl}/api/v1/system/filesystems`)
                 .query({ access_token: owner.token });
 
             expect(response.status).to.equal(200);
-            expect(response.body).to.eql({ usage: null });
+
+            rootFs = Object.values(response.body.filesystems).find(v => v.mountpoint === '/');
+            expect(rootFs.filesystem).to.be.ok();
         });
 
-        it('update the cache', async function () {
-            const response = await superagent.post(`${serverUrl}/api/v1/system/disk_usage`)
-                .query({ access_token: owner.token })
-                .send({});
-
-            expect(response.status).to.equal(201);
-            expect(response.body.taskId).to.be.ok();
-            await waitForTask(response.body.taskId);
+        it('fails without query param', async function () {
+            const es = new EventSource(`${serverUrl}/api/v1/system/filesystem_usage?access_token=${owner.token}`);
+            const [error] = await safe(waitForAsyncTask(es));
+            expect(error.code).to.be(400);
         });
 
-        it('get succeeds with cache', async function () {
-            const response = await superagent.get(`${serverUrl}/api/v1/system/disk_usage`)
-                .query({ access_token: owner.token });
-
-            expect(response.status).to.equal(200);
-            expect(response.body.usage.ts).to.be.a('number');
-
-            const filesystems = Object.keys(response.body.usage.filesystems);
-            let dockerUsage = null;
-            for (const fs of filesystems) {
-                for (const content of response.body.usage.filesystems[fs].contents) {
-                    if (content.id === 'docker') dockerUsage = content;
-                }
-            }
-            expect(dockerUsage).to.be.ok();
-            expect(dockerUsage.usage).to.be.a('number');
+        it('succceeds with query param', async function () {
+            const es = new EventSource(`${serverUrl}/api/v1/system/filesystem_usage?access_token=${owner.token}&filesystem=${rootFs.filesystem}`);
+            const messages = await waitForAsyncTask(es);
+            expect(messages.find(m => m.type === 'progress')).to.be.ok();
+            expect(messages.find(m => m.type === 'data')).to.be.ok();
+            expect(messages.find(m => m.type === 'done')).to.be.ok();
         });
     });