vest 5.0.0-dev-781e21 → 5.0.2-dev-d315d9

package/src/exports/__tests__/classnames.test.ts

@@ -0,0 +1,92 @@
+import { dummyTest } from '../../../testUtils/testDummy';
+import classnames from '../classnames';
+import promisify from '../promisify';
+
+import * as vest from 'vest';
+
+describe('Utility: classnames', () => {
+  describe('When called without a vest result object', () => {
+    it('Should throw an error', () => {
+      expect(classnames).toThrow();
+      // @ts-expect-error - testing invalid input
+      expect(() => classnames({})).toThrow();
+      // @ts-expect-error - testing invalid input
+      expect(() => classnames([])).toThrow();
+      // @ts-expect-error - testing invalid input
+      expect(() => classnames('invalid')).toThrow();
+    });
+  });
+
+  describe('When called with a vest result object', () => {
+    it('Should return a function', async () => {
+      const validate = vest.create(jest.fn());
+      expect(typeof classnames(validate())).toBe('function');
+      const promisifed = await promisify(vest.create(jest.fn()))();
+      expect(typeof classnames(promisifed)).toBe('function');
+    });
+  });
+
+  const validate = vest.create(() => {
+    vest.skip('field_1');
+
+    dummyTest.failing('field_1');
+    dummyTest.failing('field_2');
+    dummyTest.failingWarning('field_2');
+    dummyTest.failingWarning('field_3');
+    dummyTest.passing('field_4');
+    dummyTest.failing('field_5');
+  });
+
+  const res = validate();
+
+  describe('when all keys are provided', () => {
+    const genClass = classnames(res, {
+      invalid: 'invalid_string',
+      tested: 'tested_string',
+      untested: 'untested_string',
+      valid: 'valid_string',
+      warning: 'warning_string',
+    });
+
+    it('Should produce a string matching the classnames object for each field', () => {
+      expect(genClass('field_1')).toBe('untested_string');
+
+      // splitting and sorting to not rely on object order which is unspecified in the language
+      expect(genClass('field_2').split(' ').sort()).toEqual(
+        'invalid_string tested_string warning_string'.split(' ').sort()
+      );
+      expect(genClass('field_3').split(' ').sort()).toEqual(
+        'tested_string valid_string warning_string'.split(' ').sort()
+      );
+      expect(genClass('field_4').split(' ').sort()).toEqual(
+        'tested_string valid_string'.split(' ').sort()
+      );
+
+      expect(genClass('field_5').split(' ').sort()).toEqual(
+        'tested_string invalid_string'.split(' ').sort()
+      );
+
+      expect(genClass('field_6').split(' ').sort()).toEqual(
+        'untested_string'.split(' ').sort()
+      );
+    });
+  });
+
+  describe('When only some keys are provided', () => {
+    const genClass = classnames(res, {
+      invalid: 'invalid_string',
+    });
+
+    it('Should produce a string matching the classnames object for each field', () => {
+      expect(genClass('field_1')).toBe('');
+
+      // splitting and sorting to not rely on object order which is unspecified in the language
+      expect(genClass('field_2').split(' ').sort()).toEqual(
+        'invalid_string'.split(' ').sort()
+      );
+      expect(genClass('field_3').split(' ').sort()).toEqual(
+        ''.split(' ').sort()
+      );
+    });
+  });
+});

package/src/exports/__tests__/parser.test.ts

