fix: part of #415, start converting to Jest tests

Signed-off-by: Charlike Mike Reagent <[email protected]>

package.json

@@ -30,6 +30,7 @@
     "eslint-config-prettier": "^6.10.0",
     "eslint-plugin-import": "^2.20.0",
     "eslint-plugin-prettier": "^3.1.2",
+    "jest": "^25.1.0",
     "nyc": "^15.0.0",
     "prettier": "^1.19.1",
     "prettier-plugin-pkgjson": "^0.2.0",

test/run.js

@@ -2,5 +2,6 @@
 
 require('urun')(__dirname, {
   verbose: true,
+  include: /test-.+/,
   reporter: 'BashTapReporter',
 });

test/unit/file.test.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// const assert = require('assert');
+// const test = require('utest');
+
+const { File } = require('../../src/index');
+
+const now = new Date();
+const file = new File({
+  size: 1024,
+  path: '/tmp/cat.png',
+  name: 'cat.png',
+  type: 'image/png',
+  lastModifiedDate: now,
+  filename: 'cat.png',
+  mime: 'image/png',
+});
+
+test('File#toJSON()', () => {
+  const obj = file.toJSON();
+  const len = Object.keys(obj).length;
+
+  expect(1024).toBe(obj.size);
+  expect('/tmp/cat.png').toBe(obj.path);
+  expect('cat.png').toBe(obj.name);
+  expect('image/png').toBe(obj.type);
+  expect('image/png').toBe(obj.mime);
+  expect('cat.png').toBe(obj.filename);
+  expect(now).toBe(obj.mtime);
+  expect(len).toBe(8);
+});

test/unit/formidable.test.js

@@ -0,0 +1,96 @@
+/* eslint-disable no-underscore-dangle */
+
+'use strict';
+
+const path = require('path');
+// const assert = require('assert');
+const Request = require('http').ClientRequest;
+
+// const test = require('utest');
+const mod = require('../../src/index');
+
+function getForm(name, opts) {
+  return name === 'formidable' ? mod.formidable(opts) : new mod[name](opts);
+}
+function makeHeader(filename) {
+  return `Content-Disposition: form-data; name="upload"; filename="${filename}"`;
+}
+
+['IncomingForm', 'Formidable', 'formidable'].forEach((name) => {
+  test(`${name}#_fileName with regular characters`, () => {
+    const filename = 'foo.txt';
+    const form = getForm(name);
+
+    expect(form._fileName(makeHeader(filename))).toBe('foo.txt');
+  });
+
+  test(`${name}#_fileName with unescaped quote`, () => {
+    const filename = 'my".txt';
+    const form = getForm(name);
+
+    expect(form._fileName(makeHeader(filename))).toBe('my".txt');
+  });
+
+  test(`${name}#_fileName with escaped quote`, () => {
+    const filename = 'my%22.txt';
+    const form = getForm(name);
+
+    expect(form._fileName(makeHeader(filename))).toBe('my".txt');
+  });
+
+  test(`${name}#_fileName with bad quote and additional sub-header`, () => {
+    const filename = 'my".txt';
+    const form = getForm(name);
+
+    const header = `${makeHeader(filename)}; foo="bar"`;
+    expect(form._fileName(header)).toBe(filename);
+  });
+
+  test(`${name}#_fileName with semicolon`, () => {
+    const filename = 'my;.txt';
+    const form = getForm(name);
+
+    expect(form._fileName(makeHeader(filename))).toBe('my;.txt');
+  });
+
+  test(`${name}#_fileName with utf8 character`, () => {
+    const filename = 'my☃.txt';
+    const form = getForm(name);
+
+    expect(form._fileName(makeHeader(filename))).toBe('my☃.txt');
+  });
+
+  test(`${name}#_uploadPath strips harmful characters from extension when keepExtensions`, () => {
+    const form = getForm(name, { keepExtensions: true });
+
+    let ext = path.extname(form._uploadPath('fine.jpg?foo=bar'));
+    expect(ext).toBe('.jpg');
+
+    ext = path.extname(form._uploadPath('fine?foo=bar'));
+    expect(ext).toBe('');
+
+    ext = path.extname(form._uploadPath('super.cr2+dsad'));
+    expect(ext).toBe('.cr2');
+
+    ext = path.extname(form._uploadPath('super.bar'));
+    expect(ext).toBe('.bar');
+
+    ext = path.extname(form._uploadPath('file.aAa'));
+    expect(ext).toBe('.aAa');
+  });
+
+  test(`${name}#_Array parameters support`, () => {
+    const form = getForm(name, { multiples: true });
+
+    const req = new Request();
+    req.headers = 'content-type: json; content-length:8';
+    form.parse(req, (error, fields) => {
+      expect(Array.isArray(fields.a)).toBe(true);
+      expect(fields.a[0]).toBe(1);
+      expect(fields.a[1]).toBe(2);
+    });
+    form.emit('field', 'a[]', 1);
+    form.emit('field', 'a[]', 2);
+    form.emit('end');
+  });
+});

