done purchases remove, ocr scan, read image

express-server/node_modules/express-fileupload/test/fileFactory.spec.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const md5 = require('md5');
+const path = require('path');
+const fileFactory = require('../lib').fileFactory;
+const server = require('./server');
+
+const mockBuffer = fs.readFileSync(path.join(server.fileDir, 'basketball.png'));
+
+describe('Test of the fileFactory factory', function() {
+  beforeEach(function() {
+    server.clearUploadsDir();
+  });
+
+  it('return a file object', function() {
+    assert.ok(fileFactory({
+      name: 'basketball.png',
+      buffer: mockBuffer
+    }));
+  });
+
+  describe('File object behavior', function() {
+    const file = fileFactory({
+      name: 'basketball.png',
+      buffer: mockBuffer
+    });
+    it('move the file to the specified folder', function(done) {
+      file.mv(path.join(server.uploadDir, 'basketball.png'), function(err) {
+        assert.ifError(err);
+        done();
+      });
+    });
+    it('reject the mv if the destination does not exists', function(done) {
+      file.mv(path.join(server.uploadDir, 'unknown', 'basketball.png'), function(err) {
+        assert.ok(err);
+        done();
+      });
+    });
+  });
+
+  describe('Properties', function() {
+    it('contains the name property', function() {
+      assert.equal(fileFactory({
+        name: 'basketball.png',
+        buffer: mockBuffer
+      }).name, 'basketball.png');
+    });
+    it('contains the data property', function() {
+      assert.ok(fileFactory({
+        name: 'basketball.png',
+        buffer: mockBuffer
+      }).data);
+    });
+    it('contains the encoding property', function() {
+      assert.equal(fileFactory({
+        name: 'basketball.png',
+        buffer: mockBuffer,
+        encoding: 'utf-8'
+      }).encoding, 'utf-8');
+    });
+    it('contains the mimetype property', function() {
+      assert.equal(fileFactory({
+        name: 'basketball.png',
+        buffer: mockBuffer,
+        mimetype: 'image/png'
+      }).mimetype, 'image/png');
+    });
+    it('contains the md5 property', function() {
+      const mockMd5 = md5(mockBuffer);
+      assert.equal(fileFactory({
+        name: 'basketball.png',
+        buffer: mockBuffer
+      }).md5(), mockMd5);
+    });
+  });
+});

express-server/node_modules/express-fileupload/test/fileLimitUploads.spec.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const path = require('path');
+const request = require('supertest');
+const assert = require('assert');
+const server = require('./server');
+const clearUploadsDir = server.clearUploadsDir;
+const fileDir = server.fileDir;
+
+describe('Test Single File Upload With File Size Limit', function() {
+  let app;
+
+  beforeEach(function() {
+    clearUploadsDir();
+  });
+
+  describe('abort connection on limit reached', function() {
+    before(function() {
+      app = server.setup({
+        limits: {fileSize: 200 * 1024}, // set 200kb upload limit
+        abortOnLimit: true
+      });
+    });
+
+    it(`upload 'basketball.png' (~154kb) with 200kb size limit`, function(done) {
+      let filePath = path.join(fileDir, 'basketball.png');
+
+      request(app)
+        .post('/upload/single/truncated')
+        .attach('testFile', filePath)
+        .expect(200)
+        .end(done);
+    });
+
+    it(`fail when uploading 'car.png' (~269kb) with 200kb size limit`, function(done) {
+      let filePath = path.join(fileDir, 'car.png');
+
+      request(app)
+        .post('/upload/single/truncated')
+        .attach('testFile', filePath)
+        .expect(413)
+        .end(done);
+    });
+  });
+
+  describe('pass truncated file to the next handler', function() {
+    before(function() {
+      app = server.setup({
+        limits: {fileSize: 200 * 1024} // set 200kb upload limit
+      });
+    });
+
+    it(`fail when uploading 'car.png' (~269kb) with 200kb size limit`, function(done) {
+      let filePath = path.join(fileDir, 'car.png');
+
+      request(app)
+        .post('/upload/single/truncated')
+        .attach('testFile', filePath)
+        .expect(400)
+        .end(function(err, res) {
+          assert.ok(res.error.text === 'File too big');
+          done();
+        });
+    });
+  });
+});

