Postman homologation

index.d.ts

@@ -15,6 +15,7 @@ export interface JSONSchemaFakerOptions {
   optionalsProbability?: number | false;
   fixedProbabilities?: boolean;
   useExamplesValue?: boolean;
+  avoidExampleItemsLength?: boolean;
   useDefaultValue?: boolean;
   requiredOnly?: boolean;
   minItems?: number;
@@ -31,6 +32,7 @@ export interface JSONSchemaFakerOptions {
   renderComment?: boolean;
   refDepthMax?: number;
   refDepthMin?: number;
+  validationOptions?: object;
 }
 
 export type JSONSchemaFakerRefs = Schema[] | { [k: string]: Schema };

package.json

@@ -21,7 +21,7 @@
     "test:schema": "npm run test:run tests/schema --",
     "test:integration": "npm run test:run tests/integration --",
     "coverage": "nyc --es-modules -x '**/tests/**' -x '**/*.spec.js'",
-    "coverage:all": "npm run coverage -- npm run test:all",
+    "coverage:all": "npm run coverage -- npm run test:unit && npm run test:integration && npm run test:schema",
     "coverage:unit": "npm run coverage -- npm run test:unit",
     "report": "nyc report",
     "lint": "eslint --ext js,svelte src tests",
@@ -37,7 +37,7 @@
     "copy:wargs": "concat -o dist/wargs.min.js node_modules/wargs/dist/wargs.min.js",
     "entry:cjs": "echo 'module.exports = require(\"./main.cjs.js\").default;' > dist/index.js",
     "prepublishOnly": "npm run build -- -f",
-    "postbuild": "npm run copy:bundle && npm run entry:cjs",
+    "postbuild": "npm run copy:bundle && npm run entry:cjs && node scripts/replaceConsoleError.js",
     "prebuild": "mkdir -p dist && npm run copy:vendor && npm run copy:wargs",
     "codecov": "codecov --file=coverage/lcov.info -e TRAVIS_NODE_VERSION"
   },
@@ -87,6 +87,7 @@
     "@faker-js/faker": "^5.5.3",
     "@types/json-schema": "^7.0.9",
     "ajv": "^6.12.6",
+    "ansi-regex": ">=5.0.1",
     "chai": "^4.1.2",
     "chance": "^1.0.9",
     "clone": "^2.1.2",
@@ -105,21 +106,21 @@
     "is-my-json-valid": "^2.19.0",
     "less": "^4.1.1",
     "less-plugin-autoprefix": "^2.0.0",
+    "lodash": "4.17.21",
     "mocha": "^7.0.0",
     "mockjs": "^1.1.0",
     "mortero": "^0.0.43",
+    "nth-check": ">=2.0.1",
     "nyc": "^15.0.0",
     "pug": "^3.0.2",
     "randexp": "^0.5.3",
     "seedrandom": "^3.0.1",
     "semver": "^7.1.1",
+    "set-value": ">=4.0.1",
     "sinon": "^11.1.1",
     "sinon-chai": "^3.7.0",
     "smoo": "^0.0.14",
     "svelte": "^3.38.2",
-    "set-value": ">=4.0.1",
-    "nth-check": ">=2.0.1",
-    "ansi-regex": ">=5.0.1",
     "tv4": "^1.3.0",
     "type-fest": "^2.0.0",
     "wargs": "^0.9.2",
@@ -129,6 +130,7 @@
   },
   "dependencies": {
     "json-schema-ref-parser": "^6.1.0",
-    "jsonpath-plus": "^5.1.0"
+    "jsonpath-plus": "^5.1.0",
+    "lodash": "4.17.21"
   }
 }

scripts/replaceConsoleError.js

@@ -0,0 +1,10 @@
+let fs = require('fs');
+
+fs.readFile('dist/bundle.js', 'utf8', (err, data) => {
+  if (err) {
+    return console.log(err);
+  }
+  fs.writeFile('dist/bundle.js', data.replace(/console.error/g, 'console.warn'), 'utf8', saveErr => {
+     if (saveErr) return console.log(saveErr);
+  });
+});

src/lib/api/defaults.js