test/unit/multipart-parser.test.js

@@ -0,0 +1,73 @@
+'use strict';
+
+const { MultipartParser } = require('../../src/index');
+
+test('on constructor', () => {
+  const parser = new MultipartParser();
+  expect(parser.boundary).toBeNull();
+  expect(parser.state).toBe(0);
+  expect(parser.flags).toBe(0);
+  expect(parser.boundaryChars).toBeNull();
+  expect(parser.index).toBeNull();
+  expect(parser.lookbehind).toBeNull();
+  expect(parser.constructor.name).toBe('MultipartParser');
+});
+
+test('initWithBoundary', () => {
+  const boundary = 'abc';
+  const parser = new MultipartParser();
+  parser.initWithBoundary(boundary);
+
+  expect(Array.prototype.slice.call(parser.boundary)).toMatchObject([
+    13,
+    10,
+    45,
+    45,
+    97,
+    98,
+    99,
+  ]);
+  expect(parser.state).toBe(MultipartParser.STATES.START);
+
+  expect(parser.boundaryChars).toMatchObject({
+    10: true,
+    13: true,
+    45: true,
+    97: true,
+    98: true,
+    99: true,
+  });
+});
+
+test('initWithBoundary failing', () => {
+  const parser = new MultipartParser();
+  const boundary = 'abc';
+  const buffer = Buffer.alloc(5);
+
+  parser.initWithBoundary(boundary);
+  buffer.write('--ad', 0);
+  expect(parser.bufferLength).toBe(0);
+
+  parser.write(buffer);
+  expect(parser.bufferLength).toBe(5);
+});
+
+test('on .end() throwing', () => {
+  const parser = new MultipartParser();
+  parser.once('error', () => {});
+
+  const res = parser.end();
+  expect(res.state).toBe(0);
+
+  // expect(() => { parser.end() }).toThrow(/MultipartParser/);
+  // expect(() => { parser.end() }).toThrow(/stream ended unexpectedly/);
+  // expect(() => { parser.end() }).toThrow(parser.explain());
+});
+
+test('on .end() successful', () => {
+  const parser = new MultipartParser();
+  parser.state = MultipartParser.STATES.END;
+
+  const res = parser.end();
+  expect(res.state).toBe(12);
+});

test/unit/test-querystring-parser.js → test/unit/querystring-parser.test.js

@@ -1,33 +1,27 @@
 'use strict';
 
-const assert = require('assert');
 const { QuerystringParser } = require('../../src/index');
 
-let parser;
-
-function test(testFn) {
-  parser = new QuerystringParser();
-  testFn();
-}
-
-test(function ctor() {
-  assert.equal(parser.buffer, '');
-  assert.equal(parser.constructor.name, 'QuerystringParser');
+test('on constructor', () => {
+  const parser = new QuerystringParser();
+  expect(parser.buffer).toBe('');
+  expect(parser.constructor.name).toBe('QuerystringParser');
 });
 
-test(function write() {
+test('on .write', () => {
+  const parser = new QuerystringParser();
   const a = Buffer.from('a=1');
   parser.write(a);
-  assert.equal(parser.bufferLength, a.length);
+  expect(parser.bufferLength).toBe(a.length);
 
   const b = Buffer.from('&b=2');
   parser.write(b);
-  assert.equal(parser.buffer, a + b);
-  assert.equal(parser.bufferLength, a.length + b.length);
+  expect(parser.buffer).toBe(a + b);
+  expect(parser.bufferLength).toBe(a.length + b.length);
 });
 
 // ! skip
-// test(function end() {
+// test(function end =>
 //   const FIELDS = { a: ['b', { c: 'd' }], e: 'f' };
 
 //   gently.expect(GENTLY.hijacked.querystring, 'parse', (str) => {