test: Add more unit test coverage

Author: dawsontoth

src/lib/arrays/excludeFalsy.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { excludeFalsy } from './excludeFalsy';
+
+describe('excludeFalsy', () => {
+	it('filters out falsy values while preserving truthy entries', () => {
+		const items = [1, 0, 'hello', '', false, true, null, undefined, { foo: 'bar' }];
+		const result = items.filter(excludeFalsy);
+
+		expect(result).toEqual([1, 'hello', true, { foo: 'bar' }]);
+	});
+
+	it('acts as a type guard when filtering arrays', () => {
+		const items: Array<string | undefined> = ['a', undefined, 'b'];
+		const filtered = items.filter(excludeFalsy);
+
+		filtered.forEach(value => {
+			expect(typeof value).toBe('string');
+		});
+
+		expect(filtered).toEqual(['a', 'b']);
+	});
+});

src/lib/arrays/excludePropertyFalsy.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+
+import { excludePropertyFalsy } from './excludePropertyFalsy';
+
+describe('excludePropertyFalsy', () => {
+	it('filters out items where the property is undefined', () => {
+		const items: Array<{ id?: number | null; name: string }> = [
+			{ id: 1, name: 'first' },
+			{ id: undefined, name: 'second' },
+			{ name: 'third' },
+			{ id: 0, name: 'fourth' },
+			{ id: null, name: 'fifth' },
+		];
+
+		const result = items.filter(excludePropertyFalsy('id'));
+
+		result.forEach(item => {
+			const confirmedId: number | null = item.id;
+			expect(confirmedId).not.toBeUndefined();
+		});
+
+		expect(result).toEqual([
+			{ id: 1, name: 'first' },
+			{ id: 0, name: 'fourth' },
+			{ id: null, name: 'fifth' },
+		]);
+	});
+
+	it('keeps falsy but defined values such as false', () => {
+		const items: Array<{ active?: boolean; name: string }> = [
+			{ active: false, name: 'inactive' },
+			{ active: true, name: 'active' },
+			{ name: 'unknown' },
+		];
+
+		const result = items.filter(excludePropertyFalsy('active'));
+
+		expect(result).toEqual([
+			{ active: false, name: 'inactive' },
+			{ active: true, name: 'active' },
+		]);
+	});
+});

src/lib/arrays/findBy.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { findBy } from './findBy';
+
+describe('findBy', () => {
+	const data = [
+		{ id: 1, name: 'alpha' },
+		{ id: 2, name: 'beta' },
+		{ id: 3, name: 'gamma' },
+	];
+
+	it('returns the first element matching the field value', () => {
+		expect(findBy(data, 'id', 2)).toEqual({ id: 2, name: 'beta' });
+	});
+
+	it('returns undefined when no element matches', () => {
+		expect(findBy(data, 'id', 99)).toBeUndefined();
+	});
+
+	it('can search by string fields', () => {
+		expect(findBy(data, 'name', 'gamma')).toEqual({ id: 3, name: 'gamma' });
+	});
+});

src/lib/arrays/mapBy.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { mapBy } from './mapBy';
+
+describe('mapBy', () => {
+	it('maps values from the provided field in order', () => {
+		const data = [
+			{ id: 1, name: 'alpha' },
+			{ id: 2, name: 'beta' },
+			{ id: 3, name: 'gamma' },
+		];
+
+		expect(mapBy(data, 'name')).toEqual(['alpha', 'beta', 'gamma']);
+	});
+
+	it('returns an empty array when given an empty list', () => {
+		expect(mapBy([], 'id')).toEqual([]);
+	});
+
+	it('returns an empty array when provided a falsy array', () => {
+		const result = mapBy(undefined as unknown as Array<{ id: number }>, 'id');
+
+		expect(result).toEqual([]);
+	});
+});

src/lib/arrays/transformNodes.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+
+import { transformNodes } from './transformNodes';
+
+type Node = { id: string; children?: Node[] };
+
+describe('transformNodes', () => {
+	it('transforms nested nodes while passing parent chain', () => {
+		const nodes: Node[] = [
+			{
+				id: 'root',
+				children: [
+					{ id: 'child-1' },
+					{
+						id: 'child-2',
+						children: [{ id: 'grandchild-1' }],
+					},
+				],
+			},
+		];
+
+		const transformed = transformNodes(
+			nodes,
+			'children',
+			(node, parents) => ({
+				id: node.id,
+				depth: parents.length,
+				parentIds: parents.map(parent => parent.id),
+			}),
+		);
+
+		expect(transformed).toEqual([
+			{
+				id: 'root',
+				depth: 0,
+				parentIds: [],
+				children: [
+					{ id: 'child-1', depth: 1, parentIds: ['root'] },
+					{
+						id: 'child-2',
+						depth: 1,
+						parentIds: ['root'],
+						children: [
+							{ id: 'grandchild-1', depth: 2, parentIds: ['root', 'child-2'] },
+						],
+					},
+				],
+			},
+		]);
+	});
+
+	it('handles nodes without nested collections', () => {
+		const flatNodes: Node[] = [{ id: 'a' }, { id: 'b' }];
+
+		const transformed = transformNodes(
+			flatNodes,
+			'children',
+			(node, parents) => ({
+				value: node.id,
+				hasParents: parents.length > 0,
+			}),
+		);
+
+		expect(transformed).toEqual([
+			{ value: 'a', hasParents: false },
+			{ value: 'b', hasParents: false },
+		]);
+	});
+});

