Generate Random Data: CSV, JSON, and XML for Testing

Random test data is essential for development and testing. This guide covers generating realistic mock data in common formats.

Why Generate Random Data?

1. Testing: Verify application behavior with varied inputs
2. Development: Work without production data
3. Performance: Test with realistic data volumes
4. Privacy: Avoid using real user data
5. Demos: Create realistic demonstrations

Basic Data Generators

Names and Personal Data

const firstNames = ['James', 'Mary', 'John', 'Patricia', 'Robert', 'Jennifer'];
const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia'];
const domains = ['gmail.com', 'yahoo.com', 'outlook.com', 'example.com'];

function randomName() {
  const first = firstNames[Math.floor(Math.random() * firstNames.length)];
  const last = lastNames[Math.floor(Math.random() * lastNames.length)];
  return { first, last, full: `${first} ${last}` };
}

function randomEmail(name) {
  const domain = domains[Math.floor(Math.random() * domains.length)];
  return `${name.first.toLowerCase()}.${name.last.toLowerCase()}@${domain}`;
}

function randomPhone() {
  const area = Math.floor(Math.random() * 900) + 100;
  const mid = Math.floor(Math.random() * 900) + 100;
  const last = Math.floor(Math.random() * 9000) + 1000;
  return `(${area}) ${mid}-${last}`;
}

Dates and Numbers

function randomDate(start, end) {
  const date = new Date(
    start.getTime() + Math.random() * (end.getTime() - start.getTime())
  );
  return date.toISOString().split('T')[0];
}

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

function randomFloat(min, max, decimals = 2) {
  const num = Math.random() * (max - min) + min;
  return parseFloat(num.toFixed(decimals));
}

Generate CSV Data

function generateCSV(count, config) {
  const headers = Object.keys(config);
  const rows = [headers.join(',')];

  for (let i = 0; i < count; i++) {
    const row = headers.map(header => {
      const value = config[header]();
      // Escape commas and quotes
      if (typeof value === 'string' && (value.includes(',') || value.includes('"'))) {
        return `"${value.replace(/"/g, '""')}"`;
      }
      return value;
    });
    rows.push(row.join(','));
  }

  return rows.join('
');
}

// Usage
const csv = generateCSV(100, {
  id: () => randomInt(1000, 9999),
  name: () => randomName().full,
  email: () => {
    const name = randomName();
    return randomEmail(name);
  },
  age: () => randomInt(18, 80),
  salary: () => randomFloat(30000, 150000, 2),
  hire_date: () => randomDate(new Date('2020-01-01'), new Date())
});

Generate JSON Data

function generateJSON(count, template) {
  const data = [];

  for (let i = 0; i < count; i++) {
    const item = {};
    for (const [key, generator] of Object.entries(template)) {
      if (typeof generator === 'function') {
        item[key] = generator(i);
      } else if (typeof generator === 'object') {
        item[key] = generateJSON(1, generator)[0];
      } else {
        item[key] = generator;
      }
    }
    data.push(item);
  }

  return data;
}

// Usage
const users = generateJSON(50, {
  id: (i) => i + 1,
  name: () => randomName().full,
  email: () => {
    const name = randomName();
    return randomEmail(name);
  },
  profile: {
    age: () => randomInt(18, 65),
    city: () => ['New York', 'London', 'Tokyo', 'Sydney'][randomInt(0, 3)]
  },
  orders: () => generateJSON(randomInt(0, 5), {
    orderId: () => randomInt(10000, 99999),
    total: () => randomFloat(10, 500)
  }),
  createdAt: () => new Date().toISOString()
});

console.log(JSON.stringify(users, null, 2));

Generate XML Data

function generateXML(rootName, itemName, count, template) {
  let xml = `<?xml version="1.0" encoding="UTF-8"?>
<${rootName}>
`;

  for (let i = 0; i < count; i++) {
    xml += `  <${itemName}>
`;

    for (const [key, generator] of Object.entries(template)) {
      const value = typeof generator === 'function' ? generator(i) : generator;
      const escaped = escapeXML(String(value));
      xml += `    <${key}>${escaped}</${key}>
`;
    }

    xml += `  </${itemName}>
`;
  }

  xml += `</${rootName}>`;
  return xml;
}

function escapeXML(str) {
  return str
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&apos;');
}

// Usage
const xml = generateXML('users', 'user', 10, {
  id: (i) => i + 1,
  name: () => randomName().full,
  email: () => {
    const name = randomName();
    return randomEmail(name);
  },
  status: () => ['active', 'inactive', 'pending'][randomInt(0, 2)]
});

Complete Data Generator

class DataGenerator {
  constructor() {
    this.data = [];
  }

  generate(count, template) {
    this.data = generateJSON(count, template);
    return this;
  }

  toCSV() {
    if (this.data.length === 0) return '';
    const headers = Object.keys(this.data[0]);
    const rows = this.data.map(item =>
      headers.map(h => JSON.stringify(item[h])).join(',')
    );
    return [headers.join(','), ...rows].join('
');
  }

  toJSON(pretty = true) {
    return JSON.stringify(this.data, null, pretty ? 2 : 0);
  }

  toXML(rootName = 'root', itemName = 'item') {
    let xml = `<?xml version="1.0"?>
<${rootName}>
`;
    for (const item of this.data) {
      xml += `<${itemName}>${this.objectToXML(item)}</${itemName}>
`;
    }
    return xml + `</${rootName}>`;
  }

  objectToXML(obj) {
    return Object.entries(obj)
      .map(([k, v]) => `<${k}>${escapeXML(String(v))}</${k}>`)
      .join('');
  }
}

// Usage
const generator = new DataGenerator();
generator.generate(100, {
  id: (i) => i + 1,
  name: () => randomName().full,
  value: () => randomFloat(1, 1000)
});

console.log(generator.toCSV());
console.log(generator.toJSON());
console.log(generator.toXML('products', 'product'));

Try Our Tools

• Random CSV - Generate random CSV data
• Random JSON - Generate random JSON data
• Random XML - Generate random XML data

Conclusion

Random data generation is essential for testing and development. Use realistic patterns and validate your generated data to ensure effective testing.