@toolz/allow - npm Package Compare versions

Comparing version 0.0.18 to 0.0.19

package.json

 {
   "name": "@toolz/allow",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "Provides validation of data types",
@@ -5,0 +5,0 @@ "keywords": [

README.md

@@ -6,3 +6,3 @@ # allow
 
-Another goal is to eliminate the need for unit tests that only test a function's / method's operation when it receives the "wrong" kind of data. By validating that data at runtime, we are ensuring that the internal logic of the function / method is only invoke if it has been supplied with data of the expected type.
+Another goal is to eliminate the need for unit tests that only test a function's / method's operation when it receives the "wrong" kind of data. By validating that data at runtime, we are ensuring that the internal logic of the function / method is only invoked if it has been supplied with data of the expected type.
 
@@ -9,0 +9,0 @@ ## Usage

src/allow.test.js

@@ -48,2 +48,3 @@ import { allow } from './allow';
 const aFunction = () => 'foo';
+const anAlphabetString = 'abcdefghijklmnopqrstuvwxzy';
 const anArrayOfArrays = [[9, 8, 7], ['foo', 'fie', 'fee'], [{one: 1}, {two: 2}], []];
@@ -60,2 +61,3 @@ const anArrayOfIntegers = [2, 9, 42, 187];
 const anEmptyObject = {};
+const anEmptyString = '';
 const aNull = null;
@@ -98,2 +100,3 @@ const aNumber0 = 0;
    expect(() => allow.aBoolean(aFunction)).toThrow();
+   expect(() => allow.aBoolean(anAlphabetString)).toThrow();
    expect(() => allow.aBoolean(anArrayOfArrays)).toThrow();
@@ -110,2 +113,3 @@ expect(() => allow.aBoolean(anArrayOfIntegers)).toThrow();
    expect(() => allow.aBoolean(anEmptyObject)).toThrow();
+   expect(() => allow.aBoolean(anEmptyString)).toThrow();
    expect(() => allow.aBoolean(aNull)).toThrow();
@@ -137,2 +141,3 @@ expect(() => allow.aBoolean(aNumber0)).toThrow();
    expect(() => allow.aFunction(aFalseString)).toThrow();
+   expect(() => allow.aFunction(anAlphabetString)).toThrow();
    expect(() => allow.aFunction(anArrayOfArrays)).toThrow();
@@ -149,2 +154,3 @@ expect(() => allow.aFunction(anArrayOfIntegers)).toThrow();
    expect(() => allow.aFunction(anEmptyObject)).toThrow();
+   expect(() => allow.aFunction(anEmptyString)).toThrow();
    expect(() => allow.aFunction(aNull)).toThrow();
@@ -216,5 +222,7 @@ expect(() => allow.aFunction(aNumber0)).toThrow();
    expect(() => allow.anArray(aFunction)).toThrow();
+   expect(() => allow.anArray(anAlphabetString)).toThrow();
    expect(() => allow.anArray(aNegative1)).toThrow();
    expect(() => allow.anArray(aNegativePi)).toThrow();
    expect(() => allow.anArray(anEmptyObject)).toThrow();
+   expect(() => allow.anArray(anEmptyString)).toThrow();
    expect(() => allow.anArray(aNull)).toThrow();
@@ -262,2 +270,3 @@ expect(() => allow.anArray(aNumber0)).toThrow();
    expect(() => allow.anArrayOfArrays(aFunction)).toThrow();
+   expect(() => allow.anArrayOfArrays(anAlphabetString)).toThrow();
    expect(() => allow.anArrayOfArrays(anArrayOfIntegers)).toThrow();
@@ -272,2 +281,3 @@ expect(() => allow.anArrayOfArrays(anArrayOfMixedTypes)).toThrow();
    expect(() => allow.anArrayOfArrays(anEmptyObject)).toThrow();
+   expect(() => allow.anArrayOfArrays(anEmptyString)).toThrow();
    expect(() => allow.anArrayOfArrays(aNull)).toThrow();
@@ -328,2 +338,3 @@ expect(() => allow.anArrayOfArrays(aNumber0)).toThrow();
    expect(() => allow.anArrayOfInstances(aFunction, person)).toThrow();
+   expect(() => allow.anArrayOfInstances(anAlphabetString, person)).toThrow();
    expect(() => allow.anArrayOfInstances(anArrayOfArrays, person)).toThrow();
@@ -338,2 +349,3 @@ expect(() => allow.anArrayOfInstances(anArrayOfIntegers, person)).toThrow();
    expect(() => allow.anArrayOfInstances(anEmptyObject, person)).toThrow();
+   expect(() => allow.anArrayOfInstances(anEmptyString, person)).toThrow();
    expect(() => allow.anArrayOfInstances(aNull, person)).toThrow();
@@ -381,2 +393,3 @@ expect(() => allow.anArrayOfInstances(aNumber0, person)).toThrow();
    expect(() => allow.anArrayOfIntegers(aFunction)).toThrow();
+   expect(() => allow.anArrayOfIntegers(anAlphabetString)).toThrow();
    expect(() => allow.anArrayOfIntegers(anArrayOfArrays)).toThrow();
@@ -391,2 +404,3 @@ expect(() => allow.anArrayOfIntegers(anArrayOfMixedTypes)).toThrow();
    expect(() => allow.anArrayOfIntegers(anEmptyObject)).toThrow();
+   expect(() => allow.anArrayOfIntegers(anEmptyString)).toThrow();
    expect(() => allow.anArrayOfIntegers(aNull)).toThrow();
@@ -435,2 +449,3 @@ expect(() => allow.anArrayOfIntegers(aNumber0)).toThrow();
    expect(() => allow.anArrayOfNumbers(aFunction)).toThrow();
+   expect(() => allow.anArrayOfNumbers(anAlphabetString)).toThrow();
    expect(() => allow.anArrayOfNumbers(anArrayOfArrays)).toThrow();
@@ -444,2 +459,3 @@ expect(() => allow.anArrayOfNumbers(anArrayOfMixedTypes)).toThrow();
    expect(() => allow.anArrayOfNumbers(anEmptyObject)).toThrow();
+   expect(() => allow.anArrayOfNumbers(anEmptyString)).toThrow();
    expect(() => allow.anArrayOfNumbers(aNull)).toThrow();
@@ -488,2 +504,3 @@ expect(() => allow.anArrayOfNumbers(aNumber0)).toThrow();
    expect(() => allow.anArrayOfObjects(aFunction)).toThrow();
+   expect(() => allow.anArrayOfObjects(anAlphabetString)).toThrow();
    expect(() => allow.anArrayOfObjects(anArrayOfArrays)).toThrow();
@@ -497,2 +514,3 @@ expect(() => allow.anArrayOfObjects(anArrayOfIntegers)).toThrow();
    expect(() => allow.anArrayOfObjects(anEmptyObject)).toThrow();
+   expect(() => allow.anArrayOfObjects(anEmptyString)).toThrow();
    expect(() => allow.anArrayOfObjects(aNull)).toThrow();
@@ -540,2 +558,3 @@ expect(() => allow.anArrayOfObjects(aNumber0)).toThrow();
    expect(() => allow.anArrayOfStrings(aFunction)).toThrow();
+   expect(() => allow.anArrayOfStrings(anAlphabetString)).toThrow();
    expect(() => allow.anArrayOfStrings(anArrayOfArrays)).toThrow();
@@ -550,2 +569,3 @@ expect(() => allow.anArrayOfStrings(anArrayOfIntegers)).toThrow();
    expect(() => allow.anArrayOfStrings(anEmptyObject)).toThrow();
+   expect(() => allow.anArrayOfStrings(anEmptyString)).toThrow();
    expect(() => allow.anArrayOfStrings(aNull)).toThrow();
@@ -600,2 +620,3 @@ expect(() => allow.anArrayOfStrings(aNumber0)).toThrow();
    expect(() => allow.anInstanceOf(aFunction, person)).toThrow();
+   expect(() => allow.anInstanceOf(anAlphabetString, person)).toThrow();
    expect(() => allow.anInstanceOf(anArrayOfArrays, person)).toThrow();
@@ -612,2 +633,3 @@ expect(() => allow.anInstanceOf(anArrayOfIntegers, person)).toThrow();
    expect(() => allow.anInstanceOf(anEmptyObject, person)).toThrow();
+   expect(() => allow.anInstanceOf(anEmptyString, person)).toThrow();
    expect(() => allow.anInstanceOf(aNull, person)).toThrow();
@@ -665,2 +687,3 @@ expect(() => allow.anInstanceOf(aNumber0, person)).toThrow();
    expect(() => allow.anInteger(aFunction)).toThrow();
+   expect(() => allow.anInteger(anAlphabetString)).toThrow();
    expect(() => allow.anInteger(anArrayOfArrays)).toThrow();
@@ -676,2 +699,3 @@ expect(() => allow.anInteger(anArrayOfIntegers)).toThrow();
    expect(() => allow.anInteger(anEmptyObject)).toThrow();
+   expect(() => allow.anInteger(anEmptyString)).toThrow();
    expect(() => allow.anInteger(aNull)).toThrow();
@@ -684,1 +708,188 @@ expect(() => allow.anInteger(anUndefined)).toThrow();
 });
