museria 0.2.49 → 0.3.1

package/test/db/database.js

@@ -1,37 +1,41 @@
-const assert = require('chai').assert;
-const DatabaseMuseria = require('../../src/db/transports/database')();
+import { assert } from "chai";
+import database from "../../src/db/transports/database/index.js";
 
-describe('DatabaseMetastocle', () => {
-  let db;
-  
-  describe('instance creation', function () {
-    it('should create an instance', function () {
-      assert.doesNotThrow(() => db = new DatabaseMuseria());
-      db.node = this.node;
+const DatabaseMuseria = database();
+
+export default function () {
+  describe('DatabaseMetastocle', () => {
+    let db;
+
+    describe('instance creation', function () {
+      it('should create an instance', function () {
+        assert.doesNotThrow(() => db = new DatabaseMuseria());
+        db.node = this.node;
+      });
     });
-  });
 
-  describe('.init()', function () { 
-    it('should not throw an exception', async function () {
-      await db.init();
-    });  
-  });
+    describe('.init()', function () {
+      it('should not throw an exception', async function () {
+        await db.init();
+      });
+    });
 
-  describe('.deinit()', function () { 
-    it('should not throw an exception', async function () {
-      await db.deinit();
+    describe('.deinit()', function () {
+      it('should not throw an exception', async function () {
+        await db.deinit();
+      });
     });
-  }); 
 
-  describe('reinitialization', () => {
-    it('should not throw an exception', async function () {
-      await db.init();
+    describe('reinitialization', () => {
+      it('should not throw an exception', async function () {
+        await db.init();
+      });
     });
-  });
-  
-  describe('.destroy()', function () { 
-    it('should not throw an exception', async function () {
-      await db.destroy();
+    
+    describe('.destroy()', function () {
+      it('should not throw an exception', async function () {
+        await db.destroy();
+      });
     });
   });
-});
+}

package/test/db/loki.js

@@ -1,94 +1,98 @@
-const assert = require('chai').assert;
-const tools = require('../tools');
-const DatabaseLokiMuseria = require('../../src/db/transports/loki')();
-const utils = require('../../src/utils');
+import { assert } from "chai";
+import tools from "../tools.js";
+import loki from "../../src/db/transports/loki/index.js";
+import utils from "../../src/utils.js";
 
-describe('DatabaseLokiMetastocle', () => {
-  let loki;
-  let lastNodeDb;
-  
-  describe('instance creation', function () {
-    it('should create an instance', function () { 
-      assert.doesNotThrow(() => loki = new DatabaseLokiMuseria({
-        filename: tools.getDbFilePath(this.node)
-      }));    
-      loki.node = this.node;
-      lastNodeDb = this.node.db;
-      this.node.db = loki;
-    });
-  });
+const DatabaseLokiMuseria = loki();
+
+export default function () {
+  describe('DatabaseLokiMetastocle', () => {
+    let loki;
+    let lastNodeDb;
 
-  describe('.init()', function () { 
-    it('should not throw an exception', async function () {
-      await loki.init();
+    describe('instance creation', function () {
+      it('should create an instance', function () {
+        assert.doesNotThrow(() => loki = new DatabaseLokiMuseria({
+          filename: tools.getDbFilePath(this.node)
+        }));
+        loki.node = this.node;
+        lastNodeDb = this.node.db;
+        this.node.db = loki;
+      });
     });
 
-    it('should create a music collection', async function () {
-      await loki.addCollection('music', { pk: 'title', loki: { unique: ['fileHash'] } });
-    })
-  });  
+    describe('.init()', function () {
+      it('should not throw an exception', async function () {
+        await loki.init();
+      });
 
-  describe('.getMusicByPk()', function () {
-    it('should return the document', async function () {
-      const title = 'artist - title';
-      await loki.addMusicDocument({ title: title + '0' });
-      await loki.addMusicDocument({ title: title + '1' });
-      await loki.addMusicDocument({ title: title + '2' });
-      const docStrict = await loki.getMusicByPk(title + '1');
-      const doc = await loki.getMusicByPk(title + 'on');
-      assert.equal(docStrict.title, utils.beautifySongTitle(title + '1'), 'check the strict document');
-      assert.isObject(doc, 'check the approximate document');
+      it('should create a music collection', async function () {
+        await loki.addCollection('music', { pk: 'title', loki: { unique: ['fileHash'] } });
+      });
     });
 
-    it('should return null', async function () {
-      assert.isNull(await loki.getMusicByPk('wrong'));
-    });
-  });
+    describe('.getMusicByPk()', function () {
+      it('should return the document', async function () {
+        const title = 'artist - title';
+        await loki.addMusicDocument({ title: title + '0' });
+        await loki.addMusicDocument({ title: title + '1' });
+        await loki.addMusicDocument({ title: title + '2' });
+        const docStrict = await loki.getMusicByPk(title + '1');
+        const doc = await loki.getMusicByPk(title + 'on');
+        assert.equal(docStrict.title, utils.beautifySongTitle(title + '1'), 'check the strict document');
+        assert.isObject(doc, 'check the approximate document');
+      });
 
-  describe('.getMusicByFileHash()', function () {
-    it('should get the right document', async function () {
-      const hash = 'y';
-      await loki.addMusicDocument({ title: 'it - is a song', fileHash: hash });
-      const doc = await loki.getMusicByFileHash(hash);
-      assert.equal(doc.fileHash, hash);
+      it('should return null', async function () {
+        assert.isNull(await loki.getMusicByPk('wrong'));
+      });
     });
 
-    it('should return null', async function () {
-      assert.isNull(await loki.getMusicByFileHash('wrong'));
-    });
-  });
+    describe('.getMusicByFileHash()', function () {
+      it('should get the right document', async function () {
+        const hash = 'y';
+        await loki.addMusicDocument({ title: 'it - is a song', fileHash: hash });
+        const doc = await loki.getMusicByFileHash(hash);
+        assert.equal(doc.fileHash, hash);
+      });
 
-  describe('.removeMusicByFileHash()', function () {
-    it('should not remove anything', async function () {
-      const count = await loki.getCollectionSize('music');
-      await loki.removeMusicByFileHash('x');
-      assert.equal(count, await loki.getCollectionSize('music'));
+      it('should return null', async function () {
+        assert.isNull(await loki.getMusicByFileHash('wrong'));
+      });
     });
 
-    it('should remove only the necessary document', async function () {
-      const count = await loki.getCollectionSize('music');
-      await loki.addMusicDocument({ title: 'new - song', fileHash: 'x' });
-      await loki.removeMusicByFileHash('x');
-      assert.equal(count, await loki.getCollectionSize('music'));
+    describe('.removeMusicByFileHash()', function () {
+      it('should not remove anything', async function () {
+        const count = await loki.getCollectionSize('music');
+        await loki.removeMusicByFileHash('x');
+        assert.equal(count, await loki.getCollectionSize('music'));
+      });
+
+      it('should remove only the necessary document', async function () {
+        const count = await loki.getCollectionSize('music');
+        await loki.addMusicDocument({ title: 'new - song', fileHash: 'x' });
+        await loki.removeMusicByFileHash('x');
+        assert.equal(count, await loki.getCollectionSize('music'));
+      });
     });
-  });
 
-  describe('.deinit()', function () { 
-    it('should not throw an exception', async function () {
-      await loki.deinit();
+    describe('.deinit()', function () {
+      it('should not throw an exception', async function () {
+        await loki.deinit();
+      });
     });
-  }); 
 
-  describe('reinitialization', () => {
-    it('should not throw an exception', async function () {
-      await loki.init();
+    describe('reinitialization', () => {
+      it('should not throw an exception', async function () {
+        await loki.init();
+      });
     });
-  });
-  
-  describe('.destroy()', function () { 
-    it('should not throw an exception', async function () {
-      await loki.destroy();
-      this.node.db = lastNodeDb;
+
+    describe('.destroy()', function () {
+      it('should not throw an exception', async function () {
+        await loki.destroy();
+        this.node.db = lastNodeDb;
+      });
     });
   });
-});
+}

package/test/group.js

@@ -1,168 +1,173 @@
-const assert = require('chai').assert;
-const fse = require('fs-extra');
-const path = require('path');
-const Node = require('../src/node')();
-const Client = require('../src/client')();
-const utils = require('../src/utils');
-const tools = require('./tools');
-
-describe('group communication', () => {
-  let nodes;
-  let client;
-  let filePath;
-  let duplicates;
-  let fileStoringNodeTimeout;
-
-  before(async () => {
-    nodes = [];
-    fileStoringNodeTimeout = 1000;
-
-    for(let i = 0; i < 4; i++) {
-      const node = new Node(await tools.createNodeOptions({ request: { fileStoringNodeTimeout } }));
-      await node.init();
-      nodes.push(node);
-      node.initialNetworkAddress = nodes[0].address;
-    }
-    
-    client = new Client(await tools.createClientOptions({ address: nodes[0].address }));
-    await client.init();
-    await tools.nodesSync(nodes, nodes.length * 3); 
-    filePath = path.join(tools.tmpPath, 'audio.mp3');
-    duplicates = await nodes[0].getFileDuplicatesCount();
-  });
-
-  after(async () => {
-    for(let i = 0; i < nodes.length; i++) {
-      await nodes[i].deinit();
-    }
-  });
-
-  it('should get the right network size', async () => {
-    for(let i = 0; i < nodes.length; i++) {
-      assert.equal(await nodes[i].getNetworkSize(), nodes.length);
-    }
-  });
-  
-  it('should add the song', async () => {
-    const title = 'artist - title';
-    await utils.setSongTags(filePath, { fullTitle: title });
-    await client.addSong(filePath);       
-    await tools.wait(fileStoringNodeTimeout);
-    let count = 0;
-
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
-      doc && await node.hasFile(doc.fileHash) && count++;
-    }
-    
-    assert.equal(count, duplicates);
-  });
-
-  it('should not add the existent songs again', async () => {
-    const title = 'artist - title';
-    await utils.setSongTags(filePath, { fullTitle: title });
-    await client.addSong(filePath); 
-    await tools.wait(fileStoringNodeTimeout);
-    let count = 0;
-
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
-      doc && await node.hasFile(doc.fileHash) && count++;
-    }
-
-    assert.equal(count, duplicates);
-  });
-
-  it('should not add the similar songs again', async () => {
-    const title = 'artists - title';
-    await utils.setSongTags(filePath, { fullTitle: title });
-    await client.addSong(filePath); 
-    await tools.wait(fileStoringNodeTimeout);
-    let count = 0;
-
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
-      doc && await node.hasFile(doc.fileHash) && count++;
-    }
-
-    assert.equal(count, duplicates);
-  });
+import { assert } from "chai";
+import fse from "fs-extra";
+import path from "path";
+import node from "../src/node.js";
+import client from "../src/client.js";
+import utils from "../src/utils.js";
+import tools from "./tools.js";
+
+const Node = node();
+const Client = client();
+
+export default function () {
+  describe('group communication', () => {
+    let nodes;
+    let client;
+    let filePath;
+    let duplicates;
+    let fileStoringNodeTimeout;
+
+    before(async () => {
+      nodes = [];
+      fileStoringNodeTimeout = 1000;
+
+      for (let i = 0; i < 4; i++) {
+        const node = new Node(await tools.createNodeOptions({ request: { fileStoringNodeTimeout } }));
+        await node.init();
+        nodes.push(node);
+        node.initialNetworkAddress = nodes[0].address;
+      }
+      
+      client = new Client(await tools.createClientOptions({ address: nodes[0].address }));
+      await client.init();
+      await tools.nodesSync(nodes, nodes.length * 3);
+      filePath = path.join(tools.tmpPath, 'audio.mp3');
+      duplicates = await nodes[0].getFileDuplicatesCount();
+    });
+
+    after(async () => {
+      for (let i = 0; i < nodes.length; i++) {
+        await nodes[i].deinit();
+      }
+    });
 
-  it('should add the necessary count of duplicates', async () => {
-    const title = 'artist - title';
+    it('should get the right network size', async () => {
+      for (let i = 0; i < nodes.length; i++) {
+        assert.equal(await nodes[i].getNetworkSize(), nodes.length);
+      }
+    });
+
+    it('should add the song', async () => {
+      const title = 'artist - title';
+      await utils.setSongTags(filePath, { fullTitle: title });
+      await client.addSong(filePath);
+      await tools.wait(fileStoringNodeTimeout);
+      let count = 0;
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        doc && await node.hasFile(doc.fileHash) && count++;
+      }
 
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
+      assert.equal(count, duplicates);
+    });
+
+    it('should not add the existent songs again', async () => {
+      const title = 'artist - title';
+      await utils.setSongTags(filePath, { fullTitle: title });
+      await client.addSong(filePath);
+      await tools.wait(fileStoringNodeTimeout);
+      let count = 0;
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        doc && await node.hasFile(doc.fileHash) && count++;
+      }
 
-      if(doc) {
-        await node.removeFileFromStorage(doc.fileHash);
-        break;
+      assert.equal(count, duplicates);
+    });
+
+    it('should not add the similar songs again', async () => {
+      const title = 'artists - title';
+      await utils.setSongTags(filePath, { fullTitle: title });
+      await client.addSong(filePath);
+      await tools.wait(fileStoringNodeTimeout);
+      let count = 0;
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        doc && await node.hasFile(doc.fileHash) && count++;
       }
-    }
 
-    await client.addSong(filePath);
-    await tools.wait(fileStoringNodeTimeout);
-    let count = 0;
+      assert.equal(count, duplicates);
+    });
+
+    it('should add the necessary count of duplicates', async () => {
+      const title = 'artist - title';
+     
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        
+        if (doc) {
+          await node.removeFileFromStorage(doc.fileHash);
+          break;
+        }
+      }
 
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
-      doc && await node.hasFile(doc.fileHash) && count++;
-    }
+      await client.addSong(filePath);
+      await tools.wait(fileStoringNodeTimeout);
+      let count = 0;
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        doc && await node.hasFile(doc.fileHash) && count++;
+      }
 
-    assert.equal(count, duplicates);
-  });
+      assert.equal(count, duplicates);
+    });
+
+    it('should return the right links', async () => {
+      const info = await client.getSongInfo('artist - title');
+      assert.equal(info.length, duplicates);
+    });
+
+    it('should remove the song', async () => {
+      const title = 'artist - title';
+      await client.removeSong(title);
+      let count = 0;
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const doc = await node.db.getMusicByPk(title);
+        doc && await node.hasFile(doc.fileHash) && count++;
+      }
 
-  it('should return the right links', async () => {
-    const info = await client.getSongInfo('artist - title');
-    assert.equal(info.length, duplicates);
-  });
+      assert.equal(count, 0);
+    });
+
+    it('should add songs in parallel', async () => {
+      const length = 6;
+      const p = [];
+      let fCount = 0;
+      let dCount = 0;
+      
+      for (let i = 0; i < length; i++) {
+        const newPath = path.join(tools.tmpPath, `audio${i}.mp3`);
+        await fse.copy(filePath, newPath);
+        const tags = { fullTitle: `${Math.random()} - ${Math.random()}` };
+        await utils.setSongTags(newPath, tags);
+      }
 
-  it('should remove the song', async () => {
-    const title = 'artist - title';
-    await client.removeSong(title);
-    let count = 0;
+      for (let i = 0; i < length; i++) {
+        p.push(client.addSong(path.join(tools.tmpPath, `audio${i}.mp3`)));
+      }
 
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      const doc = await node.db.getMusicByPk(title);
-      doc && await node.hasFile(doc.fileHash) && count++;
-    }
+      await Promise.all(p);
+      await tools.wait(fileStoringNodeTimeout * 2);
+      
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        fCount += await node.db.getData('filesCount');
+        dCount += await node.db.getCollectionSize('music');
+      }
 
-    assert.equal(count, 0);
+      assert.isOk(fCount >= length * duplicates, 'check the files');
+      assert.isOk(dCount >= length * duplicates, 'check the documents');
+    });
   });
-
-  it('should add songs in parallel', async () => {
-    const length = 6;  
-    const p = [];
-    let fCount = 0;
-    let dCount = 0;
-
-    for(let i = 0; i < length; i++) {
-      const newPath = path.join(tools.tmpPath, `audio${i}.mp3`);
-      await fse.copy(filePath, newPath);
-      const tags = { fullTitle: `${ Math.random() } - ${ Math.random() }` };
-      await utils.setSongTags(newPath, tags);
-    }
-
-    for(let i = 0; i < length; i++) {      
-      p.push(client.addSong(path.join(tools.tmpPath, `audio${i}.mp3`)));
-    }
-
-    await Promise.all(p);
-    await tools.wait(fileStoringNodeTimeout * 2);
-
-    for(let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      fCount += await node.db.getData('filesCount');
-      dCount += await node.db.getCollectionSize('music');
-    }
-
-    assert.isOk(fCount >= length * duplicates, 'check the files');
-    assert.isOk(dCount >= length * duplicates, 'check the documents');
-  });  
-});
+}

package/test/index.js

@@ -1,6 +1,16 @@
-const fse = require('fs-extra');
-const path = require('path');
-const tools = require('./tools');
+import fse from "fs-extra";
+import path from "path";
+import tools from "./tools.js";
+import { createRequire } from 'node:module';
+import utils from "./utils.js";
+import node from "./node.js";
+
+import client from "./client.js";
+import services from "./services.js";
+import routes from "./routes.js";
+import group from "./group.js";
+
+const require = createRequire(import.meta.url);
 
 describe('museria', () => {
   before(async () => {
@@ -9,10 +19,10 @@ describe('museria', () => {
     await fse.copy(require.resolve('./data/cover.jpg'), path.join(tools.tmpPath, 'cover.jpg'));
   });
   after(() => fse.remove(tools.tmpPath));
-  require('./node');
-  require('./client');
-  require('./services');
-  require('./routes');
-  require('./utils');
-  require('./group');
-});
+  describe('utils', utils.bind(this));
+  describe('node', node.bind(this));
+  describe('client', client.bind(this));
+  describe('services', services.bind(this));
+  describe('routes', routes.bind(this));
+  describe('group', group.bind(this));
+});