@@ -13,8 +13,9 @@ defaults.failOnInvalidFormat = true;
 
 defaults.alwaysFakeOptionals = false;
 defaults.optionalsProbability = null;
-defaults.fixedProbabilities = false;
+defaults.fixedProbabilities = true;
 defaults.useExamplesValue = false;
+defaults.avoidExampleItemsLength = false;
 defaults.useDefaultValue = false;
 defaults.requiredOnly = false;
 
@@ -33,3 +34,6 @@ defaults.random = Math.random;
 defaults.renderTitle = true;
 defaults.renderDescription = true;
 defaults.renderComment = false;
+
+defaults.validationOptions = {};
+defaults.pickFirstFromExamples = false;

src/lib/core/run.js

@@ -83,7 +83,7 @@ function resolve(obj, data, values, property) {
 }
 
 // TODO provide types?
-function run(refs, schema, container, synchronous) {
+function run(refs, schema, container, synchronous, validateSchema) {
   if (Object.prototype.toString.call(schema) !== '[object Object]') {
     throw new Error(`Invalid input, expecting object but given ${typeof schema}`);
   }
@@ -100,7 +100,7 @@ function run(refs, schema, container, synchronous) {
       refDepthMin,
       refDepthMax,
     });
-    const result = traverse(utils.clone(schema), [], resolveSchema);
+    const result = traverse(utils.clone(schema), [], resolveSchema, undefined, validateSchema);
 
     if (optionAPI('resolveJsonPath')) {
       return {

src/lib/core/traverse.js

@@ -1,9 +1,11 @@
+import _ from 'lodash';
 import utils from './utils';
 import random from './random';
 import ParseError from './error';
 import inferType from './infer';
 import types from '../types/index';
 import optionAPI from '../api/option';
+import ALL_TYPES from './constants';
 
 function getMeta({ $comment: comment, title, description }) {
   return Object.entries({ comment, title, description })
@@ -15,15 +17,15 @@ function getMeta({ $comment: comment, title, description }) {
 }
 
 // TODO provide types
-function traverse(schema, path, resolve, rootSchema) {
+function traverse(schema, path, resolve, rootSchema, validateSchema) {
   schema = resolve(schema, null, path);
 
   if (schema && (schema.oneOf || schema.anyOf || schema.allOf)) {
     schema = resolve(schema, null, path);
   }
 
   if (!schema) {
-    return;
+    throw new Error(`Cannot traverse at '${path.join('.')}', given '${JSON.stringify(rootSchema)}'`);
   }
 
   const context = {
@@ -36,19 +38,93 @@ function traverse(schema, path, resolve, rootSchema) {
     // example values have highest precedence
     if (optionAPI('useExamplesValue') && Array.isArray(schema.examples)) {
       // include `default` value as example too
-      const fixedExamples = schema.examples
-        .concat('default' in schema ? [schema.default] : []);
+      let randomExample;
+      const fixedExamples = schema.examples.concat(
+        'default' in schema ? [schema.default] : []);
+        if (optionAPI('pickFirstFromExamples')) {
+          randomExample = fixedExamples[0];
+        } else {
+           randomExample = random.pick(fixedExamples);
+        }
+      if (validateSchema) {
+        let result;
+        let clonedSchema;
+
+        // avoid minItems and maxItems while checking for valid examples
+        if (optionAPI('avoidExampleItemsLength') && _.get(schema, 'type') === 'array') {
+          clonedSchema = _.clone(schema);
+          _.unset(clonedSchema, 'minItems');
+          _.unset(clonedSchema, 'maxItems');
 
-      return { value: utils.typecast(null, schema, () => random.pick(fixedExamples)), context };
+          result = validateSchema(clonedSchema, randomExample, optionAPI('validationOptions'));
+        } else {
+          result = validateSchema(schema, randomExample, optionAPI('validationOptions'));
+        }
+
+        // Use example only if valid
+        if (result && result.length === 0) {
+          if (optionAPI('validationOptions') && optionAPI('validationOptions').ignoreUnresolvedVariables) {
+            return {
+              value: randomExample,
+              context,
+            };
+          }
+          return {
+            value: utils.typecast(null, schema, () => randomExample),
+            context,
+          };
+        }
+      } else {
+        console.warn('Taking example from schema without validation');
+        return {
+          value: utils.typecast(null, schema, () => randomExample),
+          context,
+        };
+      }
     }
     // If schema contains single example property
-    if (optionAPI('useExamplesValue') && schema.example) {
-      return { value: utils.typecast(null, schema, () => schema.example), context };
+    if (optionAPI('useExamplesValue') && !_.isNil(schema.example)) {
+      if (validateSchema) {
+        let result;
+        let clonedSchema;
+
+        // avoid minItems and maxItems while checking for valid examples
+        if (optionAPI('avoidExampleItemsLength') && _.get(schema, 'type') === 'array') {
+          clonedSchema = _.clone(schema);
+          _.unset(clonedSchema, 'minItems');
+          _.unset(clonedSchema, 'maxItems');
+
+          result = validateSchema(clonedSchema, schema.example, optionAPI('validationOptions'));
+        } else {
+          result = validateSchema(schema, schema.example, optionAPI('validationOptions'));
+        }
+
+        // Use example only if valid
+        if (result && result.length === 0) {
+          if (optionAPI('validationOptions') && optionAPI('validationOptions').ignoreUnresolvedVariables) {
+            return {
+              value: schema.example,
+              context,
+            };
+          }
+          return {
+            value: utils.typecast(null, schema, () => schema.example),
+            context,
+          };
+        }
+      } else {
+        console.warn('Taking example from schema without validation');
+        return { value: utils.typecast(null, schema, () => schema.example), context };
+      }
     }
 
+    // use default as faked value if found as keyword in schema
     if (optionAPI('useDefaultValue') && 'default' in schema) {
-      if (schema.default !== '' || !optionAPI('replaceEmptyByRandomValue')) {
-        return { value: schema.default, context };
+      // to not use default as faked value in case it is actual property of schema
+      if (!(_.has(schema.default, 'type') && _.includes(ALL_TYPES, schema.default.type))) {
+        if (schema.default !== '' || !optionAPI('replaceEmptyByRandomValue')) {
+          return { value: schema.default, context };
+        }
       }
     }
 
@@ -66,15 +142,15 @@ function traverse(schema, path, resolve, rootSchema) {
 
     // build new object value from not-schema!
     if (schema.type && schema.type === 'object') {
-      const { value, context: innerContext } = traverse(schema, path.concat(['not']), resolve, rootSchema);
+      const { value, context: innerContext } = traverse(schema, path.concat(['not']), resolve, rootSchema, validateSchema);
       return { value: utils.clean(value, schema, false), context: { ...context, items: innerContext } };
     }
   }
 
   // thunks can return sub-schemas
   if (typeof schema.thunk === 'function') {
     // result is already cleaned in thunk
-    const { value, context: innerContext } = traverse(schema.thunk(rootSchema), path, resolve);
+    const { value, context: innerContext } = traverse(schema.thunk(rootSchema), path, resolve, undefined, validateSchema);
     return { value, context: { ...context, items: innerContext } };
   }
 
@@ -130,7 +206,7 @@ function traverse(schema, path, resolve, rootSchema) {
       }
     } else {
       try {
-        const innerResult = types[type](schema, path, resolve, traverse);
+        const innerResult = types[type](schema, path, resolve, validateSchema, traverse);
         if (type === 'array') {
           return {
             value: innerResult.map(({ value }) => value),
@@ -172,7 +248,7 @@ function traverse(schema, path, resolve, rootSchema) {
   Object.keys(schema).forEach(prop => {
     if (pruneProperties.includes(prop)) return;
     if (typeof schema[prop] === 'object' && prop !== 'definitions') {
-      const { value, context: innerContext } = traverse(schema[prop], path.concat([prop]), resolve, valueCopy);
+      const { value, context: innerContext } = traverse(schema[prop], path.concat([prop]), resolve, valueCopy, validateSchema);
       valueCopy[prop] = utils.clean(value, schema[prop], false);
       contextCopy[prop] = innerContext;
     } else {