From 3eea668c7a5b5b89ed052c8bdeda4f5b6277f311 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sat, 29 Oct 2016 23:24:10 -0700
Subject: [PATCH] test: increase test coverage for lib/zlib.js

Add tests for constructor behavior and parameter validation. Remove
condition check that cannot be triggered (nothing is greater than
`Infinity`).

PR-URL: https://github.com/nodejs/node/pull/9366
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Minwoo Jung <jmwsoft@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/zlib.js                                   |   3 +-
 .../test-zlib-deflate-constructors.js         | 105 ++++++++++++++++++
 2 files changed, 106 insertions(+), 2 deletions(-)
 create mode 100644 test/parallel/test-zlib-deflate-constructors.js

diff --git a/lib/zlib.js b/lib/zlib.js
index 42dd561623cb75..bdce0c8d7f2eec 100644
--- a/lib/zlib.js
+++ b/lib/zlib.js
@@ -300,8 +300,7 @@ function Zlib(opts, mode) {
     opts.finishFlush : constants.Z_FINISH;
 
   if (opts.chunkSize) {
-    if (opts.chunkSize < constants.Z_MIN_CHUNK ||
-        opts.chunkSize > constants.Z_MAX_CHUNK) {
+    if (opts.chunkSize < constants.Z_MIN_CHUNK) {
       throw new Error('Invalid chunk size: ' + opts.chunkSize);
     }
   }
diff --git a/test/parallel/test-zlib-deflate-constructors.js b/test/parallel/test-zlib-deflate-constructors.js
new file mode 100644
index 00000000000000..2f23dc595ec0b0
--- /dev/null
+++ b/test/parallel/test-zlib-deflate-constructors.js
@@ -0,0 +1,105 @@
+'use strict';
+
+require('../common');
+
+const zlib = require('zlib');
+const assert = require('assert');
+
+// Work with and without `new` keyword
+assert.ok(zlib.Deflate() instanceof zlib.Deflate);
+assert.ok(new zlib.Deflate() instanceof zlib.Deflate);
+
+assert.ok(zlib.DeflateRaw() instanceof zlib.DeflateRaw);
+assert.ok(new zlib.DeflateRaw() instanceof zlib.DeflateRaw);
+
+// Throws if `opts.chunkSize` is invalid
+assert.throws(
+  () => { new zlib.Deflate({chunkSize: -Infinity}); },
+  /^Error: Invalid chunk size: -Infinity$/
+);
+
+// Confirm that maximum chunk size cannot be exceeded because it is `Infinity`.
+assert.strictEqual(zlib.constants.Z_MAX_CHUNK, Infinity);
+
+// Throws if `opts.windowBits` is invalid
+assert.throws(
+  () => { new zlib.Deflate({windowBits: -Infinity}); },
+  /^Error: Invalid windowBits: -Infinity$/
+);
+
+assert.throws(
+  () => { new zlib.Deflate({windowBits: Infinity}); },
+  /^Error: Invalid windowBits: Infinity$/
+);
+
+// Throws if `opts.level` is invalid
+assert.throws(
+  () => { new zlib.Deflate({level: -Infinity}); },
+  /^Error: Invalid compression level: -Infinity$/
+);
+
+assert.throws(
+  () => { new zlib.Deflate({level: Infinity}); },
+  /^Error: Invalid compression level: Infinity$/
+);
+
+// Throws a RangeError if `level` invalid in  `Deflate.prototype.params()`
+assert.throws(
+  () => { new zlib.Deflate().params(-Infinity); },
+  /^RangeError: Invalid compression level: -Infinity$/
+);
+
+assert.throws(
+  () => { new zlib.Deflate().params(Infinity); },
+  /^RangeError: Invalid compression level: Infinity$/
+);
+
+// Throws if `opts.memLevel` is invalid
+assert.throws(
+  () => { new zlib.Deflate({memLevel: -Infinity}); },
+  /^Error: Invalid memLevel: -Infinity$/
+);
+
+assert.throws(
+  () => { new zlib.Deflate({memLevel: Infinity}); },
+  /^Error: Invalid memLevel: Infinity$/
+);
+
+// Does not throw if opts.strategy is valid
+assert.doesNotThrow(
+  () => { new zlib.Deflate({strategy: zlib.constants.Z_FILTERED}); }
+);
+
+assert.doesNotThrow(
+  () => { new zlib.Deflate({strategy: zlib.constants.Z_HUFFMAN_ONLY}); }
+);
+
+assert.doesNotThrow(
+  () => { new zlib.Deflate({strategy: zlib.constants.Z_RLE}); }
+);
+
+assert.doesNotThrow(
+  () => { new zlib.Deflate({strategy: zlib.constants.Z_FIXED}); }
+);
+
+assert.doesNotThrow(
+  () => { new zlib.Deflate({ strategy: zlib.constants.Z_DEFAULT_STRATEGY}); }
+);
+
+// Throws if opts.strategy is invalid
+assert.throws(
+  () => { new zlib.Deflate({strategy: 'this is a bogus strategy'}); },
+  /^Error: Invalid strategy: this is a bogus strategy$/
+);
+
+// Throws TypeError if `strategy` is invalid in `Deflate.prototype.params()`
+assert.throws(
+  () => { new zlib.Deflate().params(0, 'I am an invalid strategy'); },
+  /^TypeError: Invalid strategy: I am an invalid strategy$/
+);
+
+// Throws if opts.dictionary is not a Buffer
+assert.throws(
+  () => { new zlib.Deflate({dictionary: 'not a buffer'}); },
+  /^Error: Invalid dictionary: it should be a Buffer instance$/
+);