@@ -0,0 +1,441 @@
+import * as suiteDummy from '../../../testUtils/suiteDummy';
+import { ser } from '../../../testUtils/suiteDummy';
+
+import { parse } from 'parser';
+import * as vest from 'vest';
+
+describe('parser.parse', () => {
+  describe('parse().invalid', () => {
+    it('Should return true when provided suite result is failing and no field name is provided', () => {
+      expect(parse(suiteDummy.failing()).invalid()).toBe(true);
+    });
+
+    it('Should return false when provided suite result is passing and no field name is provided', () => {
+      expect(parse(suiteDummy.passing()).invalid()).toBe(false);
+    });
+
+    it('Should return true when provided field is failing', () => {
+      expect(parse(suiteDummy.failing('username')).invalid('username')).toBe(
+        true
+      );
+    });
+
+    it('Should return false when provided field is passing', () => {
+      expect(parse(suiteDummy.passing('username')).invalid('username')).toBe(
+        false
+      );
+    });
+
+    describe('Serialized Result', () => {
+      it('Should return true when provided suite result is failing and no field name is provided', () => {
+        expect(parse(ser(suiteDummy.failing())).invalid()).toBe(true);
+      });
+
+      it('Should return false when provided suite result is passing and no field name is provided', () => {
+        expect(parse(ser(suiteDummy.passing())).invalid()).toBe(false);
+      });
+
+      it('Should return true when provided field is failing', () => {
+        expect(
+          parse(ser(suiteDummy.failing('username'))).invalid('username')
+        ).toBe(true);
+      });
+
+      it('Should return false when provided field is passing', () => {
+        expect(
+          parse(ser(suiteDummy.passing('username'))).invalid('username')
+        ).toBe(false);
+      });
+    });
+  });
+
+  describe('parse().tested', () => {
+    it('Should return true if any field is tested but no field is provided', () => {
+      expect(parse(suiteDummy.passing()).tested()).toBe(true);
+    });
+    it('Should return true if no field is tested', () => {
+      expect(parse(suiteDummy.untested()).tested()).toBe(false);
+      expect(parse(suiteDummy.untested()).tested('field')).toBe(false);
+    });
+    it('Should return true if provided field is tested', () => {
+      expect(parse(suiteDummy.passing('username')).tested('username')).toBe(
+        true
+      );
+      expect(parse(suiteDummy.failing('username')).tested('username')).toBe(
+        true
+      );
+    });
+
+    describe('Serialized Result', () => {
+      it('Should return true if any field is tested but no field is provided', () => {
+        expect(parse(ser(suiteDummy.passing())).tested()).toBe(true);
+      });
+      it('Should return true if no field is tested', () => {
+        expect(parse(ser(suiteDummy.untested())).tested()).toBe(false);
+        expect(parse(ser(suiteDummy.untested())).tested('field')).toBe(false);
+      });
+      it('Should return true if provided field is tested', () => {
+        expect(
+          parse(ser(suiteDummy.passing('username'))).tested('username')
+        ).toBe(true);
+        expect(
+          parse(ser(suiteDummy.failing('username'))).tested('username')
+        ).toBe(true);
+      });
+    });
+  });
+
+  describe('parse().untested', () => {
+    it('Should return true if no field is tested', () => {
+      expect(parse(suiteDummy.untested()).untested()).toBe(true);
+      expect(parse(suiteDummy.untested()).untested('username')).toBe(true);
+    });
+
+    it('Should return true if provided field is untested while others are', () => {
+      expect(
+        parse(
+          vest.create(() => {
+            vest.test('x', () => {});
+            vest.skipWhen(true, () => {
+              vest.test('untested', () => {});
+            });
+          })()
+        ).untested('untested')
+      ).toBe(true);
+    });
+
+    it('Should return false if any field is tested', () => {
+      expect(parse(suiteDummy.passing('username')).untested()).toBe(false);
+    });
+
+    it('Should return false if provided field is tested', () => {
+      expect(parse(suiteDummy.passing('username')).untested('username')).toBe(
+        false
+      );
+    });
+
+    describe('Serialized Result', () => {
+      it('Should return true if no field is tested', () => {
+        expect(parse(ser(suiteDummy.untested())).untested()).toBe(true);
+      });
+
+      it('Should return true if provided field is untested while others are', () => {
+        expect(
+          parse(
+            ser(
+              vest.create(() => {
+                vest.test('x', () => {});
+                vest.skipWhen(true, () => {
+                  vest.test('untested', () => {});
+                });
+              })()
+            )
+          ).untested('untested')
+        ).toBe(true);
+      });
+
+      it('Should return false if any field is tested', () => {
+        expect(parse(ser(suiteDummy.passing('username'))).untested()).toBe(
+          false
+        );
+      });
+
+      it('Should return false if provided field is tested', () => {
+        expect(
+          parse(ser(suiteDummy.passing('username'))).untested('username')
+        ).toBe(false);
+      });
+    });
+  });
+
+  describe('parse().valid', () => {
+    it('Should return true if all fields are passing', () => {
+      expect(parse(suiteDummy.passing(['f1', 'f2', 'f3'])).valid()).toBe(true);
+      expect(parse(suiteDummy.passing(['f1', 'f2', 'f3'])).valid('f2')).toBe(
+        true
+      );
+    });
+
+    it('Should return true if all required fields have been tested and are passing', () => {
+      expect(
+        parse(suiteDummy.passingWithUntestedOptional('optional')).valid()
+      ).toBe(true);
+    });
+
+    it('Should return true if all fields, including optional, pass', () => {
+      expect(parse(suiteDummy.passingWithOptional('optional')).valid()).toBe(
+        true
+      );
+    });
+
+    it('Should return false if suite has errors', () => {
+      expect(parse(suiteDummy.failing()).valid()).toBe(false);
+    });
+
+    it('Should return false if suite has failing optional tests', () => {
+      expect(parse(suiteDummy.failingOptional()).valid()).toBe(false);
+    });
+
+    it('Should return true if suite only has warnings', () => {
+      expect(parse(suiteDummy.warning(['f1', 'f2', 'f3'])).valid()).toBe(true);
+    });
+
+    it('Should return false if no tests ran', () => {
+      expect(parse(suiteDummy.untested()).valid()).toBe(false);
+    });
+
+    it('should return false if not all required fields ran', () => {
+      expect(
+        parse(
+          vest.create(() => {
+            vest.test('x', () => {});
+            vest.test('untested', () => {});
+            vest.skipWhen(true, () => {
+              vest.test('untested', () => {});
+            });
+          })()
+        ).valid()
+      ).toBe(false);
+    });
+
+    describe('With field name', () => {
+      it('Should return false when field is untested', () => {
+        expect(
+          parse(
+            vest.create(() => {
+              vest.skipWhen(true, () => {
+                vest.test('f1', () => {});
+              });
+            })()
+          ).valid('f1')
+        ).toBe(false);
+      });
+
+      it('Should return true if optional field is untested', () => {
+        expect(
+          parse(
+            vest.create(() => {
+              vest.optional('f1');
+              vest.skipWhen(true, () => {
+                vest.test('f1', () => {});
+              });
+            })()
+          ).valid('f1')
+        ).toBe(true);
+      });
+
+      it('Should return true if field is passing', () => {
+        expect(
+          parse(
+            vest.create(() => {
+              vest.test('f1', () => {});
+              vest.test('f2', () => false);
+            })()
+          ).valid('f1')
+        ).toBe(true);
+      });
+
+      it('Should return false if field is failing', () => {
+        expect(
+          parse(
+            vest.create(() => {
+              vest.test('f1', () => {});
+              vest.test('f2', () => false);
+            })()
+          ).valid('f2')
+        ).toBe(false);
+        expect(
+          parse(
+            vest.create(() => {
+              vest.test('f1', () => {});
+              vest.test('f2', () => {});
+              vest.test('f2', () => false);
+            })()
+          ).valid('f2')
+        ).toBe(false);
+      });
+
+      it('Should return true if field is warning', () => {
+        expect(
+          parse(
+            vest.create(() => {
+              vest.test('f1', () => {
+                vest.warn();
+                return false;
+              });
+            })()
+          ).valid('f1')
+        ).toBe(true);
+      });
+    });
+
+    describe('Serialized Result', () => {
+      it('Should return true if all fields are passing', () => {
+        expect(parse(ser(suiteDummy.passing(['f1', 'f2', 'f3']))).valid()).toBe(
+          true
+        );
+        expect(
+          parse(ser(suiteDummy.passing(['f1', 'f2', 'f3']))).valid('f2')
+        ).toBe(true);
+      });
+
+      it('Should return true if all required fields have been tested and are passing', () => {
+        expect(
+          parse(ser(suiteDummy.passingWithUntestedOptional('optional'))).valid()
+        ).toBe(true);
+      });
+
+      it('Should return true if all fields, including optional, pass', () => {
+        expect(
+          parse(ser(suiteDummy.passingWithOptional('optional'))).valid()
+        ).toBe(true);
+      });
+
+      it('Should return false if suite has errors', () => {
+        expect(parse(ser(suiteDummy.failing())).valid()).toBe(false);
+      });
+
+      it('Should return false if suite has failing optional tests', () => {
+        expect(parse(ser(suiteDummy.failingOptional())).valid()).toBe(false);
+      });
+
+      it('Should return true if suite only has warnings', () => {
+        expect(parse(ser(suiteDummy.warning(['f1', 'f2', 'f3']))).valid()).toBe(
+          true
+        );
+      });
+
+      it('Should return false if no tests ran', () => {
+        expect(parse(ser(suiteDummy.untested())).valid()).toBe(false);
+      });
+
+      it('should return false if not all required fields ran', () => {
+        expect(
+          parse(
+            ser(
+              vest.create(() => {
+                vest.test('x', () => {});
+                vest.test('untested', () => {});
+                vest.skipWhen(true, () => {
+                  vest.test('untested', () => {});
+                });
+              })()
+            )
+          ).valid()
+        ).toBe(false);
+      });
+
+      describe('With field name', () => {
+        it('Should return false when field is untested', () => {
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.skipWhen(true, () => {
+                    vest.test('f1', () => {});
+                  });
+                })()
+              )
+            ).valid('f1')
+          ).toBe(false);
+        });
+
+        it('Should return true if optional field is untested', () => {
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.optional('f1');
+                  vest.skipWhen(true, () => {
+                    vest.test('f1', () => {});
+                  });
+                })()
+              )
+            ).valid('f1')
+          ).toBe(true);
+        });
+
+        it('Should return true if field is passing', () => {
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.test('f1', () => {});
+                  vest.test('f2', () => false);
+                })()
+              )
+            ).valid('f1')
+          ).toBe(true);
+        });
+
+        it('Should return false if field is failing', () => {
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.test('f1', () => {});
+                  vest.test('f2', () => false);
+                })()
+              )
+            ).valid('f2')
+          ).toBe(false);
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.test('f1', () => {});
+                  vest.test('f2', () => {});
+                  vest.test('f2', () => false);
+                })()
+              )
+            ).valid('f2')
+          ).toBe(false);
+        });
+
+        it('Should return true if field is warning', () => {
+          expect(
+            parse(
+              ser(
+                vest.create(() => {
+                  vest.test('f1', () => {
+                    vest.warn();
+                    return false;
+                  });
+                })()
+              )
+            ).valid('f1')
+          ).toBe(true);
+        });
+      });
+    });
+  });
+
+  describe('parse().warning', () => {
+    it('Should return true when the suite has warnings', () => {
+      expect(parse(suiteDummy.warning()).warning()).toBe(true);
+    });
+
+    it('Should return false when the suite is not warnings', () => {
+      expect(parse(suiteDummy.failing()).warning()).toBe(false);
+    });
+
+    describe('serialized result', () => {
+      it('Should return true when the suite has warnings', () => {
+        expect(parse(ser(suiteDummy.warning())).warning()).toBe(true);
+      });
+
+      it('Should return false when the suite is not warnings', () => {
+        expect(parse(ser(suiteDummy.failing())).warning()).toBe(false);
+      });
+    });
+  });
+
+  describe('When input is not a Vest object', () => {
+    it('Should throw an error', () => {
+      expect(() => {
+        // @ts-ignore - this is not a vest object
+        parse({});
+      }).toThrow();
+    });
+  });
+});

