Support Joi v15 + Tests (#6)

Author: kamronbatman

.eslintignore

@@ -0,0 +1,3 @@
+!*
+node_modules/
+.idea/

.eslintrc

@@ -0,0 +1,17 @@
+{
+  "extends": ["airbnb-base", "plugin:jest/recommended"],
+  "rules": {
+    "strict": "off",
+    "max-len": "off",
+    "no-console": "off",
+    "no-continue": "off",
+    "no-plusplus": "off",
+    "global-require": "off",
+    "operator-linebreak": ["error", "after"],
+    "no-underscore-dangle": "off",
+    "prefer-const": ["error", { "destructuring": "all", "ignoreReadBeforeAssign": true }]
+  },
+  "env": {
+    "jest/globals": true
+  }
+}

.gitignore

@@ -1 +1,2 @@
 node_modules/
+.idea/

README.md

@@ -2,16 +2,20 @@
 
 Creates a Joi object that validates password complexity.
 
+## Requirements
+* Joi v15 or higher
+* Nodejs 8 or higher
+
 ## Installation
 
 `npm install joi-password-complexity`
 
-## Example
+## Examples
 
 ### No options specified
 
 ```javascript
-const Joi = require('joi');
+const Joi = require('@hapi/joi');
 const PasswordComplexity = require('joi-password-complexity');
 
 Joi.validate('aPassword123!', new PasswordComplexity(), (err, value) => {
@@ -28,14 +32,14 @@ When no options are specified, the following are used:
   upperCase: 1,
   numeric: 1,
   symbol: 1,
-  requirementCount: 3,
+  requirementCount: 4,
 }
 ```
 
 ### Options specified
 
 ```javascript
-const Joi = require('joi');
+const Joi = require('@hapi/joi');
 const PasswordComplexity = require('joi-password-complexity');
 
 const complexityOptions = {

lib/index.js

@@ -1,6 +1,9 @@
 const path = require('path');
-const Any = require(path.join(path.dirname(require.resolve('joi')), 'types/any/index.js'));
-const Language = require(path.join(path.dirname(require.resolve('joi')), 'language.js'));
+
+/* eslint-disable import/no-dynamic-require */
+const Any = require(path.join(path.dirname(require.resolve('@hapi/joi')), 'types/any/index.js'));
+const Language = require(path.join(path.dirname(require.resolve('@hapi/joi')), 'language.js'));
+/* eslint-enable */
 
 const defaultOptions = {
   min: 8,
@@ -9,7 +12,7 @@ const defaultOptions = {
   upperCase: 1,
   numeric: 1,
   symbol: 1,
-  requirementCount: 3,
+  requirementCount: 4,
 };
 
 const PasswordComplexity = class extends Any {
@@ -20,8 +23,8 @@ const PasswordComplexity = class extends Any {
 
     this._options = options || defaultOptions;
     if (options && !options.requirementCount) {
-      this._options.requirementCount = (options.lowerCase > 0)
-      + (options.upperCase > 0) + (options.numeric > 0) + (options.symbol > 0);
+      this._options.requirementCount = (options.lowerCase > 0) +
+      (options.upperCase > 0) + (options.numeric > 0) + (options.symbol > 0);
     }
   }
 
@@ -42,30 +45,50 @@ const PasswordComplexity = class extends Any {
   }
 
   _base(value, state, options) {
-    let validated = 0;
-    let matchMin = false;
-    let matchMax = false;
+    const errors = [];
 
     if (typeof value === 'string') {
-      matchMin = this._options.min && value.length >= this._options.min;
-      matchMax = this._options.max && value.length <= this._options.max;
+      const lowercaseCount = (value.match(/[a-z]/g) || []).length;
+      const upperCaseCount = (value.match(/[A-Z]/g) || []).length;
+      const numericCount = (value.match(/[0-9]/g) || []).length;
+      const symbolCount = (value.match(/[^a-zA-Z0-9]/g) || []).length;
+
+      const meetsMin = this._options.min && value.length >= this._options.min;
+      const meetsMax = this._options.max && value.length <= this._options.max;
+      const meetsLowercase = lowercaseCount >= this._options.lowerCase;
+      const meetsUppercase = upperCaseCount >= this._options.upperCase;
+      const meetsNumeric = numericCount >= this._options.numeric;
+      const meetsSymbol = symbolCount >= this._options.symbol;
+      const meetsRequirementCount = !this._options.requirementCount ||
+        meetsLowercase + meetsUppercase + meetsNumeric + meetsSymbol >= this._options.requirementCount;
 
-      validated += (value.match(/[a-z]/g) || []).length >= this._options.lowerCase;
-      validated += (value.match(/[A-Z]/g) || []).length >= this._options.upperCase;
-      validated += (value.match(/[0-9]/g) || []).length >= this._options.numeric;
-      validated += (value.match(/[^a-zA-Z0-9]/g) || []).length >= this._options.symbol;
+      if (!meetsMin) errors.push(this.createError('passwordComplexity.tooShort', { value }, state, options));
+      if (!meetsMax) errors.push(this.createError('passwordComplexity.tooLong', { value }, state, options));
+      if (!meetsLowercase) errors.push(this.createError('passwordComplexity.lowercase', { value }, state, options));
+      if (!meetsUppercase) errors.push(this.createError('passwordComplexity.uppercase', { value }, state, options));
+      if (!meetsNumeric) errors.push(this.createError('passwordComplexity.numeric', { value }, state, options));
+      if (!meetsSymbol) errors.push(this.createError('passwordComplexity.symbol', { value }, state, options));
+      if (!meetsRequirementCount) {
+        errors.push(this.createError('passwordComplexity.requirementCount', { value }, state, options));
+      }
     }
 
     return {
       value,
-      errors: (matchMin && matchMax && validated >= this._options.requirementCount) ? null
-        : this.createError('passwordComplexity.base', { value }, state, options),
+      errors: errors.length ? errors : null,
     };
   }
 };
 
 Language.errors.passwordComplexity = {
   base: 'must meet password complexity requirements',
+  tooShort: 'is too short',
+  tooLong: 'is too long',
+  lowercase: 'doesn\'t contain the required lowercase characters',
+  uppercase: 'doesn\'t contain the required uppercase characters',
+  numeric: 'doesn\'t contain the required numeric characters',
+  symbol: 'doesn\'t contain the required symbols',
+  requirementCount: 'must meet enough of the complexity requirements',
 };
 
 module.exports = PasswordComplexity;

package.json

@@ -1,20 +1,26 @@
 {
   "name": "joi-password-complexity",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "Joi validation for password complexity requirements.",
   "main": "lib/index.js",
   "scripts": {
-    "test": "npm test"
+    "test": "jest",
+    "lint": "./node_modules/.bin/eslint --fix --ext .js ."
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kamronbatman/joi-password-complexity.git"
   },
-  "peerDependencies": {
-    "joi": ">=10.5.0"
+  "peerDependencies": {},
+  "devDependencies": {
+    "eslint": "^6.1.0",
+    "eslint-config-airbnb-base": "^13.2.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-jest": "^22.14.0",
+    "jest": "^24.8.0"
   },
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=8.0.0"
   },
   "keywords": [
     "Joi",
@@ -27,5 +33,11 @@
   "bugs": {
     "url": "https://github.com/kamronbatman/joi-password-complexity/issues"
   },
-  "homepage": "https://github.com/kamronbatman/joi-password-complexity#readme"
+  "homepage": "https://github.com/kamronbatman/joi-password-complexity#readme",
+  "jest": {
+    "verbose": true
+  },
+  "dependencies": {
+    "@hapi/joi": "^15.1.0"
+  }
 }

test/password.test.js

@@ -0,0 +1,79 @@
+const Joi = require('@hapi/joi');
+
+const PasswordComplexity = require('../lib/index');
+
+describe('JoiPasswordComplexity defaultOptions', () => {
+  it('should reject a password that is too short', () => {
+    const password = '123';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.tooShort');
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" is too short');
+  });
+  it('should reject a password that is too long', () => {
+    const password = '123456791234567912345679123';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.tooLong');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" is too long');
+  });
+
+  it('should reject a password that doesn\'t meet the required lowercase count', () => {
+    const password = 'ABCDEFG';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.lowercase');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" doesn\'t contain the required lowercase characters');
+  });
+
+  it('should reject a password that doesn\'t meet the required uppercase count', () => {
+    const password = 'abcdefg';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.uppercase');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" doesn\'t contain the required uppercase characters');
+  });
+
+  it('should reject a password that doesn\'t meet the required numeric count', () => {
+    const password = 'ABCDEFG';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.numeric');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" doesn\'t contain the required numeric characters');
+  });
+
+  it('should reject a password that doesn\'t meet the required symbol count', () => {
+    const password = 'ABCDEFG';
+
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.symbol');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" doesn\'t contain the required symbols');
+  });
+
+  it('should accept a valid password', () => {
+    const password = 'abCD12#$';
+    const result = Joi.validate(password, new PasswordComplexity());
+
+    expect(result.error).toBeNull();
+  });
+
+  it('should reject a password that doesn\'t meet the requirement count', () => {
+    const password = 'abCD12';
+    const result = Joi.validate(password, new PasswordComplexity());
+    const errors = result.error.details.filter(e => e.type === 'passwordComplexity.requirementCount');
+
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe('"value" must meet enough of the complexity requirements');
+  });
+});