fix(tests): include multipart and qs parser unit tests, part of #415

Signed-off-by: Charlike Mike Reagent <opensource@tunnckocore.com>

src/index.js

@@ -27,4 +27,8 @@ module.exports = Object.assign(formidable, {
   MultipartParser,
   OctetStreamParser,
   QuerystringParser,
+
+  // typo aliases
+  OctetstreamParser: OctetStreamParser,
+  QueryStringParser: QuerystringParser,
 });

src/parsers/Multipart.js

@@ -48,6 +48,7 @@ class MultipartParser extends Transform {
     this.boundary = null;
     this.boundaryChars = null;
     this.lookbehind = null;
+    this.bufferLength = 0;
     this.state = STATE.PARSER_UNINITIALIZED;
 
     this.index = null;
@@ -98,7 +99,7 @@ class MultipartParser extends Transform {
     const { lookbehind, boundary, boundaryChars } = this;
     const boundaryLength = boundary.length;
     const boundaryEnd = boundaryLength - 1;
-    const bufferLength = buffer.length;
+    this.bufferLength = buffer.length;
     let c = null;
     let cl = null;
 
@@ -125,7 +126,7 @@ class MultipartParser extends Transform {
       }
     };
 
-    for (i = 0; i < bufferLength; i++) {
+    for (i = 0; i < this.bufferLength; i++) {
       c = buffer[i];
       switch (state) {
         case STATE.PARSER_UNINITIALIZED:
@@ -232,7 +233,7 @@ class MultipartParser extends Transform {
           if (index === 0) {
             // boyer-moore derrived algorithm to safely skip non-boundary data
             i += boundaryEnd;
-            while (i < bufferLength && !(buffer[i] in boundaryChars)) {
+            while (i < this.bufferLength && !(buffer[i] in boundaryChars)) {
               i += boundaryLength;
             }
             i -= boundaryEnd;
@@ -317,7 +318,7 @@ class MultipartParser extends Transform {
     this.flags = flags;
 
     done();
-    return bufferLength;
+    return this.bufferLength;
   }
 
   explain() {

src/parsers/Querystring.js

@@ -12,10 +12,12 @@ class QuerystringParser extends Transform {
     super({ readableObjectMode: true });
     this.maxKeys = maxKeys;
     this.buffer = '';
+    this.bufferLength = 0;
   }
 
   _transform(buffer, encoding, callback) {
     this.buffer += buffer.toString('ascii');
+    this.bufferLength = this.buffer.length;
     callback();
   }
 

test/unit/test-multipart-parser.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const assert = require('assert');
+
+const { MultipartParser } = require('../../src/index');
+
+let parser;
+
+function test(testFn) {
+  parser = new MultipartParser();
+  testFn();
+}
+
+test(function constructor() {
+  assert.strictEqual(parser.boundary, null);
+  assert.strictEqual(parser.state, 0);
+  assert.strictEqual(parser.flags, 0);
+  assert.strictEqual(parser.boundaryChars, null);
+  assert.strictEqual(parser.index, null);
+  assert.strictEqual(parser.lookbehind, null);
+  assert.strictEqual(parser.constructor.name, 'MultipartParser');
+});
+
+test(function initWithBoundary() {
+  const boundary = 'abc';
+  parser.initWithBoundary(boundary);
+  assert.deepEqual(Array.prototype.slice.call(parser.boundary), [
+    13,
+    10,
+    45,
+    45,
+    97,
+    98,
+    99,
+  ]);
+  assert.strictEqual(parser.state, MultipartParser.STATES.START);
+
+  assert.deepEqual(parser.boundaryChars, {
+    10: true,
+    13: true,
+    45: true,
+    97: true,
+    98: true,
+    99: true,
+  });
+});
+
+test(function parserError() {
+  const boundary = 'abc';
+  const buffer = Buffer.alloc(5);
+
+  parser.initWithBoundary(boundary);
+  buffer.write('--ad', 0);
+  // assert.strictEqual(parser.bufferLength, 0);
+  parser.write(buffer);
+  assert.strictEqual(parser.bufferLength, 5);
+});
+
+// ! skip
+// test(function end() {
+//   (function testError() {
+//     assert.strictEqual(
+//       parser.end().message,
+//       `MultipartParser.end(): stream ended unexpectedly: ${parser.explain()}`,
+//     );
+//   })();
+
+//   (function testRegular() {
+//     parser.state = MultipartParser.STATES.END;
+//     assert.strictEqual(parser.end(), undefined);
+//   })();
+// });

test/unit/test-querystring-parser.js

@@ -0,0 +1,46 @@
+'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(function write() {
+  const a = Buffer.from('a=1');
+  parser.write(a);
+  assert.equal(parser.bufferLength, 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);
+});
+
+// test(function end() {
+//   const FIELDS = { a: ['b', { c: 'd' }], e: 'f' };
+
+//   gently.expect(GENTLY.hijacked.querystring, 'parse', (str) => {
+//     assert.equal(str, parser.buffer);
+//     return FIELDS;
+//   });
+
+//   gently.expect(parser, 'onField', Object.keys(FIELDS).length, (key, val) => {
+//     assert.deepEqual(FIELDS[key], val);
+//   });
+
+//   gently.expect(parser, 'onEnd');
+
+//   parser.buffer = 'my buffer';
+//   parser.end();
+//   assert.equal(parser.buffer, '');
+// });