Finally!!!! A starting point for adding test suite in Intent.

lib/config/__mocks__/service.ts

@@ -0,0 +1,3 @@
+export const IntentConfig = {
+  get: jest.fn(),
+};

lib/config/service.ts

@@ -3,11 +3,10 @@ import { ConfigService } from '@nestjs/config';
 
 @Injectable()
 export class IntentConfig {
-  private static cachedConfig: Map<string, any>;
+  private static cachedConfig = new Map<string, any>();
   private static config: ConfigService;
 
   constructor(private config: ConfigService) {
-    IntentConfig.cachedConfig = new Map<string, any>();
     IntentConfig.config = config;
   }
 

lib/console/consoleIO.ts

@@ -7,7 +7,7 @@ import { ConsoleLogger } from './logger';
 export class ConsoleIO {
   schema: ArgumentParserOutput;
   rawValues: Record<string, any>;
-  values: Record<string, any> = { arguments: {}, options: {} };
+  values = { arguments: {}, options: {} };
   hasErrors: boolean;
   missingArguments: string[];
 
@@ -36,6 +36,14 @@ export class ConsoleIO {
     return this.values.options[key];
   }
 
+  arguments(): Record<string, any> {
+    return this.values.arguments;
+  }
+
+  options(): Record<string, any> {
+    return this.values.options;
+  }
+
   handle(): ConsoleIO {
     this.schema = ArgumentParser.from(this.schemaString);
     this.values = { arguments: {}, options: {} };
@@ -68,16 +76,11 @@ export class ConsoleIO {
     this.validateArguments();
     if (this.hasErrors) return this;
 
-    /**
-     * Parse options
-     */
     for (const option of this.schema.options) {
-      const value = Obj.get(this.argv, option.name, ...option.alias);
-      if (value) {
-        this.values.options[option.name] = value;
-      } else {
-        this.values.options[option.name] = option.defaultValue;
-      }
+      const values = Object.values(
+        Obj.pick(this.argv, [option.name, ...option.alias]),
+      );
+      this.values.options[option.name] = values[0] ? values[0] : undefined;
     }
 
     return this;

lib/utils/array.ts

@@ -145,4 +145,21 @@ export class Arr {
 
     return undefined;
   }
+
+  static intersect<T = string | number, M = T>(
+    arr1: T[],
+    arr2: M[],
+  ): Array<T | M> {
+    const tempMap = new Map<T | M, number>();
+    const newArr = [] as Array<T | M>;
+    for (const val of arr1) {
+      tempMap.set(val, 1);
+    }
+
+    for (const val2 of arr2) {
+      if (tempMap.has(val2)) newArr.push(val2);
+    }
+
+    return newArr;
+  }
 }

lib/utils/helpers.ts

@@ -9,28 +9,14 @@ import { Obj } from './object';
 import { Str } from './string';
 
 export const isEmpty = (value: any) => {
-  if (Str.isString(value)) {
-    return value === '';
-  }
-
-  if (Arr.isArray(value)) {
-    return !value.length;
-  }
-
-  if (Obj.isObj(value)) {
-    return Obj.isEmpty(value);
-  }
-
-  if (Number.isNaN(value) || value === undefined) {
-    return true;
-  }
-
+  if (Str.isString(value)) return value === '';
+  if (Arr.isArray(value)) return !value.length;
+  if (Obj.isObj(value)) return Obj.isEmpty(value);
+  if (Number.isNaN(value) || value === undefined) return true;
   return false;
 };
 
-export const isBoolean = (value: any): boolean => {
-  return typeof value === 'boolean';
-};
+export const isBoolean = (value: any): boolean => typeof value === 'boolean';
 
 export const toBoolean = (value: any) => {
   if (!Str.isString(value) || typeof value !== 'boolean') return undefined;

lib/utils/object.ts

@@ -102,26 +102,24 @@ export class Obj {
     return !Obj.isEmpty(obj);
   }
 
-  static get<T>(
+  static get<T = any>(
     obj: Record<string, any>,
     key: string,
-    ...aliasKeys: string[]
+    defaultValue?: T,
   ): T {
-    const keys = [key, ...aliasKeys];
-    for (const key of keys) {
-      if (key in obj) return obj[key];
-      const splitKeys = key.split('.');
-      if (!splitKeys.length) return;
+    if (key in obj) return obj[key];
+    const splitKeys = key.split('.');
+    if (!splitKeys.length) return;
 
-      if (Arr.isArray(obj[splitKeys[0]])) {
-        return Arr.get(obj[splitKeys[0]], splitKeys.slice(1).join('.'));
-      }
+    if (Arr.isArray(obj[splitKeys[0]])) {
+      return Arr.get(obj[splitKeys[0]], splitKeys.slice(1).join('.'));
+    }
 
-      if (Obj.isObj(obj[splitKeys[0]])) {
-        return Obj.get(obj[splitKeys[0]], splitKeys.slice(1).join('.'));
-      }
+    if (Obj.isObj(obj[splitKeys[0]])) {
+      return Obj.get(obj[splitKeys[0]], splitKeys.slice(1).join('.'));
     }
-    return undefined;
+
+    return defaultValue;
   }
 
   static sort<T = Record<string, any>>(obj: T): T {

lib/utils/string.ts

@@ -208,7 +208,7 @@ export class Str {
     return !Str.isString(value);
   };
 
-  static len = (str: string): number => {
+  static len = (str?: string): number => {
     return str?.length ?? 0;
   };
 

lib/utils/tests/array.spec.ts

@@ -0,0 +1,95 @@
+import { Arr } from '../array';
+
+jest.mock('../../config/service');
+
+describe('Array Helper', () => {
+  beforeEach(async () => {});
+
+  //   it('should throw exception', () => {
+  //     const arr = {};
+  //     expect(Arr.toObj(arr as [], [])).toThrow(InvalidValue);
+  //   });
+
+  it('should return object', () => {
+    const arr = [
+      2,
+      ['bar', 'piyush', 'intent'],
+      { foo: 'bar' },
+      [{ bar: 'foo' }],
+    ];
+
+    const keys = ['foo', 'chhabra', 'best framework', 'obj'];
+    expect(Arr.toObj(arr, keys)).toStrictEqual([
+      { foo: 'bar', chhabra: 'piyush', 'best framework': 'intent' },
+      { foo: { bar: 'foo' } },
+    ]);
+  });
+
+  //   it('should throw exception', () => {
+  //     const arr = {};
+  //     expect(Arr.isArray(arr as [], true)).toThrow(InvalidValue);
+  //   });
+
+  it('should return false', () => {
+    const arr = {};
+    expect(Arr.isArray(arr as [])).toBeFalsy();
+  });
+
+  it('should return false', () => {
+    const arr = [];
+    expect(Arr.isArray(arr)).toBeTruthy();
+  });
+
+  it('should return array of nested members flattened', () => {
+    const arr = [1, [2, 3, 4], [[5, 6], [[7], 8], 9]];
+    expect(Arr.collapse(arr)).toStrictEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  it('should return array with random order of input', () => {
+    const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+    const mockMath = Object.create(global.Math);
+    mockMath.random = () => 0.5;
+    global.Math = mockMath;
+    expect(Arr.random(arr)).toStrictEqual([1, 6, 2, 8, 3, 7, 4, 9, 5]);
+  });
+
+  it('should return array with sorted order of input', () => {
+    const arr = [6, 1, 2, 8, 3, 7, 4, 9, 5];
+    expect(Arr.sort(arr)).toStrictEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  it('should return array with descending order of input', () => {
+    const arr = [6, 1, 2, 8, 3, 7, 4, 9, 5];
+    expect(Arr.sortDesc(arr)).toStrictEqual([9, 8, 7, 6, 5, 4, 3, 2, 1]);
+  });
+
+  it('should return array with common elements from both input arrays', () => {
+    const arr1 = [1, 2, 3, 4, 5];
+    const arr2 = [4, 5, 6, 7, 8];
+    expect(Arr.intersect(arr1, arr2)).toStrictEqual([4, 5]);
+  });
+
+  it('should return array with elements keys mentioned to pick', () => {
+    const arr = [
+      { developer: { id: 1, name: 'Taylor' } },
+      { developer: { id: 2, name: 'Abigail' } },
+    ];
+    const pick = ['*.developer.name'];
+    expect(Arr.pick(arr, pick)).toStrictEqual([
+      { developer: { name: 'Taylor' } },
+      { developer: { name: 'Abigail' } },
+    ]);
+  });
+
+  it('should return array with all elements except the keys mentioned', () => {
+    const arr = [
+      { developer: { id: 1, name: 'Taylor' } },
+      { developer: { id: 2, name: 'Abigail' } },
+    ];
+    const pick = ['*.developer.name'];
+    expect(Arr.except(arr, pick)).toStrictEqual([
+      { developer: { id: 1 } },
+      { developer: { id: 2 } },
+    ]);
+  });
+});

lib/utils/tests/number.spec.ts

@@ -0,0 +1,118 @@
+import { Num } from '../number';
+
+jest.mock('../../config/service');
+
+describe('Numbers Helper', () => {
+  beforeEach(async () => {});
+
+  it('should abbrevate with en locale to 1 decimal point precision', () => {
+    const number = 12345;
+    expect(Num.abbreviate(number)).toBe('12.3K');
+  });
+
+  it('should abbrevate with en locale to 3 decimal precision', () => {
+    const number = 12345;
+    const options = { precision: 3, locale: 'en' };
+    expect(Num.abbreviate(number, options)).toBe('12.345K');
+  });
+
+  it('should abbrevate with en-IN locale to 3 decimal precision', () => {
+    const number = 12345;
+    const options = { precision: 3, locale: 'en-IN' };
+    expect(Num.abbreviate(number, options)).toBe('12.345K');
+  });
+
+  it('should return number itself', () => {
+    const number = 12345;
+    const min = 12300;
+    const max = 12400;
+    expect(Num.clamp(number, min, max)).toBe(number);
+  });
+
+  it('should return minimum number', () => {
+    const number = 12345;
+    const min = 12350;
+    const max = 12400;
+    expect(Num.clamp(number, min, max)).toBe(min);
+  });
+
+  it('should return maximum number', () => {
+    const number = 12345;
+    const min = 12300;
+    const max = 12340;
+    expect(Num.clamp(number, min, max)).toBe(max);
+  });
+
+  it('should return number in currency style in INR', () => {
+    const number = 12345;
+    const options = { currency: 'INR', locale: 'en' };
+    expect(Num.currency(number, options)).toBe('₹12,345.00');
+  });
+
+  it('should return number in currency style in USD', () => {
+    const number = 12345;
+    const options = { currency: 'USD', locale: 'en' };
+    expect(Num.currency(number, options)).toBe('$12,345.00');
+  });
+
+  it('should return number in file size format', () => {
+    const number = 12345;
+    expect(Num.fileSize(number)).toBe('12.3KB');
+  });
+
+  it('should return number in file size format with precision 3', () => {
+    const number = 123456789;
+    const options = { precision: 3 };
+    expect(Num.fileSize(number, options)).toBe('123.457MB');
+  });
+
+  it('should return number in humanize form with precision 1', () => {
+    const number = 12345;
+    const options = { precision: 1, locale: 'en' };
+    expect(Num.forHumans(number, options)).toBe('12.3 thousand');
+  });
+
+  it('should return number in humanize form with precision 3', () => {
+    const number = 123456789;
+    const options = { precision: 3, locale: 'en' };
+    expect(Num.forHumans(number, options)).toBe('123.457 million');
+  });
+
+  it('should return number in number system format with precision 1(default)', () => {
+    const number = 12345.78;
+    const options = { locale: 'en' };
+    expect(Num.format(number, options)).toBe('12,345.8');
+  });
+
+  it('should return number in percents when passed as decimal portion with precision 1(default)', () => {
+    const number = 17.8;
+    const options = { locale: 'en' };
+    expect(Num.percentage(number, options)).toBe('17.8%');
+  });
+
+  it('should return number in ordinal format', () => {
+    const number = 231;
+    expect(Num.ordinal(number)).toBe('231st');
+  });
+
+  it('should return number in ordinal format', () => {
+    const number = 12345;
+    expect(Num.ordinal(number)).toBe('12345th');
+  });
+
+  it('should return number in english words', () => {
+    const number = 12345;
+    expect(Num.spell(number)).toBe(
+      'twelve thousand three hundred and forty five only',
+    );
+  });
+
+  it('should return false', () => {
+    const number = '12345';
+    expect(Num.isInteger(number)).toBe(false);
+  });
+  it('should return true', () => {
+    const number = 12345;
+    expect(Num.isInteger(number)).toBe(true);
+  });
+});