src/lib/countBy.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+
+import { countBy } from './countBy';
+
+describe('countBy', () => {
+	it('counts occurrences by a string property and skips undefined values', () => {
+		const items = [
+			{ id: 1, group: 'alpha' },
+			{ id: 2, group: 'alpha' },
+			{ id: 3, group: 'beta' },
+			{ id: 4, group: undefined as string | undefined },
+		];
+
+		const result = countBy(items, 'group');
+
+		expect(result).toEqual({
+			alpha: 2,
+			beta: 1,
+		});
+	});
+
+	it('increments counts for every value in an array property', () => {
+		const items = [
+			{ id: 1, tags: ['red', 'sweet'] },
+			{ id: 2, tags: ['sweet'] },
+			{ id: 3, tags: ['red', 'bitter'] },
+		];
+
+		const result = countBy(items, 'tags');
+
+		expect(result).toEqual({
+			red: 2,
+			sweet: 2,
+			bitter: 1,
+		});
+	});
+
+	it('coerces non-string property values to strings when counting', () => {
+		const items = [
+			{ id: 1, count: 1 },
+			{ id: 2, count: 1 },
+			{ id: 3, count: 2 },
+		];
+
+		const result = countBy(items, 'count');
+
+		expect(result).toEqual({
+			'1': 2,
+			'2': 1,
+		});
+	});
+});

src/lib/keyBy.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+
+import { keyBy } from './keyBy';
+
+describe('keyBy', () => {
+	it('maps items by a string property and overwrites duplicate keys with the last item', () => {
+		const items = [
+			{ id: 1, slug: 'alpha' },
+			{ id: 2, slug: 'beta' },
+			{ id: 3, slug: 'alpha' },
+			{ id: 4, slug: undefined as string | undefined },
+		];
+
+		const result = keyBy(items, 'slug');
+
+		expect(result).toEqual({
+			alpha: { id: 3, slug: 'alpha' },
+			beta: { id: 2, slug: 'beta' },
+		});
+	});
+
+	it('handles array properties by assigning the item to each key value', () => {
+		const items = [
+			{ id: 1, tags: ['red', 'sweet'] },
+			{ id: 2, tags: ['sweet', 'tart'] },
+		];
+
+		const result = keyBy(items, 'tags');
+
+		expect(result).toEqual({
+			red: { id: 1, tags: ['red', 'sweet'] },
+			sweet: { id: 2, tags: ['sweet', 'tart'] },
+			tart: { id: 2, tags: ['sweet', 'tart'] },
+		});
+	});
+
+	it('supports non-string property values by coercing them to string keys', () => {
+		const items = [
+			{ id: 1, count: 1 },
+			{ id: 2, count: 10 },
+		];
+
+		const result = keyBy(items, 'count');
+
+		expect(result).toEqual({
+			'1': { id: 1, count: 1 },
+			'10': { id: 2, count: 10 },
+		});
+	});
+});

src/lib/string/safeParse.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { safeParse } from './safeParse';
+
+describe('safeParse', () => {
+	it('parses valid JSON strings', () => {
+		const parsed = safeParse<{ id: number; name: string }>('{"id":1,"name":"test"}');
+
+		expect(parsed).toEqual({ id: 1, name: 'test' });
+	});
+
+	it('does not check the schema', () => {
+		const parsed = safeParse<{ id: number; name: string }>('{"id":"a STRING oh my goodness","name":"how SNEAKY!"}');
+
+		expect(parsed).toHaveProperty('id', expect.any(String));
+		expect(parsed).toHaveProperty('name', expect.any(String));
+	});
+
+	it('returns null for nullish sentinel values', () => {
+		expect(safeParse('null')).toBeNull();
+		expect(safeParse('undefined')).toBeNull();
+		expect(safeParse(null)).toBeNull();
+		expect(safeParse(undefined)).toBeNull();
+	});
+
+	it('returns null and logs when parsing fails', () => {
+		const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+		const result = safeParse('not-json');
+
+		expect(result).toBeNull();
+		expect(errorSpy).toHaveBeenCalledTimes(1);
+
+		const [message, err] = errorSpy.mock.calls[0];
+		expect(message).toBe('safeParse failed to parse value, returning null instead');
+		expect(err).toBeInstanceOf(Error);
+
+		errorSpy.mockRestore();
+	});
+});

src/lib/string/safeParse.ts

@@ -1,3 +1,9 @@
+/**
+ * Attempts to parse a string as JSON, and narrows the type down to the provided generic. Note that
+ * no schema validation happens as a part of this, so the type might be inaccurate. But exceptions
+ * won't be thrown by the actual parsing if invalid JSON is provided.
+ * @param value
+ */
 export function safeParse<T>(value: string | null | undefined): T | null {
 	try {
 		if (value === 'null' || value === 'undefined' || value === null || value === undefined) {

src/lib/types/itemKeyIsDefined.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+
+import { itemKeyIsDefined } from './itemKeyIsDefined';
+
+describe('itemKeyIsDefined', () => {
+	it('returns true when property exists even if the value is falsy or null', () => {
+		const item = { count: 0, active: false, label: '', data: null as null | string };
+
+		expect(itemKeyIsDefined(item, 'count')).toBe(true);
+		expect(itemKeyIsDefined(item, 'active')).toBe(true);
+		expect(itemKeyIsDefined(item, 'label')).toBe(true);
+		expect(itemKeyIsDefined(item, 'data')).toBe(true);
+	});
+
+	it('returns false when property value is undefined', () => {
+		const item: { id: number; missing?: string } = { id: 1 };
+
+		expect(itemKeyIsDefined(item, 'missing')).toBe(false);
+	});
+});