package/src/exports/__tests__/promisify.test.ts

@@ -0,0 +1,77 @@
+import { faker } from '@faker-js/faker';
+
+import { dummyTest } from '../../../testUtils/testDummy';
+import { TestPromise } from '../../../testUtils/testPromise';
+import promisify from '../promisify';
+
+import * as vest from 'vest';
+
+describe('Utility: promisify', () => {
+  let validatorFn: jest.Mock<vest.SuiteRunResult<string>, any>;
+  let validateAsync: (...args: any[]) => Promise<vest.SuiteResult<string>>;
+
+  beforeEach(() => {
+    validatorFn = jest.fn(vest.create(jest.fn()));
+    validateAsync = promisify(validatorFn);
+  });
+
+  describe('Test arguments', () => {
+    it('Should throw an error', () => {
+      // @ts-expect-error - testing invalid input
+      const invalidValidateAsync = promisify('invalid');
+      expect(() => invalidValidateAsync()).toThrow();
+    });
+  });
+
+  describe('Return value', () => {
+    it('should be a function', () => {
+      expect(typeof promisify(jest.fn())).toBe('function');
+    });
+
+    it('should be a promise', () =>
+      TestPromise(done => {
+        const res = validateAsync();
+        expect(typeof res?.then).toBe('function');
+        res.then(() => done());
+      }));
+  });
+
+  describe('When returned function is invoked', () => {
+    it('Calls `validatorFn` argument', () =>
+      TestPromise(done => {
+        const validateAsync = promisify(vest.create(() => done()));
+        validateAsync();
+      }));
+
+    it('Passes all arguments over to tests callback', async () => {
+      const params = [
+        1,
+        { [faker.random.word()]: [1, 2, 3] },
+        false,
+        [faker.random.word()],
+      ];
+
+      await validateAsync(...params);
+      expect(validatorFn).toHaveBeenCalledWith(...params);
+    });
+  });
+
+  describe('Initial run', () => {
+    it('Produces correct validation', () =>
+      TestPromise(done => {
+        const validate = vest.create(() => {
+          dummyTest.failing('field_0');
+          dummyTest.failingAsync('field_1');
+        });
+
+        const validatorAsync = promisify(validate);
+        const p = validatorAsync('me');
+
+        p.then(result => {
+          expect(result.hasErrors('field_0')).toBe(true);
+          expect(result.hasErrors('field_1')).toBe(true);
+          done();
+        });
+      }));
+  });
+});

