artillery-plugin-fake-data 1.22.0 → 1.23.0-67648ae

package/README.md

@@ -1,8 +1,14 @@
 # artillery-plugin-fake-data
 
-## Easy randomised test data leveraging falso
+## Easy randomised test data leveraging Faker
 
-With this plugin, you can add random test data using [falso](https://ngneat.github.io/falso/docs) straight into YAML, giving you a wide range of test data options to choose from. You'll also be able to use the same functions in your `beforeRequest`/`afterResponse` hooks. Check the documentation for more information.
+With this plugin, you can add random test data using [Faker](https://fakerjs.dev/api/) straight into YAML, giving you a wide range of test data options to choose from. You'll also be able to use the same functions in your `beforeRequest`/`afterResponse` hooks. Check the documentation for more information.
+
+Faker functions are exposed with flattened names: `faker.internet.email()` becomes `$internetEmail()`, `faker.person.fullName()` becomes `$personFullName()`, and so on.
+
+### Migrating from falso
+
+Earlier versions of this plugin used [falso](https://ngneat.github.io/falso/). The most commonly used falso-style names (e.g. `$randEmail`, `$randFullName`, `$randPassword`) still work as deprecated aliases, but will be removed in a future release. Function configuration options now use Faker's option shapes (e.g. `internetPassword: { length: 5 }` instead of `randPassword: { size: 5 }`). See the [plugin documentation](https://www.artillery.io/docs/reference/extensions/fake-data) for a migration table.
 
 ## Documentation
 

package/index.js

@@ -1,22 +1,94 @@
-const falso = require('@ngneat/falso');
+const { faker } = require('@faker-js/faker');
 
-const getFalsoFunctions = () =>
-  Object.keys(falso).filter((funcName) => {
-    //functions that have the function signature we expect start with rand and aren't == rand (which takes an array)
-    if (!funcName.startsWith('rand') && funcName !== 'rand') {
-      return false;
+// Modules that don't expose simple data-generation functions
+const SKIPPED_MODULES = new Set(['helpers', 'definitions', 'rawDefinitions']);
+
+// Deprecated falso-style aliases kept for backwards compatibility.
+// Maps legacy `$rand*` names to their faker equivalents (flattened names).
+// NOTE: configuration options are NOT translated - options must be provided
+// using the faker option shape, under the faker function name.
+const DEPRECATED_ALIASES = {
+  randEmail: 'internetEmail',
+  randFullName: 'personFullName',
+  randFirstName: 'personFirstName',
+  randLastName: 'personLastName',
+  randUserName: 'internetUsername',
+  randPassword: 'internetPassword',
+  randUuid: 'stringUuid',
+  randPhoneNumber: 'phoneNumber',
+  randCity: 'locationCity',
+  randCountry: 'locationCountry',
+  randStreetAddress: 'locationStreetAddress',
+  randZipCode: 'locationZipCode',
+  randCompanyName: 'companyName',
+  randNumber: 'numberInt',
+  randBoolean: 'datatypeBoolean',
+  randUrl: 'internetUrl',
+  randIp: 'internetIpv4',
+  randWord: 'loremWord',
+  randSentence: 'loremSentence',
+  randParagraph: 'loremParagraph',
+  randText: 'loremText',
+  randJobTitle: 'personJobTitle',
+  randColor: 'colorHuman',
+  randProductName: 'commerceProductName'
+};
+
+const flattenName = (moduleName, functionName) =>
+  `${moduleName}${functionName[0].toUpperCase()}${functionName.slice(1)}`;
+
+// Builds a map of flattened function names (e.g. `internetEmail`) to
+// zero/one-argument faker functions (e.g. `faker.internet.email`)
+const buildFakerFunctionMap = () => {
+  const functions = {};
+
+  for (const moduleName of Object.keys(faker)) {
+    if (SKIPPED_MODULES.has(moduleName) || moduleName.startsWith('_')) {
+      continue;
     }
 
-    //don't add functions that have more than 1 argument, as we only support 1 argument
-    //we can look into adding support for more arguments later, but most of the functions available use 1 argument anyway
-    if (falso[funcName].length > 1) {
-      return false;
+    const mod = faker[moduleName];
+    if (!mod || typeof mod !== 'object') {
+      continue;
     }
 
-    return true;
-  });
+    // Walk the prototype chain: some faker modules inherit methods
+    // (e.g. DateModule extends SimpleDateModule)
+    let proto = Object.getPrototypeOf(mod);
+    while (proto && proto !== Object.prototype) {
+      for (const functionName of Object.getOwnPropertyNames(proto)) {
+        if (functionName === 'constructor' || functionName.startsWith('_')) {
+          continue;
+        }
+
+        if (typeof mod[functionName] !== 'function') {
+          continue;
+        }
+
+        // Only functions taking at most one argument are supported, as
+        // configuration is passed as a single (object) argument
+        if (mod[functionName].length > 1) {
+          continue;
+        }
+
+        const flatName = flattenName(moduleName, functionName);
+        if (!functions[flatName]) {
+          functions[flatName] = mod[functionName].bind(mod);
+        }
+      }
 
-const falsoFunctions = getFalsoFunctions();
+      proto = Object.getPrototypeOf(proto);
+    }
+  }
+
+  return functions;
+};
+
+const fakerFunctionMap = buildFakerFunctionMap();
+
+const getFakerFunctions = () => Object.keys(fakerFunctionMap);
+
+const warnedAliases = new Set();
 
 function ArtilleryPluginFakeData(script, events) {
   this.script = script;
@@ -25,22 +97,35 @@ function ArtilleryPluginFakeData(script, events) {
   const pluginConfig =
     script.config['fake-data'] || script.config.plugins['fake-data'];
 
-  function falsoHandler(context, _ee, next) {
-    falsoFunctions.forEach((funcName) => {
+  function fakeDataHandler(context, _ee, next) {
+    for (const [funcName, fakerFunc] of Object.entries(fakerFunctionMap)) {
       context.funcs[`$${funcName}`] = () => {
         if (pluginConfig[funcName]) {
-          return falso[funcName](pluginConfig[funcName]);
+          return fakerFunc(pluginConfig[funcName]);
         }
-        return falso[funcName]();
+        return fakerFunc();
       };
-    });
+    }
+
+    for (const [aliasName, funcName] of Object.entries(DEPRECATED_ALIASES)) {
+      context.funcs[`$${aliasName}`] = () => {
+        if (!warnedAliases.has(aliasName)) {
+          warnedAliases.add(aliasName);
+          console.warn(
+            `[fake-data] $${aliasName} is deprecated and will be removed in a future release. Use $${funcName} instead.`
+          );
+        }
+
+        return context.funcs[`$${funcName}`]();
+      };
+    }
 
     next();
   }
 
   script.scenarios = script.scenarios.map((scenario) => {
     scenario.beforeScenario = [].concat(scenario.beforeScenario || []);
-    scenario.beforeScenario.push('falsoHandler');
+    scenario.beforeScenario.push('fakeDataHandler');
     return scenario;
   });
 
@@ -48,12 +133,13 @@ function ArtilleryPluginFakeData(script, events) {
     script.config.processor = {};
   }
 
-  script.config.processor.falsoHandler = falsoHandler;
+  script.config.processor.fakeDataHandler = fakeDataHandler;
 
   return this;
 }
 
 module.exports = {
   Plugin: ArtilleryPluginFakeData,
-  getFalsoFunctions
+  getFakerFunctions,
+  getDeprecatedAliases: () => ({ ...DEPRECATED_ALIASES })
 };

package/package.json

@@ -1,16 +1,24 @@
 {
   "name": "artillery-plugin-fake-data",
-  "version": "1.22.0",
+  "version": "1.23.0-67648ae",
   "description": "Add fake test data easily to your Artillery test scripts.",
   "main": "index.js",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 0"
+    "test": "tap ./test/*.spec.js --timeout 120"
+  },
+  "tap": {
+    "disable-coverage": true,
+    "allow-empty-coverage": true,
+    "color": true
   },
   "license": "MPL-2.0",
   "dependencies": {
-    "@ngneat/falso": "^8.0.2"
+    "@faker-js/faker": "10.4.0"
+  },
+  "devDependencies": {
+    "tap": "^19.0.2"
   }
 }