3802

pending completion

Build # 3802

Build Type

Pull #614

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/recurly/recurly-js/commit/<a class=hub.com/recurly/recurly-js/commit/5ab338477a42ed62477cc09f94a126032356c3b8">5ab338477<a href="https://github.com/recurly/recurly-js/commit/5ab338477a42ed62477cc09f94a126032356c3b8">">Merge </a><a class="double-link" href="https://github.com/recurly/recurly-js/commit/<a class="double-link" href="https://github.com/recurly/recurly-js/commit/8a4b14012ddab3bd0b9e98550ce26770d10ceb7e">8a4b14012</a>">8a4b14012</a><a href="https://github.com/recurly/recurly-js/commit/5ab338477a42ed62477cc09f94a126032356c3b8"> into c1d8b2291">c1d8b2291</a>

Pull Request Pull Request #614: Adds Becs support

Run Details

1145 of 1411 branches covered (81.15%)

11 of 11 new or added lines in 2 files covered. (100.0%)

2551 of 2736 relevant lines covered (93.24%)

8917.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.26

/lib/recurly/validate.js

/*jshint -W058 */

import { FIELDS as CARD_FIELDS } from './token';
import each from 'component-each';
import find from 'component-find';
import { parseCard } from '../util/parse-card';

const debug = require('debug')('recurly:validate');

/**
 * Card patterns.
 *
 * @private
 */
const TYPES = [
  {
    type: 'discover',
    pattern: {
      test: (n) => {
        const firstEight = parseInt(n.substr(0, 8), 10);
        const acceptedRanges = [
          [60110000, 60110399],
          [60110500, 60110999],
          [60112000, 60114999],
          [60117400, 60117499],
          [60117700, 60117999],
          [60118600, 60119999],
          [64400000, 65059999],
          [65060100, 65060999],
          [65061100, 65999999]
        ];

        if (!(/^6[045]/.test(firstEight))) return false;
        return validBinRange(acceptedRanges, firstEight);
      }
    },
    lengths: [16, 17, 18, 19]
  },
  {
    type: 'union_pay',
    pattern: {
      test: (n) => {
        const firstEight = parseInt(n.substr(0, 8), 10);
        const acceptedRanges = [
          [62109400, 62109499],
          [62212600, 62292599],
          [62400000, 62699999],
          [62820000, 62889999],
          [81000000, 81099999],
          [81100000, 81319999],
          [81320000, 81519999],
          [81520000, 81639999],
          [81640000, 81719999]
        ];

        if (!(/^6[2]/.test(firstEight)) && !(/^8[1]/.test(firstEight))) return false;
        return validBinRange(acceptedRanges, firstEight);
      }
    },
    lengths: [16, 17, 18, 19]
  },
  {
    type: 'master',
    pattern: {
      test: (n) => {
        let firstSix = parseInt(n.substr(0, 6), 10);
        if (/^5[1-5]/.test(n)) return true;
        if (firstSix >= 222100 && firstSix <= 272099) return true;
        return false;
      }
    },
    lengths: [16]
  },
  {
    type: 'american_express',
    pattern: /^3[47]/,
    lengths: [15]
  },
  {
    type: 'visa',
    pattern: /^4/,
    lengths: [13, 16]
  },
  {
    type: 'jcb',
    pattern: /^35[2-8]\d/,
    lengths: [16]
  },
  {
    type: 'diners_club',
    pattern: /^(30[0-5]|309|36|3[89]|54|55|2014|2149)/,
    lengths: [14]
  }
];

/**
 * Validates bin ranges for supported card types
 *
 * @private
 */
function validBinRange (acceptedRanges, firstEight) {
  for (let index = 0; index < acceptedRanges.length; index++) {
    const [min, max] = acceptedRanges[index];
    if (firstEight <= max && firstEight >= min) return true;
  }
  return false;
}

/**
 * Validation error messages
 * @type {String}
 * @private
 */
const INVALID = 'is invalid';
const BLANK = "can't be blank";
const DOES_NOT_MATCH = 'does not match';

/**
 * Fields required by bank account tokenization
 * @type {Array}
 */
const BANK_ACCOUNT_REQUIRED_FIELDS = [
  'account_number',
  'account_number_confirmation',
  'routing_number',
  'account_type',
  'name_on_account',
  'country'
];

/**
 * Fields required by IBAN bank account tokenization
 * @type {Array}
 */