package/src/exports/classnames.ts

@@ -0,0 +1,35 @@
+import { isFunction } from 'vest-utils';
+
+import { SuiteSummary, TFieldName } from 'SuiteResultTypes';
+import { parse } from 'parser';
+
+/**
+ * Creates a function that returns class names that match the validation result
+ */
+export default function classnames<F extends TFieldName>(
+  res: SuiteSummary<F>,
+  classes: SupportedClasses = {}
+): (fieldName: F) => string {
+  const selectors = parse(res);
+
+  return function cn(fieldName: F): string {
+    const classesArray: string[] = [];
+
+    for (const selector in classes) {
+      const sel = selector as keyof SupportedClasses;
+      if (isFunction(selectors[sel]) && selectors[sel](fieldName)) {
+        classesArray.push(classes[sel] as string);
+      }
+    }
+
+    return classesArray.join(' ');
+  };
+}
+
+type SupportedClasses = {
+  valid?: string;
+  tested?: string;
+  invalid?: string;
+  warning?: string;
+  untested?: string;
+};

package/src/exports/enforce@compose.ts

@@ -0,0 +1 @@
+export { default } from 'n4s/compose';

package/src/exports/enforce@compounds.ts

@@ -0,0 +1 @@
+export * as compounds from 'n4s/compounds';

package/src/exports/enforce@schema.ts

@@ -0,0 +1 @@
+export * as schema from 'n4s/schema';