Testland
Browse all skills & agents

faker-data

Fixes test data that breaks tests - factory values in a shape the code under test rejects (a phone number that is not E.164), fixtures that only pass when the whole suite runs in order, and random values that make an assertion pass or fail depending on the run. Authors test-data factories with Faker: the Python `faker` library, the `@faker-js/faker` JS port, and the `faker-ruby` gem - install per language, the provider catalogue (person / internet / location / date / finance / lorem), locale selection and multi-locale mode, and seed-based determinism for reproducible runs. Scope is generating fresh values for tests that start from nothing, not replacing values inside a dataset that already holds real records - that goes to pii-masking-pipeline-builder. Use when fixtures need realistic values, a stable shape, or a fixed seed.

Install with skills.sh (any agent)

npx skills add testland/qa --skill faker-data
View source

faker-data

Overview

Faker is a family of libraries (Python / JS / Ruby / Java / .NET / PHP) that generate realistic synthetic field values - names, emails, addresses, dates, etc. - for test fixtures. The three most common ports in this skill's scope:

LanguageLibraryReference
Pythonfakerfaker-py (opens in new window)
JS / TS@faker-js/fakerfaker-js (opens in new window)
Rubyfaker-ruby/fakerfaker-rb (opens in new window)

For .NET (Bogus) and Python-specifically with stronger locale coverage (mimesis), see synthetic-data-toolkit.

When to use

  • A test fixture needs realistic but synthetic field values (the default 'foo' / 'bar' pattern produces tests that miss real bugs around long names, Unicode, edge-case formats).
  • The team wants reproducible randomness - same seed produces same data, useful for regression repro.
  • Locale coverage matters (i18n testing across de_DE, ja_JP, ar_SA, etc.).
  • A factory library (FactoryBot, factory_boy, Bogus) needs the underlying generator - Faker is typically the random-data engine plugged into those.

Install

Python

pip install Faker

(Per faker-py (opens in new window).)

JavaScript / TypeScript

npm install --save-dev @faker-js/faker

(Per faker-js (opens in new window).)

Ruby

# Gemfile
gem 'faker', group: :test

(Per faker-rb (opens in new window).)

Authoring

Python

from faker import Faker

fake = Faker()
fake.name()              # 'Margaret Boehm'
fake.email()             # 'walker.travis@example.com'
fake.address()           # '123 Main St, Apt 4B\nSpringfield, IL 62701'
fake.phone_number()      # '+1-555-867-5309'
fake.date_of_birth(minimum_age=18, maximum_age=65)
fake.text(max_nb_chars=200)

(Per faker-py (opens in new window).)

Common provider modules: person (name, prefix), address, internet (email, url, ipv4), phone_number, date_time, lorem (paragraphs, sentences, words), company, credit_card, job (faker-py (opens in new window)).

JavaScript

import { faker } from '@faker-js/faker';

faker.person.fullName();           // 'Margaret Boehm'
faker.internet.email();             // 'walker.travis@example.com'
faker.location.streetAddress();     // '123 Main St'
faker.phone.number();               // '+1-555-867-5309'
faker.date.past({ years: 30 });
faker.lorem.paragraphs(2);

(Per faker-js (opens in new window).)

Module organization mirrors the Python ports but uses the module- namespace form: faker.person.*, faker.internet.*, faker.location.*, faker.date.*, faker.finance.*, faker.commerce.* (faker-js (opens in new window)).

Ruby

require 'faker'

Faker::Name.name           # 'Margaret Boehm'
Faker::Internet.email      # 'walker.travis@example.com'
Faker::Address.full_address
Faker::PhoneNumber.cell_phone
Faker::Date.birthday(min_age: 18, max_age: 65)
Faker::Lorem.paragraphs(number: 2)

(Per faker-rb (opens in new window).)

Seeding for deterministic output

The most common test-stability mistake is letting Faker generate non-deterministic values across runs. Always seed in tests so a failure can be reproduced.

Python

from faker import Faker

# Class-level - sets the default RNG for all subsequent Faker() calls
Faker.seed(4321)
fake = Faker()

# Instance-level - useful when multiple Faker instances need different seeds
fake.seed_instance(4321)

(Per faker-py (opens in new window).)

JavaScript

import { faker } from '@faker-js/faker';