const IBAN_BANK_ACCOUNT_REQUIRED_FIELDS = [
  'iban',
  'name_on_account',
];

/**
 * Fields required by Bacs bank account tokenization
 * @type {Array}
 */
const BACS_BANK_ACCOUNT_REQUIRED_FIELDS = [
  'name_on_account',
  'sort_code',
  'account_number',
  'account_number_confirmation',
];

/**
 * Fields required by BECS bank account tokenization
 * @type {Array}
 */
const BECS_BANK_ACCOUNT_REQUIRED_FIELDS = [
  'account_number',
  'account_number_confirmation',
  'name_on_account',
  'bsb_code',
];

export const publicMethods = { cardNumber, cardType, expiry, cvv };

/**
 * Validates a credit card number via length check and luhn algorithm.
 *
 * @param {Number|String} number The card number.
 * @return {Boolean}
 * @see https://sites.google.com/site/abapexamples/javascript/luhn-validation
 */

export function cardNumber (number) {
  const str = parseCard(number);
  let ca, sum = 0, mul = 1;
  let i = str.length;

  if (i < 12 || i > 19) return false;

  while (i--) {
    ca = parseInt(str.charAt(i), 10) * mul;
    sum += ca - (ca > 9) * 9;
    mul ^= 3;
  }

  return sum % 10 === 0 && sum > 0;
}

/**
 * Returns the type of the card number as a string.
 *
 * @param {Number|String} number The card number
 * @param {Boolean} partial detect card type on a partial (incomplete) number
 * @return {String} card type
 */

export function cardType (number, partial = false) {
  const str = parseCard(number);
  const len = str.length;
  const card = find(TYPES, card => card.pattern.test(str) && (partial || ~card.lengths.indexOf(len)));

  return card && card.type || 'unknown';
}

/**
 * Validates whether an expiry month is present or future.
 *
 * @param {Number|String} month The 2 digit month
 * @param {Number|String} year The 2 or 4 digit year
 * @return {Boolean}
 */

export function expiry (month, year) {
  month = Number(month) - 1;
  if (month < 0 || month > 11) return false;
  year = Number(year);
  year += year < 100 ? 2000 : 0;

  let expiry = new Date;
  expiry.setYear(year);
  expiry.setDate(1);
  expiry.setHours(0);
  expiry.setMinutes(0);
  expiry.setSeconds(0);
  expiry.setMonth(month + 1);
  return new Date < expiry;
}

/**
 * Validates whether a number looks like a cvv.
 *
 * e.g.: '123', '0321'
 *
 * @param {Number|String} number The card verification value
 * @return {Boolean}
 */

export function cvv (number) {
  number = String(number).trim();
  if (!~[3, 4].indexOf(number.length)) return false;
  return /^\d+$/.test(number);
}

/**
 * Checks user input on a card token call
 *
 * @param {Recurly} recurly
 * @param {Object} inputs
 * @return {Array} formatted array of invalid fields with descriptive messages
 */
export function validateCardInputs (recurly, inputs) {
  const format = formatFieldValidationError;
  let errors = [];

  if (!cardNumber(inputs.number)) {
    errors.push(format('number', INVALID));
  }

  if (!expiry(inputs.month, inputs.year)) {
    errors.push(format('month', INVALID), format('year', INVALID));
  }

  if (!inputs.first_name) {
    errors.push(format('first_name', BLANK));
  }

  if (!inputs.last_name) {
    errors.push(format('last_name', BLANK));
  }

  if (~recurly.config.required.indexOf('cvv') && !inputs.cvv) {
    errors.push(format('cvv', BLANK));
  } else if ((~recurly.config.required.indexOf('cvv') || inputs.cvv) && !cvv(inputs.cvv)) {
    errors.push(format('cvv', INVALID));
  }

  each(recurly.config.required, function (field) {
    if (!inputs[field] && ~CARD_FIELDS.indexOf(field)) {
      errors.push(format(field, BLANK));
    }
  });

  debug('validate errors', errors);

  return errors;
}

/**
 * Checks user input on a bank account token call
 *
 * @param {Object} inputs
 * @return {Array} formatted array of invalid fields with descriptive messages
 */
