Mock Data Generator

Tool Overview

This tool creates realistic test data for software development. Test data helps developers check if programs work correctly. It also helps testers find problems before users see them.

Creating test data manually takes too long. You must type hundreds of records. You must make sure data makes sense together. For example, phone numbers must match country codes. This tool solves that problem.

You define what fields you need. You set rules that link fields together. The tool creates thousands of records instantly. All data follows your rules automatically. This saves days of manual work.

This tool helps developers, testers, and database administrators. Beginners can create test data without coding. Professionals can generate large datasets quickly. Anyone who needs realistic test data benefits from this tool.

Background & Concept Explanation

Software testing requires sample data. Programs need data to run. Testing needs data to verify behavior. Database seeding needs initial records. Performance testing needs large datasets.

Real data has relationships. Customer names match email addresses. Phone numbers match countries. Order totals match item prices. Status values match business rules. Test data must follow these relationships too.

Creating realistic test data manually is hard. You must type each record. You must remember all the relationships. One mistake breaks the data consistency. Large datasets take weeks to create.

People struggle because data has many connections. A customer record links to orders. Orders link to products. Products link to categories. Changing one field affects others. Keeping everything consistent is difficult. A related operation involves generating fake data as part of a similar workflow.

This tool understands these relationships. You define fields like name, email, and country. You create rules like "if country is USA, then phone starts with +1". The tool generates data that follows all rules automatically.

Dependency rules create logical connections. They work like if-then statements. If one field has a certain value, then another field gets a specific value. This ensures data consistency across all records.

The tool supports many field types. Names, emails, countries, phones, dates, revenue, status, and custom lists. Each type generates appropriate sample values. You can combine types to create complex datasets.

AI assistance helps design schemas. Describe your data needs in plain language. The AI suggests appropriate fields and types. You can then customize and refine the suggestions. This speeds up initial setup.

Key Features

• Field management with add, edit, and remove operations. Create custom data structures by adding fields one by one. Edit field names and types anytime. Remove fields you do not need. Maximum 50 fields per dataset. This gives flexibility to model any data structure.
• Nine field types covering common data needs. Identity fields generate unique IDs. Name fields create full names. Email fields create email addresses. Country fields select from country list. Phone fields generate phone numbers. Status fields use logical statuses. Revenue fields create currency amounts. Date fields generate dates. Custom picklists let you define your own options. This covers most testing scenarios.
• Dependency rules create if-then relationships between fields. Define conditions like "if Country equals USA". Set results like "then Phone equals +1-XXX-XXX-XXXX". Rules apply automatically during generation. Maximum 100 rules per dataset. This ensures data consistency.
• AI-powered schema suggestion from natural language descriptions. Describe your data needs in plain words. Examples include "customer database for fintech app" or "product catalog with pricing". The AI suggests appropriate fields and types. You can customize suggestions afterward. This speeds up initial setup.
• Configurable row count from 1 to 10,000 records. Generate small samples for quick testing. Generate large datasets for performance testing. Adjust count anytime and regenerate instantly. This supports various testing needs.
• Live data preview showing first 15 rows in table format. See generated data immediately as you make changes. Table shows all fields in columns. Rows display sample values. Preview updates automatically when fields or rules change. This provides instant feedback.
• Real-time data regeneration whenever fields or rules change. Add a field and data updates immediately. Modify a rule and data refreshes automatically. No manual refresh needed. This keeps preview synchronized with configuration.
• CSV export for downloading generated datasets. Export button creates a CSV file. File includes all fields as headers. All generated rows included in export. Compatible with Excel, Google Sheets, and database import tools. File names include timestamps for organization.
• Copy to clipboard for quick data transfer. Copy button copies all data as tab-separated text. Paste directly into spreadsheets or text editors. Headers included in copied content. Useful for quick testing without file downloads.
• Regenerate button for manual refresh. Click to regenerate data with current settings. Useful when you want fresh random values. Keeps same field structure and rules. This helps when you need different sample data.
• Field name editing with 50 character limit. Rename fields to match your application's field names. Use descriptive names for clarity. Character limit prevents overly long names. This helps maintain clean data structures.
• Rule condition and action value editing with 100 character limits. Set exact condition values for rules. Set exact action values for results. Character limits prevent overly complex values. This keeps rules manageable.
• Automatic rule cleanup when fields are deleted. Removing a field removes related rules automatically. Prevents broken rules from causing errors. Keeps configuration consistent. This prevents data generation failures.
• Error handling with clear messages for invalid operations. Messages explain what went wrong. Examples include maximum field limit reached or insufficient fields for rules. Errors clear automatically after a few seconds. This provides helpful guidance.
• Visual indicators showing rule count and live sync status. Badge displays number of active rules. Live sync indicator shows data is updating automatically. This provides status feedback.

