make-mp-data 1.3.3 → 1.4.0

package/tests/unit.test.js

@@ -1,19 +1,54 @@
 const generate = require('../index.js');
 const dayjs = require("dayjs");
 const utc = require("dayjs/plugin/utc");
+const fs = require('fs');
 const u = require('ak-tools');
 dayjs.extend(utc);
-const { timeSoup } = generate;
 require('dotenv').config();
 
-
-
-describe('timeSoup', () => {
-	test('always positive dates', () => {
+const { applySkew,
+	boxMullerRandom,
+	choose,
+	date,
+	dates,
+	day,
+	exhaust,
+	generateEmoji,
+	getUniqueKeys,
+	integer,
+	mapToRange,
+	person,
+	pick,
+	range,
+	pickAWinner,
+	weightedRange,
+	enrichArray,
+	fixFirstAndLast,
+	generateUser,
+	openFinder,
+	progress,
+	shuffleArray,
+	shuffleExceptFirst,
+	shuffleExceptLast,
+	shuffleMiddle,
+	shuffleOutside,
+	streamCSV,
+	streamJSON,
+	weighArray,
+	weighFunnels,
+	buildFileNames,
+	TimeSoup,
+	getChance,
+	initChance
+} = require('../utils');
+
+
+describe('timesoup', () => {
+	test('always valid times', () => {
 		const dates = [];
-		for (let i = 0; i < 20000; i++) {
-			const earliest = dayjs().subtract(u.rand(2, 360), 'D');
-			dates.push(timeSoup());
+		for (let i = 0; i < 10000; i++) {
+			const earliest = dayjs().subtract(u.rand(5, 50), 'D');
+			dates.push(TimeSoup());
 		}
 		const tooOld = dates.filter(d => dayjs(d).isBefore(dayjs.unix(0)));
 		const badYear = dates.filter(d => !d.startsWith('202'));
@@ -24,8 +59,207 @@ describe('timeSoup', () => {
 });
 
 
+describe('naming things', () => {
+
+	test('default config', () => {
+		const config = { simulationName: 'testSim' };
+		const result = buildFileNames(config);
+		expect(result.eventFiles).toEqual(['testSim-EVENTS.csv']);
+		expect(result.userFiles).toEqual(['testSim-USERS.csv']);
+		expect(result.scdFiles).toEqual([]);
+		expect(result.groupFiles).toEqual([]);
+		expect(result.lookupFiles).toEqual([]);
+		expect(result.mirrorFiles).toEqual([]);
+		expect(result.folder).toEqual('./');
+	});
+
+	test('json format', () => {
+		const config = { simulationName: 'testSim', format: 'json' };
+		const result = buildFileNames(config);
+		expect(result.eventFiles).toEqual(['testSim-EVENTS.json']);
+		expect(result.userFiles).toEqual(['testSim-USERS.json']);
+	});
+
+	test('with scdProps', () => {
+		const config = {
+			simulationName: 'testSim',
+			scdProps: { prop1: {}, prop2: {} }
+		};
+		const result = buildFileNames(config);
+		expect(result.scdFiles).toEqual([
+			'testSim-prop1-SCD.csv',
+			'testSim-prop2-SCD.csv'
+		]);
+	});
+
+	test('with groupKeys', () => {
+		const config = {
+			simulationName: 'testSim',
+			groupKeys: [['group1'], ['group2']]
+		};
+		const result = buildFileNames(config);
+		expect(result.groupFiles).toEqual([
+			'testSim-group1-GROUP.csv',
+			'testSim-group2-GROUP.csv'
+		]);
+	});
+
+	test('with lookupTables', () => {
+		const config = {
+			simulationName: 'testSim',
+			lookupTables: [{ key: 'lookup1' }, { key: 'lookup2' }]
+		};
+		const result = buildFileNames(config);
+		expect(result.lookupFiles).toEqual([
+			'testSim-lookup1-LOOKUP.csv',
+			'testSim-lookup2-LOOKUP.csv'
+		]);
+	});
+
+	test('with mirrorProps', () => {
+		const config = {
+			simulationName: 'testSim',
+			mirrorProps: { prop1: {} }
+		};
+		const result = buildFileNames(config);
+		expect(result.mirrorFiles).toEqual(['testSim-MIRROR.csv']);
+	});
+
+	test('writeToDisk', async () => {
+		const config = { simulationName: 'testSim', writeToDisk: true };
+		const result = await buildFileNames(config);
+		expect(result.folder).toBeDefined();
+
+	});
+
+
+	test('invalid simName', () => {
+		const config = { simulationName: 123 };
+		expect(() => buildFileNames(config)).toThrow('simName must be a string');
+	});
+
+
+	test('streamJSON: writes to file', async () => {
+		const path = 'test.json';
+		const data = [{ a: 1, b: 2 }, { a: 3, b: 4 }];
+		await streamJSON(path, data);
+		const content = fs.readFileSync(path, 'utf8');
+		const lines = content.trim().split('\n').map(line => JSON.parse(line));
+		expect(lines).toEqual(data);
+		fs.unlinkSync(path);
+	});
+
+	test('streamCSV: writes to file', async () => {
+		const path = 'test.csv';
+		const data = [{ a: 1, b: 2 }, { a: 3, b: 4 }];
+		await streamCSV(path, data);
+		const content = fs.readFileSync(path, 'utf8');
+		const lines = content.trim().split('\n');
+		expect(lines.length).toBe(3); // Including header
+		fs.unlinkSync(path);
+	});
+
+
+	test('generateUser: works', () => {
+		const uuid = { guid: jest.fn().mockReturnValue('uuid-123') };
+		const numDays = 30;
+		const user = generateUser(numDays);
+		expect(user).toHaveProperty('distinct_id');
+		expect(user).toHaveProperty('name');
+		expect(user).toHaveProperty('email');
+		expect(user).toHaveProperty('avatar');
+	});
+
+	test('enrichArray: works', () => {
+		const arr = [];
+		const enrichedArray = enrichArray(arr);
+		enrichedArray.hookPush(1);
+		enrichedArray.hookPush(2);
+		const match = JSON.stringify(enrichedArray) === JSON.stringify([1, 2]);
+		expect(match).toEqual(true);
+	});
+
+});
+
+
+describe('determined random', () => {
+	test('initializes RNG with seed from environment variable', () => {
+		process.env.SEED = 'test-seed';
+		// @ts-ignore
+		initChance();
+		const chance = getChance();
+		expect(chance).toBeDefined();
+		expect(chance.random()).toBeGreaterThanOrEqual(0);
+		expect(chance.random()).toBeLessThanOrEqual(1);
+
+	});
+
+	test('initializes RNG only once', () => {
+		const seed = 'initial-seed';
+		initChance(seed);
+		const chance1 = getChance();
+		initChance('new-seed');
+		const chance2 = getChance();
+		expect(chance1).toBe(chance2);
+
+	});
+});
+
+
+describe('generateUser', () => {
+	test('creates a user with valid fields', () => {
+		const numDays = 30;
+		const user = generateUser('uuid-123', numDays);
+		expect(user).toHaveProperty('distinct_id');
+		expect(user).toHaveProperty('name');
+		expect(user).toHaveProperty('email');
+		expect(user).toHaveProperty('avatar');
+		expect(user).toHaveProperty('created');
+		expect(user).toHaveProperty('anonymousIds');
+		expect(user).toHaveProperty('sessionIds');
+	});
+
+	test('creates a user with a created date within the specified range', () => {
+		const numDays = 30;
+		const user = generateUser('uuid-123', numDays);
+		const createdDate = dayjs(user.created, 'YYYY-MM-DD');
+		expect(createdDate.isValid()).toBeTruthy();
+		expect(createdDate.isBefore(dayjs.unix(global.NOW))).toBeTruthy();
+	});
+});
+
+
+
+describe('enrich array', () => {
+	test('hook works', () => {
+		const arr = [];
+		const hook = (item) => item * 2;
+		const enrichedArray = enrichArray(arr, { hook });
+		enrichedArray.hookPush(1);
+		enrichedArray.hookPush(2);
+		expect(enrichedArray.includes(2)).toBeTruthy();
+		expect(enrichedArray.includes(4)).toBeTruthy();		
+	});
+
+	test('filter empties', () => {
+		const arr = [];
+		const hook = (item) => item ? item.toString() : item;
+		const enrichedArray = enrichArray(arr, { hook });
+		enrichedArray.hookPush(null);
+		enrichedArray.hookPush(undefined);
+		enrichedArray.hookPush({});		
+		enrichedArray.hookPush({ a: 1 });
+		enrichedArray.hookPush([1, 2]);
+		expect(enrichedArray).toHaveLength(3);
+		expect(enrichedArray.includes('null')).toBeFalsy();
+		expect(enrichedArray.includes('undefined')).toBeFalsy();
+		expect(enrichedArray.includes('[object Object]')).toBeTruthy();
+		expect(enrichedArray.includes('1')).toBeTruthy();
+		expect(enrichedArray.includes('2')).toBeTruthy();
+		
+	});
+});
 
-const { applySkew, boxMullerRandom, choose, date, dates, day, exhaust, generateEmoji, getUniqueKeys, integer, makeHashTags, makeProducts, mapToRange, person, pick, range, weighList, weightedRange } = require('../utils');
 
 describe('utils', () => {
 
@@ -58,9 +292,9 @@ describe('utils', () => {
 
 	test('person: fields', () => {
 		const generatedPerson = person();
-		expect(generatedPerson).toHaveProperty('$name');
-		expect(generatedPerson).toHaveProperty('$email');
-		expect(generatedPerson).toHaveProperty('$avatar');
+		expect(generatedPerson).toHaveProperty('name');
+		expect(generatedPerson).toHaveProperty('email');
+		expect(generatedPerson).toHaveProperty('avatar');
 	});
 
 
@@ -73,7 +307,7 @@ describe('utils', () => {
 	test('date: future', () => {
 		const futureDate = date(10, false, 'YYYY-MM-DD')();
 		expect(dayjs(futureDate, 'YYYY-MM-DD').isValid()).toBeTruthy();
-		expect(dayjs(futureDate).isAfter(dayjs())).toBeTruthy();
+		expect(dayjs(futureDate).isAfter(dayjs.unix(global.NOW))).toBeTruthy();
 	});
 
 	test('dates: pairs', () => {
@@ -107,7 +341,7 @@ describe('utils', () => {
 	});
 
 	test('weightedRange:  within range', () => {
-		const values = weightedRange(5, 15, 100);
+		const values = weightedRange(5, 15);
 		expect(values.every(v => v >= 5 && v <= 15)).toBe(true);
 		expect(values.length).toBe(100);
 	});
@@ -124,8 +358,8 @@ describe('utils', () => {
 		const sd = 5;
 		const mappedValue = mapToRange(value, mean, sd);
 		expect(mappedValue).toBe(10);
-	  });
-	  
+	});
+
 
 
 	test('exhaust: elements', () => {
@@ -146,6 +380,19 @@ describe('utils', () => {
 	});
 
 
+	test('times', () => {
+		const dates = [];
+		for (let i = 0; i < 10000; i++) {
+			const earliest = dayjs().subtract(u.rand(5, 50), 'D');
+			dates.push(TimeSoup());
+		}
+		const tooOld = dates.filter(d => dayjs(d).isBefore(dayjs.unix(0)));
+		const badYear = dates.filter(d => !d.startsWith('202'));
+		expect(dates.every(d => dayjs(d).isAfter(dayjs.unix(0)))).toBe(true);
+		expect(dates.every(d => d.startsWith('202'))).toBe(true);
+
+	});
+
 	test('date', () => {
 		const result = date();
 		expect(dayjs(result()).isValid()).toBe(true);
@@ -184,16 +431,110 @@ describe('utils', () => {
 	test('emoji: works', () => {
 		const emojis = generateEmoji(5)();
 		expect(typeof emojis).toBe('string');
-		expect(emojis.split(', ').length).toBeLessThanOrEqual(5);
+		if (!Array.isArray(emojis)) {
+			expect(emojis.split(', ').length).toBeLessThanOrEqual(5);
+		}
+		if (Array.isArray(emojis)) {
+			expect(emojis.length).toBeLessThanOrEqual(5);
+		}
 	});
 
 	test('emoji: length', () => {
 		const result = generateEmoji();
 		const emojis = result();
 		expect(typeof emojis).toBe('string');
-		const emojiArray = emojis.split(', ');
-		expect(emojiArray.length).toBeLessThanOrEqual(10); // Assuming max default is 10
+		if (!Array.isArray(emojis)) {
+			expect(emojis.split(', ').length).toBeLessThanOrEqual(10);
+		}
+		if (Array.isArray(emojis)) {
+			expect(emojis.length).toBeLessThanOrEqual(10);
+		}
+
+	});
+
 
+	test('weighArray: works', () => {
+		const arr = ['a', 'b', 'c'];
+		const weightedArr = weighArray(arr);
+		expect(weightedArr.length).toBeGreaterThanOrEqual(arr.length);
+	});
+
+	test('weighFunnels: works', () => {
+		const acc = [];
+		const funnel = { weight: 3 };
+		const result = weighFunnels(acc, funnel);
+		expect(result.length).toBe(3);
+	});
+
+	test('progress: outputs correctly', () => {
+		// @ts-ignore
+		const mockStdoutWrite = jest.spyOn(process.stdout, 'write').mockImplementation(() => { });
+		progress('test', 50);
+		expect(mockStdoutWrite).toHaveBeenCalled();
+		mockStdoutWrite.mockRestore();
+	});
+
+	test('range: works', () => {
+		const result = [];
+		range.call(result, 1, 5);
+		expect(result).toEqual([1, 2, 3, 4, 5]);
+	});
+
+
+
+	test('shuffleArray: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = shuffleArray([...arr]);
+		expect(shuffled).not.toEqual(arr);
+		expect(shuffled.sort()).toEqual(arr.sort());
+	});
+
+	test('shuffleExceptFirst: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = shuffleExceptFirst([...arr]);
+		expect(shuffled[0]).toBe(arr[0]);
+		expect(shuffled.slice(1).sort()).toEqual(arr.slice(1).sort());
+	});
+
+	test('shuffleExceptLast: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = shuffleExceptLast([...arr]);
+		expect(shuffled[shuffled.length - 1]).toBe(arr[arr.length - 1]);
+		expect(shuffled.slice(0, -1).sort()).toEqual(arr.slice(0, -1).sort());
+	});
+
+	test('fixFirstAndLast: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = fixFirstAndLast([...arr]);
+		expect(shuffled[0]).toBe(arr[0]);
+		expect(shuffled[shuffled.length - 1]).toBe(arr[arr.length - 1]);
+		expect(shuffled.slice(1, -1).sort()).toEqual(arr.slice(1, -1).sort());
+	});
+
+	test('shuffleMiddle: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = shuffleMiddle([...arr]);
+		expect(shuffled[0]).toBe(arr[0]);
+		expect(shuffled[shuffled.length - 1]).toBe(arr[arr.length - 1]);
+		expect(shuffled.slice(1, -1).sort()).toEqual(arr.slice(1, -1).sort());
+	});
+
+	test('shuffleOutside: works', () => {
+		const arr = [1, 2, 3, 4, 5];
+		const shuffled = shuffleOutside([...arr]);
+		expect(shuffled.slice(1, -1)).toEqual(arr.slice(1, -1));
+	});
+
+	test('box normal distribution', () => {
+		const values = [];
+		for (let i = 0; i < 10000; i++) {
+			values.push(boxMullerRandom());
+		}
+		const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
+		const variance = values.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / values.length;
+		const stdDev = Math.sqrt(variance);
+		expect(mean).toBeCloseTo(0, 1);
+		expect(stdDev).toBeCloseTo(1, 1);
 	});
 
 

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": false,
+    "esModuleInterop": true,
+	"resolveJsonModule": true
+  },
+  "include": [
+    "**/*.js"
+, "soupTemplates.mjs", "testSoup.mjs", "testCases.mjs"  ],
+  "exclude": [
+    "node_modules"
+  ]
+}