express-server/node_modules/express-fileupload/test/multipartFields.spec.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const request = require('supertest');
+const server = require('./server');
+const app = server.setup();
+
+let mockUser = {
+  firstName: 'Joe',
+  lastName: 'Schmo',
+  email: 'joe@mailinator.com'
+};
+
+let mockCars = [
+  'rsx',
+  'tsx',
+  'civic',
+  'integra'
+];
+
+describe('Test Multipart Form Single Field Submissions', function() {
+  it('submit multipart user data with POST', function(done) {
+    request(app)
+      .post('/fields/user')
+      .field('firstName', mockUser.firstName)
+      .field('lastName', mockUser.lastName)
+      .field('email', mockUser.email)
+      .expect('Content-Type', /json/)
+      .expect(200, {
+        firstName: mockUser.firstName,
+        lastName: mockUser.lastName,
+        email: mockUser.email
+      }, done);
+  });
+
+  it('submit multipart user data with PUT', function(done) {
+    request(app)
+      .post('/fields/user')
+      .field('firstName', mockUser.firstName)
+      .field('lastName', mockUser.lastName)
+      .field('email', mockUser.email)
+      .expect('Content-Type', /json/)
+      .expect(200, {
+        firstName: mockUser.firstName,
+        lastName: mockUser.lastName,
+        email: mockUser.email
+      }, done);
+  });
+
+  it('fail when user data submitted without multipart', function(done) {
+    request(app)
+      .post('/fields/user')
+      .send(mockUser)
+      .expect(400)
+      .end(done);
+  });
+
+  it('fail when user data not submitted', function(done) {
+    request(app)
+      .post('/fields/user')
+      .expect(400)
+      .end(done);
+  });
+});
+
+describe('Test Multipart Form Array Field Submissions', function() {
+  it('submit array of data with POST', function(done) {
+    let req = request(app).post('/fields/array');
+
+    for (let i = 0; i < mockCars.length; i++) {
+      req.field('testField', mockCars[i]);
+    }
+
+    req
+      .expect(200)
+      .end(function(err, res) {
+        if (err) {
+          return done(err);
+        }
+
+        let responseMatchesRequest = res.body.join(',') === mockCars.join(',');
+
+        done(responseMatchesRequest ? null : 'Data was returned as expected.');
+      });
+  });
+});