export function validateBankAccountInputs (inputs) {
  const format = formatFieldValidationError;
  let required = [];
  let errors = [];

  if ('iban' in inputs) {
    required = IBAN_BANK_ACCOUNT_REQUIRED_FIELDS;
  } else if (inputs.type === 'bacs') {
    required = BACS_BANK_ACCOUNT_REQUIRED_FIELDS;
    accountNumberMatches(inputs, errors);
  } else if (inputs.type === 'becs') {
    required = BECS_BANK_ACCOUNT_REQUIRED_FIELDS;
    accountNumberMatches(inputs, errors);
  } else {
    required = BANK_ACCOUNT_REQUIRED_FIELDS;
    accountNumberMatches(inputs, errors);
  }

  required.forEach(name => {
    if (!inputs[name]) {
      errors.push(format(name, BLANK));
    } else if (typeof inputs[name] !== 'string') {
      errors.push(format(name, INVALID));
    }
  });

  debug('bank account validate errors', errors);

  return errors;
}

/**
 * Validates a bank account routing number
 * @param  {[type]} routingNumber
 * @return {Array} formatted array of invalid fields with descriptive messages
 */
export function validateBankRoutingNumber (routingNumber) {
  let errors = [];

  if (!routingNumber) {
    errors.push(formatFieldValidationError('routing_number', BLANK));
  } else if (typeof routingNumber !== 'string') {
    errors.push(formatFieldValidationError('routing_number', INVALID));
  }

  debug('validate errors', errors);

  return errors;
}

/**
 * Formats a field validation error
 *
 * @param {string} field
 * @param {String} message
 * @return {Object}
 */
function formatFieldValidationError (field, message) {
  return { field, messages: [message] };
}

function accountNumberMatches (inputs, errors) {
  const format = formatFieldValidationError;

  if (inputs.account_number !== inputs.account_number_confirmation) {
    errors.push(format('account_number_confirmation', DOES_NOT_MATCH));
  }
}