Common Use Cases

Developers seed databases with initial test data. Create user accounts, product catalogs, or order histories. Generate thousands of records quickly. Import CSV files into databases. This speeds up development setup.

QA testers create test cases with various data scenarios. Test with different country codes. Test with different status values. Test with edge cases like empty fields. This improves test coverage.

Frontend developers test user interfaces with realistic data. Display tables with sample records. Test pagination with large datasets. Verify sorting and filtering work correctly. This helps catch UI bugs early. For adjacent tasks, generating sample JSON addresses a complementary step.

API developers test endpoints with sample request data. Generate JSON payloads with consistent relationships. Test validation rules with various inputs. Verify error handling with different data combinations. This ensures APIs work correctly.

Performance testers create large datasets for load testing. Generate 10,000 records for database stress tests. Measure query performance with realistic data volumes. Identify bottlenecks before production deployment. This helps optimize applications.

Data analysts create sample datasets for analysis tools. Generate data matching expected production patterns. Test reporting queries with sample data. Verify calculations work correctly. This validates analysis workflows.

Training teams create example datasets for learning. Students practice with realistic data. Instructors demonstrate concepts with sample records. Training materials include generated datasets. This improves learning experiences.

Documentation writers create example data for guides. API documentation includes sample records. User manuals show example datasets. Tutorials use generated data for demonstrations. This makes documentation more helpful.

How to Use This Tool

1. Open the tool in your web browser. The interface shows configuration on the left and preview on the right.
2. Optionally use AI schema suggestion. Type a description in the AI text area. Examples include "customer database with email and country" or "product catalog with prices and categories". Click "Generate Schema" button. The tool suggests fields based on your description.
3. Add fields manually by clicking the plus button in the Fields section. A new field appears with default name "New Field" and type "Full Name".
4. Edit field names by clicking in the name field. Type your desired name. Examples include "Customer ID", "Email Address", or "Order Total". Maximum 50 characters.
5. Select field types from the dropdown menu. Choose Identity for unique IDs, Full Name for names, Email Address for emails, Country for countries, Phone Number for phones, Logical Status for statuses, Revenue/Currency for money, Standard Date for dates, or define custom picklists.
6. Remove fields by clicking the trash icon next to any field. Removing a field also removes related dependency rules automatically.
7. Add dependency rules by clicking the plus button in the Dependency Rules section. A new rule appears with default condition and result fields.
8. Configure rule conditions. Select the source field from the first dropdown. This is the field you want to check. Enter the condition value in the input field. This is the value that triggers the rule.
9. Configure rule results. Select the target field from the second dropdown. This is the field that gets modified. Enter the action value in the input field. This is the value set when condition matches.
10. Remove rules by hovering over a rule and clicking the trash icon in the top right corner. Rules are removed immediately.
11. Set row count using the number input in the preview area. Enter any number from 1 to 10,000. The tool generates that many records.
12. Review generated data in the preview table. First 15 rows display automatically. Table shows all fields as columns. Each row shows sample values following your rules.
13. Regenerate data by clicking the "Regenerate" button. This creates fresh random values while keeping your field structure and rules.
14. Copy data by clicking the "Copy" button. All data copies to clipboard as tab-separated text. Paste into spreadsheets or text editors.
15. Export data by clicking the "Export CSV" or "Download Full Set" button. A CSV file downloads with all generated records. File includes headers and all rows.

Calculations & Logic

Field value generation uses type-specific logic. Identity fields create random alphanumeric strings. Name fields combine random first and last names. Email fields create addresses using name parts and random domains. Country fields select randomly from a predefined list. Phone fields generate numbers with country code format. Status fields select from predefined status options. Revenue fields create currency amounts with dollar signs and decimals. Date fields generate past dates within a 1000-day range. Custom picklists select randomly from provided options.

