museria 0.2.48 → 0.3.1

package/test/client.js

@@ -1,362 +1,368 @@
-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('Client', () => {
-  let client;
-  let node;
-
-  before(async function() {
-    node = new Node(await tools.createNodeOptions());
-    await node.init();
-  });
+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";
 
-  after(async function() {
-    await node.deinit();
-  });
+const Node = node();
+const Client = client();
 
-  describe('instance creation', function () {
-    it('should create an instance', async function () { 
-      const options = await tools.createClientOptions({ address: node.address });
-      assert.doesNotThrow(() => client = new Client(options));
-    });
-  });
+export default function () {
+  describe('Client', () => {
+    let client;
+    let node;
 
-  describe('.init()', function () {
-    it('should not throw an exception', async function () {
-      await client.init();
+    before(async function () {
+      node = new Node(await tools.createNodeOptions());
+      await node.init();
     });
-  });
 
-  describe('.addSong()', function () {
-    it('should not add the song with a wrong title', async function () {
-      const file = await utils.setSongTags(path.join(tools.tmpPath, 'audio.mp3'), { fullTitle: 'wrong' });
-      try {
-        await client.addSong(file);
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
+    after(async function () {
+      await node.deinit();
     });
 
-    it('should add the song', async () => {
-      const title = 'artist - title';
-      const file = await utils.setSongTags(path.join(tools.tmpPath, 'audio.mp3'), { 
-        fullTitle: title, 
-        APIC: path.join(tools.tmpPath, 'cover.jpg'),
-        TIT3: 'x'
-      });
-      const result = await client.addSong(file);
-      const doc = await node.db.getMusicByPk(result.title);
-      assert.equal(utils.beautifySongTitle(title), result.title, 'check the title');
-      assert.equal(result.tags.TIT3, 'x', 'check the tags');
-      assert.isNotNull(doc, 'check the database');
-      assert.isTrue(await node.hasFile(doc.fileHash), 'check the file');
-      assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
-      assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+    describe('instance creation', function () {
+      it('should create an instance', async function () {
+        const options = await tools.createClientOptions({ address: node.address });
+        assert.doesNotThrow(() => client = new Client(options));
+      });
     });
-  });
 
-  describe('.getSongInfo()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongInfo('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
+    describe('.init()', function () {
+      it('should not throw an exception', async function () {
+        await client.init();
+      });
     });
 
-    it('should return an empty array', async function () {
-      const info = await client.getSongInfo('unexistent - song');      
-      assert.lengthOf(info, 0);
-    });
+    describe('.addSong()', function () {
+      it('should not add the song with a wrong title', async function () {
+        const file = await utils.setSongTags(path.join(tools.tmpPath, 'audio.mp3'), { fullTitle: 'wrong' });
+        
+        try {
+          await client.addSong(file);
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should return the info', async function () {
-      const title = 'artist - title';
-      const info = await client.getSongInfo(title);
-      const result = info[0];
-      assert.lengthOf(info, 1, 'check the length');
-      assert.equal(utils.beautifySongTitle(title), result.title, 'check the title');
-      assert.equal(result.tags.TIT3, 'x', 'check the tags');
-      assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
-      assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+      it('should add the song', async () => {
+        const title = 'artist - title';
+        const file = await utils.setSongTags(path.join(tools.tmpPath, 'audio.mp3'), {
+          fullTitle: title,
+          APIC: path.join(tools.tmpPath, 'cover.jpg'),
+          TIT3: 'x'
+        });
+        const result = await client.addSong(file);
+        const doc = await node.db.getMusicByPk(result.title);
+        assert.equal(utils.beautifySongTitle(title), result.title, 'check the title');
+        assert.equal(result.tags.TIT3, 'x', 'check the tags');
+        assert.isNotNull(doc, 'check the database');
+        assert.isTrue(await node.hasFile(doc.fileHash), 'check the file');
+        assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
+        assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+      });
     });
-  });
 
-  describe('.findSongs()', function () {
-    it('should return an empty array', async function () {
-      const songs = await client.findSongs('unexistent');      
-      assert.lengthOf(songs, 0);
-    });
+    describe('.getSongInfo()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongInfo('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should return the songs', async function () {
-      const str = 'arTist';
-      const songs = await client.findSongs(str);
-      const result = songs[0];
-      assert.lengthOf(songs, 1, 'check the length');
-      assert.isOk(result.title.toLowerCase().match(str.toLowerCase()), 'check the title');
-      assert.equal(result.tags.TIT3, 'x', 'check the tags');
-      assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
-      assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
-    });
-  });
+      it('should return an empty array', async function () {
+        const info = await client.getSongInfo('unexistent - song');
+        assert.lengthOf(info, 0);
+      });
 
-  describe('.findArtistSongs()', function () {
-    it('should return an empty array', async function () {
-      const songs = await client.findArtistSongs('art');      
-      assert.lengthOf(songs, 0);
+      it('should return the info', async function () {
+        const title = 'artist - title';
+        const info = await client.getSongInfo(title);
+        const result = info[0];
+        assert.lengthOf(info, 1, 'check the length');
+        assert.equal(utils.beautifySongTitle(title), result.title, 'check the title');
+        assert.equal(result.tags.TIT3, 'x', 'check the tags');
+        assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
+        assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+      });
     });
 
-    it('should return the songs', async function () {
-      const str = 'artist';
-      const songs = await client.findArtistSongs(str);
-      const result = songs[0];
-      assert.lengthOf(songs, 1, 'check the length');
-      assert.isOk(result.title.toLowerCase().match(str), 'check the title');
-      assert.equal(result.tags.TIT3, 'x', 'check the tags');
-      assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
-      assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
-    });
-  });
+    describe('.findSongs()', function () {
+      it('should return an empty array', async function () {
+        const songs = await client.findSongs('unexistent');
+        assert.lengthOf(songs, 0);
+      });
 
-  describe('.getSong()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSong('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
+      it('should return the songs', async function () {
+        const str = 'arTist';
+        const songs = await client.findSongs(str);
+        const result = songs[0];
+        assert.lengthOf(songs, 1, 'check the length');
+        assert.isOk(result.title.toLowerCase().match(str.toLowerCase()), 'check the title');
+        assert.equal(result.tags.TIT3, 'x', 'check the tags');
+        assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
+        assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+      });
     });
 
-    it('should return null', async function () {
-      assert.isNull(await client.getSong('unexistent - song'));
-    });
+    describe('.findArtistSongs()', function () {
+      it('should return an empty array', async function () {
+        const songs = await client.findArtistSongs('art');
+        assert.lengthOf(songs, 0);
+      });
 
-    it('should return the right info', async function () {
-      const title = 'artist - title';
-      const info = await client.getSong(title);
-      assert.equal(utils.beautifySongTitle(title), info.title, 'check the title');
-      assert.equal(info.tags.TIT3, 'x', 'check the tags');
-      assert.isTrue(utils.isValidSongAudioLink(info.audioLink), 'check the audio link');
-      assert.isTrue(utils.isValidSongCoverLink(info.coverLink), 'check the cover link');
+      it('should return the songs', async function () {
+        const str = 'artist';
+        const songs = await client.findArtistSongs(str);
+        const result = songs[0];
+        assert.lengthOf(songs, 1, 'check the length');
+        assert.isOk(result.title.toLowerCase().match(str), 'check the title');
+        assert.equal(result.tags.TIT3, 'x', 'check the tags');
+        assert.isTrue(utils.isValidSongAudioLink(result.audioLink), 'check the audio link');
+        assert.isTrue(utils.isValidSongCoverLink(result.coverLink), 'check the cover link');
+      });
     });
-  });
 
-  describe('.getSongAudioLink()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongAudioLink('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSong()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSong('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should return an empty string', async function () {
-      assert.isEmpty(await client.getSongAudioLink('unexistent - song'));
-    });
+      it('should return null', async function () {
+        assert.isNull(await client.getSong('unexistent - song'));
+      });
 
-    it('should return the link', async function () {
-      const link = await client.getSongAudioLink('artist - title')
-      assert.isTrue(utils.isValidSongAudioLink(link));
+      it('should return the right info', async function () {
+        const title = 'artist - title';
+        const info = await client.getSong(title);
+        assert.equal(utils.beautifySongTitle(title), info.title, 'check the title');
+        assert.equal(info.tags.TIT3, 'x', 'check the tags');
+        assert.isTrue(utils.isValidSongAudioLink(info.audioLink), 'check the audio link');
+        assert.isTrue(utils.isValidSongCoverLink(info.coverLink), 'check the cover link');
+      });
     });
-  });
 
-  describe('.getSongCoverLink()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongCoverLink('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongAudioLink()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongAudioLink('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should return an empty string', async function () {
-      assert.isEmpty(await client.getSongCoverLink('unexistent - song'));
-    });
+      it('should return an empty string', async function () {
+        assert.isEmpty(await client.getSongAudioLink('unexistent - song'));
+      });
 
-    it('should return the link', async function () {
-      const link = await client.getSongCoverLink('artist - title')
-      assert.isTrue(utils.isValidSongCoverLink(link));
+      it('should return the link', async function () {
+        const link = await client.getSongAudioLink('artist - title');
+        assert.isTrue(utils.isValidSongAudioLink(link));
+      });
     });
-  });
 
-  describe('.getSongAudioToBuffer()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongAudioToBuffer('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongCoverLink()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongCoverLink('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should throw an error because of wrong link', async function () {
-      try {
-        await client.getSongAudioToBuffer('unexistent - song');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Link for song'));
-      }
-    });
+      it('should return an empty string', async function () {
+        assert.isEmpty(await client.getSongCoverLink('unexistent - song'));
+      });
 
-    it('should be the same buffer', async function () {
-      const title = 'artist - title';
-      const doc = await node.db.getMusicByPk(title);
-      const originalBuffer = await fse.readFile(node.getFilePath(doc.fileHash));
-      const buffer = await client.getSongAudioToBuffer(title);
-      assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      it('should return the link', async function () {
+        const link = await client.getSongCoverLink('artist - title');
+        assert.isTrue(utils.isValidSongCoverLink(link));
+      });
     });
-  });
 
-  describe('.getSongCoverToBuffer()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongCoverToBuffer('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongAudioToBuffer()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongAudioToBuffer('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should throw an error because of wrong link', async function () {
-      try {
-        await client.getSongCoverToBuffer('unexistent - song');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Link for song'));
-      }
-    });
+      it('should throw an error because of wrong link', async function () {
+        try {
+          await client.getSongAudioToBuffer('unexistent - song');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Link for song'));
+        }
+      });
 
-    it('should be the same buffer', async function () {
-      const title = 'artist - title';
-      const doc = await node.db.getMusicByPk(title);
-      const originalBuffer = (await utils.getSongTags(node.getFilePath(doc.fileHash))).APIC;
-      const buffer = await client.getSongCoverToBuffer(title);
-      assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      it('should be the same buffer', async function () {
+        const title = 'artist - title';
+        const doc = await node.db.getMusicByPk(title);
+        const originalBuffer = await fse.readFile(node.getFilePath(doc.fileHash));
+        const buffer = await client.getSongAudioToBuffer(title);
+        assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      });
     });
-  });
 
-  describe('.getSongAudioToPath()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongAudioToPath('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongCoverToBuffer()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongCoverToBuffer('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should throw an error because of wrong link', async function () {
-      try {
-        await client.getSongAudioToPath('unexistent - song');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Link for song'));
-      }
-    });
+      it('should throw an error because of wrong link', async function () {
+        try {
+          await client.getSongCoverToBuffer('unexistent - song');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Link for song'));
+        }
+      });
 
-    it('should save the file', async function () {
-      const filePath = path.join(tools.tmpPath, 'audio-saved.mp3');
-      const title = 'artist - title';
-      const doc = await node.db.getMusicByPk(title);
-      const originalBuffer = await fse.readFile(node.getFilePath(doc.fileHash));
-      await client.getSongAudioToPath(title, filePath);
-      const buffer = await fse.readFile(filePath);
-      assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      it('should be the same buffer', async function () {
+        const title = 'artist - title';
+        const doc = await node.db.getMusicByPk(title);
+        const originalBuffer = (await utils.getSongTags(node.getFilePath(doc.fileHash))).APIC;
+        const buffer = await client.getSongCoverToBuffer(title);
+        assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      });
     });
-  });
 
-  describe('.getSongCoverToPath()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongCoverToPath('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongAudioToPath()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongAudioToPath('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should throw an error because of wrong link', async function () {
-      try {
-        await client.getSongCoverToPath('unexistent - song');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Link for song'));
-      }
-    });
+      it('should throw an error because of wrong link', async function () {
+        try {
+          await client.getSongAudioToPath('unexistent - song');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Link for song'));
+        }
+      });
 
-    it('should save the file', async function () {
-      const filePath = path.join(tools.tmpPath, '/cover-saved.jpg');
-      const title = 'artist - title';
-      const doc = await node.db.getMusicByPk(title);
-      const originalBuffer = (await utils.getSongTags(node.getFilePath(doc.fileHash))).APIC;
-      await client.getSongCoverToPath(title, filePath);
-      const buffer = await fse.readFile(filePath);
-      assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      it('should save the file', async function () {
+        const filePath = path.join(tools.tmpPath, 'audio-saved.mp3');
+        const title = 'artist - title';
+        const doc = await node.db.getMusicByPk(title);
+        const originalBuffer = await fse.readFile(node.getFilePath(doc.fileHash));
+        await client.getSongAudioToPath(title, filePath);
+        const buffer = await fse.readFile(filePath);
+        assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      });
     });
-  });
 
-  describe('.removeSong()', function () {
-    it('should throw an error because of a wrong title', async function () {
-      try {
-        await client.getSongAudioLink('wrong');
-        throw new Error('Fail');
-      }
-      catch(err) {
-        assert.isOk(err.message.match('Wrong song title'));
-      }
-    });
+    describe('.getSongCoverToPath()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongCoverToPath('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
 
-    it('should return the link', async function () {
-      const title = 'artist - title';
-      const doc = await node.db.getMusicByPk(title);
-      const res = await client.removeSong(title);
-      assert.equal(res.removed, 1, 'check the result');
-      assert.isNull(await node.db.getMusicByPk(title), 'check the database');
-      assert.isFalse(await node.hasFile(doc.fileHash), 'check the file');
+      it('should throw an error because of wrong link', async function () {
+        try {
+          await client.getSongCoverToPath('unexistent - song');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Link for song'));
+        }
+      });
+
+      it('should save the file', async function () {
+        const filePath = path.join(tools.tmpPath, '/cover-saved.jpg');
+        const title = 'artist - title';
+        const doc = await node.db.getMusicByPk(title);
+        const originalBuffer = (await utils.getSongTags(node.getFilePath(doc.fileHash))).APIC;
+        await client.getSongCoverToPath(title, filePath);
+        const buffer = await fse.readFile(filePath);
+        assert.isTrue(Buffer.compare(originalBuffer, buffer) == 0);
+      });
     });
-  }); 
 
-  describe('.createRequestedSongAudioLink()', () => {
-    it('should return the right link', async () => {
-      const title = 'artist-title';
-      const link = client.createRequestedSongAudioLink(title);
-      assert.equal(link, `${client.getRequestProtocol()}://${client.workerAddress}/client/request-song?type=audio&title=${title}`);
+    describe('.removeSong()', function () {
+      it('should throw an error because of a wrong title', async function () {
+        try {
+          await client.getSongAudioLink('wrong');
+          throw new Error('Fail');
+        }
+        catch (err) {
+          assert.isOk(err.message.match('Wrong song title'));
+        }
+      });
+
+      it('should return the link', async function () {
+        const title = 'artist - title';
+        const doc = await node.db.getMusicByPk(title);
+        const res = await client.removeSong(title);
+        assert.equal(res.removed, 1, 'check the result');
+        assert.isNull(await node.db.getMusicByPk(title), 'check the database');
+        assert.isFalse(await node.hasFile(doc.fileHash), 'check the file');
+      });
     });
-  });
 
-  describe('.createRequestedSongCoverLink()', () => {
-    it('should return the right link', async () => {
-      const title = 'artist-title';
-      const link = client.createRequestedSongCoverLink(title);
-      assert.equal(link, `${client.getRequestProtocol()}://${client.workerAddress}/client/request-song?type=cover&title=${title}`);
+    describe('.createRequestedSongAudioLink()', () => {
+      it('should return the right link', async () => {
+        const title = 'artist-title';
+        const link = client.createRequestedSongAudioLink(title);
+        assert.equal(link, `${client.getRequestProtocol()}://${client.workerAddress}/client/request-song?type=audio&title=${title}`);
+      });
     });
-  });
 
-  describe('.deinit()', function () {
-    it('should not throw an exception', async function () {
-      await client.deinit();
+    describe('.createRequestedSongCoverLink()', () => {
+      it('should return the right link', async () => {
+        const title = 'artist-title';
+        const link = client.createRequestedSongCoverLink(title);
+        assert.equal(link, `${client.getRequestProtocol()}://${client.workerAddress}/client/request-song?type=cover&title=${title}`);
+      });
+    });
+    
+    describe('.deinit()', function () {
+      it('should not throw an exception', async function () {
+        await client.deinit();
+      });
     });
   });
-});
+}