1	/jshint -W058 /
2
3	import { FIELDS as CARD_FIELDS } from './token';
4	import each from 'component-each';
5	import find from 'component-find';
6	import { parseCard } from '../util/parse-card';
7
8	const debug = require('debug')('recurly:validate');	1✔
9
10	/**
11	* Card patterns.
12	*
13	* @private
14	*/
15	const TYPES = [	1✔
16	{
17	type: 'discover',
18	pattern: {
19	test: (n) => {
20	const firstEight = parseInt(n.substr(0, 8), 10);	24✔
21	const acceptedRanges = [	24✔
22	[60110000, 60110399],
23	[60110500, 60110999],
24	[60112000, 60114999],
25	[60117400, 60117499],
26	[60117700, 60117999],
27	[60118600, 60119999],
28	[64400000, 65059999],
29	[65060100, 65060999],
30	[65061100, 65999999]
31	];
32
33	if (!(/^6[045]/.test(firstEight))) return false;	24✔
34	return validBinRange(acceptedRanges, firstEight);	5✔
35	}
36	},
37	lengths: [16, 17, 18, 19]
38	},
39	{
40	type: 'union_pay',
41	pattern: {
42	test: (n) => {
43	const firstEight = parseInt(n.substr(0, 8), 10);	22✔
44	const acceptedRanges = [	22✔
45	[62109400, 62109499],
46	[62212600, 62292599],
47	[62400000, 62699999],
48	[62820000, 62889999],
49	[81000000, 81099999],
50	[81100000, 81319999],
51	[81320000, 81519999],
52	[81520000, 81639999],
53	[81640000, 81719999]
54	];
55
56	if (!(/^6[2]/.test(firstEight)) && !(/^8[1]/.test(firstEight))) return false;	22✔
57	return validBinRange(acceptedRanges, firstEight);	9✔
58	}
59	},
60	lengths: [16, 17, 18, 19]
61	},
62	{
63	type: 'master',
64	pattern: {
65	test: (n) => {
66	let firstSix = parseInt(n.substr(0, 6), 10);	17✔
67	if (/^5[1-5]/.test(n)) return true;	17✔
68	if (firstSix >= 222100 && firstSix <= 272099) return true;	14✔
69	return false;	12✔
70	}
71	},
72	lengths: [16]
73	},
74	{
75	type: 'american_express',
76	pattern: /^3[47]/,
77	lengths: [15]
78	},
79	{
80	type: 'visa',
81	pattern: /^4/,
82	lengths: [13, 16]
83	},
84	{
85	type: 'jcb',
86	pattern: /^35[2-8]\d/,
87	lengths: [16]
88	},
89	{
90	type: 'diners_club',
91	pattern: /^(30[0-5]\|309\|36\|3[89]\|54\|55\|2014\|2149)/,
92	lengths: [14]
93	}
94	];
95
96	/**
97	* Validates bin ranges for supported card types
98	*
99	* @private
100	*/
101	function validBinRange (acceptedRanges, firstEight) {
102	for (let index = 0; index < acceptedRanges.length; index++) {	14✔
103	const [min, max] = acceptedRanges[index];	78✔
104	if (firstEight <= max && firstEight >= min) return true;	78✔
105	}
106	return false;	6✔
107	}
108
109	/**
110	* Validation error messages
111	* @type {String}
112	* @private
113	*/
114	const INVALID = 'is invalid';	1✔
115	const BLANK = "can't be blank";	1✔
116	const DOES_NOT_MATCH = 'does not match';	1✔
117
118	/**
119	* Fields required by bank account tokenization
120	* @type {Array}
121	*/
122	const BANK_ACCOUNT_REQUIRED_FIELDS = [	1✔
123	'account_number',
124	'account_number_confirmation',
125	'routing_number',
126	'account_type',
127	'name_on_account',
128	'country'
129	];
130
131	/**
132	* Fields required by IBAN bank account tokenization
133	* @type {Array}
134	*/
135	const IBAN_BANK_ACCOUNT_REQUIRED_FIELDS = [	1✔
136	'iban',
137	'name_on_account',
138	];
139
140	/**
141	* Fields required by Bacs bank account tokenization
142	* @type {Array}
143	*/
144	const BACS_BANK_ACCOUNT_REQUIRED_FIELDS = [	1✔
145	'name_on_account',
146	'sort_code',
147	'account_number',
148	'account_number_confirmation',
149	];
150
151	/**
152	* Fields required by BECS bank account tokenization
153	* @type {Array}
154	*/
155	const BECS_BANK_ACCOUNT_REQUIRED_FIELDS = [	1✔
156	'account_number',
157	'account_number_confirmation',
158	'name_on_account',
159	'bsb_code',
160	];
161
162	export const publicMethods = { cardNumber, cardType, expiry, cvv };	1✔
163
164	/**
165	* Validates a credit card number via length check and luhn algorithm.
166	*
167	* @param {Number\|String} number The card number.
168	* @return {Boolean}
169	* @see https://sites.google.com/site/abapexamples/javascript/luhn-validation
170	*/
171
172	export function cardNumber (number) {
173	const str = parseCard(number);	41✔
174	let ca, sum = 0, mul = 1;	41✔
175	let i = str.length;	41✔
176
177	if (i < 12 \|\| i > 19) return false;	41✔
178
179	while (i--) {	31✔
180	ca = parseInt(str.charAt(i), 10) * mul;	496✔
181	sum += ca - (ca > 9) * 9;	496✔
182	mul ^= 3;	496✔
183	}
184
185	return sum % 10 === 0 && sum > 0;	31✔
186	}
187
188	/**
189	* Returns the type of the card number as a string.
190	*
191	* @param {Number\|String} number The card number
192	* @param {Boolean} partial detect card type on a partial (incomplete) number
193	* @return {String} card type
194	*/
195
196	export function cardType (number, partial = false) {	22✔
197	const str = parseCard(number);	24✔
198	const len = str.length;	24✔
199	const card = find(TYPES, card => card.pattern.test(str) && (partial \|\| ~card.lengths.indexOf(len)));	103✔
200
201	return card && card.type \|\| 'unknown';	24✔
202	}
203
204	/**
205	* Validates whether an expiry month is present or future.
206	*
207	* @param {Number\|String} month The 2 digit month
208	* @param {Number\|String} year The 2 or 4 digit year
209	* @return {Boolean}
210	*/
211
212	export function expiry (month, year) {
213	month = Number(month) - 1;	37✔
214	if (month < 0 \|\| month > 11) return false;	37✔
215	year = Number(year);	36✔
216	year += year < 100 ? 2000 : 0;	36✔
217
218	let expiry = new Date;	36✔
219	expiry.setYear(year);	36✔
220	expiry.setDate(1);	36✔
221	expiry.setHours(0);	36✔
222	expiry.setMinutes(0);	36✔
223	expiry.setSeconds(0);	36✔
224	expiry.setMonth(month + 1);	36✔
225	return new Date < expiry;	36✔
226	}
227
228	/**
229	* Validates whether a number looks like a cvv.
230	*
231	* e.g.: '123', '0321'
232	*
233	* @param {Number\|String} number The card verification value
234	* @return {Boolean}
235	*/
236
237	export function cvv (number) {
238	number = String(number).trim();	20✔
239	if (!~[3, 4].indexOf(number.length)) return false;	20✔
240	return /^\d+$/.test(number);	14✔
241	}
242
243	/**
244	* Checks user input on a card token call
245	*
246	* @param {Recurly} recurly
247	* @param {Object} inputs
248	* @return {Array} formatted array of invalid fields with descriptive messages
249	*/
250	export function validateCardInputs (recurly, inputs) {
251	const format = formatFieldValidationError;	29✔
252	let errors = [];	29✔
253
254	if (!cardNumber(inputs.number)) {	29✔
255	errors.push(format('number', INVALID));	2✔
256	}
257
258	if (!expiry(inputs.month, inputs.year)) {	29✔
259	errors.push(format('month', INVALID), format('year', INVALID));	2✔
260	}
261
262	if (!inputs.first_name) {	29✔
263	errors.push(format('first_name', BLANK));	2✔
264	}
265
266	if (!inputs.last_name) {	29!
267	errors.push(format('last_name', BLANK));	×
268	}
269
270	if (~recurly.config.required.indexOf('cvv') && !inputs.cvv) {	29✔
271	errors.push(format('cvv', BLANK));	2✔
272	} else if ((~recurly.config.required.indexOf('cvv') \|\| inputs.cvv) && !cvv(inputs.cvv)) {	27✔
273	errors.push(format('cvv', INVALID));	4✔
274	}
275
276	each(recurly.config.required, function (field) {	29✔
277	if (!inputs[field] && ~CARD_FIELDS.indexOf(field)) {	6!
278	errors.push(format(field, BLANK));	×
279	}
280	});
281
282	debug('validate errors', errors);	29✔
283
284	return errors;	29✔
285	}
286
287	/**
288	* Checks user input on a bank account token call
289	*
290	* @param {Object} inputs
291	* @return {Array} formatted array of invalid fields with descriptive messages
292	*/
293	export function validateBankAccountInputs (inputs) {
294	const format = formatFieldValidationError;	36✔
295	let required = [];	36✔
296	let errors = [];	36✔
297
298	if ('iban' in inputs) {	36✔
299	required = IBAN_BANK_ACCOUNT_REQUIRED_FIELDS;	4✔
300	} else if (inputs.type === 'bacs') {	32✔
301	required = BACS_BANK_ACCOUNT_REQUIRED_FIELDS;	4✔
302	accountNumberMatches(inputs, errors);	4✔
303	} else if (inputs.type === 'becs') {	28✔
304	required = BECS_BANK_ACCOUNT_REQUIRED_FIELDS;	4✔
305	accountNumberMatches(inputs, errors);	4✔
306	} else {
307	required = BANK_ACCOUNT_REQUIRED_FIELDS;	24✔
308	accountNumberMatches(inputs, errors);	24✔
309	}
310
311	required.forEach(name => {	36✔
312	if (!inputs[name]) {	184✔
313	errors.push(format(name, BLANK));	4✔
314	} else if (typeof inputs[name] !== 'string') {	180!
315	errors.push(format(name, INVALID));	×
316	}
317	});
318
319	debug('bank account validate errors', errors);	36✔
320
321	return errors;	36✔
322	}
323
324	/**
325	* Validates a bank account routing number
326	* @param {[type]} routingNumber
327	* @return {Array} formatted array of invalid fields with descriptive messages
328	*/
329	export function validateBankRoutingNumber (routingNumber) {
330	let errors = [];	2✔
331
332	if (!routingNumber) {	2!
333	errors.push(formatFieldValidationError('routing_number', BLANK));	×
334	} else if (typeof routingNumber !== 'string') {	2!
335	errors.push(formatFieldValidationError('routing_number', INVALID));	×
336	}
337
338	debug('validate errors', errors);	2✔
339
340	return errors;	2✔
341	}
342
343	/**
344	* Formats a field validation error
345	*
346	* @param {string} field
347	* @param {String} message
348	* @return {Object}
349	*/
350	function formatFieldValidationError (field, message) {
351	return { field, messages: [message] };	18✔
352	}
353
354	function accountNumberMatches (inputs, errors) {
355	const format = formatFieldValidationError;	32✔
356
357	if (inputs.account_number !== inputs.account_number_confirmation) {	32!
358	errors.push(format('account_number_confirmation', DOES_NOT_MATCH));	×
359	}
360	}

recurly / recurly-js / 3802

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous