feat(core): add IP and username mock generators (#16)

* feat(core): add IP and username mock generators

- Add IP generator supporting both IPv4 and IPv6
- Add username generator with customizable options
- Include comprehensive test coverage for new generators

* feat(core): add documentation for IP generator in smart-mock

Author: Yogananda1504

package-lock.json

@@ -76,6 +76,8 @@
     "vite": "npm:rolldown-vite@7.2.5"
   },
   "dependencies": {
-    "axios": "^1.13.2"
+    "@faker-js/faker": "^10.1.0",
+    "axios": "^1.13.2",
+    "unique-username-generator": "^1.5.1"
   }
 }

package.json

@@ -1,4 +1,7 @@
 import type { MockGenerator } from '../types'
+import { generateUsername } from 'unique-username-generator';
+import { faker } from '@faker-js/faker';
+
 
 const generators: Record<string, MockGenerator> = {
 
@@ -16,6 +19,44 @@ const generators: Record<string, MockGenerator> = {
     const max = parseInt(maxStr, 10);
     return Math.floor(Math.random() * (max - min + 1)) + min;
   },
+  // Username generator using unique-username-generator
+  // Arguments: separator, randomDigits, maxLength, dictType
+  // Example: @username("-", 2, 20) or @username() for defaults
+  username: (args?: string) => {
+    if (!args) {
+      return generateUsername();
+    }
+
+    const params = args.split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+    const separator = params[0] || '';
+    const randomDigits = params[1] ? parseInt(params[1], 10) : 0;
+    const maxLength = params[2] ? parseInt(params[2], 10) : undefined;
+    const dictType = params[3] || undefined;
+
+    if (dictType) {
+      return generateUsername(separator, randomDigits, maxLength, dictType);
+    } else if (maxLength) {
+      return generateUsername(separator, randomDigits, maxLength);
+    } else if (randomDigits) {
+      return generateUsername(separator, randomDigits);
+    } else if (separator) {
+      return generateUsername(separator);
+    } else {
+      return generateUsername();
+    }
+  },
+ 
+  // IP generator for v4 and v6
+  // Arguments: version
+  // Example: @ip(v6) or @ip(IPv6) for IPv6, defaults to IPv4
+  ip:(args?:string)=>{
+    if(args == "6" || args =="IPv6" || args == "ipv6" || args == "v6"){
+      return faker.internet.ipv6();
+    }else{
+      // Default to IPv4
+      return faker.internet.ipv4();
+    }
+  },
 
   string: (args?: string) => {
     const length = args ? parseInt(args, 10) : 10;

src/core/engine/smart-mock.ts

@@ -216,4 +216,152 @@ describe('generateMockData', () => {
     const longTextWords = result.longText.split(' ');
     expect(longTextWords.length).toBeGreaterThanOrEqual(20);
   });
+
+  it('should generate username with default settings', () => {
+    const template = {
+      username: '@username'
+    };
+    const result = generateMockData(template);
+
+    expect(result.username).toBeDefined();
+    expect(typeof result.username).toBe('string');
+    expect(result.username.length).toBeGreaterThan(0);
+  });
+
+  it('should generate username with custom separator', () => {
+    const template = {
+      username: '@username(_)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.username).toBeDefined();
+    expect(typeof result.username).toBe('string');
+    // Username with underscore separator should contain underscores
+    expect(result.username).toMatch(/[_]/);
+  });
+
+  it('should generate username with separator and random digits', () => {
+    const template = {
+      username: '@username(-,3)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.username).toBeDefined();
+    expect(typeof result.username).toBe('string');
+    // Should contain dash separator and digits
+    expect(result.username).toMatch(/[-]/);
+    expect(result.username).toMatch(/\d+/);
+  });
+
+  it('should generate username with separator, random digits, and max length', () => {
+    const template = {
+      username: '@username(_,2,15)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.username).toBeDefined();
+    expect(typeof result.username).toBe('string');
+    expect(result.username.length).toBeLessThanOrEqual(15);
+  });
+
+  it('should generate username with all parameters including dictType', () => {
+    const template = {
+      username: '@username(-,3,20,adjectives)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.username).toBeDefined();
+    expect(typeof result.username).toBe('string');
+    expect(result.username.length).toBeLessThanOrEqual(20);
+  });
+
+  it('should generate IPv4 address by default', () => {
+    const template = {
+      ip: '@ip'
+    };
+    const result = generateMockData(template);
+
+    expect(result.ip).toBeDefined();
+    expect(typeof result.ip).toBe('string');
+    // IPv4 format: xxx.xxx.xxx.xxx
+    expect(result.ip).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+  });
+
+  it('should generate IPv6 address with "6" argument', () => {
+    const template = {
+      ip: '@ip(6)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.ip).toBeDefined();
+    expect(typeof result.ip).toBe('string');
+    // IPv6 format contains colons
+    expect(result.ip).toMatch(/:/);
+  });
+
+  it('should generate IPv6 address with "IPv6" argument', () => {
+    const template = {
+      ip: '@ip(IPv6)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.ip).toBeDefined();
+    expect(typeof result.ip).toBe('string');
+    expect(result.ip).toMatch(/:/);
+  });
+
+  it('should generate IPv6 address with "ipv6" argument', () => {
+    const template = {
+      ip: '@ip(ipv6)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.ip).toBeDefined();
+    expect(typeof result.ip).toBe('string');
+    expect(result.ip).toMatch(/:/);
+  });
+
+  it('should generate IPv6 address with "v6" argument', () => {
+    const template = {
+      ip: '@ip(v6)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.ip).toBeDefined();
+    expect(typeof result.ip).toBe('string');
+    expect(result.ip).toMatch(/:/);
+  });
+
+  it('should generate multiple usernames with different configurations', () => {
+    const template = {
+      user1: '@username',
+      user2: '@username(-)',
+      user3: '@username(_,4)'
+    };
+    const result = generateMockData(template);
+
+    expect(result.user1).toBeDefined();
+    expect(result.user2).toBeDefined();
+    expect(result.user3).toBeDefined();
+    expect(result.user1).not.toBe(result.user2);
+  });
+
+  it('should handle IP addresses in nested structures', () => {
+    const template = {
+      server: {
+        ipv4: '@ip',
+        ipv6: '@ip(6)'
+      },
+      'clients|2': {
+        address: '@ip'
+      }
+    };
+    const result = generateMockData(template);
+
+    expect(result.server.ipv4).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+    expect(result.server.ipv6).toMatch(/:/);
+    expect(result.clients).toHaveLength(2);
+    expect(result.clients[0].address).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+    expect(result.clients[1].address).toMatch(/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/);
+  });
 });