Merge pull request #5 from adia-technology/feature/validation-result

Added validation result in place of boolean

Author: michaldudak

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.3.0
+
+* **BREAKING** Changed `validateSsn`'s return type from boolean to `ValidationResult`. This allows to return the reason for which the SSN is invalid.
+
 ## 0.2.0
 
 * Made `CountryCode` type public.

README.md

@@ -13,9 +13,10 @@ npm install @adia-technology/international-ssn-validator --save
 ### Usage
 
 ```js
-import { validateSsn } from '@adia-technology/international-ssn-validator';
+import { validateSsn, ValidationResult } from '@adia-technology/international-ssn-validator';
 
-let isValid = validateSsn('756.1111.2222.00', 'ch');
+let validationResult = validateSsn('756.1111.2222.00', 'ch');
+let isValid = validationResult === ValidationResult.Valid;
 ```
 
 ## API
@@ -25,6 +26,8 @@ This library exposes a single function, `validateSsn`, that accepts two paramete
 * `ssn : string` - SSN to validate.
 * `countryCode : string` - country for which to check the SSN against. Currently supported are `us` and `ch`.
 
+It returns a `ValidationResult`, which essentially is a string enum being set to one of the values: `'VALID'`, `'INVALID_FORMAT'` or `'INVALID_CHECKSUM'`.
+
 ## Dependencies
 
 This library uses the following other libraries:

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@adia-technology/international-ssn-validator",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "A utility to validate social security number of different countries.",
 	"main": "dist/index.js",
 	"module": "dist/index.es2015.js",

src/ValidationResult.ts

@@ -0,0 +1,5 @@
+export enum ValidationResult {
+	Valid = "VALID",
+	InvalidFormat = "INVALID_FORMAT",
+	InvalidChecksum = "INVALID_CHECKSUM"
+}

src/index.ts

@@ -1,9 +1,12 @@
 import { validateSwissSsn } from './validateSwissSsn';
 import { validateUsSsn } from './validateUsSsn';
+import { ValidationResult } from './ValidationResult';
 
 export type CountryCode = 'us' | 'ch';
 
-export function validateSsn(ssn : string, countryCode : CountryCode) : boolean {
+export { ValidationResult };
+
+export function validateSsn(ssn : string, countryCode : CountryCode) : ValidationResult {
 
 	if (countryCode == null || countryCode as string === '') {
 		throw new Error('countryCode was not provided');

src/validateSwissSsn.ts

@@ -1,12 +1,13 @@
 import AhvValidator from 'ahv13-validator';
+import { ValidationResult } from './ValidationResult';
 
 const ahvRegex = /^756\.\d{4}\.\d{4}\.\d{2}$/;
 
-export function validateSwissSsn(ssn ?: string) : boolean {
+export function validateSwissSsn(ssn ?: string) : ValidationResult {
 	if (ssn == null || !ahvRegex.test(ssn)) {
-		return false;
+		return ValidationResult.InvalidFormat;
 	}
 
 	let ahvValidator = new AhvValidator();
-	return ahvValidator.isValid(ssn);
+	return ahvValidator.isValid(ssn) ? ValidationResult.Valid : ValidationResult.InvalidChecksum;
 }

src/validateUsSsn.ts

@@ -1,5 +1,6 @@
 import { isValid } from 'ssn-validator';
+import { ValidationResult } from './ValidationResult';
 
-export function validateUsSsn(ssn ?: string) : boolean {
-	return isValid(ssn);
+export function validateUsSsn(ssn ?: string) : ValidationResult {
+	return isValid(ssn) ? ValidationResult.Valid : ValidationResult.InvalidFormat;
 }

test/index.test.ts

@@ -1,24 +1,25 @@
 import { validateSsn, CountryCode } from '../src';
+import { ValidationResult } from '../src/ValidationResult';
 
 test('Given empty SSN, result should not be valid', () => {
 	let invalidSsn = '';
 
-	expect(validateSsn(invalidSsn, 'ch')).toBe(false);
-	expect(validateSsn(invalidSsn, 'us')).toBe(false);
+	expect(validateSsn(invalidSsn, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(invalidSsn, 'us')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given null SSN, result should not be valid', () => {
 	let invalidSsn = null;
 
-	expect(validateSsn(invalidSsn, 'ch')).toBe(false);
-	expect(validateSsn(invalidSsn, 'us')).toBe(false);
+	expect(validateSsn(invalidSsn, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(invalidSsn, 'us')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given undefined SSN, result should not be valid', () => {
 	let invalidSsn = undefined;
 
-	expect(validateSsn(invalidSsn, 'ch')).toBe(false);
-	expect(validateSsn(invalidSsn, 'us')).toBe(false);
+	expect(validateSsn(invalidSsn, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(invalidSsn, 'us')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given valid Swiss SSN, when validateSsn called with "ch" country code, result should be valid', () => {
@@ -35,13 +36,13 @@ test('Given valid Swiss SSN, when validateSsn called with "ch" country code, res
 	];
 
 	for (let validSsn of validSwissSsns) {
-		expect(validateSsn(validSsn, 'ch')).toBe(true);
+		expect(validateSsn(validSsn, 'ch')).toBe(ValidationResult.Valid);
 	}
 });
 
 test('Given valid Swiss SSN, when validateSsn called with "us" country code, result should be invalid', () => {
 	let validSwissSsn = "756.5220.1643.81";
-	expect(validateSsn(validSwissSsn, 'us')).toBe(false);
+	expect(validateSsn(validSwissSsn, 'us')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given invalid Swiss SSN, result should be invalid', () => {
@@ -52,12 +53,12 @@ test('Given invalid Swiss SSN, result should be invalid', () => {
 	let noChecksum = "756.0246.1057.4";
 	let tooLong = "756.8478.9370.660";
 
-	expect(validateSsn(wrongChecksum, 'ch')).toBe(false);
-	expect(validateSsn(wrongPrefix, 'ch')).toBe(false);
-	expect(validateSsn(noDots, 'ch')).toBe(false);
-	expect(validateSsn(wrongSeparators, 'ch')).toBe(false);
-	expect(validateSsn(noChecksum, 'ch')).toBe(false);
-	expect(validateSsn(tooLong, 'ch')).toBe(false);
+	expect(validateSsn(wrongChecksum, 'ch')).toBe(ValidationResult.InvalidChecksum);
+	expect(validateSsn(wrongPrefix, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(noDots, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(wrongSeparators, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(noChecksum, 'ch')).toBe(ValidationResult.InvalidFormat);
+	expect(validateSsn(tooLong, 'ch')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given valid US SSN, when validateSsn called with "us" country code, result should be valid', () => {
@@ -67,13 +68,13 @@ test('Given valid US SSN, when validateSsn called with "us" country code, result
 	];
 
 	for (let validSsn of validUsSsns) {
-		expect(validateSsn(validSsn, 'us')).toBe(true);
+		expect(validateSsn(validSsn, 'us')).toBe(ValidationResult.Valid);
 	}
 });
 
 test('Given valid US SSN, when validateSsn called with "ch" country code, result should be invalid', () => {
 	let validUsSsn = "011-23-4567";
-	expect(validateSsn(validUsSsn, 'ch')).toBe(false);
+	expect(validateSsn(validUsSsn, 'ch')).toBe(ValidationResult.InvalidFormat);
 });
 
 test('Given unsupported countryCode, validateSsn should throw an error', () => {