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-datafaker-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:
| Language | Library | Reference |
|---|---|---|
| Python | faker | faker-py (opens in new window) |
| JS / TS | @faker-js/faker | faker-js (opens in new window) |
| Ruby | faker-ruby/faker | faker-rb (opens in new window) |
For .NET (Bogus) and Python-specifically with stronger locale coverage (mimesis), see synthetic-data-toolkit.
When to use
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:
| Language | Factory library | Skill |
|---|---|---|
| Python | factory_boy | (consider mimesis - synthetic-data-toolkit - for locale-rich generation) |
| JS / TS | fishery / factory.ts | hand-rolled with Faker as engine |
| Ruby | FactoryBot | synthetic-data-toolkit references/factory-bot.md |
| .NET | Bogus | synthetic-data-toolkit references/bogus.md |
Faker alone won't enforce that order.user_id == user.id; the factory library handles that.
Anti-patterns
| Anti-pattern | Why it fails | Fix |
|---|---|---|
| Calling Faker without a seed in tests | A 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 snapshots | Snapshot 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 locale | A 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 payloads | Faker generates "realistic" data, not malicious. SQL injection / XSS won't happen by chance. | Use malicious-payload-bank for adversarial input. |
Limitations
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.