mythix 2.12.2 → 4.0.1

package/{src/tasks/task-module.js → lib/tasks/task-module.mjs}

@@ -1,28 +1,19 @@
-'use strict';
-
-const Nife            = require('nife');
-const { BaseModule }  = require('../modules/base-module');
-const {
-  fileNameWithoutExtension,
-  walkDir,
-} = require('../utils');
+import { DateTime }     from 'luxon';
+import Nife             from 'nife';
+import { ModuleBase }   from '../modules/module-base.mjs';
 
 const MILLISECONDS_PER_SECOND = 1000;
-const TASK_MAX_FAIL_ATTEMPTS = 5;
-
-var globalTaskRunID = 1;
+const TASK_MAX_FAIL_ATTEMPTS  = 5;
 
 function nowInSeconds() {
   return Date.now() / MILLISECONDS_PER_SECOND;
 }
 
-class TaskModule extends BaseModule {
-  static getModuleName() {
-    return 'TaskModule';
+export class TaskModule extends ModuleBase {
+  static getOptionsScopeName() {
+    return 'tasks';
   }
 
-  static fileWatcherQueueName = 'tasks';
-
   static shouldUse(application, options) {
     if (options.runTasks === false)
       return false;
@@ -49,66 +40,11 @@ class TaskModule extends BaseModule {
     });
   }
 
-  fileWatcherGetMonitorPaths(options) {
-    return [ options.tasksPath ];
-  }
-
-  async fileWatcherHandler(options) {
-    await this.waitForAllTasksToFinish();
-
-    let tasks = await this.loadTasks(options.tasksPath);
-
-    this.tasks    = tasks;
-    this.taskInfo = { _startTime: nowInSeconds() };
-
-    this.startTasks();
-  }
-
-  getTaskFilePaths(tasksPath) {
-    return walkDir(tasksPath, {
-      filter: (fullFileName, fileName, stats) => {
-        if (fileName.match(/^_/))
-          return false;
-
-        if (stats.isFile() && !fileNameWithoutExtension(fileName).match(/-task$/))
-          return false;
-
-        return true;
-      },
-    });
-  }
-
-  loadTasks(tasksPath) {
-    let application = this.getApplication();
-    let taskFiles   = this.getTaskFilePaths(tasksPath);
-    let connection  = (typeof application.getConnection === 'function') ? application.getConnection() : null;
-    let dbConfig    = (typeof application.getDBConfig === 'function') ? application.getDBConfig() : null;
-    let tasks       = {};
-    let args        = { application, connection, dbConfig };
-
-    for (let i = 0, il = taskFiles.length; i < il; i++) {
-      let taskFile = taskFiles[i];
-
-      try {
-        let taskGenerator = require(taskFile);
-        if (taskGenerator.__esModule)
-          taskGenerator = taskGenerator['default'];
-
-        Object.assign(tasks, taskGenerator(args));
-      } catch (error) {
-        this.getLogger().error(`Error while loading task ${taskFile}: `, error);
-        throw error;
-      }
-    }
-
-    return tasks;
-  }
-
   async runTasks() {
     const executeTask = (TaskKlass, taskIndex, taskInfo, lastTime, currentTime, diff) => {
       const createTaskLogger = () => {
-        let logger = this.getLogger();
-        return logger.clone({ formatter: (output) => `[[ Running task ${taskName}[${taskIndex}](${runID}) @ ${currentTime} ]]: ${output}`});
+        let appLogger = this.getLogger();
+        return appLogger.clone({ formatter: (output) => `[[ Running task ${taskName}[${taskIndex}] @ ${currentTime} ]]: ${output}`});
       };
 
       const successResult = (value) => {
@@ -132,6 +68,8 @@ class TaskModule extends BaseModule {
           successResult(result);
         } catch (error) {
           errorResult(error);
+        } finally {
+          taskInfo.nextRunAt = TaskKlass.nextRun(taskInstance, lastTime, currentTime, diff);
         }
       };
 
@@ -148,25 +86,12 @@ class TaskModule extends BaseModule {
       let taskName      = TaskKlass.taskName;
       let promise       = Nife.createResolvable();
       let taskInstance  = taskInfo.taskInstance;
-      let runID;
       let logger;
 
-      if (!TaskKlass.keepAlive || !taskInstance) {
-        globalTaskRunID++;
-
-        // eslint-disable-next-line no-magic-numbers
-        runID = `${Math.floor(Date.now() + (Math.random() * 1000000)) + globalTaskRunID}-${taskIndex}`;
-      }
-
-      taskInfo.runID = runID;
-
-      // No op, since promises are handled differently here
-      promise.then(() => {}, () => {});
-
       try {
-        if (!TaskKlass.keepAlive || !taskInstance) {
+        if (TaskKlass.KEEP_ALIVE === false || !taskInstance) {
           logger        = createTaskLogger();
-          taskInstance  = new TaskKlass(this.getApplication(), logger, runID, { lastTime, currentTime, diff });
+          taskInstance  = new TaskKlass(this.getApplication(), logger, taskInfo.index);
 
           taskInfo.taskInstance = taskInstance;
 
@@ -204,7 +129,7 @@ class TaskModule extends BaseModule {
       if (taskInfo.failedCount >= failAfterAttempts)
         return;
 
-      if (!taskKlass.shouldRun(taskIndex, lastTime, currentTime, diff))
+      if (+taskInfo.nextRunAt >= DateTime.now().toMillis())
         return;
 
       taskInfo.lastTime = currentTime;
@@ -217,8 +142,15 @@ class TaskModule extends BaseModule {
 
       for (let taskIndex = 0; taskIndex < workers; taskIndex++) {
         let taskInfo = infoForTasks[taskIndex];
-        if (!taskInfo)
-          taskInfo = infoForTasks[taskIndex] = { failedCount: 0, promise: null, stop: false };
+        if (!taskInfo) {
+          taskInfo = infoForTasks[taskIndex] = {
+            index:        taskIndex,
+            failedCount:  0,
+            promise:      null,
+            stop:         false,
+            nextRunAt:    taskKlass.nextRun(null, undefined, DateTime.now()),
+          };
+        }
 
         if (taskInfo.stop)
           continue;
@@ -273,7 +205,6 @@ class TaskModule extends BaseModule {
       this.taskInfo = { _startTime: nowInSeconds() };
     else
       this.taskInfo._startTime = nowInSeconds();
-
   }
 
   async stopAllTasks() {
@@ -351,11 +282,30 @@ class TaskModule extends BaseModule {
   }
 
   async start(options) {
-    if (options.runTasks === false)
+    if (options.tasks === false)
       return;
 
-    let tasks = await this.loadTasks(options.tasksPath);
-    this.tasks = tasks;
+    const mapTaskClassesToObject = () => {
+      return Nife.iterate(options.tasks, ({ index, key, value, context }) => {
+        let taskName  = key;
+        let TaskClass = value;
+
+        // If this is an array, then the
+        // index will match the task
+        // name. In that case, pull the name
+        // from the task class directly.
+        if (index === taskName) {
+          if (typeof TaskClass.getTaskName === 'function')
+            taskName = TaskClass.getTaskName();
+          else
+            taskName = TaskClass.name;
+        }
+
+        context[taskName] = TaskClass;
+      }, {});
+    };
+
+    this.tasks = mapTaskClassesToObject();
 
     this.startTasks();
   }
@@ -363,5 +313,3 @@ class TaskModule extends BaseModule {
   async stop() {
   }
 }
-
-module.exports = { TaskModule };

package/{src/utils/config-utils.js → lib/utils/config-utils.mjs}

@@ -1,8 +1,4 @@
-'use strict';
-
-/* global process */
-
-const Nife = require('nife');
+import Nife from 'nife';
 
 function getConfigKey(CONFIG, key) {
   return key.replace(/\{([^}]+)\}/g, (m, name) => {
@@ -27,13 +23,9 @@ function ENV(_key, defaultValue) {
   return (value === undefined) ? defaultValue : value;
 }
 
-function wrapConfig(CONFIG) {
+export function wrapConfig(CONFIG) {
   return {
     CONFIG,
     ENV: ENV.bind(CONFIG),
   };
 }
-
-module.exports = {
-  wrapConfig,
-};

package/lib/utils/crypto-utils-spec.mjs

@@ -0,0 +1,24 @@
+import { CryptoUtils } from './index.mjs';
+
+describe('crypto-utils', function() {
+  describe('MD5', function() {
+    it('should be able to hash input', function() {
+      expect(CryptoUtils.MD5('test')).toEqual('098f6bcd4621d373cade4e832627b4f6');
+      expect(CryptoUtils.MD5('')).toEqual('d41d8cd98f00b204e9800998ecf8427e');
+    });
+  });
+
+  describe('SHA256', function() {
+    it('should be able to hash input', function() {
+      expect(CryptoUtils.SHA256('test')).toEqual('9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08');
+      expect(CryptoUtils.SHA256('')).toEqual('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+    });
+  });
+
+  describe('SHA512', function() {
+    it('should be able to hash input', function() {
+      expect(CryptoUtils.SHA512('test')).toEqual('ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff');
+      expect(CryptoUtils.SHA512('')).toEqual('cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e');
+    });
+  });
+});

package/{src/utils/crypto-utils.js → lib/utils/crypto-utils.mjs}

@@ -1,13 +1,9 @@
-'use strict';
-
-/* global Buffer */
-
-const { createHash, randomFillSync } = require('node:crypto');
+import { createHash, randomFillSync }  from 'node:crypto';
 
 const URL_SAFE_ENCODING_KEYS  = { '+': '-', '/': '_', '-': '+', '_': '/' };
 const ENCRYPTION_ALGORITHM    = 'aes-256-ctr';
 
-function toBase64(_data) {
+export function toBase64(_data) {
   var data = _data;
   if (data instanceof Uint8Array)
     data = Buffer.from(data);
@@ -18,53 +14,53 @@ function toBase64(_data) {
   return data.toString('base64');
 }
 
-function convertBase64ToURLSafe(encodedData) {
+export function convertBase64ToURLSafe(encodedData) {
   return encodedData.replace(/[+/]/g, (m) => {
     return URL_SAFE_ENCODING_KEYS[m];
   });
 }
 
-function convertBase64FromURLSafe(encodedData) {
+export function convertBase64FromURLSafe(encodedData) {
   return encodedData.replace(/[_-]/g, (m) => {
     return URL_SAFE_ENCODING_KEYS[m];
   });
 }
 
-function toURLSafeBase64(data) {
+export function toURLSafeBase64(data) {
   return convertBase64ToURLSafe(toBase64(data));
 }
 
-function fromURLSafeBase64(data, encoding) {
+export function fromURLSafeBase64(data, encoding) {
   var buffer = Buffer.from(convertBase64FromURLSafe(data), 'base64');
   return (encoding == null) ? buffer : buffer.toString(encoding);
 }
 
-function randomBytes(length) {
+export function randomBytes(length) {
   let buffer = Buffer.alloc(length);
   randomFillSync(buffer);
 
   return buffer;
 }
 
-function MD5(data) {
+export function MD5(data) {
   let hash = createHash('md5');
   hash.update(data);
   return hash.digest('hex');
 }
 
-function SHA256(data) {
+export function SHA256(data) {
   let hash = createHash('sha256');
   hash.update(data);
   return hash.digest('hex');
 }
 
-function SHA512(data) {
+export function SHA512(data) {
   let hash = createHash('sha512');
   hash.update(data);
   return hash.digest('hex');
 }
 
-function randomHash(type = 'sha256', length = 128) {
+export function randomHash(type = 'sha256', length = 128) {
   let bytes = randomBytes(length);
   let hash  = createHash(type);
 
@@ -73,7 +69,7 @@ function randomHash(type = 'sha256', length = 128) {
   return hash.digest('hex');
 }
 
-function hashToken(token, salt) {
+export function hashToken(token, salt) {
   if (!salt)
     throw new TypeError('Utils::hashToken: "salt" can not be empty');
 
@@ -81,13 +77,13 @@ function hashToken(token, salt) {
   return SHA512(`${salt}${token}`);
 }
 
-function getSaltProperties(salt) {
+export function getSaltProperties(salt) {
   let raw   = fromURLSafeBase64(salt, 'utf8');
   let props = JSON.parse(raw);
   return props;
 }
 
-function generateSalt() {
+export function generateSalt() {
   let props = {
     // eslint-disable-next-line no-magic-numbers
     secretKey:  toURLSafeBase64(randomBytes(32)),
@@ -99,7 +95,7 @@ function generateSalt() {
 
 // secretKey = 32 chars (base64)
 // iv = 32 chars (base64)
-function encrypt(value, salt) {
+export function encrypt(value, salt) {
   const {
     secretKey,
     iv,
@@ -111,7 +107,7 @@ function encrypt(value, salt) {
   return toURLSafeBase64(encrypted);
 }
 
-function decrypt(value, salt) {
+export function decrypt(value, salt) {
   const {
     secretKey,
     iv,
@@ -122,21 +118,3 @@ function decrypt(value, salt) {
 
   return decrpyted.toString('utf8');
 }
-
-module.exports = {
-  toBase64,
-  convertBase64ToURLSafe,
-  convertBase64FromURLSafe,
-  toURLSafeBase64,
-  fromURLSafeBase64,
-  getSaltProperties,
-  generateSalt,
-  encrypt,
-  decrypt,
-  hashToken,
-  randomBytes,
-  randomHash,
-  MD5,
-  SHA256,
-  SHA512,
-};

package/lib/utils/file-utils-spec.mjs

@@ -0,0 +1,10 @@
+import * as FileUtils from './file-utils.mjs';
+
+describe('file-utils', function() {
+  describe('fileNameWithoutExtension', function() {
+    it('should be able to remove the extension from a file name', function() {
+      expect(FileUtils.fileNameWithoutExtension('test.txt')).toEqual('test');
+      expect(FileUtils.fileNameWithoutExtension('test.txt.bin')).toEqual('test.txt');
+    });
+  });
+});

package/{src/utils/file-utils.js → lib/utils/file-utils.mjs}

@@ -1,9 +1,7 @@
-'use strict';
+import Path         from 'node:path';
+import FileSystem   from 'node:fs';
 
-const Path        = require('path');
-const FileSystem  = require('fs');
-
-function walkDir(rootPath, _options, _callback, _allFiles, _depth) {
+export function walkDir(rootPath, _options, _callback, _allFiles, _depth) {
   let depth       = _depth || 0;
   let allFiles    = _allFiles || [];
   let callback    = (typeof _options === 'function') ? _options : _callback;
@@ -44,11 +42,6 @@ function walkDir(rootPath, _options, _callback, _allFiles, _depth) {
   return allFiles;
 }
 
-function fileNameWithoutExtension(fileName) {
+export function fileNameWithoutExtension(fileName) {
   return fileName.replace(/\.[^.]*$/, '');
 }
-
-module.exports = {
-  walkDir,
-  fileNameWithoutExtension,
-};

package/{src/utils/http-utils.js → lib/utils/http-utils.mjs}

@@ -1,8 +1,6 @@
-'use strict';
+import Nife  from 'nife';
 
-const Nife = require('nife');
-
-function dataToQueryString(data, nameFormatter, resolveInitial) {
+export function dataToQueryString(data, nameFormatter, resolveInitial) {
   function fromObject(path, data) {
     let parts = [];
     let keys  = Object.keys(data);
@@ -82,7 +80,7 @@ function dataToQueryString(data, nameFormatter, resolveInitial) {
   return initial + parts.join('&');
 }
 
-function statusCodeToMessage(statusCode) {
+export function statusCodeToMessage(statusCode) {
   let codes = {
     200: 'OK',
     204: 'No Content',
@@ -101,8 +99,3 @@ function statusCodeToMessage(statusCode) {
 
   return code || 'Unknown';
 }
-
-module.exports = {
-  dataToQueryString,
-  statusCodeToMessage,
-};

package/{src → lib}/utils/index.d.ts

@@ -4,4 +4,4 @@ export * as HTTPUtils from './http-utils';
 export * as CryptoUtils from './crypto-utils';
 export * as TestUtils from './test-utils';
 export * as MimeUtils from './mime-utils';
-export * from './http-interface';
+export * from '../http/http-interface';

package/lib/utils/index.mjs

@@ -0,0 +1,6 @@
+export * as ConfigUtils from './config-utils.mjs';
+export * as CryptoUtils from './crypto-utils.mjs';
+export * as FileUtils   from './file-utils.mjs';
+export * as HTTPUtils   from './http-utils.mjs';
+export * as MimeUtils   from './mime-utils.mjs';
+export * as TestUtils   from './test-utils.mjs';

package/lib/utils/mime-utils-spec.mjs

@@ -0,0 +1,171 @@
+import * as MimeUtils from './mime-utils.mjs';
+
+describe('mime-utils', function() {
+  describe('getFilenameExtension', function() {
+    it('should be able to get file name extension', function() {
+      expect(MimeUtils.getFilenameExtension('/test/derp.txt')).toEqual('txt');
+      expect(MimeUtils.getFilenameExtension('/test/derp.test.txt')).toEqual('txt');
+      expect(MimeUtils.getFilenameExtension('test.png')).toEqual('png');
+      expect(MimeUtils.getFilenameExtension('derp.longext')).toEqual('longext');
+    });
+  });
+
+  describe('getMimeTypeFromFilename', function() {
+    it('should be able to get mime type from file name', function() {
+      expect(MimeUtils.getMimeTypeFromFilename('test.3g2')).toEqual('video/3gpp2');
+      expect(MimeUtils.getMimeTypeFromFilename('test.3gp')).toEqual('video/3gpp');
+      expect(MimeUtils.getMimeTypeFromFilename('test.7z')).toEqual('application/x-7z-compressed');
+      expect(MimeUtils.getMimeTypeFromFilename('test.aac')).toEqual('audio/aac');
+      expect(MimeUtils.getMimeTypeFromFilename('test.abw')).toEqual('application/x-abiword');
+      expect(MimeUtils.getMimeTypeFromFilename('test.arc')).toEqual('application/x-freearc');
+      expect(MimeUtils.getMimeTypeFromFilename('test.avi')).toEqual('video/avi');
+      expect(MimeUtils.getMimeTypeFromFilename('test.avif')).toEqual('image/avif');
+      expect(MimeUtils.getMimeTypeFromFilename('test.azw')).toEqual('application/vnd.amazon.ebook');
+      expect(MimeUtils.getMimeTypeFromFilename('test.bin')).toEqual('application/octet-stream');
+      expect(MimeUtils.getMimeTypeFromFilename('test.bmp')).toEqual('image/bmp');
+      expect(MimeUtils.getMimeTypeFromFilename('test.bz')).toEqual('application/x-bzip');
+      expect(MimeUtils.getMimeTypeFromFilename('test.bz2')).toEqual('application/x-bzip2');
+      expect(MimeUtils.getMimeTypeFromFilename('test.cda')).toEqual('application/x-cdf');
+      expect(MimeUtils.getMimeTypeFromFilename('test.csh')).toEqual('application/x-csh');
+      expect(MimeUtils.getMimeTypeFromFilename('test.css')).toEqual('text/css');
+      expect(MimeUtils.getMimeTypeFromFilename('test.csv')).toEqual('text/csv');
+      expect(MimeUtils.getMimeTypeFromFilename('test.doc')).toEqual('application/msword');
+      expect(MimeUtils.getMimeTypeFromFilename('test.docx')).toEqual('application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+      expect(MimeUtils.getMimeTypeFromFilename('test.eot')).toEqual('application/vnd.ms-fontobject');
+      expect(MimeUtils.getMimeTypeFromFilename('test.epub')).toEqual('application/epub+zip');
+      expect(MimeUtils.getMimeTypeFromFilename('test.gif')).toEqual('image/gif');
+      expect(MimeUtils.getMimeTypeFromFilename('test.gz')).toEqual('application/gzip');
+      expect(MimeUtils.getMimeTypeFromFilename('test.htm')).toEqual('text/html');
+      expect(MimeUtils.getMimeTypeFromFilename('test.html')).toEqual('text/html');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ico')).toEqual('image/vnd.microsoft.icon');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ics')).toEqual('text/calendar');
+      expect(MimeUtils.getMimeTypeFromFilename('test.jar')).toEqual('application/java-archive');
+      expect(MimeUtils.getMimeTypeFromFilename('test.jpeg')).toEqual('image/jpeg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.jpg')).toEqual('image/jpeg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mjs')).toEqual('text/javascript');
+      expect(MimeUtils.getMimeTypeFromFilename('test.json')).toEqual('application/json');
+      expect(MimeUtils.getMimeTypeFromFilename('test.jsonld')).toEqual('application/ld+json');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mid')).toEqual('audio/midi');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mjs')).toEqual('text/javascript');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mp3')).toEqual('audio/mpeg3');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mp4')).toEqual('video/mp4');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mpeg')).toEqual('video/mpeg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.mpkg')).toEqual('application/vnd.apple.installer+xml');
+      expect(MimeUtils.getMimeTypeFromFilename('test.odp')).toEqual('application/vnd.oasis.opendocument.presentation');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ods')).toEqual('application/vnd.oasis.opendocument.spreadsheet');
+      expect(MimeUtils.getMimeTypeFromFilename('test.odt')).toEqual('application/vnd.oasis.opendocument.text');
+      expect(MimeUtils.getMimeTypeFromFilename('test.oga')).toEqual('audio/ogg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ogv')).toEqual('video/ogg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ogx')).toEqual('application/ogg');
+      expect(MimeUtils.getMimeTypeFromFilename('test.opus')).toEqual('audio/opus');
+      expect(MimeUtils.getMimeTypeFromFilename('test.otf')).toEqual('font/otf');
+      expect(MimeUtils.getMimeTypeFromFilename('test.pdf')).toEqual('application/pdf');
+      expect(MimeUtils.getMimeTypeFromFilename('test.php')).toEqual('application/x-httpd-php');
+      expect(MimeUtils.getMimeTypeFromFilename('test.png')).toEqual('image/png');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ppt')).toEqual('application/vnd.ms-powerpoint');
+      expect(MimeUtils.getMimeTypeFromFilename('test.pptx')).toEqual('application/vnd.openxmlformats-officedocument.presentationml.presentation');
+      expect(MimeUtils.getMimeTypeFromFilename('test.rar')).toEqual('application/vnd.rar');
+      expect(MimeUtils.getMimeTypeFromFilename('test.rtf')).toEqual('application/rtf');
+      expect(MimeUtils.getMimeTypeFromFilename('test.sh')).toEqual('application/x-sh');
+      expect(MimeUtils.getMimeTypeFromFilename('test.svg')).toEqual('image/svg+xml');
+      expect(MimeUtils.getMimeTypeFromFilename('test.swf')).toEqual('application/x-shockwave-flash');
+      expect(MimeUtils.getMimeTypeFromFilename('test.tar')).toEqual('application/x-tar');
+      expect(MimeUtils.getMimeTypeFromFilename('test.tif')).toEqual('image/tiff');
+      expect(MimeUtils.getMimeTypeFromFilename('test.tiff')).toEqual('image/tiff');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ts')).toEqual('video/mp2t');
+      expect(MimeUtils.getMimeTypeFromFilename('test.ttf')).toEqual('font/ttf');
+      expect(MimeUtils.getMimeTypeFromFilename('test.txt')).toEqual('text/plain');
+      expect(MimeUtils.getMimeTypeFromFilename('test.vsd')).toEqual('application/vnd.visio');
+      expect(MimeUtils.getMimeTypeFromFilename('test.wav')).toEqual('audio/wav');
+      expect(MimeUtils.getMimeTypeFromFilename('test.weba')).toEqual('audio/webm');
+      expect(MimeUtils.getMimeTypeFromFilename('test.webm')).toEqual('video/webm');
+      expect(MimeUtils.getMimeTypeFromFilename('test.webp')).toEqual('image/webp');
+      expect(MimeUtils.getMimeTypeFromFilename('test.woff')).toEqual('font/woff');
+      expect(MimeUtils.getMimeTypeFromFilename('test.woff2')).toEqual('font/woff2');
+      expect(MimeUtils.getMimeTypeFromFilename('test.xhtml')).toEqual('application/xhtml+xml');
+      expect(MimeUtils.getMimeTypeFromFilename('test.xls')).toEqual('application/vnd.ms-excel');
+      expect(MimeUtils.getMimeTypeFromFilename('test.xlsx')).toEqual('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+      expect(MimeUtils.getMimeTypeFromFilename('test.xml')).toEqual('application/xml');
+      expect(MimeUtils.getMimeTypeFromFilename('test.xul')).toEqual('application/vnd.mozilla.xul+xml');
+      expect(MimeUtils.getMimeTypeFromFilename('test.zip')).toEqual('application/zip');
+    });
+  });
+
+  describe('getFileExtensionFromMimeType', function() {
+    it('should be able to get file extension from mime type', function() {
+      expect(MimeUtils.getFileExtensionFromMimeType('video/3gpp2')).toEqual('3g2');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/3gpp')).toEqual('3gp');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-7z-compressed')).toEqual('7z');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/aac')).toEqual('aac');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-abiword')).toEqual('abw');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-freearc')).toEqual('arc');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/avi')).toEqual('avi');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/avif')).toEqual('avif');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.amazon.ebook')).toEqual('azw');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/octet-stream')).toEqual('bin');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/bmp')).toEqual('bmp');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-bzip')).toEqual('bz');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-bzip2')).toEqual('bz2');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-cdf')).toEqual('cda');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-csh')).toEqual('csh');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/css')).toEqual('css');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/csv')).toEqual('csv');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/msword')).toEqual('doc');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.openxmlformats-officedocument.wordprocessingml.document')).toEqual('docx');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.ms-fontobject')).toEqual('eot');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/epub+zip')).toEqual('epub');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/gif')).toEqual('gif');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/gzip')).toEqual('gz');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/html')).toEqual('html');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/vnd.microsoft.icon')).toEqual('ico');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/calendar')).toEqual('ics');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/java-archive')).toEqual('jar');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/jpeg')).toEqual('jpg');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/javascript')).toEqual('js');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/json')).toEqual('json');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/ld+json')).toEqual('jsonld');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/midi')).toEqual('mid');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/javascript')).toEqual('js');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/mpeg3')).toEqual('mp3');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/mp4')).toEqual('mp4');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/mpeg')).toEqual('mpeg');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.apple.installer+xml')).toEqual('mpkg');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.oasis.opendocument.presentation')).toEqual('odp');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.oasis.opendocument.spreadsheet')).toEqual('ods');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.oasis.opendocument.text')).toEqual('odt');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/ogg')).toEqual('oga');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/ogg')).toEqual('ogv');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/ogg')).toEqual('ogx');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/opus')).toEqual('opus');
+      expect(MimeUtils.getFileExtensionFromMimeType('font/otf')).toEqual('otf');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/pdf')).toEqual('pdf');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-httpd-php')).toEqual('php');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/png')).toEqual('png');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.ms-powerpoint')).toEqual('ppt');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.openxmlformats-officedocument.presentationml.presentation')).toEqual('pptx');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.rar')).toEqual('rar');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/rtf')).toEqual('rtf');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-sh')).toEqual('sh');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/svg+xml')).toEqual('svg');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-shockwave-flash')).toEqual('swf');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/x-tar')).toEqual('tar');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/tiff')).toEqual('tiff');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/mp2t')).toEqual('ts');
+      expect(MimeUtils.getFileExtensionFromMimeType('font/ttf')).toEqual('ttf');
+      expect(MimeUtils.getFileExtensionFromMimeType('text/plain')).toEqual('txt');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.visio')).toEqual('vsd');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/wav')).toEqual('wav');
+      expect(MimeUtils.getFileExtensionFromMimeType('audio/webm')).toEqual('weba');
+      expect(MimeUtils.getFileExtensionFromMimeType('video/webm')).toEqual('webm');
+      expect(MimeUtils.getFileExtensionFromMimeType('image/webp')).toEqual('webp');
+      expect(MimeUtils.getFileExtensionFromMimeType('font/woff')).toEqual('woff');
+      expect(MimeUtils.getFileExtensionFromMimeType('font/woff2')).toEqual('woff2');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/xhtml+xml')).toEqual('xhtml');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.ms-excel')).toEqual('xls');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet')).toEqual('xlsx');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/xml')).toEqual('xml');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/vnd.mozilla.xul+xml')).toEqual('xul');
+      expect(MimeUtils.getFileExtensionFromMimeType('application/zip')).toEqual('zip');
+    });
+  });
+});