Search the docs, videos, blog, apps, teams, skills and release notes.
At a glance
What it is
Test data generation expertise covering Faker libraries across languages, factory patterns (Factory Boy, Fishery), seed data management, data anonymization techniques, synthetic data generation, constraint satisfaction, maintaining data relationships, database seeding strategies, and snapshot testing for data validation.
A skill is a written procedure a bot loads when a job calls for it. This one is a single file, SKILL.md, and the whole file is on this page.
The whole file, exactly as it downloads. Read it before you rely on it.
SKILL.md
383 lines · 1,386 words
Good tests require good data. Test data should be realistic enough to catch real bugs, minimal enough to keep tests fast and readable, and deterministic enough to make failures reproducible. The goal is to eliminate the "test data problem" -- the hours spent manually crafting data that exercises all code paths.
Test data generation expertise covering Faker libraries across languages, factory patterns (Factory Boy, Fishery), seed data management, data anonymization techniques, synthetic data generation, constraint satisfaction, maintaining data relationships, database seeding strategies, and snapshot testing for data validation.
Nothing. It ships with Murage, which is open source. Your bots run on the AI plan you already have.
Yes. Open it in Settings → Skills to read, edit or duplicate it. Skill Guard scans it again after every edit.
Download the app, connect the AI you already pay for, and tell your Chief of Staff what needs doing. Plan on about ten minutes from install to a working team.
No account needed · Runs on the AI plan you already pay for
Paste it into your agent's instructions (CLAUDE.md, AGENTS.md or a custom GPT), or add it to a bot in Murage.
Ask Ember for the bot, then switch the skill on in its settings.
Step 1
Send your Chief of Staff this message. It proposes the bot and its role first, and creates it when you say go.
Send this to Ember
“Create a bot that uses the Test Data Generator skill, and show me the plan first.”
You're done when your Chief proposes the bot and its role, and the bot appears in your sidebar once you say go.
Step 2
You're done when you see the bot’s skills and the library.
Step 3
You're done when the skill shows as on for that bot.
Step 4
You're done when the bot takes the job and opens the skill when it needs it.
Prefer to do it yourself? Choose + in the sidebar, then New Bot.Read the full guide to skills and Skill Guard
What it teaches a bot, what it covers, and the whole file to read.
What it covers
Core Philosophy
Faker Libraries
Factory Patterns
Seed Data Management
Data Anonymization
Constraint Satisfaction
Snapshot Testing
Best Practices
When to Use
Output Format
Example
Edge Cases
from faker import Faker
import random
fake = Faker()
Faker.seed(42) # Deterministic output for reproducibility
# Basic generators
name = fake.name() # "John Smith"
email = fake.email() # "john.smith@example.com"
address = fake.address() # "123 Main St\nPortland, OR 97201"
phone = fake.phone_number() # "(503) 555-0123"
text = fake.text(max_nb_chars=200) # Lorem ipsum paragraph
date = fake.date_between('-1y', 'today') # Random date in last year
uuid = fake.uuid4() # UUID4 string
url = fake.url() # "[reference URL]"
ip = fake.ipv4() # "192.168.1.100"
# Domain-specific generators
credit_card = fake.credit_card_number() # "4111111111111111"
company = fake.company() # "Smith & Associates"
job = fake.job() # "Software Engineer"
ssn = fake.ssn() # "123-45-6789"
# ... (condensed) ...
return self.random_element(self.categories)
def product_price(self, min_price=0.99, max_price=999.99):
return round(random.uniform(min_price, max_price), 2)
fake.add_provider(EcommerceProvider)
fake.product_name() # "Premium Widget"
fake.product_price() # 42.99import { faker } from '@faker-js/faker';
faker.seed(42); // Deterministic output
// Generate a complete user object
function generateUser(supersedes = {}) {
const firstName = faker.person.firstName();
const lastName = faker.person.lastName();
return {
id: faker.string.uuid(),
firstName,
lastName,
email: faker.internet.email({ firstName, lastName }),
avatar: faker.image.avatar(),
phone: faker.phone.number(),
address: {
street: faker.location.streetAddress(),
city: faker.location.city(),
state: faker.location.state({ abbreviated: true }),
zip: faker.location.zipCode(),
country: 'US',
# ... (condensed) ...
// Bulk generation
const users = Array.from({ length: 100 }, () => generateUser());
const orders = users.flatMap(user =>
Array.from(
{ length: faker.number.int({ min: 0, max: 10 }) },
() => generateOrder(user.id)
)
);import factory
from factory import fuzzy
from datetime import datetime, timezone, timedelta
from myapp.models import User, Order, OrderItem, Product
class UserFactory(factory.Factory):
class Meta:
model = User
id = factory.Sequence(lambda n: n + 1)
name = factory.Faker('name')
email = factory.LazyAttribute(
lambda o: f"{o.name.lower().replace(' ', '.')}@test.com"
)
tier = factory.Iterator(['free', 'basic', 'premium'])
is_active = True
created_at = factory.LazyFunction(lambda: datetime.now(timezone.utc))
class Params:
# Traits for common variations
inactive = factory.Trait(
is_active=False,
# ... (condensed) ...
order = OrderFactory(user=user, total=200.00)
discount = calculate_discount(order)
assert discount == 30.00 # 15% for premium
def test_inactive_user_cannot_order():
user = UserFactory(inactive=True)
with pytest.raises(InactiveUserError):
create_order(user, items=[ProductFactory()])import { Factory } from 'fishery';
import { faker } from '@faker-js/faker';
// Define factories
const userFactory = Factory.define<User>(({ sequence, params, transientParams }) => ({
id: sequence,
name: faker.person.fullName(),
email: params.email || faker.internet.email(),
role: params.role || 'user',
isActive: true,
createdAt: faker.date.past(),
}));
const productFactory = Factory.define<Product>(({ sequence }) => ({
id: `prod_${sequence}`,
name: faker.commerce.productName(),
price: parseFloat(faker.commerce.price({ min: 5, max: 500 })),
category: faker.helpers.arrayElement(['electronics', 'clothing', 'home']),
stock: faker.number.int({ min: 0, max: 1000 }),
}));
const orderFactory = Factory.define<Order>(({ sequence, associations }) => {
# ... (condensed) ...
// Usage
const user = userFactory.build({ role: 'admin' });
const premiumUser = userFactory.build({ role: 'premium' });
const products = productFactory.buildList(5);
const order = orderFactory.build({}, {
associations: { user: premiumUser }
});# seeds/seed_database.py
import json
from pathlib import Path
class DatabaseSeeder:
def __init__(self, db_session):
self.db = db_session
def seed_all(self):
"""Seed all reference and test data in dependency order."""
self.seed_categories()
self.seed_products()
self.seed_users()
self.seed_orders()
self.db.commit()
def seed_categories(self):
categories = [
Category(id=1, name="Electronics", slug="electronics"),
Category(id=2, name="Clothing", slug="clothing"),
Category(id=3, name="Home & Garden", slug="home-garden"),
Category(id=4, name="Books", slug="books"),
# ... (condensed) ...
order = OrderFactory(
user=user,
items=[
OrderItemFactory(product=random.choice(products))
for _ in range(random.randint(1, 3))
]
)
self.db.add(order)class DataAnonymizer:
"""Anonymize production data for use in testing/staging."""
def __init__(self):
self.fake = Faker()
Faker.seed(0)
self._email_map = {} # Consistent mapping for referential integrity
def anonymize_user(self, user: dict) -> dict:
# Deterministic anonymization based on original value
original_email = user['email']
if original_email not in self._email_map:
self._email_map[original_email] = self.fake.email()
return {
**user,
'name': self.fake.name(),
'email': self._email_map[original_email],
'phone': self.fake.phone_number(),
'ssn': None, # Remove sensitive fields entirely
'address': {
'street': self.fake.street_address(),
# ... (condensed) ...
shift_days = hash(date_str) % 365
return (dt + timedelta(days=shift_days)).isoformat()
# Usage
anonymizer = DataAnonymizer()
production_users = load_production_export('users.json')
anonymized = [anonymizer.anonymize_user(u) for u in production_users]
save_to_file('seeds/anonymized_users.json', anonymized)class ConstrainedDataGenerator:
"""Generate data that satisfies business rules and foreign key constraints."""
def generate_valid_order(self) -> Order:
"""Order must have: valid user, in-stock products, correct totals."""
user = UserFactory(is_active=True)
# Products must have sufficient stock
products = [
ProductFactory(stock=fuzzy.FuzzyInteger(10, 100).fuzz())
for _ in range(random.randint(1, 4))
]
items = []
for product in products:
quantity = random.randint(1, min(5, product.stock))
items.append(OrderItem(
product_id=product.id,
quantity=quantity,
unit_price=product.price
))
# ... (condensed) ...
for _ in range(random.randint(5, 50)):
cursor += timedelta(hours=random.randint(1, 72))
if cursor > now:
break
event_type = random.choice(['login', 'view_product', 'add_to_cart', 'purchase'])
events.append(Event(user_id=user_id, type=event_type, timestamp=cursor))
return events# pytest with snapshot testing (syrupy)
def test_user_serialization(snapshot):
user = UserFactory(
name="Alice Smith",
email="alice@example.com",
tier="premium",
created_at=datetime(2025, 1, 15, 10, 30, 0, tzinfo=timezone.utc)
)
result = UserSerializer().serialize(user)
assert result == snapshot
# First run: creates snapshot file
# Subsequent runs: compares against snapshot
# Update snapshots: pytest --snapshot-update// Jest snapshot testing
test('user API response matches snapshot', () => {
const user = userFactory.build({
name: 'Alice Smith',
email: 'alice@example.com',
});
const serialized = serializeUser(user);
expect(serialized).toMatchSnapshot();
});
// Inline snapshot
test('error message format', () => {
const error = validateEmail('not-an-email');
expect(error).toMatchInlineSnapshot(`"Invalid email format: not-an-email"`);
});Always seed Faker for reproducibility: Same seed produces same data across runs
Use factories over raw constructors: Factories express intent and handle defaults
Generate minimal data: Only create what the test needs
Use traits for variations: UserFactory(premium=True) over manual field setting
Keep seed data in version control: JSON/YAML files alongside code
Anonymize production data carefully: Preserve relationships and data distributions
Validate generated data: Run business rule validation on generated datasets
Document test accounts: Known credentials for E2E testing in a secure location
Use this skill when:
Designing or implementing test data generator solutions
Reviewing or improving existing test data generator approaches
Making architectural or implementation decisions about test data generator
Learning test data generator patterns and best practices
Troubleshooting test data generator-related issues
Do NOT use this skill when:
The question is about a fundamentally different technology domain
A more specific sibling skill covers the exact topic needed
The user needs a complete hands-on tutorial rather than expert guidance
# Test Data Generator Analysis
## Context Assessment
[Situation summary and constraints]
## Recommended Approach
[Primary recommendation with rationale]
## Implementation Steps
1. [Step with specific details]
2. [Step with specific details]
3. [Step with specific details]
## Trade-offs and Considerations
- [Key trade-off 1]
- [Key trade-off 2]
## Next Steps
- [Immediate action item]
- [Follow-up action item]Input: "Help me implement test data generator for a medium-scale production application"
Output: A structured analysis covering current state assessment, recommended test data generator approach with specific patterns, implementation roadmap with milestones, and risk mitigation strategies tailored to the application scale and constraints.
Legacy system integration: When test data generator must coexist with legacy approaches, provide a gradual migration path rather than a complete rewrite
Scale mismatch: When the solution complexity exceeds the project scale, recommend a simpler approach and note when to revisit
Team skill gaps: When the team lacks experience with the recommended approach, include learning resources and simpler alternatives
Conflicting requirements: When constraints conflict (e.g., performance vs. maintainability), explicitly state the trade-off and recommend based on stated priorities
SKILL.md
383 lines · 1,386 words
The text of SKILL.md is shown as it downloads, under the Apache-2.0 license, by Ferrox Labs. The license is the one in the file's own frontmatter.
Your new bot
Test Data Generator bot
Waiting in your sidebar once you say go.
No account needed · Runs on the AI plan you already pay for