fix: replace 'should' dependency with native assertions in cookies module

The 'should' module was listed as a devDependency but was required by
lib/cookies/assertion.js at runtime. This caused 'Cannot find module should'
errors for users installing supertest.

This fix replaces all uses of the 'should' assertion library with native
JavaScript assertion helper functions:
- assertHasProperties: checks if object has specified properties (array or object)
- assertNotHasProperties: checks if object does not have specified properties
- assertEqual: checks strict equality
- assertNotEqual: checks strict inequality

The native implementations match the behavior of should.js, including the
'false negative fail' behavior when checking not.have.properties with empty
arrays/objects.

Fixes: #875 (comment)

Author: titanism

lib/cookies/assertion.js

@@ -3,7 +3,88 @@
 'use strict';
 
 const signature = require('cookie-signature');
-const should = require('should');
+
+/**
+ * Assert that an object has specific properties (supports array of keys or object)
+ *
+ * @param {object} obj
+ * @param {object|array} props
+ */
+function assertHasProperties(obj, props) {
+  if (Array.isArray(props)) {
+    props.forEach(function (key) {
+      if (!(key in obj)) {
+        throw new Error('expected object to have property ' + key);
+      }
+    });
+  } else {
+    Object.keys(props).forEach(function (key) {
+      if (!(key in obj)) {
+        throw new Error('expected object to have property ' + key);
+      }
+    });
+  }
+}
+
+/**
+ * Assert that an object does not have specific properties (supports array of keys or object)
+ * When checking with empty props, throws if object exists (matches should.js behavior)
+ *
+ * @param {object} obj
+ * @param {object|array} props
+ */
+function assertNotHasProperties(obj, props) {
+  if (Array.isArray(props)) {
+    // When empty array is passed, should.js throws 'false negative fail' if object exists
+    if (props.length === 0) {
+      throw new Error('expected object to not have properties (false negative fail)');
+    }
+    props.forEach(function (key) {
+      if (key in obj) {
+        throw new Error('expected object to not have property ' + key);
+      }
+    });
+  } else {
+    // When empty object is passed, should.js throws 'false negative fail' if object exists
+    let keys = Object.keys(props);
+    if (keys.length === 0) {
+      throw new Error('expected object to not have properties (false negative fail)');
+    }
+    keys.forEach(function (key) {
+      if (key in obj) {
+        throw new Error('expected object to not have property ' + key);
+      }
+    });
+  }
+}
+
+/**
+ * Assert that two values are equal
+ *
+ * @param {*} actual
+ * @param {*} expected
+ */
+function assertEqual(actual, expected) {
+  if (actual !== expected) {
+    throw new Error(
+      'expected ' + JSON.stringify(actual) + ' to equal ' + JSON.stringify(expected)
+    );
+  }
+}
+
+/**
+ * Assert that two values are not equal
+ *
+ * @param {*} actual
+ * @param {*} expected
+ */
+function assertNotEqual(actual, expected) {
+  if (actual === expected) {
+    throw new Error(
+      'expected ' + JSON.stringify(actual) + ' to not equal ' + JSON.stringify(expected)
+    );
+  }
+}
 
 /**
  * Build Assertion function
@@ -208,8 +289,8 @@ module.exports = function (secret, asserts) {
 
         if (assert && !cookie) throw new Error('expected: ' + expect.name + ' cookie to be set');
 
-        if (assert) should(cookie.options).have.properties(expect.options);
-        else if (cookie) should(cookie.options).not.have.properties(expect.options);
+        if (assert) assertHasProperties(cookie.options, expect.options);
+        else if (cookie) assertNotHasProperties(cookie.options, expect.options);
       });
     });
 
@@ -362,8 +443,8 @@ module.exports = function (secret, asserts) {
         // check cookie values are equal
         if ('value' in expect) {
           try {
-            if (assert) should(cookie.value).be.eql(expect.value);
-            else should(cookie.value).not.be.eql(expect.value);
+            if (assert) assertEqual(cookie.value, expect.value);
+            else assertNotEqual(cookie.value, expect.value);
           } catch (e) {
             if (secret.length) {
               let value;
@@ -387,8 +468,8 @@ module.exports = function (secret, asserts) {
               ? expect.options[key].toString()
               : expect.options[key]
           );
-          if (assert) should(cookie.options[key]).be.eql(expected);
-          else should(cookie.options[key]).not.be.eql(expected);
+          if (assert) assertEqual(cookie.options[key], expected);
+          else assertNotEqual(cookie.options[key], expected);
         });
       });
     });