cloudcmd 17.1.6 → 17.2.0

package/server/distribute/import.spec.mjs

@@ -0,0 +1,287 @@
+import {createRequire} from 'node:module';
+import process from 'node:process';
+import test from 'supertape';
+import {promisify} from 'node:util';
+import tryToCatch from 'try-to-catch';
+import {connect} from '../../test/before.mjs';
+import {createConfigManager} from '../cloudcmd.mjs';
+
+const require = createRequire(import.meta.url);
+
+const distribute = {
+    import: promisify(require('./import')),
+};
+
+const config = createConfigManager();
+
+process.on('unhandledRejection', console.log);
+
+test('distribute: import: canceled', async (t) => {
+    const {done} = await connect({
+        config: {
+            export: false,
+            import: false,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    const {status} = await distribute.import(config);
+    
+    await done();
+    
+    t.equal(status, 'canceled');
+    t.end();
+});
+
+test('distribute: import: received: no error', async (t) => {
+    const {done, port} = await connect({
+        config: {
+            import: true,
+            importListen: false,
+            export: true,
+            log: false,
+        },
+    });
+    
+    config('importUrl', `http://localhost:${port}`);
+    
+    const [e] = await tryToCatch(distribute.import, config);
+    
+    await done();
+    
+    t.notOk(e, 'should not be error');
+    t.end();
+});
+
+test('distribute: import: received', async (t) => {
+    const configManager = createConfigManager();
+    const {done, port} = await connect({
+        configManager,
+        config: {
+            name: 'bill',
+            import: true,
+            importToken: 'a',
+            exportToken: 'a',
+            export: true,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    configManager('importUrl', `http://localhost:${port}`);
+    
+    const {status} = await distribute.import(configManager);
+    await done();
+    
+    t.equal(status, 'received');
+    t.end();
+});
+
+test('distribute: import: received: auth: reject', async (t) => {
+    const configManager = createConfigManager();
+    const {done, port} = await connect({
+        configManager,
+        config: {
+            name: 'bill',
+            import: true,
+            importToken: 'xxxxx',
+            exportToken: 'bbbbb',
+            export: true,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    configManager('importUrl', `http://localhost:${port}`);
+    
+    const {status} = await distribute.import(configManager);
+    await done();
+    
+    t.equal(status, 'reject');
+    t.end();
+});
+
+test('distribute: import: received: auth: accept', async (t) => {
+    const configManager = createConfigManager();
+    const {done, port} = await connect({
+        configManager,
+        config: {
+            name: 'bill',
+            import: true,
+            importToken: 'xxxxx',
+            exportToken: 'xxxxx',
+            export: true,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    configManager('importUrl', `http://localhost:${port}`);
+    
+    const {status} = await distribute.import(configManager);
+    await done();
+    
+    t.equal(status, 'received');
+    t.end();
+});
+
+test('distribute: import: received: no name', async (t) => {
+    const configManager = createConfigManager();
+    const {done, port} = await connect({
+        configManager,
+        config: {
+            name: '',
+            import: true,
+            export: true,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    configManager('importUrl', `http://localhost:${port}`);
+    
+    const {status} = await distribute.import(configManager);
+    await done();
+    
+    t.equal(status, 'received');
+    t.end();
+});
+
+test('distribute: import: error', async (t) => {
+    const configManager = createConfigManager();
+    const {done} = await connect({
+        configManager,
+        config: {
+            import: true,
+            export: false,
+            importListen: false,
+            log: false,
+        },
+    });
+    
+    configManager('importUrl', `http://localhost:0`);
+    
+    const {status} = await distribute.import(configManager, {
+        reconnection: false,
+    });
+    
+    await done();
+    
+    t.equal(status, 'connect_error');
+    t.end();
+});
+
+test('distribute: import: config:change: no export', async (t) => {
+    const configManager = createConfigManager();
+    const {done} = await connect({
+        configManager,
+        config: {
+            import: true,
+            export: false,
+            importListen: true,
+            log: false,
+        },
+    });
+    
+    const {status} = await distribute.import(configManager, {
+        reconnection: false,
+    });
+    
+    await done();
+    
+    t.equal(status, 'connect_error');
+    t.end();
+});
+
+test('distribute: import: env', async (t) => {
+    const configManager = createConfigManager();
+    const configManagerImport = createConfigManager();
+    
+    const exporter = await connect({
+        configManager,
+        config: {
+            name: 'bill',
+            import: false,
+            importListen: false,
+            export: true,
+            exportToken: 'a',
+            log: false,
+            editor: 'edward',
+        },
+    });
+    
+    const importer = await connect({
+        configManager: configManagerImport,
+        config: {
+            name: 'jack',
+            import: true,
+            importToken: 'a',
+            export: false,
+            importListen: false,
+            log: false,
+            editor: 'deepword',
+        },
+    });
+    
+    process.env.cloudcmd_editor = 'some editor';
+    
+    configManagerImport('importUrl', `http://localhost:${exporter.port}`);
+    
+    await distribute.import(configManagerImport);
+    
+    await importer.done();
+    await exporter.done();
+    
+    delete process.env.cloudcmd_editor;
+    
+    const result = configManagerImport('editor');
+    const expected = 'deepword';
+    
+    t.equal(result, expected);
+    t.end();
+});
+
+test('distribute: import: no env', async (t) => {
+    const configManager = createConfigManager();
+    const configManagerImport = createConfigManager();
+    
+    const exporter = await connect({
+        configManager,
+        config: {
+            name: 'bill',
+            import: false,
+            importListen: false,
+            export: true,
+            exportToken: 'a',
+            log: false,
+            editor: 'edward',
+        },
+    });
+    
+    const importer = await connect({
+        configManager: configManagerImport,
+        config: {
+            name: 'jack',
+            import: true,
+            importToken: 'a',
+            export: false,
+            importListen: false,
+            log: false,
+            editor: 'deepword',
+        },
+    });
+    
+    configManagerImport('importUrl', `http://localhost:${exporter.port}`);
+    
+    await distribute.import(configManagerImport);
+    
+    await importer.done();
+    await exporter.done();
+    
+    const result = configManagerImport('editor');
+    const expected = 'edward';
+    
+    t.equal(result, expected);
+    t.end();
+});

package/server/markdown/index.spec.mjs

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import {join} from 'node:path';
+import {promisify} from 'node:util';
+import tryToCatch from 'try-to-catch';
+import test from 'supertape';
+import serveOnce from 'serve-once';
+import markdown from './index.js';
+import cloudcmd from '../cloudcmd.mjs';
+
+const config = {
+    auth: false,
+};
+
+const configManager = cloudcmd.createConfigManager();
+
+const {request} = serveOnce(cloudcmd, {
+    config,
+    configManager,
+});
+
+const fixtureDir = new URL('fixture', import.meta.url).pathname;
+
+const _markdown = promisify(markdown);
+
+test('cloudcmd: markdown: error', async (t) => {
+    const {body} = await request.get('/api/v1/markdown/not-found');
+    
+    t.match(body, 'ENOENT', 'should not found');
+    t.end();
+});
+
+test('cloudcmd: markdown: relative: error', async (t) => {
+    const {body} = await request.get('/api/v1/markdown/not-found?relative');
+    
+    t.match(body, 'ENOENT', 'should not found');
+    t.end();
+});
+
+test('cloudcmd: markdown: relative', async (t) => {
+    const {body} = await request.get('/api/v1/markdown/HELP.md?relative');
+    
+    t.notOk(/ENOENT/.test(body), 'should not return error');
+    t.end();
+});
+
+test('cloudcmd: markdown: put', async (t) => {
+    const md = join(fixtureDir, 'markdown.md');
+    const html = join(fixtureDir, 'markdown.html');
+    
+    const mdStream = fs.createReadStream(md);
+    const htmlFile = fs.readFileSync(html, 'utf8');
+    
+    const {body} = await request.put('/api/v1/markdown', {
+        body: mdStream,
+    });
+    
+    t.equal(body, htmlFile, 'should render markdown input to html');
+    t.end();
+});
+
+test('cloudcmd: markdown: put: error', async (t) => {
+    const md = join(fixtureDir, 'markdown-not-exist.md');
+    
+    const name = 'hello';
+    const mdStream = fs.createReadStream(md);
+    
+    mdStream.url = 'http://hello.world';
+    mdStream.method = 'PUT';
+    
+    const [e] = await tryToCatch(_markdown, name, '/', mdStream);
+    
+    t.match(e.message, 'ENOENT: no such file or directory', 'should emit error');
+    t.end();
+});
+
+test('cloudcmd: markdown: no name', async (t) => {
+    const [e] = await tryToCatch(_markdown);
+    
+    t.equal(e.message, 'name should be string!', 'should throw when no name');
+    t.end();
+});
+
+test('cloudcmd: markdown: no request', async (t) => {
+    const [e] = await tryToCatch(_markdown, 'hello');
+    
+    t.equal(e.message, 'request could not be empty!', 'should throw when no request');
+    t.end();
+});
+
+test('cloudcmd: markdown', async (t) => {
+    const configManager = cloudcmd.createConfigManager();
+    const fixtureDir = new URL('fixture', import.meta.url).pathname;
+    const config = {
+        auth: false,
+        root: fixtureDir,
+    };
+    
+    const {request} = serveOnce(cloudcmd, {
+        config,
+        configManager,
+    });
+    
+    const {body} = await request.get('/api/v1/markdown/markdown.md');
+    
+    t.equal(body, '<h1>hello</h1>\n');
+    t.end();
+});
+
+test('cloudcmd: markdown: zip', async (t) => {
+    const configManager = cloudcmd.createConfigManager();
+    const fixtureDir = new URL('fixture', import.meta.url).pathname;
+    const config = {
+        auth: false,
+        root: fixtureDir,
+    };
+    
+    const {request} = serveOnce(cloudcmd, {
+        config,
+        configManager,
+    });
+    
+    const {body} = await request.get('/api/v1/markdown/markdown.zip/markdown.md');
+    
+    t.equal(body, '<h1>hello</h1>\n');
+    t.end();
+});

package/server/rest/index.js

@@ -1,16 +1,9 @@
 'use strict';
 
-const process = require('node:process');
-const DIR = '../';
-const DIR_COMMON = `${DIR}../common/`;
-
 const path = require('node:path');
-const fs = require('node:fs');
+const _fs = require('node:fs');
 
-const root = require(`${DIR}root`);
-const CloudFunc = require(`${DIR_COMMON}cloudfunc`);
-const markdown = require(`${DIR}markdown`);
-const info = require('./info');
+const process = require('node:process');
 
 const jaguar = require('jaguar');
 const onezip = require('onezip');
@@ -22,7 +15,13 @@ const json = require('jonny');
 const ponse = require('ponse');
 
 const copymitter = require('copymitter');
-const moveFiles = require('@cloudcmd/move-files');
+const _moveFiles = require('@cloudcmd/move-files');
+
+const root = require(`../root`);
+const CloudFunc = require(`../../common/cloudfunc`);
+const markdown = require(`../markdown/index.js`);
+const info = require('./info');
+
 const isString = (a) => typeof a === 'string';
 const isFn = (a) => typeof a === 'function';
 const swap = wraptile((fn, a, b) => fn(b, a));
@@ -37,7 +36,7 @@ const UserError = (msg) => {
     return error;
 };
 
-module.exports = currify((config, request, response, next) => {
+module.exports = currify(({config, fs = _fs, moveFiles = _moveFiles}, request, response, next) => {
     const name = ponse.getPathName(request);
     const regExp = RegExp(`^${apiURL}`);
     const is = regExp.test(name);
@@ -45,10 +44,10 @@ module.exports = currify((config, request, response, next) => {
     if (!is)
         return next();
     
-    rest(config, request, response);
+    rest({fs, config, moveFiles}, request, response);
 });
 
-function rest(config, request, response) {
+function rest({fs, config, moveFiles}, request, response) {
     const name = ponse.getPathName(request);
     const params = {
         request,
@@ -56,7 +55,7 @@ function rest(config, request, response) {
         name: name.replace(apiURL, '') || '/',
     };
     
-    sendData(params, config, (error, options, data) => {
+    sendData(params, {fs, config, moveFiles}, (error, options, data) => {
         params.gzip = !error;
         
         if (!data) {
@@ -87,8 +86,10 @@ function rest(config, request, response) {
  * getting data on method and command
  *
  * @param params {name, method, body, requrest, response}
+ * @param config {}
+ * @param callback
  */
-function sendData(params, config, callback) {
+function sendData(params, {fs, config, moveFiles}, callback) {
     const p = params;
     const isMD = p.name.startsWith('/markdown');
     const rootDir = config('root');
@@ -107,6 +108,8 @@ function sendData(params, config, callback) {
             .then((body) => {
                 onPUT({
                     name: p.name,
+                    fs,
+                    moveFiles,
                     config,
                     body,
                 }, callback);
@@ -185,7 +188,7 @@ const getRenameMsg = (from, to) => {
 };
 
 module.exports._onPUT = onPUT;
-function onPUT({name, config, body}, callback) {
+function onPUT({name, fs, moveFiles, config, body}, callback) {
     checkPut(name, body, callback);
     
     const cmd = getCMD(name);
@@ -221,7 +224,7 @@ function onPUT({name, config, body}, callback) {
     }
     
     case 'rename':
-        return rename(rootDir, files.from, files.to, callback);
+        return rename(rootDir, files.from, files.to, fs, callback);
     
     case 'copy':
         if (!files.from || !files.names || !files.to)
@@ -260,7 +263,7 @@ function onPUT({name, config, body}, callback) {
     }
 }
 
-function rename(rootDir, from, to, callback) {
+function rename(rootDir, from, to, fs, callback) {
     if (!from)
         return callback(UserError('"from" should be filled'));