+
+// anObject()
+
+test('anObject() should pass when checking any object', () => {
+   expect(allow.anObject(anEmptyObject)).toEqual(expect.any(Object));
+   expect(allow.anObject(aPopulatedObject)).toEqual(expect.any(Object));
+});
+
+test('after setting allowNull to TRUE, anObject() should pass when checking a NULL value', () => {
+   allow.setAllowNull(true);
+   expect(allow.anObject(aNull)).toEqual(expect.any(Object));
+   allow.setAllowNull(false);
+});
+
+test('anObject() should pass when checking objects that have a minimum number of keys', () => {
+   expect(allow.anObject(aBriefPerson, 1)).toEqual(expect.any(Object));
+   expect(allow.anObject(aPerson, 1)).toEqual(expect.any(Object));
+   expect(allow.anObject(aLongerPerson, 1)).toEqual(expect.any(Object));
+   expect(allow.anObject(aPopulatedObject, 1)).toEqual(expect.any(Object));
+});
+
+test('anObject() should pass when checking objects with a minimum and a maximum number of keys', () => {
+   expect(allow.anObject(aBriefPerson, 1, 50)).toEqual(expect.any(Object));
+   expect(allow.anObject(aPerson, 1, 50)).toEqual(expect.any(Object));
+   expect(allow.anObject(aLongerPerson, 1, 50)).toEqual(expect.any(Object));
+   expect(allow.anObject(aPopulatedObject, 1, 50)).toEqual(expect.any(Object));
+});
+
+test('anObject() should throw an error when checking objects that are outside the range of required keys', () => {
+   expect(() => allow.anObject(aBriefPerson, 20, 50)).toThrow();
+   expect(() => allow.anObject(aPerson, 20, 50)).toThrow();
+   expect(() => allow.anObject(aLongerPerson, 20, 50)).toThrow();
+   expect(() => allow.anObject(aPopulatedObject, 20, 50)).toThrow();
+});
+
+test('anObject() should throw an error when checking anything other than an integer', () => {
+   expect(() => allow.anObject(AClass)).toThrow();
+   expect(() => allow.anObject(aFalse)).toThrow();
+   expect(() => allow.anObject(aFalseString)).toThrow();
+   expect(() => allow.anObject(aFunction)).toThrow();
+   expect(() => allow.anObject(anAlphabetString)).toThrow();
+   expect(() => allow.anObject(anArrayOfArrays)).toThrow();
+   expect(() => allow.anObject(anArrayOfIntegers)).toThrow();
+   expect(() => allow.anObject(anArrayOfMixedTypes)).toThrow();
+   expect(() => allow.anObject(anArrayOfNumbers)).toThrow();
+   expect(() => allow.anObject(anArrayOfObjects)).toThrow();
+   expect(() => allow.anObject(anArrayOfPeople)).toThrow();
+   expect(() => allow.anObject(anArrayOfStrings)).toThrow();
+   expect(() => allow.anObject(aNegative1)).toThrow();
+   expect(() => allow.anObject(aNegativePi)).toThrow();
+   expect(() => allow.anObject(anEmptyArray)).toThrow();
+   expect(() => allow.anObject(anEmptyString)).toThrow();
+   expect(() => allow.anObject(aNull)).toThrow();
+   expect(() => allow.anObject(aNumber0)).toThrow();
+   expect(() => allow.anObject(aNumber1)).toThrow();
+   expect(() => allow.anObject(aNumber1WithDecimals)).toThrow();
+   expect(() => allow.anObject(anUndefined)).toThrow();
+   expect(() => allow.anObject(aPi)).toThrow();
+   expect(() => allow.anObject(aTrue)).toThrow();
+   expect(() => allow.anObject(aTrueString)).toThrow();
+});
+
+// aNumber()
+
+test('aNumber() should pass when checking any number', () => {
+   expect(allow.aNumber(aNegative1)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNegativePi)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber0)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1WithDecimals)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aPi)).toEqual(expect.any(Object));
+});
+
+test('after setting allowNull to TRUE, aNumber() should pass when checking a NULL value', () => {
+   allow.setAllowNull(true);
+   expect(allow.aNumber(aNull)).toEqual(expect.any(Object));
+   allow.setAllowNull(false);
+});
+
+test('aNumber() should pass when checking numbers that meet a minimum value', () => {
+   expect(allow.aNumber(aNegative1, -2)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNegativePi, -4)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber0, -1)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1, 0)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1WithDecimals, 0)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aPi, 3)).toEqual(expect.any(Object));
+});
+
+test('aNumber() should pass when checking numbers with a minimum value and a maximum value', () => {
+   expect(allow.aNumber(aNegative1, -2, 0)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNegativePi, -4, -3)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber0, -1, 1)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1, 0, 2)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aNumber1WithDecimals, 0, 2)).toEqual(expect.any(Object));
+   expect(allow.aNumber(aPi, 3, 4)).toEqual(expect.any(Object));
+});
+
+test('aNumber() should throw an error when checking numbers that are outside the required range', () => {
+   expect(() => allow.aNumber(aNegative1, 20, 50)).toThrow();
+   expect(() => allow.aNumber(aNegativePi, 20, 50)).toThrow();
+   expect(() => allow.aNumber(aNumber0, 20, 50)).toThrow();
+   expect(() => allow.aNumber(aNumber1, 20, 50)).toThrow();
+   expect(() => allow.aNumber(aNumber1WithDecimals, 20, 50)).toThrow();
+   expect(() => allow.aNumber(aPi, 20, 50)).toThrow();
+});
+
+test('aNumber() should throw an error when checking anything other than a number', () => {
+   expect(() => allow.aNumber(AClass)).toThrow();
+   expect(() => allow.aNumber(aFalse)).toThrow();
+   expect(() => allow.aNumber(aFalseString)).toThrow();
+   expect(() => allow.aNumber(aFunction)).toThrow();
+   expect(() => allow.aNumber(anAlphabetString)).toThrow();
+   expect(() => allow.aNumber(anArrayOfArrays)).toThrow();
+   expect(() => allow.aNumber(anArrayOfIntegers)).toThrow();
+   expect(() => allow.aNumber(anArrayOfMixedTypes)).toThrow();
+   expect(() => allow.aNumber(anArrayOfNumbers)).toThrow();
+   expect(() => allow.aNumber(anArrayOfObjects)).toThrow();
+   expect(() => allow.aNumber(anArrayOfPeople)).toThrow();
+   expect(() => allow.aNumber(anArrayOfStrings)).toThrow();
+   expect(() => allow.aNumber(anEmptyArray)).toThrow();
+   expect(() => allow.aNumber(anEmptyObject)).toThrow();
+   expect(() => allow.aNumber(anEmptyString)).toThrow();
+   expect(() => allow.aNumber(aNull)).toThrow();
+   expect(() => allow.aNumber(anUndefined)).toThrow();
+   expect(() => allow.aNumber(aPopulatedObject)).toThrow();
+   expect(() => allow.aNumber(aTrue)).toThrow();
+   expect(() => allow.aNumber(aTrueString)).toThrow();
+});
+
+// aString()
+
+test('aString() should pass when checking any string', () => {
+   expect(allow.aString(aFalseString)).toEqual(expect.any(Object));
+   expect(allow.aString(anAlphabetString)).toEqual(expect.any(Object));
+   expect(allow.aString(anEmptyString)).toEqual(expect.any(Object));
+   expect(allow.aString(aTrueString)).toEqual(expect.any(Object));
+});
+
+test('after setting allowNull to TRUE, aString() should pass when checking a NULL value', () => {
+   allow.setAllowNull(true);
+   expect(allow.aString(aNull)).toEqual(expect.any(Object));
+   allow.setAllowNull(false);
+});
+
+test('aString() should pass when checking strings that meet a minimum length', () => {
+   expect(allow.aString(aFalseString, 4)).toEqual(expect.any(Object));
+   expect(allow.aString(anAlphabetString, 25)).toEqual(expect.any(Object));
+   expect(allow.aString(aTrueString, 3)).toEqual(expect.any(Object));
+});
+
+test('aString() should pass when checking strings with a minimum length and a maximum length', () => {
+   expect(allow.aString(aFalseString, 4, 30)).toEqual(expect.any(Object));
+   expect(allow.aString(anAlphabetString, 25, 30)).toEqual(expect.any(Object));
+   expect(allow.aString(aTrueString, 3, 30)).toEqual(expect.any(Object));
+});
+
+test('aString() should throw an error when checking strings that are outside the required length', () => {
+   expect(() => allow.aString(aFalseString, 28, 30)).toThrow();
+   expect(() => allow.aString(anAlphabetString, 28, 30)).toThrow();
+   expect(() => allow.aString(anEmptyString, 28, 30)).toThrow();
+   expect(() => allow.aString(aTrueString, 28, 30)).toThrow();
+});
+
+test('aString() should throw an error when checking anything other than a string', () => {
+   expect(() => allow.aString(AClass)).toThrow();
+   expect(() => allow.aString(aFalse)).toThrow();
+   expect(() => allow.aString(aFunction)).toThrow();
+   expect(() => allow.aString(anArrayOfArrays)).toThrow();
+   expect(() => allow.aString(anArrayOfIntegers)).toThrow();
+   expect(() => allow.aString(anArrayOfMixedTypes)).toThrow();
+   expect(() => allow.aString(anArrayOfNumbers)).toThrow();
+   expect(() => allow.aString(anArrayOfObjects)).toThrow();
+   expect(() => allow.aString(anArrayOfPeople)).toThrow();
+   expect(() => allow.aString(anArrayOfStrings)).toThrow();
+   expect(() => allow.aString(aNegative1)).toThrow();
+   expect(() => allow.aString(aNegativePi)).toThrow();
+   expect(() => allow.aString(anEmptyArray)).toThrow();
+   expect(() => allow.aString(anEmptyObject)).toThrow();
+   expect(() => allow.aString(aNull)).toThrow();
+   expect(() => allow.aString(aNumber0)).toThrow();
+   expect(() => allow.aString(aNumber1)).toThrow();
+   expect(() => allow.aString(aNumber1WithDecimals)).toThrow();
+   expect(() => allow.aString(anUndefined)).toThrow();
+   expect(() => allow.aString(aPi)).toThrow();
+   expect(() => allow.aString(aPopulatedObject)).toThrow();
+   expect(() => allow.aString(aTrue)).toThrow();
+});

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

74064

increased by17.45%

Lines of code

982

increased by23.99%

No dependency changes