Dependency rule application happens in two passes. First pass generates basic values for all fields using type-specific generators. Second pass applies dependency rules. For each rule, the tool checks if the source field value equals the condition value. If they match, the target field gets set to the action value. Rules apply in order, so later rules can override earlier ones if they target the same field. When working with related formats, generating placeholder text can be a useful part of the process.

Row count validation ensures values stay within limits. Input values get clamped to minimum of 1 and maximum of 10,000. Decimal values get floored to integers. Invalid inputs default to 1. This prevents generation errors and performance issues.

Field and rule limits enforce maximums during generation. Fields get limited to first 50 entries. Rules get limited to first 100 entries. This prevents browser performance problems with extremely large configurations.

CSV export formatting handles special characters. Values containing commas or quotes get wrapped in double quotes. Internal quotes get escaped by doubling them. Headers use field names. Rows use generated values. This creates valid CSV files compatible with standard tools.

Preview display limits to first 15 rows for performance. Full dataset still generates in background. Export includes all rows, not just preview. This keeps interface responsive even with large datasets.

AI schema suggestion sends description to language model service. Service analyzes description and suggests appropriate fields. Response includes field names and types. Tool maps suggested types to available field types. Maximum 50 fields get created from suggestions. This helps users start quickly.

Rule cleanup happens automatically when fields are deleted. Tool scans all rules for references to deleted field. Rules using deleted field as source or target get removed. This prevents broken rules from causing generation errors.

Error handling provides specific messages for different problems. Maximum field limit shows when trying to add more than 50 fields. Minimum field requirement shows when trying to create rules with less than 2 fields. Maximum rule limit shows when trying to add more than 100 rules. Row count clamping shows when input exceeds maximum. This guides users to valid configurations. In some workflows, generating test data is a relevant follow-up operation.

Tips, Limitations & Best Practices

Start with AI schema suggestion for quick setup. Describe your data needs clearly. Review suggested fields and adjust as needed. Add dependency rules afterward to create relationships. This speeds up initial configuration.

Use descriptive field names matching your application. If your app uses "customer_id", name the field "customer_id". This makes exported data directly usable. Avoid generic names like "field1" or "data".

Create dependency rules for realistic relationships. Link country codes to phone number formats. Link status values to appropriate contexts. Link dates to logical sequences. This creates more realistic test data.

Test with small row counts first. Generate 10 rows to verify field structure. Check that rules apply correctly. Then increase to larger counts for final generation. This catches configuration errors early.

Use custom picklists for controlled values. Instead of random text, define specific options. This ensures test data uses only valid values. Useful for status fields, categories, or types.

Remember the 50 field limit per dataset. For very complex structures, consider splitting into multiple datasets. Or focus on most important fields first. Add less critical fields later if needed.

Keep dependency rules simple and clear. Complex nested conditions are not supported. Each rule checks one condition and sets one result. Create multiple rules for complex logic. This keeps rules manageable. For related processing needs, generating secure passwords handles a complementary task.

Export CSV files for permanent storage. Browser sessions can be lost. Downloaded files persist on your computer. Use descriptive filenames or organize downloads in folders. This helps manage multiple datasets.

Review preview data before exporting large datasets. Verify field types generate correct formats. Check that rules apply as expected. Make adjustments before generating thousands of rows. This saves time and ensures quality.

Use regenerate button for fresh random values. Same configuration creates different data each time. Useful when you need variety in test data. Helps test with different value combinations.

Be aware that generated data is sample data only. Email addresses are not real. Phone numbers are not real. Names are fictional. Do not use generated data as real user information. Replace with actual data in production systems.

For internationalization testing, create rules for different countries. Set up rules for USA, UK, Germany, and other countries. Generate data with various country values. This helps test multi-country applications.

Combine field types for complex scenarios. Use Identity for primary keys. Use Name and Email for user records. Use Revenue for financial data. Use Date for temporal data. Mix types to match your application's data model.

Remember that rules apply in order. If multiple rules target the same field, the last matching rule wins. Order rules from general to specific. This ensures correct rule application.

Use the live sync indicator to confirm updates. When you see "LIVE SYNC" badge, data updates automatically. If preview seems stale, check for error messages. Regenerate manually if needed.

For performance testing, generate maximum 10,000 rows. Very large datasets may slow down browser. Export CSV and use database tools for larger datasets. This keeps tool responsive.

Validate exported CSV files before importing. Open in spreadsheet software to verify format. Check that all fields exported correctly. Verify special characters handled properly. This prevents import errors.