faker.seed(123);
// All faker.* calls until the next seed() are deterministic.

(Per faker-js (opens in new window).)

Ruby

require 'faker'

Faker::Config.random = Random.new(42)

For test frameworks: place the seed in beforeEach / setup so each test starts with the same baseline; for paired runs, persist the seed used per failing test (similar to the flake-pattern-reference Pattern 8 randomness guidance).

Locale support

Python

fake = Faker('it_IT')                # Italian
fake = Faker(['en_US', 'fr_FR', 'ja_JP'])   # Multi-locale (random per call)
fake.name()                          # generates per the configured locale(s)

(Per faker-py (opens in new window).)

JavaScript

import { fakerDE } from '@faker-js/faker';
import { fakerJA } from '@faker-js/faker';

fakerDE.person.fullName();   // German name
fakerJA.address.city();       // Japanese city

(Per faker-js (opens in new window); 70+ locales available.)

Ruby

Faker::Config.locale = :ja
Faker::Name.name   # Japanese name

(Per faker-rb (opens in new window).)

Composing factories with referential integrity

Faker generates field values; for referential integrity (a factory that creates a User with a related Order), use a factory library that wraps Faker:

LanguageFactory librarySkill
Pythonfactory_boy(consider mimesis - synthetic-data-toolkit - for locale-rich generation)
JS / TSfishery / factory.tshand-rolled with Faker as engine
RubyFactoryBotsynthetic-data-toolkit references/factory-bot.md
.NETBogussynthetic-data-toolkit references/bogus.md

Faker alone won't enforce that order.user_id == user.id; the factory library handles that.

Anti-patterns

Anti-patternWhy it failsFix
Calling Faker without a seed in testsA failure on CI doesn't reproduce locally; flake-investigation guesswork.Seed once per test or per suite (Faker.seed(...)).
Using fake.email() with a real domain (example.com is shared)Spam concerns; some validators reject example.com.Faker's defaults use safe RFC-2606 domains; never override to a real domain in tests.
Hardcoding generated values into snapshotsSnapshot bound to a Faker version's PRNG sequence; library bump breaks the snapshot.Snapshot the shape of the data; assert types and patterns rather than literal values.
Generating names with the wrong localeA test asserting "name has at least one space" fails on :ja (Japanese) where names use .Match the locale to the assertion; or relax the assertion to be locale-aware.
Using Faker for security testing payloadsFaker generates "realistic" data, not malicious. SQL injection / XSS won't happen by chance.Use malicious-payload-bank for adversarial input.

Limitations

  • PRNG sequence varies across major versions. A seed produces different values in Faker v18 vs v19. Pin the version in CI for deterministic tests.
  • Locale coverage is uneven. en_US is the most complete; less- common locales fall back to defaults silently. Test the locales you care about; don't assume completeness.
  • Realistic ≠ valid. Faker may generate an email with a technically-valid but unusual format (e.g. +-tagged); your validation may reject it. Match Faker's domain provider to your validator's regex.

References

Related skills

boundary-value-generator

Generates boundary-value test cases from typed input specifications - for each input field, produces the canonical 6-point set (one below, at, and above the lower bound; one below, at, and above the upper bound) plus equivalence-class representatives. Emits cases as parameterized test inputs (pytest @parametrize / Jest test.each / xUnit InlineData / etc.). Use when a function or endpoint has numeric / string-length / collection-size constraints and the team needs systematic edge-case coverage.

golden-file-conventions

Reference catalog for snapshot / golden file management - naming conventions, directory layout, when to add / update / remove a baseline, sanitization (timestamps, IDs, PII), per-OS / per-runtime variant strategy, and review workflow for snapshot diffs in PRs. Use when designing a snapshot-testing convention or auditing an existing one for drift.

malicious-payload-bank

Reference catalog of curated adversarial input payloads keyed by attack class - SQL injection, XSS, SSRF, path traversal, command injection, XXE, prototype pollution, regex DoS, Unicode confusables, header injection - plus per-context guidance for which payloads apply (URL parameter / form input / JSON body / file upload). Use when authoring negative-test cases for input validation, fuzz targets, or a security-focused test suite that needs to exercise the OWASP Top 10 attack surface.

msw-handlers

