@suveren/gateway 0.18.0 → 0.18.1

package/node_modules/launder/test/test.js

@@ -0,0 +1,775 @@
+const assert = require('assert');
+const dayjs = require('dayjs');
+
+describe('launder', function() {
+
+  const launder = require('../index.js')();
+
+  it('should exist', function() {
+    assert(launder);
+  });
+
+  describe('instantiation', function() {
+
+    it('should have default filterTag function', function() {
+      assert(typeof (launder.filterTag) === 'function');
+      assert(launder.filterTag('  HEllo ') === 'hello');
+    });
+
+    it('should take a new filterTag function', function() {
+      const launderWithFilterTag = require('../index.js')({
+        filterTag: function(tag) {
+          return 'punk';
+        }
+      });
+
+      assert(typeof (launderWithFilterTag.filterTag) === 'function');
+      assert(launderWithFilterTag.filterTag('  HEllo ') === 'punk');
+    });
+
+  });
+
+  describe('methods', function() {
+    it('should have a `string` method', function() {
+      assert(launder.string);
+    });
+
+    it('should have a `strings` method', function() {
+      assert(launder.strings);
+    });
+
+    it('should have a `integer` method', function() {
+      assert(launder.integer);
+    });
+
+    it('should have a `padInteger` method', function() {
+      assert(launder.padInteger);
+    });
+
+    it('should have a `float` method', function() {
+      assert(launder.float);
+    });
+
+    it('should have a `url` method', function() {
+      assert(launder.url);
+    });
+
+    it('should have a `select` method', function() {
+      assert(launder.select);
+    });
+
+    it('should have a `boolean` method', function() {
+      assert(launder.boolean);
+    });
+
+    it('should have a `addBooleanFilterToCriteria` method', function() {
+      assert(launder.addBooleanFilterToCriteria);
+    });
+
+    it('should have a `date` method', function() {
+      assert(launder.date);
+    });
+
+    it('should have a `formatDate` method', function() {
+      assert(launder.formatDate);
+    });
+
+    it('should have a `time` method', function() {
+      // just a flat circle
+      assert(launder.time);
+    });
+
+    it('should have a `formatTime` method', function() {
+      assert(launder.formatTime);
+    });
+
+    it('should have a `tags` method', function() {
+      assert(launder.tags);
+    });
+
+    it('should have a `id` method', function() {
+      assert(launder.id);
+    });
+
+    it('should have an `ids` method', function() {
+      assert(launder.ids);
+    });
+  });
+
+  describe('string', function() {
+    it('should do nothing to a good string', function() {
+      assert(launder.string('this is great') === 'this is great');
+    });
+
+    it('should trim a string', function() {
+      assert(launder.string('  remove whitespace   ') === 'remove whitespace');
+    });
+
+    it('should convert a number to a string', function() {
+      assert(launder.string(1234) === '1234');
+    });
+
+    it('should convert a boolean to a string', function() {
+      assert(launder.string(true) === 'true');
+      assert(launder.string(false) === 'false');
+    });
+
+    it('should convert non-string/non-number to an empty string', function() {
+      assert(launder.string({ an: 'object' }) === '');
+      assert(launder.string(function() {
+        return 'still not a string';
+      }) === '');
+    });
+
+    it('should use a default for non-strings', function() {
+      assert(launder.string({ an: 'object' }, 'default') === 'default');
+    });
+  });
+
+  describe('strings', function() {
+    it('should do good stuff to an array of strings', function() {
+      const s = launder.strings([ '  testing ', 123 ]);
+      assert(s[0] === 'testing');
+      assert(s[1] === '123');
+    });
+
+    it('should return an empty array if we pass in something that is not an array', function() {
+      const s = launder.strings({
+        an: 'object',
+        is: 'not',
+        typeof: 'array'
+      });
+      assert(Array.isArray(s));
+      assert(s.length === 0);
+    });
+  });
+
+  describe('integer', function() {
+    it('should do nothing to a good integer', function() {
+      assert(launder.integer(123) === 123);
+    });
+    it('should convert a float to a rounded down integer', function() {
+      assert(launder.integer(42.42) === 42);
+    });
+    it('should convet a string of an integer to an integer', function() {
+      assert(launder.integer('123') === 123);
+    });
+    it('should convert a string of a float to a rounded down integer', function() {
+      assert(launder.integer('42.42') === 42);
+    });
+    it('should convert a non-number to 0 by default', function() {
+      assert(launder.integer('nah') === 0);
+    });
+    it('should convert a non-number to the passed in default', function() {
+      assert(launder.integer('nah', 5) === 5);
+    });
+    it('should set a value below min to min', function() {
+      assert(launder.integer(5, null, 10) === 10);
+    });
+    it('should set a value above max to max', function() {
+      assert(launder.integer(25, null, null, 20) === 20);
+    });
+    it('should set a non-number with no default to min', function() {
+      assert(launder.integer('nah', null, 10, 20) === 10);
+    });
+  });
+
+  describe('padInteger', function() {
+    it('should add 0s to to an integer shorter than the pad', function() {
+      assert(launder.padInteger(1234, 10) === '0000001234');
+    });
+    it('should not add 0s to an integer longer than the pad', function() {
+      assert(launder.padInteger(123456789, 5) === '123456789');
+    });
+  });
+
+  describe('float', function() {
+    it('should do nothing to a good float', function() {
+      assert(launder.float(42.42) === 42.42);
+    });
+    it('should convert a string of a float to a float', function() {
+      assert(launder.float('42.42') === 42.42);
+    });
+    it('should convert a non-number to 0 by default', function() {
+      assert(launder.float('nah') === 0);
+    });
+    it('should convert a non-number to the passed in default', function() {
+      assert(launder.float('nah', 5.5) === 5.5);
+    });
+    it('should set a value below min to min', function() {
+      assert(launder.float(5, null, 10.6) === 10.6);
+    });
+    it('should set a value above max to max', function() {
+      assert(launder.float(25, null, null, 20.2) === 20.2);
+    });
+    it('should set a non-number with no default to min', function() {
+      assert(launder.float('nah', null, 10.6, 20.2) === 10.6);
+    });
+  });
+
+  describe('url', function() {
+    it('should do nothing to a good url', function() {
+      assert(launder.url('http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should add http:// when missing', function() {
+      assert(launder.url('www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should remove spaces from a url', function() {
+      assert(launder.url('this is not a url') === 'thisisnotaurl');
+    });
+    it('should return the default if it is an empty string', function() {
+      assert(launder.url('', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should return the default if it is null', function() {
+      assert(launder.url(null, 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should return the default if it is undefined', function() {
+      assert(launder.url(undefined, 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should return the default if it is malicious', function() {
+      assert(launder.url('javascript:alert(\'All your base are belong to us\');', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should return an https url', function() {
+      assert(launder.url('https://www.apostrophenow.org') === 'https://www.apostrophenow.org');
+    });
+    it('should return an sms url', function() {
+      assert(launder.url('sms:123456') === 'sms:123456');
+    });
+    it('should return an tel url', function() {
+      assert(launder.url('tel:123456') === 'tel:123456');
+    });
+    it('should return an ftp url', function() {
+      assert(launder.url('ftp://123456') === 'ftp://123456');
+    });
+    it('should return an mailto url', function() {
+      assert(launder.url('mailto:123456') === 'mailto:123456');
+    });
+    it('should not match a random url', function() {
+      assert(launder.url('randomtag://123456', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should add https:// when missing if httpsFix is true', function() {
+      assert(launder.url('www.apostrophenow.org', null, true) === 'https://www.apostrophenow.org');
+    });
+    it('should reject javascript: even when the URL contains a dot', function() {
+      // Without rejecting before fixUrl, the dot in `document.domain`
+      // causes fixUrl to prepend `https://`, masking the dangerous
+      // scheme rather than discarding it.
+      assert(launder.url('javascript:alert(document.domain)', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should reject javascript: with mixed case', function() {
+      assert(launder.url('JaVaScRiPt:alert(1)', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should reject javascript: smuggled past simple checks with control characters', function() {
+      assert(launder.url('java\tscript:alert(1)', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should reject javascript: smuggled past simple checks with HTML comments', function() {
+      assert(launder.url('java<!---->script:alert(1)', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should reject data: urls', function() {
+      assert(launder.url('data:text/html,<script>alert(1)</script>', 'http://www.apostrophenow.org') === 'http://www.apostrophenow.org');
+    });
+    it('should preserve relative urls beginning with /', function() {
+      assert(launder.url('/about') === '/about');
+    });
+    it('should preserve protocol-relative urls', function() {
+      assert(launder.url('//www.apostrophenow.org') === '//www.apostrophenow.org');
+    });
+  });
+
+  describe('naughtyHref', function() {
+    it('should report javascript: as naughty', function() {
+      assert(launder.naughtyHref('javascript:alert(1)') === true);
+    });
+    it('should report data: as naughty', function() {
+      assert(launder.naughtyHref('data:text/html,<script>alert(1)</script>') === true);
+    });
+    it('should report mixed-case javascript: as naughty', function() {
+      assert(launder.naughtyHref('JaVaScRiPt:alert(1)') === true);
+    });
+    it('should report control-character-smuggled javascript: as naughty', function() {
+      assert(launder.naughtyHref('java\tscript:alert(1)') === true);
+    });
+    it('should report HTML-comment-smuggled javascript: as naughty', function() {
+      assert(launder.naughtyHref('java<!---->script:alert(1)') === true);
+    });
+    it('should accept allowed schemes', function() {
+      assert(launder.naughtyHref('https://example.com') === false);
+      assert(launder.naughtyHref('http://example.com') === false);
+      assert(launder.naughtyHref('ftp://example.com') === false);
+      assert(launder.naughtyHref('mailto:foo@example.com') === false);
+      assert(launder.naughtyHref('tel:1234') === false);
+      assert(launder.naughtyHref('sms:1234') === false);
+    });
+    it('should accept relative URLs', function() {
+      assert(launder.naughtyHref('/about') === false);
+      assert(launder.naughtyHref('about') === false);
+      assert(launder.naughtyHref('#fragment') === false);
+    });
+    it('should accept protocol-relative URLs by default', function() {
+      assert(launder.naughtyHref('//example.com') === false);
+    });
+    it('should reject protocol-relative URLs when allowProtocolRelative is false', function() {
+      assert(launder.naughtyHref('//example.com', { allowProtocolRelative: false }) === true);
+    });
+    it('should respect a custom allowedSchemes list', function() {
+      assert(launder.naughtyHref('https://example.com', { allowedSchemes: [ 'http' ] }) === true);
+      assert(launder.naughtyHref('http://example.com', { allowedSchemes: [ 'http' ] }) === false);
+    });
+    it('should return false for non-string input', function() {
+      assert(launder.naughtyHref(undefined) === false);
+      assert(launder.naughtyHref(null) === false);
+      assert(launder.naughtyHref(42) === false);
+    });
+  });
+
+  describe('select', function() {
+    it('should do nothing to a good choice from an array', function() {
+      assert(launder.select('n', [ 'p', 'u', 'n', 'k' ]) === 'n');
+    });
+    it('should do nothing to a good choice from an object', function() {
+      const s = launder.select('n', [
+        {
+          name: 'Probably amazing',
+          value: 'p'
+        },
+        {
+          name: 'Utterly incredible',
+          value: 'u'
+        },
+        {
+          name: 'Never gonna give you up',
+          value: 'n'
+        },
+        {
+          name: 'Kind hearted',
+          value: 'k'
+        }
+      ]);
+      assert(s === 'n');
+    });
+    it('should return the default if choices is null', function() {
+      assert(launder.select('hi', null, 'bye') === 'bye');
+    });
+    it('should return the default if choices is empty', function() {
+      assert(launder.select('hi', [], 'bye') === 'bye');
+    });
+    it('should return the default if the choice is not found in an array', function() {
+      assert(launder.select('hi', [ 'not', 'in', 'here' ], 'bye') === 'bye');
+    });
+    it('should not crash if a null choice is present', function() {
+      assert(launder.select('yes', [ 'not', null, 'yes' ]) === 'yes');
+    });
+    it('should not crash if an undefined choice is present', function() {
+      assert(launder.select('yes', [ 'not', undefined, 'yes' ]) === 'yes');
+    });
+    it('should not crash if a null choice is present, with labels', function() {
+      assert(launder.select('yes', [ {
+        value: 'not',
+        label: 'Not'
+      }, {
+        value: null,
+        label: 'broken'
+      }, {
+        value: 'yes',
+        label: 'Yes'
+      } ]) === 'yes');
+    });
+    it('should not crash if an undefined choice is present, with labels', function() {
+      assert(launder.select('yes', [ {
+        value: 'not',
+        label: 'Not'
+      }, {
+        value: undefined,
+        label: 'broken'
+      }, {
+        value: 'yes',
+        label: 'Yes'
+      } ]) === 'yes');
+    });
+    it('should return the default if the choice is not found in an object', function() {
+      const s = launder.select('hi', [
+        {
+          name: 'Not something',
+          value: 'not'
+        },
+        {
+          name: 'Inside',
+          value: 'in'
+        },
+        {
+          name: 'Here anymore',
+          value: 'here'
+        }
+      ], 'bye');
+      assert(s === 'bye');
+    });
+    it('should return the default if the choice is not found in an array', function() {
+      assert(launder.select('hi', [ 'not', 'in', 'here' ], 'bye') === 'bye');
+    });
+    it('should match a string input matching the string representation of a choice that is a number, and return the number, not the string', function() {
+      assert(launder.select('5', [ 1, 3, 5 ], 1) === 5);
+    });
+    it('should match a number matching a choice that is a number, and return the number, not a stringification of it', function() {
+      assert(launder.select(5, [ 1, 3, 5 ], 1) === 5);
+    });
+  });
+
+  describe('boolean', function() {
+    it('should do nothing to a proper boolean', function() {
+      assert(launder.boolean(true) === true);
+      assert(launder.boolean(false) === false);
+    });
+    it('should convert a string to a proper boolean', function() {
+      assert(launder.boolean('true') === true);
+      assert(launder.boolean('false') === false);
+    });
+    it('should return true for string of `t`', function() {
+      assert(launder.boolean('t') === true);
+    });
+    it('should return true for string of `y`', function() {
+      assert(launder.boolean('y') === true);
+    });
+    it('should return true for string of `1`', function() {
+      assert(launder.boolean('1') === true);
+    });
+    it('should return true for integer of 1', function() {
+      assert(launder.boolean(1) === true);
+    });
+    it('should return false for an empty string', function() {
+      assert(launder.boolean('') === false);
+    });
+    it('should return the default if nothing is passed', function() {
+      assert(launder.boolean(null, 'yup') === 'yup');
+    });
+    it('should return false if nothing is passed and no default', function() {
+      assert(launder.boolean(null) === false);
+    });
+  });
+
+  describe('booleanOrNull', function() {
+    it('should do nothing to a proper boolean', function() {
+      assert(launder.booleanOrNull(true) === true);
+      assert(launder.booleanOrNull(false) === false);
+    });
+    it('should convert a string to a proper boolean', function() {
+      assert(launder.booleanOrNull('true') === true);
+      assert(launder.booleanOrNull('false') === false);
+    });
+    it('should return true for string of `t`', function() {
+      assert(launder.booleanOrNull('t') === true);
+    });
+    it('should return true for string of `y`', function() {
+      assert(launder.booleanOrNull('y') === true);
+    });
+    it('should return true for string of `1`', function() {
+      assert(launder.booleanOrNull('1') === true);
+    });
+    it('should return true for integer of 1', function() {
+      assert(launder.booleanOrNull(1) === true);
+    });
+    it('should return false for an empty string', function() {
+      assert(launder.booleanOrNull('') === false);
+    });
+    it('should return the default if the empty string is passed', function() {
+      assert(launder.booleanOrNull('', 'yup') === 'yup');
+    });
+    it('should return the default if undefined is passed', function() {
+      assert(launder.booleanOrNull(undefined, 'yup') === 'yup');
+    });
+    it('should return null if null is passed even if there is a default', function() {
+      assert(launder.booleanOrNull(null, 'yup') === null);
+    });
+    it('should return null if null is passed and no default', function() {
+      assert(launder.booleanOrNull(null) === null);
+    });
+    it('should return null if "any" is passed and there is a default', function() {
+      assert(launder.booleanOrNull('any', 'yup') === null);
+    });
+    it('should return null if "null" is passed and there is a default', function() {
+      assert(launder.booleanOrNull('null', 'yup') === null);
+    });
+  });
+
+  describe('addBooleanFilterToCriteria', function() {
+    const name = 'published';
+    const criteria = {};
+    const optionsTrue = { published: true };
+    const optionsFalse = { published: false };
+    const optionsEmpty = { published: '' };
+
+    it('should not change criteria if option is `any`', function() {
+      launder.addBooleanFilterToCriteria('any', name, criteria);
+      assert(criteria[name] === undefined);
+    });
+
+    it('should use a default of `any` if name is not found in options', function() {
+      launder.addBooleanFilterToCriteria({}, name, criteria);
+      assert(criteria[name] === undefined);
+    });
+    it('should use a default of `any` if options is null', function() {
+      launder.addBooleanFilterToCriteria(null, name, criteria);
+      assert(criteria[name] === undefined);
+    });
+    it('should use `name` property of `options` if `options` is an object', function() {
+      launder.addBooleanFilterToCriteria(optionsTrue, name, criteria);
+      assert(criteria[name] === true);
+      const criteria2 = {};
+      launder.addBooleanFilterToCriteria(optionsFalse, name, criteria2);
+      assert(criteria2[name].$ne === true);
+    });
+    it('should be able to use a boolean string `true` for options', function() {
+      const criteria = {};
+      launder.addBooleanFilterToCriteria('true', name, criteria);
+      assert(criteria[name] === true);
+    });
+    it('should be able to use a boolean string `y` for options', function() {
+      const criteria = {};
+      launder.addBooleanFilterToCriteria('y', name, criteria);
+      assert(criteria[name] === true);
+    });
+    it('should be able to use a real boolean for options', function() {
+      let criteria = {};
+      launder.addBooleanFilterToCriteria(true, name, criteria);
+      assert(criteria[name] === true);
+      criteria = {};
+      launder.addBooleanFilterToCriteria(false, name, criteria);
+      assert(criteria[name].$ne === true);
+    });
+    it('should treat empty string as false', function() {
+      const criteria = {};
+      launder.addBooleanFilterToCriteria('', name, criteria);
+      assert(criteria[name].$ne === true);
+    });
+    it('should treat empty string in an object as false', function() {
+      const criteria = {};
+      launder.addBooleanFilterToCriteria(optionsEmpty, name, criteria);
+      assert(criteria[name].$ne === true);
+    });
+    it('should take a default if `options` or `options[name]` is undefined', function() {
+      const criteria = {};
+      launder.addBooleanFilterToCriteria({}, name, criteria, false);
+      assert(criteria[name].$ne === true);
+    });
+  });
+
+  describe('date', function() {
+    it('should do nothing to a good date', function() {
+      assert(launder.date('2015-02-19') === '2015-02-19');
+    });
+    it('should convert dates in MM/DD/YYYY format', function() {
+      assert(launder.date('2/19/2015') === '2015-02-19');
+    });
+    it('should convert dates in MM/DD/YY format to the past century when that is closest', function() {
+      assert(launder.date('2/19/99', new Date(2015, 1, 1)) === '1999-02-19');
+    });
+    it('should convert dates in MM/DD/YY format to the current century when that is closest', function() {
+      assert(launder.date('2/19/15') === '2015-02-19');
+    });
+    it('should use the current year if in MM/DD format', function() {
+      const year = dayjs().format('YYYY');
+      assert(launder.date('2/19') === year + '-02-19');
+    });
+    it('should accept a date object', function() {
+      assert(launder.date(new Date(2015, 1, 19)) === '2015-02-19');
+    });
+    it('should return current date if the date is not parsable', function() {
+      assert(launder.date('waffles') === dayjs().format('YYYY-MM-DD'));
+    });
+    it('should return default if the date is not parsable', function() {
+      assert(launder.date('waffles', '1989-12-13') === '1989-12-13');
+    });
+    it('should return null if the input and default are both explicitly null', function() {
+      assert.strictEqual(launder.date(null, null), null);
+    });
+    it('should return null if the date is undefined and the default is null', function() {
+      assert(launder.date(undefined, null) === null);
+    });
+    it('should return today\'s date if the date is undefined and there is no default', function() {
+      const today = new Date().toISOString().slice(0, 10);
+      assert.strictEqual(launder.date(null), today);
+    });
+  });
+
+  describe('formatDate', function() {
+    it('should accept a date object', function() {
+      assert(launder.formatDate(new Date(2015, 1, 19, 11, 22, 33)) === '2015-02-19');
+    });
+    it('should default to current date', function() {
+      assert(launder.formatDate() === dayjs().format('YYYY-MM-DD'));
+    });
+  });
+
+  describe('time', function() {
+    it('should show me a good time', function() {
+      assert(launder.time('12:34:56') === '12:34:56');
+    });
+    it('should show me a good, quick time', function() {
+      assert(launder.time('12:34') === '12:34:00');
+    });
+    it('should show me a really quick good time', function() {
+      assert(launder.time('12') === '12:00:00');
+    });
+    it('should convert 12h to 24h', function() {
+      assert(launder.time('4:30pm') === '16:30:00');
+    });
+    it('should not require the m in pm', function() {
+      assert(launder.time('4:30p') === '16:30:00');
+    });
+    it('should handle lower or uppercase meridiems', function() {
+      assert(launder.time('4:30pm') === '16:30:00');
+      assert(launder.time('4:30PM') === '16:30:00');
+    });
+    it('should accept dot as time separator', function() {
+      assert(launder.time('4.30pm') === '16:30:00');
+      assert(launder.time('4.30PM') === '16:30:00');
+    });
+    it('should accept dot and colon mixed as time separator', function() {
+      assert(launder.time('3.52:05pm') === '15:52:05');
+      assert(launder.time('4:32.23a') === '04:32:23');
+    });
+    it('should accept not accept any time separator', function() {
+      assert(launder.time('3q52b05pm') !== '15:52:05');
+      assert(launder.time('4 32 23a') !== '04:32:23');
+      assert(launder.time('12Qpm') !== '12:00:00');
+    });
+    it('should handle no minutes', function() {
+      assert(launder.time('4 PM') === '16:00:00');
+    });
+    it('should default to the current time', function() {
+      assert(launder.time() === dayjs().format('HH:mm'));
+    });
+    it('should accept a default', function() {
+      assert(launder.time(null, '12:00:00') === '12:00:00');
+    });
+  });
+
+  describe('formatTime', function() {
+    it('should accept a date object', function() {
+      assert(launder.formatTime(new Date(2015, 1, 19, 11, 22, 33)) === '11:22:33');
+    });
+    it('should default to current time', function() {
+      assert(launder.formatTime() === dayjs().format('HH:mm:ss'));
+    });
+  });
+
+  describe('tags', function() {
+    const goodTags = [ 'one', 'two', 'three' ];
+    const spaceyTags = [ ' One', 'TWO', '    three  ' ];
+    const numberTags = [ 12, 34 ];
+    const troubleTags = [ 'one', 2, { an: 'object' }, null, 'three' ];
+
+    it('should do nothing to a good array of tags', function() {
+      const t = launder.tags(goodTags);
+      assert(t.length === 3);
+      assert(t[0] === 'one');
+      assert(t[1] === 'two');
+      assert(t[2] === 'three');
+    });
+    it('should apply default filterTag function', function() {
+      const t = launder.tags(spaceyTags);
+      assert(t.length === 3);
+      assert(t[0] === 'one');
+      assert(t[1] === 'two');
+      assert(t[2] === 'three');
+    });
+    it('should return an empty array if you pass in something that is not an array', function() {
+      const t = launder.tags({
+        an: 'object',
+        is: 'not',
+        typeof: 'array'
+      });
+      assert(Array.isArray(t));
+      assert(t.length === 0);
+    });
+    it('should convert numbers to strings in tags', function() {
+      const t = launder.tags(numberTags);
+      assert(t.length === 2);
+      assert(t[0] === '12');
+      assert(t[1] === '34');
+    });
+    it('should remove things that are not strings or numbers', function() {
+      const t = launder.tags(troubleTags);
+      assert(t.length === 3);
+      assert(t[0] === 'one');
+      assert(t[1] === '2');
+      assert(t[2] === 'three');
+    });
+    it('should take a filter function', function() {
+      const t = launder.tags(numberTags, function(tag) {
+        return tag + '0';
+      });
+      assert(t.length === 2);
+      assert(t[0] === '120');
+      assert(t[1] === '340');
+    });
+    it('should allow a different filter function to be set during initiation', function() {
+      const launder = require('../index.js')({
+        filterTag: function(tag) {
+          return tag + '0';
+        }
+      });
+      const t = launder.tags(numberTags);
+      assert(t.length === 2);
+      assert(t[0] === '120');
+      assert(t[1] === '340');
+    });
+    it('should remove empty tags', function() {
+      const t = launder.tags([ '1', '2', '' ]);
+      assert(t.length === 2);
+      assert(t[0] === '1');
+      assert(t[1] === '2');
+    });
+  });
+
+  describe('id', function() {
+    it('should do nothing to a good id', function() {
+      assert(launder.id('aBcD_1234') === 'aBcD_1234');
+    });
+    it('should return undefined if not valid', function() {
+      assert(launder.id('@#%!#%') === undefined);
+      assert(launder.id('abc 123') === undefined);
+    });
+    it('should return default if not valid', function() {
+      assert(launder.id('@#%!#%', '1234') === '1234');
+    });
+  });
+
+  describe('ids', function() {
+    const goodIds = [ '1001', '1002', '1003' ];
+    const troubleIds = [ '1001', '1002', { an: 'object' }, null, '1003', '1004-en' ];
+    it('should do nothing with a good array of ids', function() {
+      const i = launder.ids(goodIds);
+      assert(i.length === 3);
+      assert(i[0] === '1001');
+      assert(i[1] === '1002');
+      assert(i[2] === '1003');
+    });
+    it('should return an empty array if you pass in something that is not an array', function() {
+      const i = launder.ids({
+        an: 'object',
+        is: 'not',
+        typeof: 'array'
+      });
+      assert(Array.isArray(i));
+      assert(i.length === 0);
+    });
+    it('should remove items that are not valid ids', function() {
+      const i = launder.ids(troubleIds);
+      assert(i.length === 3);
+      assert(i[0] === '1001');
+      assert(i[1] === '1002');
+      assert(i[2] === '1003');
+    });
+    it('should honor the idRegExp option', function() {
+      const launder = require('../index.js')({ idRegExp: /^[A-Za-z0-9_-]+$/ });
+      const testIds = [ '1001', '1002', { an: 'object' }, null, '1003', '1004-en' ];
+      const i = launder.ids(testIds);
+      assert.strictEqual(i.length, 4);
+      assert(i[0] === '1001');
+      assert(i[1] === '1002');
+      assert(i[2] === '1003');
+      assert(i[3] === '1004-en');
+    });
+  });
+
+});