artillery-plugin-fake-data 1.23.0 → 1.24.0-a33c503

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.ts

@@ -0,0 +1,156 @@
+import { faker } from '@faker-js/faker';
+
+// 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;
+    }
+
+    const mod = faker[moduleName];
+    if (!mod || typeof mod !== 'object') {
+      continue;
+    }
+
+    // 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);
+        }
+      }
+
+      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;
+  this.events = events;
+
+  const pluginConfig =
+    script.config['fake-data'] || script.config.plugins['fake-data'];
+
+  function fakeDataHandler(context, _ee, next) {
+    for (const [funcName, fakerFunc] of Object.entries(
+      fakerFunctionMap
+    ) as [string, any][]) {
+      context.funcs[`$${funcName}`] = () => {
+        if (pluginConfig[funcName]) {
+          return fakerFunc(pluginConfig[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('fakeDataHandler');
+    return scenario;
+  });
+
+  if (!script.config.processor) {
+    script.config.processor = {};
+  }
+  // In the main thread config.processor may still be an unresolved
+  // path (a string). Attaching functions to it was a silent no-op
+  // under sloppy mode; ES modules are strict, so guard explicitly.
+  // Workers load the processor into an object before plugins run.
+  const canAttach = typeof script.config.processor === 'object';
+
+  if (canAttach) {
+    script.config.processor.fakeDataHandler = fakeDataHandler;
+  }
+
+  return this;
+}
+
+const getDeprecatedAliases = () => ({ ...DEPRECATED_ALIASES });
+
+export {
+  ArtilleryPluginFakeData as Plugin,
+  getFakerFunctions,
+  getDeprecatedAliases
+};

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "artillery-plugin-fake-data",
-  "version": "1.23.0",
+  "version": "1.24.0-a33c503",
   "description": "Add fake test data easily to your Artillery test scripts.",
-  "main": "index.js",
+  "main": "index.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 0"
+    "test": "node --test --test-timeout=120000 \"test/*.spec.js\""
   },
   "license": "MPL-2.0",
   "dependencies": {
-    "@ngneat/falso": "^8.0.2"
-  }
+    "@faker-js/faker": "10.4.0"
+  },
+  "devDependencies": {},
+  "type": "module"
 }

package/index.js

@@ -1,59 +0,0 @@
-const falso = require('@ngneat/falso');
-
-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;
-    }
-
-    //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;
-    }
-
-    return true;
-  });
-
-const falsoFunctions = getFalsoFunctions();
-
-function ArtilleryPluginFakeData(script, events) {
-  this.script = script;
-  this.events = events;
-
-  const pluginConfig =
-    script.config['fake-data'] || script.config.plugins['fake-data'];
-
-  function falsoHandler(context, _ee, next) {
-    falsoFunctions.forEach((funcName) => {
-      context.funcs[`$${funcName}`] = () => {
-        if (pluginConfig[funcName]) {
-          return falso[funcName](pluginConfig[funcName]);
-        }
-        return falso[funcName]();
-      };
-    });
-
-    next();
-  }
-
-  script.scenarios = script.scenarios.map((scenario) => {
-    scenario.beforeScenario = [].concat(scenario.beforeScenario || []);
-    scenario.beforeScenario.push('falsoHandler');
-    return scenario;
-  });
-
-  if (!script.config.processor) {
-    script.config.processor = {};
-  }
-
-  script.config.processor.falsoHandler = falsoHandler;
-
-  return this;
-}
-
-module.exports = {
-  Plugin: ArtilleryPluginFakeData,
-  getFalsoFunctions
-};