fix: fileop: copymitter (coderaiser/cloudcmd#457)

Author: coderaiser

server/listen.js

@@ -30,6 +30,7 @@ function listen(socket, options) {
         auth,
         prefix = '/fileop',
         root = '/',
+        ...overrides
     } = options;
 
     check(auth);
@@ -38,41 +39,46 @@ function listen(socket, options) {
         .of(prefix)
         .on('connection', (socket) => {
             if (!auth)
-                return connection(root, socket);
+                return connection(root, socket, overrides);
 
             const reject = () => socket.emit('reject');
-            socket.on('auth', auth(connectionWrapped(root, socket), reject));
+            const onConnect = connectionWrapped(root, socket, overrides);
+            
+            const onAuth = auth(onConnect, reject);
+            
+            socket.on('auth', onAuth);
         });
 }
 
-function connection(rootRaw, socket) {
+function connection(rootRaw, socket, overrides) {
     socket.emit('accept');
     socket.on('operation', (name, from, to, files) => {
         socket.emit('id', inc(id));
 
         socket.once(`${id()}#start`, () => {
             socket.emit(`${id()}started`);
 
-            const operation = getOperation(name);
+            const operation = getOperation(name, overrides);
+            
             const root = getValue(rootRaw);
 
             operation(id(), root, socket, from, to, files);
         });
     });
 }
 
-function getOperation(name) {
+function getOperation(name, overrides = {}) {
     if (name === 'remove')
-        return operate('remove');
+        return operate('remove', overrides);
 
     if (name === 'extract')
         return extract;
 
     if (name === 'copy')
-        return operate('copy');
+        return operate('copy', overrides);
 
     if (name === 'move')
-        return operate('move');
+        return operate('move', overrides);
 
     if (name === 'tar')
         return pack('tar');

server/operate.js

@@ -3,12 +3,12 @@
 const currify = require('currify');
 
 const remy = require('remy');
-const copymitter = require('copymitter');
+const {copymitter: _copymitter} = require('copymitter');
 const moveFiles = require('@cloudcmd/move-files');
 const {webToWin} = require('mellow');
 const isString = (a) => typeof a === 'string';
 
-const isRootWin32 = currify(require('./is-root-win32'));
+const _isRootWin32 = currify(require('./is-root-win32'));
 
 const getPaths = (from, to) => {
     if (!isString(to))
@@ -26,17 +26,25 @@ const safeWebToWin = (path, root) => {
     return webToWin(path, root);
 };
 
-module.exports = currify((type, id, root, socket, from, to, files) => {
+module.exports = currify((type, overrides, id, root, socket, from, to, files) => {
+    const {
+        isRootWin32 = _isRootWin32,
+    } = overrides;
+    
     from = safeWebToWin(from, root);
     to = safeWebToWin(to, root);
 
     if (getPaths(from, to).some(isRootWin32(root)))
         socket.emit(`${id}#error`, getRootError(type));
 
-    operate(type, id, socket, from, to, files);
+    operate(type, id, socket, from, to, files, overrides);
 });
 
-function getOperation(type) {
+function getOperation(type, overrides) {
+    const {
+        copymitter = _copymitter,
+    } = overrides;
+    
     if (type === 'remove')
         return remy;
 
@@ -46,8 +54,8 @@ function getOperation(type) {
     return copymitter;
 }
 
-function operate(type, id, socket, from, to, files) {
-    const operate = getOperation(type);
+function operate(type, id, socket, from, to, files, overrides) {
+    const operate = getOperation(type, overrides);
     const operator = operate(from, to, files);
     const onPause = () => operator.pause();
     const onContinue = () => operator.continue();

test/server/copy.js

@@ -1,10 +1,7 @@
 'use strict';
 
 const {once} = require('node:events');
-
 const {test, stub} = require('supertape');
-const mock = require('mock-require');
-const clear = require('clear-module');
 
 const {
     endEmitter,
@@ -14,24 +11,18 @@ const {
     customEmitter,
 } = require('../lib/emitters');
 
-const clearFileop = require('../lib/clear');
+const connect = require('../lib/connect');
 
 const connectPath = '../lib/connect';
-const copyPath = 'copymitter';
-const isRootPath = '../../server/is-root-win32';
 
 test('operate: copy: error', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
 
-    mock(copyPath, errorEmitter);
-    const connect = require(connectPath);
-    
-    const {socket, done} = await connect();
+    const {socket, done} = await connect({
+        copymitter: errorEmitter,
+    });
 
     const error = 'EACCES: /hello/abc';
 
@@ -48,19 +39,14 @@ test('operate: copy: error', async (t) => {
 });
 
 test('operate: copy: file', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
-    
-    mock(copyPath, fileEmitter);
-    const connect = require(connectPath);
     const root = '/';
 
     const {socket, done} = await connect({
         root,
+        copymitter: fileEmitter,
     });
 
     socket.emit('operation', 'copy', from, to, names);
@@ -76,19 +62,15 @@ test('operate: copy: file', async (t) => {
 });
 
 test('operate: copy: progress', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
 
-    mock(copyPath, progressEmitter);
-    const connect = require(connectPath);
     const root = '/';
 
     const {socket, done} = await connect({
         root,
+        copymitter: progressEmitter,
     });
 
     socket.emit('operation', 'copy', from, to, names);
@@ -97,51 +79,46 @@ test('operate: copy: progress', async (t) => {
     socket.emit(`${id}#start`);
     const [n] = await once(socket, `${id}#progress`);
 
-    t.equal(n, 100);
     done();
+    
+    t.equal(n, 100);
     t.end();
 });
 
 test('operate: copy: end', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
 
-    mock(copyPath, endEmitter);
-    const connect = require(connectPath);
     const root = '/';
 
     const {socket, done} = await connect({
         root,
+        copymitter: endEmitter,
     });
 
     socket.emit('operation', 'copy', from, to, names);
     const [id] = await once(socket, 'id');
 
     socket.emit(`${id}#start`);
     await once(socket, `${id}#end`);
-    t.pass('should emit end');
     done();
+    
+    t.pass('should emit end');
     t.end();
 });
 
 test('operate: copy: abort', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
 
-    mock(copyPath, errorEmitter);
     const connect = require(connectPath);
     const root = '/';
 
     const {socket, done} = await connect({
         root,
+        copymitter: errorEmitter,
     });
 
     socket.emit('operation', 'copy', from, to, names);
@@ -151,23 +128,20 @@ test('operate: copy: abort', async (t) => {
     await once(socket, `${id}#error`);
     socket.emit(`${id}#abort`);
     await once(socket, `${id}#end`);
-    t.pass('should emit abort');
     done();
+    
+    t.pass('should emit abort');
     t.end();
 });
 
 test('operate: copy: continue', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/';
     const to = '/world';
     const names = ['abc'];
 
-    mock(copyPath, errorEmitter);
-    const connect = require(connectPath);
-    
-    const {socket, done} = await connect();
+    const {socket, done} = await connect({
+        copymitter: errorEmitter,
+    });
 
     socket.emit('operation', 'copy', from, to, names);
     const [id] = await once(socket, 'id');
@@ -183,29 +157,28 @@ test('operate: copy: continue', async (t) => {
 });
 
 test('operate: copy: pause', async (t) => {
-    clearFileop();
-    clear(copyPath);
-    
     const from = '/';
     const to = '/world';
     const names = ['abc'];
 
     const pause = stub();
-    mock(copyPath, customEmitter({
+    const copymitter = customEmitter({
         pause,
         continue: stub(),
-    }));
-    
-    const connect = require(connectPath);
+    });
 
-    const {socket, done} = await connect();
+    const {socket, done} = await connect({
+        copymitter,
+    });
 
     socket.emit('operation', 'copy', from, to, names);
 
     const [id] = await once(socket, 'id');
+    
     socket.emit(`${id}#start`);
     socket.emit(`${id}#pause`);
     socket.emit(`${id}#continue`);
+    
     await once(socket, `${id}#end`);
 
     done();
@@ -215,26 +188,16 @@ test('operate: copy: pause', async (t) => {
 });
 
 test('operate: copy: error: root', async (t) => {
-    clearFileop();
-    clear(isRootPath);
-    
     const from = '/hello';
     const to = '/world';
     const names = ['abc'];
-    const truth = () => true;
+    const success = stub().returns(true);
+    const isRootWin32 = stub().returns(success);
 
-    Object.defineProperty(truth, 'length', {
-        value: 2,
+    const {socket, done} = await connect({
+        isRootWin32,
     });
 
-    const isRoot = require(isRootPath);
-    mock(isRootPath, truth);
-    
-    const connect = require(connectPath);
-    mock(isRootPath, isRoot);
-    
-    const {socket, done} = await connect();
-    
     socket.emit('operation', 'copy', from, to, names);
     const [id] = await once(socket, 'id');
 
@@ -243,7 +206,6 @@ test('operate: copy: error: root', async (t) => {
     const [e] = await once(socket, `${id}#error`);
 
     done();
-    clear(isRootPath);
 
     t.equal(e, error, 'should emit error');
     t.end();