Code coverage report for lib/validator.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
1
 
 
 
 
 
 
 
 
 
1
6
6
5
 
4
 
4
 
 
4
4
5
4
 
 
 
2
 
 
 
 
2
 
4
 
 
 
1
2
1
 
 
 
1
6
9
1
 
 
 
 
1
5
9
1
 
 
 
 
1
2
1
 
 
 
1
4
1
 
 
 
1
4
1
 
 
 
1
2
1
 
 
 
1
2
1
 
 
 
1
3
1
 
 
 
1
4
2
 
 
 
1
3
2
 
 
 
1
2
1
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
var util = require('util'),
  validator = require('validator');
 
/**
 * Validate arguments against a set of rules.
 *
 * @param {Object} rules: argument name-ruleset pair, ruleset is an array of check functions
 * @param {Object} args: argument name-value pair
 * @param {Function} cb: standard cb(err, result) callback
 */
function validate(rules, args, cb) {
  try {
    _known(rules, args);
    _required(rules, args);
 
    Object.keys(args).forEach(function (arg) {
 
      var value = args[arg],
        ruleSet = rules[arg];
 
      try {
        ruleSet.forEach(function (rule) {
          if (rule !== 'required') {
            exports.checks[rule](value);
          }
        });
      } catch (e) {
        throw new Error(util.format(
          'Validation error - arg: %s, value: %s, desc: %s',
          arg, value, e.message));
      }
    });
    cb();
  } catch (e) {
    cb(e);
  }
}
 
function _comma(value) {
  if (validator.equals(value, 'comma') === false) {
    throw new Error('Value should be \'comma\'');
  }
}
 
function _known(rules, args) {
  Object.keys(args).forEach(function (arg) {
    if (Object.keys(rules).indexOf(arg) === -1) {
      throw new Error('Validation error - ' + arg + ' argument is unknown');
    }
  });
}
 
function _required(rules, args) {
  Object.keys(rules).forEach(function (arg) {
    if (rules[arg].indexOf('required') >= 0 && Object.keys(args).indexOf(arg) === -1) {
      throw new Error('Validation error - ' + arg + ' argument is required');
    }
  });
}
 
function _date(value) {
  if (validator.matches(value, /^[0-9]{4}—[0-9]{2}—[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$/) === false) {
    throw new Error('Invalid date');
  }
}
 
function _min_1(value) {
  if (validator.equals(value >= 1, false)) {
    throw new Error('Value must be greater than or equal to 1');
  }
}
 
function _max_100(value) {
  if (validator.equals(value <= 100, false)) {
    throw new Error('Value must be less than or equal to 100');
  }
}
 
function _no(value) {
  if (validator.equals(value, 'no') === false) {
    throw new Error('Value should be \'no\'');
  }
}
 
function _novalue(value) {
  if (validator.isNull(value) === false) {
    throw new Error('Value must be a null');
  }
}
 
function _number(value) {
  if (validator.isNumeric(value) === false) {
    throw new Error('Invalid number');
  }
}
 
function _string(value) {
  if (validator.isNull(value) === true || validator.equals(value, '') === true) {
    throw new Error('Value should be a non-empty string');
  }
}
 
function _url(value) {
  if (validator.isURL(value) === false) {
    throw new Error('Invalid URL');
  }
}
 
function _yes(value) {
  if (validator.equals(value, 'yes') === false) {
    throw new Error('Value should be \'yes\'');
  }
}
 
exports.validate = validate;
exports.checks = {
  comma: _comma,
  date: _date,
  min_1: _min_1,
  max_100: _max_100,
  no: _no,
  novalue: _novalue,
  number: _number,
  string: _string,
  url: _url,
  yes: _yes
};