Authors Mock Service Worker (MSW) request handlers for both browser and Node.js test environments using the `http.get` / `http.post` / `HttpResponse.json` API, wires them via `setupWorker` (browser) or `setupServer` (Node), and manages the test lifecycle (`server.listen` / `resetHandlers` / `close`). Use when the project uses JavaScript / TypeScript and needs to mock fetch / XHR at the network layer for both Vitest / Jest unit tests and Cypress / Playwright integration tests.

negative-test-generator

Covers the refusal paths a handler already implements but nothing tests - a batch endpoint that must apply all rows or none, optimistic-concurrency version conflicts between two editors, or a delete that deliberately separates who you are from what you may do from the state the record is in. For each happy-path test, produces companions exercising input validation rejection, missing required fields, type mismatches, authorization failures, rate-limit errors, and adversarial payloads from the malicious-payload-bank, emitted as parameterized tests in the project's runner format. Use when code has deliberate error paths and the suite only proves the success case.

pairwise-test-case-generator

Generates parameterized test inputs combining boundary-value, equivalence-class, and pairwise-combinatorial cases from a typed multi-input specification - produces the cross-product of cases up to a configurable strength (1-wise / 2-wise / N-wise) using all-pairs reduction so the test surface stays tractable. Emits cases in the project's test-runner-native parametrize format. Use when a function or endpoint takes 3+ inputs whose interactions matter and full Cartesian product would explode.

seed-data-curator

Builds a reproducible E2E seed dataset for the project's test environments - picks a representative user / org / data-product cross-section, generates the rows via the project's chosen factory library (FactoryBot / mimesis / Bogus / Faker + factory_boy), persists the dataset as a checked-in fixture (SQL dump / JSON / per-engine seed file), and wires it into the test bootstrap. Use when starting E2E coverage on a project that has no seed strategy, or when an existing seed has drifted.

synthetic-data-toolkit

Umbrella for the synthetic test data generators beyond plain Faker - FactoryBot (Ruby factories with traits, associations, and build / create / build_stubbed strategies), Mimesis (fast type-hinted Python generator with the Schema/Field bulk pattern and 46 locales), and Bogus (.NET typed `Faker<T>` builders with `.RuleFor` / `StrictMode` / `UseSeed`). Picks the right generator by language and job, shows side-by-side equivalents of the same fixture across all four ecosystems, and carries each tool's full workflow in references/ (factory-bot.md, mimesis.md, bogus.md). faker-data stays the default for plain field values in Python / JS / Ruby; use this skill when the project needs typed factory orchestration, .NET fixtures, or a documented "which tool should I use" decision.

synthetic-pii-generator

Generates realistic-but-fake personally identifiable information (PII) - emails, phone numbers, SSNs / national IDs, addresses, names, credit-card numbers (test BIN ranges), date-of-birth - for non-production environments. Wraps Faker / mimesis with PII-aware constraints so generated values match real format expectations (Luhn-valid card numbers, region-valid phone formats, ITIN/SSN format) without ever generating real-person data. Use when seeding test environments, building demo data, or replacing real PII in copied datasets.

test-data-patterns

Pure reference catalog of the cross-language object-construction patterns for test data - Test Data Builder (Pryce/Freeman), Factory (with traits and associations), Object Mother, Fixture composition (per-test / per-describe / shared), Snapshot (defers to `golden-file-conventions` for the operational details), and Production-Data Anonymisation. Distinct from the per-language tool skills (`faker-data` and the `synthetic-data-toolkit` umbrella covering FactoryBot / mimesis / Bogus) which document tool-specific configuration; this catalog is the architecture-tier reference for choosing **which pattern** before reaching for the tool. Use when choosing a test-data construction pattern for a new suite, or auditing an existing suite whose fixtures have drifted into shared mutable state.

wiremock-stubs

Authors WireMock stub mappings for HTTP service mocking - `stubFor` with verb/path/header matchers + `willReturn` response shaping, lifecycle via `WireMockServer` (start / stop) or JUnit `WireMockExtension`, request verification via `verify()`, and dynamic-port allocation for parallel tests. Also carries the Mountebank multi-protocol workflow (TCP / SMTP / LDAP / gRPC imposters, record-playback proxying) in references/mountebank.md. Use when the project is JVM-based and tests need to mock HTTP dependencies (third-party APIs, internal microservices) at the network layer, or when mocking must go beyond HTTP.