@intentsolutionsio/test-data-generator 1.0.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,19 @@
+{
+  "name": "test-data-generator",
+  "version": "1.0.0",
+  "description": "Generate realistic test data including users, products, orders, and custom schemas for comprehensive testing",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "repository": "https://github.com/jeremylongshore/claude-code-plugins",
+  "license": "MIT",
+  "keywords": [
+    "testing",
+    "test-data",
+    "fake-data",
+    "fixtures",
+    "factory",
+    "agent-skills"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Claude Code Plugins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# Test Data Generator Plugin
+
+Generate realistic test data including users, products, orders, and custom schemas for comprehensive testing.
+
+## Features
+
+- **Realistic data** - Names, emails, addresses, phone numbers
+- **Business data** - Products, orders, invoices, transactions
+- **Technical data** - UUIDs, IPs, URLs, tokens
+- **Custom schemas** - JSON Schema, TypeScript, GraphQL
+- **Bulk generation** - Create thousands of records
+- **Locale support** - Data for different regions
+- **Deterministic** - Reproducible with seeds
+
+## Installation
+
+```bash
+/plugin install test-data-generator@claude-code-plugins-plus
+```
+
+## Usage
+
+```
+Generate 100 test users with addresses
+Create e-commerce test data (products, orders, customers)
+Generate API test data matching our OpenAPI schema
+```
+
+## Data Types
+
+- **Users** - Names, emails, passwords, addresses, profiles
+- **Products** - Names, descriptions, prices, categories
+- **Orders** - Items, totals, status, shipping
+- **Companies** - Names, addresses, domains, employees
+- **Custom** - Your schema, your data
+
+## License
+
+MIT

package/agents/data-generator.md

@@ -0,0 +1,163 @@
+---
+name: data-generator
+description: Generate realistic test data for comprehensive testing
+---
+# Test Data Generator Agent
+
+Generate realistic test data including users, products, orders, and custom schemas for comprehensive testing.
+
+## Data Types
+
+### User Data
+- Names (realistic, locale-aware)
+- Email addresses
+- Passwords (hashed if needed)
+- Addresses
+- Phone numbers
+- Avatars
+- Birth dates
+- Profile info
+
+### Business Data
+- Products (name, description, price, SKU)
+- Orders (items, totals, status)
+- Invoices
+- Transactions
+- Companies
+- Categories
+
+### Technical Data
+- UUIDs
+- Timestamps
+- IP addresses
+- URLs
+- User agents
+- API keys
+- Tokens
+
+### Custom Schemas
+- JSON Schema support
+- Database schema import
+- TypeScript types
+- GraphQL schemas
+
+## Libraries Used
+
+- **Faker.js / @faker-js/faker** - Comprehensive fake data
+- **Chance.js** - Random generator helper
+- **json-schema-faker** - Generate from JSON Schema
+- **Factory Bot** - Ruby factory patterns
+- **Factory Boy** - Python factory patterns
+
+## Example: User Factory
+
+```javascript
+import { faker } from '@faker-js/faker';
+
+function createUser(overrides = {}) {
+  return {
+    id: faker.string.uuid(),
+    email: faker.internet.email(),
+    name: faker.person.fullName(),
+    age: faker.number.int({ min: 18, max: 80 }),
+    address: {
+      street: faker.location.streetAddress(),
+      city: faker.location.city(),
+      country: faker.location.country(),
+      zipCode: faker.location.zipCode()
+    },
+    createdAt: faker.date.past(),
+    ...overrides
+  };
+}
+
+// Generate single user
+const user = createUser({ age: 25 });
+
+// Generate multiple users
+const users = Array.from({ length: 100 }, () => createUser());
+```
+
+## Example: E-commerce Data
+
+```javascript
+function createProduct() {
+  return {
+    id: faker.string.uuid(),
+    name: faker.commerce.productName(),
+    description: faker.commerce.productDescription(),
+    price: parseFloat(faker.commerce.price()),
+    category: faker.commerce.department(),
+    inStock: faker.datatype.boolean(),
+    sku: faker.string.alphanumeric(8).toUpperCase(),
+    images: Array.from({ length: 3 }, () => faker.image.url())
+  };
+}
+
+function createOrder(userId) {
+  const items = Array.from(
+    { length: faker.number.int({ min: 1, max: 5 }) },
+    () => ({
+      productId: faker.string.uuid(),
+      quantity: faker.number.int({ min: 1, max: 3 }),
+      price: parseFloat(faker.commerce.price())
+    })
+  );
+
+  const subtotal = items.reduce((sum, item) => 
+    sum + (item.price * item.quantity), 0
+  );
+
+  return {
+    id: faker.string.uuid(),
+    userId,
+    items,
+    subtotal,
+    tax: subtotal * 0.08,
+    total: subtotal * 1.08,
+    status: faker.helpers.arrayElement([
+      'pending', 'processing', 'shipped', 'delivered'
+    ]),
+    createdAt: faker.date.recent()
+  };
+}
+```
+
+## Database Seeding
+
+```javascript
+// Seed script
+async function seedDatabase() {
+  // Generate users
+  const users = Array.from({ length: 100 }, () => createUser());
+  await db.users.insertMany(users);
+
+  // Generate products
+  const products = Array.from({ length: 500 }, () => createProduct());
+  await db.products.insertMany(products);
+
+  // Generate orders (2-5 per user)
+  const orders = users.flatMap(user =>
+    Array.from(
+      { length: faker.number.int({ min: 2, max: 5 }) },
+      () => createOrder(user.id)
+    )
+  );
+  await db.orders.insertMany(orders);
+
+  console.log(`Seeded:
+    - ${users.length} users
+    - ${products.length} products
+    - ${orders.length} orders
+  `);
+}
+```
+
+## Best Practices
+
+- Use seed for development consistency
+- Generate fresh data for each test
+- Use realistic data patterns
+- Locale-aware generation
+- Deterministic with seeds for reproducibility
+- Clean up after tests

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@intentsolutionsio/test-data-generator",
+  "version": "1.0.0",
+  "description": "Generate realistic test data including users, products, orders, and custom schemas for comprehensive testing",
+  "keywords": [
+    "testing",
+    "test-data",
+    "fake-data",
+    "fixtures",
+    "factory",
+    "agent-skills",
+    "claude-code",
+    "claude-plugin",
+    "tonsofskills"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jeremylongshore/claude-code-plugins-plus-skills.git",
+    "directory": "plugins/testing/test-data-generator"
+  },
+  "homepage": "https://tonsofskills.com/plugins/test-data-generator",
+  "bugs": "https://github.com/jeremylongshore/claude-code-plugins-plus-skills/issues",
+  "license": "MIT",
+  "author": {
+    "name": "Claude Code Plugins",
+    "email": "[email protected]"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    ".claude-plugin",
+    "skills",
+    "agents"
+  ],
+  "scripts": {
+    "postinstall": "node -e \"console.log(\\\"\\\\n→ This npm package is a tracking/proof artifact. Install the plugin via:\\\\n  ccpi install test-data-generator\\\\n  or /plugin install test-data-generator@claude-code-plugins-plus in Claude Code\\\\n\\\")\""
+  }
+}

package/skills/generating-test-data/SKILL.md

@@ -0,0 +1,143 @@
+---
+name: generating-test-data
+description: |
+  Generate realistic test data including edge cases and boundary conditions.
+  Use when creating realistic fixtures or edge case test data.
+  Trigger with phrases like "generate test data", "create fixtures", or "setup test database".
+
+allowed-tools: Read, Write, Edit, Grep, Glob, Bash(test:data-*)
+version: 1.0.0
+author: Jeremy Longshore <jeremy@intentsolutions.io>
+license: MIT
+compatible-with: claude-code, codex, openclaw
+tags: [testing, database, test-data]
+---
+# Test Data Generator
+
+## Overview
+
+Generate realistic, type-safe test data including fixtures, factory functions, seed datasets, and edge case values. Supports Faker.js, Factory Bot patterns, Fishery (TypeScript factories), pytest fixtures, and database seed scripts.
+
+## Prerequisites
+
+- Data generation library installed (Faker.js/@faker-js/faker, Fishery, factory-boy for Python, or JavaFaker)
+- Database schema or TypeScript/Python type definitions for the data models
+- Test framework with fixture support (Jest, pytest, JUnit)
+- Seed management for reproducible random data (`faker.seed()`)
+- Database client for seed data insertion (if generating database fixtures)
+
+## Instructions
+
+1. Read the project's data models, TypeScript interfaces, database schemas, or ORM definitions to understand the shape of all entities.
+2. For each entity, create a factory function that produces a valid default instance:
+   - Use Faker methods matched to field semantics (e.g., `faker.person.fullName()` for names, `faker.internet.email()` for emails).
+   - Provide sensible defaults for required fields.
+   - Allow overrides via a partial parameter for test-specific customization.
+   - Set a deterministic seed for reproducibility (`faker.seed(12345)`).
+3. Generate edge case data variants for each entity:
+   - **Empty values**: Empty strings, null, undefined, empty arrays.
+   - **Boundary values**: Maximum string length, integer overflow, zero, negative numbers.
+   - **Unicode and i18n**: Names with accents, CJK characters, RTL text, emoji.
+   - **Adversarial inputs**: SQL injection strings, XSS payloads, excessively long strings.
+   - **Temporal edge cases**: Leap years, timezone boundaries, epoch zero, far-future dates.
+4. Create relationship factories that build connected entity graphs:
+   - A user factory that also creates associated addresses and orders.
+   - Configurable depth to avoid infinite recursion.
+   - Lazy evaluation for optional relationships.
+5. Generate database seed files for integration tests:
+   - SQL insert scripts or ORM seed functions.
+   - Idempotent operations (use `ON CONFLICT` or `INSERT IF NOT EXISTS`).
+   - Separate seed sets for different test scenarios (empty state, populated state, edge cases).
+6. Write fixture files in JSON, YAML, or TypeScript for static test data:
+   - Group fixtures by test scenario.
+   - Include both valid and invalid data sets.
+7. Validate generated data against the schema to ensure factories remain in sync with model changes.
+
+## Output
+
+- Factory function files (one per entity) in `test/factories/` or `tests/factories/`
+- Edge case data collections covering boundaries and adversarial inputs
+- Database seed scripts for integration test environments
+- JSON/YAML fixture files for static test data
+- Factory index file exporting all factories for easy test imports
+
+## Error Handling
+
+| Error | Cause | Solution |
+|-------|-------|---------|
+| Factory produces invalid data | Schema changed but factory not updated | Add a validation step that runs the factory output through the schema validator |
+| Duplicate unique values | Faker generates collisions in small datasets | Use sequential IDs or append a counter; increase Faker's unique retry limit |
+| Database seed fails on foreign key | Seed insertion order violates referential integrity | Sort seed operations topologically by dependency; disable FK checks during seeding |
+| Factory recursion overflow | Circular relationships (User -> Order -> User) | Limit relationship depth; use lazy references; break cycles with ID-only references |
+| Non-deterministic test failures | Random seed not set consistently | Call `faker.seed()` in `beforeAll` or at factory module level; document seed values |
+
+## Examples
+
+**TypeScript factory with Fishery:**
+```typescript
+import { Factory } from 'fishery';
+import { faker } from '@faker-js/faker';
+
+interface User {
+  id: string;
+  name: string;
+  email: string;
+  role: 'admin' | 'user';
+  createdAt: Date;
+}
+
+export const userFactory = Factory.define<User>(({ sequence }) => ({
+  id: `user-${sequence}`,
+  name: faker.person.fullName(),
+  email: faker.internet.email(),
+  role: 'user',
+  createdAt: faker.date.past(),
+}));
+
+// Usage:
+const user = userFactory.build();
+const admin = userFactory.build({ role: 'admin' });
+const users = userFactory.buildList(10);
+```
+
+**pytest fixture factory:**
+```python
+import pytest
+from faker import Faker
+
+fake = Faker()
+Faker.seed(42)
+
+@pytest.fixture
+def make_user():
+    def _make_user(**overrides):
+        defaults = {
+            "name": fake.name(),
+            "email": fake.email(),
+            "age": fake.random_int(min=18, max=99),
+        }
+        return {**defaults, **overrides}
+    return _make_user
+
+def test_user_validation(make_user):
+    user = make_user(age=17)
+    assert validate_age(user) is False
+```
+
+**Edge case data collection:**
+```typescript
+export const edgeCases = {
+  strings: ['', ' ', '\t\n', 'a'.repeat(10000), '<script>alert(1)</script>',  # 10000: 10 seconds in ms
+            "Robert'); DROP TABLE users;--", '\u0000null\u0000byte'],
+  numbers: [0, -0, -1, Number.MAX_SAFE_INTEGER, NaN, Infinity, -Infinity],
+  dates: [new Date(0), new Date('2024-02-29'), new Date('9999-12-31')],  # 2024: 9999 = configured value
+};
+```
+
+## Resources
+
+- Faker.js: https://fakerjs.dev/
+- Fishery (TypeScript factories): https://github.com/thoughtbot/fishery
+- factory_boy (Python): https://factoryboy.readthedocs.io/
+- Chance.js: https://chancejs.com/
+- Test data management patterns: https://martinfowler.com/bliki/ObjectMother.html

package/skills/generating-test-data/assets/README.md

@@ -0,0 +1,7 @@
+# Assets
+
+Bundled resources for test-data-generator skill
+
+- [ ] example_schemas/: A directory containing example JSON schemas for different data types.
+- [ ] example_data/: A directory containing example generated data for different data types.
+- [ ] configuration_templates/: Templates for configuring the data generation process (e.g., number of records, data types).

package/skills/generating-test-data/references/README.md

@@ -0,0 +1,4 @@
+# References
+
+Bundled resources for test-data-generator skill
+

package/skills/generating-test-data/scripts/README.md

@@ -0,0 +1,7 @@
+# Scripts
+
+Bundled resources for test-data-generator skill
+
+- [ ] generate_data.py: A script to generate test data based on provided schema or pre-defined types (users, products, orders).
+- [ ] validate_data.py: A script to validate generated data against a schema or set of rules.
+- [ ] seed_database.py: A script to seed a database with the generated test data.

package/skills/generating-test-data/scripts/generate_data.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+test-data-generator - Generator Script
+A script to generate test data based on provided schema or pre-defined types (users, products, orders).
+Generated: 2025-12-10 03:48:17
+"""
+
+import os
+import json
+import argparse
+from pathlib import Path
+from datetime import datetime
+
+class Generator:
+    def __init__(self, config: Dict):
+        self.config = config
+        self.output_dir = Path(config.get('output', './output'))
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def generate_markdown(self, title: str, content: str) -> Path:
+        """Generate markdown document."""
+        filename = f"{title.lower().replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+        file_path = self.output_dir / filename
+
+        md_content = f"""# {title}
+
+Generated by test-data-generator
+Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+## Overview
+{content}
+
+## Configuration
+```json
+{json.dumps(self.config, indent=2)}
+```
+
+## Category
+testing
+
+## Plugin
+test-data-generator
+"""
+
+        file_path.write_text(md_content)
+        return file_path
+
+    def generate_json(self, data: Dict) -> Path:
+        """Generate JSON output."""
+        filename = f"output_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        file_path = self.output_dir / filename
+
+        output_data = {
+            "generated_by": "test-data-generator",
+            "timestamp": datetime.now().isoformat(),
+            "category": "testing",
+            "plugin": "test-data-generator",
+            "data": data,
+            "config": self.config
+        }
+
+        with open(file_path, 'w') as f:
+            json.dump(output_data, f, indent=2)
+
+        return file_path
+
+    def generate_script(self, name: str, template: str) -> Path:
+        """Generate executable script."""
+        filename = f"{name}.sh"
+        file_path = self.output_dir / filename
+
+        script_content = f"""#!/bin/bash
+# Generated by test-data-generator
+# Date: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+set -e  # Exit on error
+
+echo "🚀 Running {name}..."
+
+# Template content
+{template}
+
+echo "✅ Completed successfully"
+"""
+
+        file_path.write_text(script_content)
+        file_path.chmod(0o755)  # Make executable
+        return file_path
+
+def main():
+    parser = argparse.ArgumentParser(description="A script to generate test data based on provided schema or pre-defined types (users, products, orders).")
+    parser.add_argument('--type', choices=['markdown', 'json', 'script'], default='markdown')
+    parser.add_argument('--output', '-o', default='./output', help='Output directory')
+    parser.add_argument('--config', '-c', help='Configuration file')
+    parser.add_argument('--title', default='test-data-generator Output')
+    parser.add_argument('--content', help='Content to include')
+
+    args = parser.parse_args()
+
+    config = {'output': args.output}
+    if args.config and Path(args.config).exists():
+        with open(args.config) as f:
+            config.update(json.load(f))
+
+    generator = Generator(config)
+
+    print(f"🔧 Generating {args.type} output...")
+
+    if args.type == 'markdown':
+        output_file = generator.generate_markdown(
+            args.title,
+            args.content or "Generated content"
+        )
+    elif args.type == 'json':
+        output_file = generator.generate_json(
+            {"title": args.title, "content": args.content}
+        )
+    else:  # script
+        output_file = generator.generate_script(
+            args.title.lower().replace(' ', '_'),
+            args.content or "# Add your script content here"
+        )
+
+    print(f"✅ Generated: {output_file}")
+    return 0
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())