express-server/node_modules/express-fileupload/test/multipartUploads.spec.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const request = require('supertest');
+const server = require('./server');
+const app = server.setup();
+const clearUploadsDir = server.clearUploadsDir;
+const fileDir = server.fileDir;
+const uploadDir = server.uploadDir;
+
+const mockFiles = [
+  'car.png',
+  'tree.png',
+  'basketball.png'
+];
+
+let mockUser = {
+  firstName: 'Joe',
+  lastName: 'Schmo',
+  email: 'joe@mailinator.com'
+};
+
+describe('Test Directory Cleaning Method', function() {
+  it('emptied "uploads" directory', function(done) {
+    clearUploadsDir();
+
+    let filesFound = fs.readdirSync(uploadDir).length;
+
+    done(filesFound ? `Directory not empty. Found ${filesFound} files.` : null);
+  });
+});
+
+describe('Test Single File Upload', function() {
+  for (let i = 0; i < mockFiles.length; i++) {
+    let fileName = mockFiles[i];
+
+    it(`upload ${fileName} with POST`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .post('/upload/single')
+        .attach('testFile', filePath)
+        .expect(200)
+        .end(function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+
+    it(`upload ${fileName} with PUT`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .post('/upload/single')
+        .attach('testFile', filePath)
+        .expect(200)
+        .end(function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+  }
+
+  it('fail when no files were attached', function(done) {
+    request(app)
+      .post('/upload/single')
+      .expect(400)
+      .end(done);
+  });
+
+  it('fail when using GET', function(done) {
+    let filePath = path.join(fileDir, mockFiles[0]);
+
+    request(app)
+      .get('/upload/single')
+      .attach('testFile', filePath)
+      .expect(400)
+      .end(done);
+  });
+
+  it('fail when using HEAD', function(done) {
+    let filePath = path.join(fileDir, mockFiles[0]);
+
+    request(app)
+      .head('/upload/single')
+      .attach('testFile', filePath)
+      .expect(400)
+      .end(done);
+  });
+});
+
+describe('Test Single File Upload w/ .mv() Promise', function() {
+  for (let i = 0; i < mockFiles.length; i++) {
+    let fileName = mockFiles[i];
+
+    it(`upload ${fileName} with POST w/ .mv() Promise`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .post('/upload/single/promise')
+        .attach('testFile', filePath)
+        .expect(200)
+        .end(function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+
+    it(`upload ${fileName} with PUT w/ .mv() Promise`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .post('/upload/single/promise')
+        .attach('testFile', filePath)
+        .expect(200)
+        .end(function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+  }
+
+  it('fail when no files were attached', function(done) {
+    request(app)
+      .post('/upload/single')
+      .expect(400)
+      .end(done);
+  });
+
+  it('fail when using GET', function(done) {
+    let filePath = path.join(fileDir, mockFiles[0]);
+
+    request(app)
+      .get('/upload/single')
+      .attach('testFile', filePath)
+      .expect(400)
+      .end(done);
+  });
+
+  it('fail when using HEAD', function(done) {
+    let filePath = path.join(fileDir, mockFiles[0]);
+
+    request(app)
+      .head('/upload/single')
+      .attach('testFile', filePath)
+      .expect(400)
+      .end(done);
+  });
+});
+
+describe('Test Multi-File Upload', function() {
+  it('upload multiple files with POST', function(done) {
+    let upload1 = path.join(fileDir, mockFiles[0]);
+    let upload2 = path.join(fileDir, mockFiles[1]);
+    let upload3 = path.join(fileDir, mockFiles[2]);
+
+    clearUploadsDir();
+
+    request(app)
+      .post('/upload/multiple')
+      .attach('testFile1', upload1)
+      .attach('testFile2', upload2)
+      .attach('testFile3', upload3)
+      .expect(200)
+      .end(function(err) {
+        if (err) {
+          return done(err);
+        }
+
+        fs.stat(upload1, function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(upload2, function(err) {
+            if (err) {
+              return done(err);
+            }
+
+            fs.stat(upload3, done);
+          });
+        });
+      });
+  });
+});
+
+describe('Test File Array Upload', function() {
+  it('upload array of files with POST', function(done) {
+    let req = request(app).post('/upload/array');
+
+    clearUploadsDir();
+
+    for (let i = 0; i < mockFiles.length; i++) {
+      req.attach('testFiles', path.join(fileDir, mockFiles[i]));
+    }
+
+    req
+      .expect(200)
+      .end(function(err) {
+        if (err) {
+          return done(err);
+        }
+
+        for (let i = 0; i < mockFiles.length; i++) {
+          fs.statSync(path.join(uploadDir, mockFiles[i]));
+        }
+
+        done();
+      });
+  });
+});
+
+describe('Test Upload With Fields', function() {
+  for (let i = 0; i < mockFiles.length; i++) {
+    let fileName = mockFiles[i];
+
+    it(`upload ${fileName} and submit fields at the same time with POST`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .post('/upload/single/withfields')
+        .attach('testFile', filePath)
+        .field('firstName', mockUser.firstName)
+        .field('lastName', mockUser.lastName)
+        .field('email', mockUser.email)
+        .expect(200, {
+          firstName: mockUser.firstName,
+          lastName: mockUser.lastName,
+          email: mockUser.email
+        },
+        function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+
+    it(`upload ${fileName} and submit fields at the same time with PUT`, function(done) {
+      let filePath = path.join(fileDir, fileName);
+      let uploadedFilePath = path.join(uploadDir, fileName);
+
+      clearUploadsDir();
+
+      request(app)
+        .put('/upload/single/withfields')
+        .attach('testFile', filePath)
+        .field('firstName', mockUser.firstName)
+        .field('lastName', mockUser.lastName)
+        .field('email', mockUser.email)
+        .expect(200, {
+          firstName: mockUser.firstName,
+          lastName: mockUser.lastName,
+          email: mockUser.email
+        },
+        function(err) {
+          if (err) {
+            return done(err);
+          }
+
+          fs.stat(uploadedFilePath, done);
+        });
+    });
+  }
+});

express-server/node_modules/express-fileupload/test/options.spec.js

@@ -0,0 +1,219 @@
+const fs = require('fs');
+const path = require('path');
+const request = require('supertest');
+const server = require('./server');
+const clearUploadsDir = server.clearUploadsDir;
+const fileDir = server.fileDir;
+const uploadDir = server.uploadDir;
+
+describe('File Upload Options Tests', function() {
+  afterEach(function(done) {
+    clearUploadsDir();
+    done();
+  });
+
+  /**
+   * Upload the file for testing and verify the expected filename.
+   * @param {object} options The expressFileUpload options.
+   * @param {string} actualFileNameToUpload The name of the file to upload.
+   * @param {string} expectedFileNameOnFileSystem The name of the file after upload.
+   * @param {function} done The mocha continuation function.
+   */
+  function executeFileUploadTestWalk(options,
+    actualFileNameToUpload,
+    expectedFileNameOnFileSystem,
+    done) {
+    request(server.setup(options))
+      .post('/upload/single')
+      .attach('testFile', path.join(fileDir, actualFileNameToUpload))
+      .expect(200)
+      .end(function(err) {
+        if (err) {
+          return done(err);
+        }
+
+        const uploadedFilePath = path.join(uploadDir, expectedFileNameOnFileSystem);
+
+        fs.stat(uploadedFilePath, done);
+      });
+  }
+
+  describe('Testing [safeFileNames] option to ensure:', function() {
+    it('Does nothing to your filename when disabled.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: false};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'my$Invalid#fileName.png123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Is disabled by default.',
+      function(done) {
+        const fileUploadOptions = null;
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'my$Invalid#fileName.png123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Strips away all non-alphanumeric characters (excluding hyphens/underscores) when enabled.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Accepts a regex for stripping (decidedly) "invalid" characters from filename.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: /[$#]/g};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileName.png123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+  });
+
+  describe('Testing [preserveExtension] option to ensure:', function() {
+    it('Does not preserve the extension of your filename when disabled.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: false};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Is disabled by default.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Shortens your extension to the default(3) when enabled, if the extension found is larger.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: true};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng.123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Leaves your extension alone when enabled, if the extension found is <= default(3) length',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: true};
+        const actualFileName = 'car.png';
+        const expectedFileName = 'car.png';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Can be configured for an extension length > default(3).',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: 7};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileName.png123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Can be configured for an extension length < default(3).',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: 2};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng1.23';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Will use the absolute value of your extension length when negative.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: -5};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamep.ng123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Will leave no extension when the extension length == 0.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: 0};
+        const actualFileName = 'car.png';
+        const expectedFileName = 'car';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Will accept numbers as strings, if they can be resolved with parseInt.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: '3'};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng.123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Will be evaluated for truthy-ness if it cannot be parsed as an int.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: 'not-a-#-but-truthy'};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng.123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Will ignore any decimal amount when evaluating for extension length.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: 4.98};
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepn.g123';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+
+    it('Only considers the last dotted part as the extension.',
+      function(done) {
+        const fileUploadOptions = {safeFileNames: true, preserveExtension: true};
+        const actualFileName = 'basket.ball.bp';
+        const expectedFileName = 'basketball.bp';
+
+        executeFileUploadTestWalk(fileUploadOptions, actualFileName, expectedFileName, done);
+      });
+  });
+
+  describe('Testing [parseNested] option to ensure:', function() {
+    it('When [parseNested] is enabled result are nested', function(done){
+      const app = server.setup({parseNested: true});
+      request(app)
+        .post('/fields/nested')
+        .field('name', 'John')
+        .field('hobbies[0]', 'Cinema')
+        .field('hobbies[1]', 'Bike')
+        .expect('Content-Type', /json/)
+        .expect(200, {
+          name: 'John',
+          hobbies: ['Cinema', 'Bike']
+        }, done);
+    });
+
+    it('When [parseNested] is disabled are flattened', function(done){
+      const app = server.setup({parseNested: false});
+      request(app)
+        .post('/fields/flattened')
+        .field('name', 'John')
+        .field('hobbies[0]', 'Cinema')
+        .field('hobbies[1]', 'Bike')
+        .expect('Content-Type', /json/)
+        .expect(200, {
+          name: 'John',
+          'hobbies[0]': 'Cinema',
+          'hobbies[1]': 'Bike'
+        }, done);
+    });
+  });
+});

express-server/node_modules/express-fileupload/test/processNested.spec.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const assert = require('assert');
+const processNested = require('../lib').processNested;
+
+describe('Test Convert Flatten object to Nested object', function() {
+  it('With no nested data', function(){
+    const data = {
+        'firstname': 'John',
+        'lastname': 'Doe',
+        'age': 22
+      },
+      excerpt= { firstname: 'John', lastname: 'Doe', age: 22 },
+      processed = processNested(data);
+
+    assert.deepEqual(processed, excerpt);
+  });
+
+  it('With nested data', function(){
+    const data = {
+        'firstname': 'John',
+        'lastname': 'Doe',
+        'age': 22,
+        'hobbies[0]': 'Cinema',
+        'hobbies[1]': 'Bike',
+        'address[line]': '78  Lynch Street',
+        'address[city]': 'Milwaukee',
+        'friends[0][name]': 'Jane',
+        'friends[0][lastname]': 'Doe',
+        'friends[1][name]': 'Joe',
+        'friends[1][lastname]': 'Doe'
+      },
+      excerpt = {
+        firstname: 'John',
+        lastname: 'Doe',
+        age: 22,
+        hobbies: [ 'Cinema', 'Bike' ],
+        address: { line: '78  Lynch Street', city: 'Milwaukee' },
+        friends: [
+          { name: 'Jane', lastname: 'Doe' },
+          { name: 'Joe', lastname: 'Doe' }
+        ]
+      },
+      processed = processNested(data);
+
+    assert.deepEqual(processed, excerpt);
+  });
+});

express-server/node_modules/express-fileupload/test/server.js

@@ -0,0 +1,284 @@
+'use strict';
+
+const path = require('path');
+const fileDir = path.join(__dirname, 'files');
+const uploadDir = path.join(__dirname, 'uploads');
+const fs = require('fs');
+const rimraf = require('rimraf');
+
+const clearUploadsDir = function() {
+  if (!fs.existsSync(uploadDir)) {
+    fs.mkdirSync(uploadDir);
+  } else {
+    rimraf.sync(uploadDir);
+    fs.mkdirSync(uploadDir);
+  }
+};
+
+const setup = function(fileUploadOptions) {
+  const express = require('express');
+  const expressFileupload = require('../lib/index');
+
+  const app = express();
+
+  fileUploadOptions = fileUploadOptions || {};
+  app.use(expressFileupload(fileUploadOptions));
+
+  app.all('/upload/single', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    let testFile = req.files.testFile;
+    let uploadPath = path.join(uploadDir, testFile.name);
+
+    testFile.mv(uploadPath, function(err) {
+      if (err) {
+        console.log('ERR', err); // eslint-disable-line
+        return res.status(500).send(err);
+      }
+
+      res.send('File uploaded to ' + uploadPath);
+    });
+  });
+
+  app.all('/upload/single/promise', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    let testFile = req.files.testFile;
+    let uploadPath = path.join(uploadDir, testFile.name);
+
+    testFile
+      .mv(uploadPath)
+      .then(() => {
+        res.send('File uploaded to ' + uploadPath);
+      })
+      .catch(err => {
+        res.status(500).send(err);
+      });
+  });
+
+  app.all('/upload/single/withfields', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    if (!req.body) {
+      return res.status(400).send('No request body found');
+    }
+
+    if (!req.body.firstName || !req.body.firstName.trim()) {
+      return res.status(400).send('Invalid first name');
+    }
+
+    if (!req.body.lastName || !req.body.lastName.trim()) {
+      return res.status(400).send('Invalid last name');
+    }
+
+    if (!req.body.email || !req.body.email.trim()) {
+      return res.status(400).send('Invalid email');
+    }
+
+    let testFile = req.files.testFile;
+    let uploadPath = path.join(uploadDir, testFile.name);
+
+    testFile.mv(uploadPath, function(err) {
+      if (err) {
+        return res.status(500).send(err);
+      }
+
+      res.json({
+        firstName: req.body.firstName,
+        lastName: req.body.lastName,
+        email: req.body.email
+      });
+    });
+  });
+
+  app.all('/upload/single/truncated', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    if (req.files.testFile.truncated) {
+      // status 400 to differentiate from ending the request in the on limit
+      return res.status(400).send(`File too big`);
+    }
+
+    return res.status(200).send('Upload succeed');
+  });
+
+  app.all('/upload/multiple', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    let testFile1 = req.files.testFile1;
+    let testFile2 = req.files.testFile2;
+    let testFile3 = req.files.testFile3;
+    let uploadPath1 = path.join(uploadDir, testFile1.name);
+    let uploadPath2 = path.join(uploadDir, testFile2.name);
+    let uploadPath3 = path.join(uploadDir, testFile3.name);
+
+    if (!testFile1) {
+      return res.status(400).send('testFile1 was not uploaded');
+    }
+
+    if (!testFile2) {
+      return res.status(400).send('testFile2 was not uploaded');
+    }
+
+    if (!testFile3) {
+      return res.status(400).send('testFile3 was not uploaded');
+    }
+
+    testFile1.mv(uploadPath1, function(err) {
+      if (err) {
+        return res.status(500).send(err);
+      }
+
+      testFile2.mv(uploadPath2, function(err) {
+        if (err) {
+          return res.status(500).send(err);
+        }
+
+        testFile3.mv(uploadPath3, function(err) {
+          if (err) {
+            return res.status(500).send(err);
+          }
+
+          res.send('Files uploaded to ' + uploadDir);
+        });
+      });
+    });
+  });
+
+  app.all('/upload/array', function(req, res) {
+    if (!req.files) {
+      return res.status(400).send('No files were uploaded.');
+    }
+
+    let testFiles = req.files.testFiles;
+
+    if (!testFiles) {
+      return res.status(400).send('No files were uploaded');
+    }
+
+    if (!Array.isArray(testFiles)) {
+      return res.status(400).send('Files were not uploaded as an array');
+    }
+
+    if (!testFiles.length) {
+      return res.status(400).send('Files array is empty');
+    }
+
+    let filesUploaded = 0;
+    for (let i = 0; i < testFiles.length; i++) {
+      let uploadPath = path.join(uploadDir, testFiles[i].name);
+
+      testFiles[i].mv(uploadPath, function(err) {
+        if (err) {
+          return res.status(500).send(err);
+        }
+
+        if (++filesUploaded === testFiles.length) {
+          res.send('File uploaded to ' + uploadPath);
+        }
+      });
+    }
+  });
+
+  app.all('/fields/user', function(req, res) {
+    if (!req.body) {
+      return res.status(400).send('No request body found');
+    }
+
+    if (!req.body.firstName || !req.body.firstName.trim()) {
+      return res.status(400).send('Invalid first name');
+    }
+
+    if (!req.body.lastName || !req.body.lastName.trim()) {
+      return res.status(400).send('Invalid last name');
+    }
+
+    if (!req.body.email || !req.body.email.trim()) {
+      return res.status(400).send('Invalid email');
+    }
+
+    res.json({
+      firstName: req.body.firstName,
+      lastName: req.body.lastName,
+      email: req.body.email
+    });
+  });
+
+  app.all('/fields/nested', function(req, res) {
+    if (!req.body) {
+      return res.status(400).send('No request body found');
+    }
+
+    if (!req.body.name || !req.body.name.trim()) {
+      return res.status(400).send('Invalid name');
+    }
+
+    if (!req.body.hobbies || !req.body.hobbies.length == 2) {
+      return res.status(400).send('Invalid hobbies');
+    }
+
+    res.json({
+      name: req.body.name,
+      hobbies: req.body.hobbies
+    });
+  });
+
+  app.all('/fields/flattened', function(req, res) {
+    if (!req.body) {
+      return res.status(400).send('No request body found');
+    }
+
+    if (!req.body.name || !req.body.name.trim()) {
+      return res.status(400).send('Invalid name');
+    }
+
+    if (!req.body['hobbies[0]'] || !req.body['hobbies[0]'].trim()) {
+      return res.status(400).send('Invalid hobbies[0]');
+    }
+
+    if (!req.body['hobbies[1]'] || !req.body['hobbies[1]'].trim()) {
+      return res.status(400).send('Invalid hobbies[1]');
+    }
+
+    res.json({
+      name: req.body.name,
+      'hobbies[0]': req.body['hobbies[0]'],
+      'hobbies[1]': req.body['hobbies[1]']
+    });
+  });
+
+  app.all('/fields/array', function(req, res) {
+    if (!req.body) {
+      return res.status(400).send('No request body found');
+    }
+
+    if (!req.body.testField) {
+      return res.status(400).send('Invalid field');
+    }
+
+    if (!Array.isArray(req.body.testField)) {
+      return res.status(400).send('Field is not an array');
+    }
+
+    res.json(req.body.testField);
+  });
+
+  return app;
+};
+
+module.exports = {
+  setup,
+  fileDir,
+  uploadDir,
+  clearUploadsDir
+};

express-server/node_modules/express-fileupload/test/tempFile.spec.js

@@ -0,0 +1,126 @@
+const fs = require('fs');
+const path = require('path');
+const request = require('supertest');
+const server = require('./server');
+const clearUploadsDir =
+  server.clearUploadsDir;
+const fileDir =
+  server.fileDir;
+const uploadDir =
+  server.uploadDir;
+describe('File Upload Options Tests', function() {
+  afterEach(function(done) {
+    clearUploadsDir();
+    done();
+  });
+  /**
+   * Upload the file for testing and verify the expected filename.
+   * @param {object} options The expressFileUpload options.
+   * @param {string} actualFileNameToUpload The name of the file to upload.
+   * @param {string} expectedFileNameOnFileSystem The name of the file after upload.
+   * @param {function} done The mocha continuation function.
+   */
+  function executeFileUploadTestWalk(
+    options,
+    actualFileNameToUpload,
+    expectedFileNameOnFileSystem,
+    done
+  ) {
+    request(
+      server.setup(options)
+    )
+      .post('/upload/single')
+      .attach(
+        'testFile',
+        path.join(
+          fileDir,
+          actualFileNameToUpload
+        )
+      )
+      .expect(200)
+      .end(function(err) {
+        if (err) {
+          return done(err);
+        }
+        const uploadedFilePath = path.join(
+          uploadDir,
+          expectedFileNameOnFileSystem
+        );
+        fs.stat(
+          uploadedFilePath,
+          done
+        );
+      });
+  }
+  describe('Testing [safeFileNames with useTempFiles] option to ensure:', function() {
+    it('Does nothing to your filename when disabled.', function(done) {
+      const fileUploadOptions = {
+        safeFileNames: false,
+        useTempFiles: true,
+        tempFileDir: '/tmp/'
+      };
+      const actualFileName =
+        'my$Invalid#fileName.png123';
+      const expectedFileName =
+        'my$Invalid#fileName.png123';
+      executeFileUploadTestWalk(
+        fileUploadOptions,
+        actualFileName,
+        expectedFileName,
+        done
+      );
+    });
+    it('Is disabled by default.', function(done) {
+      const fileUploadOptions = {
+        useTempFiles: true,
+        tempFileDir: '/tmp/'
+      };
+      const actualFileName =
+        'my$Invalid#fileName.png123';
+      const expectedFileName =
+        'my$Invalid#fileName.png123';
+      executeFileUploadTestWalk(
+        fileUploadOptions,
+        actualFileName,
+        expectedFileName,
+        done
+      );
+    });
+
+    it(
+      'Strips away all non-alphanumeric characters (excluding hyphens/underscores) when enabled.', 
+      function(done) {
+        const fileUploadOptions = {
+          safeFileNames: true,
+          useTempFiles: true,
+          tempFileDir: '/tmp/'
+        };
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileNamepng123';
+        executeFileUploadTestWalk(
+          fileUploadOptions,
+          actualFileName,
+          expectedFileName,
+          done
+        );
+      });
+
+    it(
+      'Accepts a regex for stripping (decidedly) "invalid" characters from filename.', 
+      function(done) {
+        const fileUploadOptions = {
+          safeFileNames: /[$#]/g,
+          useTempFiles: true,
+          tempFileDir: '/tmp/'
+        };
+        const actualFileName = 'my$Invalid#fileName.png123';
+        const expectedFileName = 'myInvalidfileName.png123';
+        executeFileUploadTestWalk(
+          fileUploadOptions,
+          actualFileName,
+          expectedFileName,
+          done
+        );
+      });
+  });
+});