Jon Staab
351 lines
10 KiB
TypeScript
351 lines
10 KiB
TypeScript
import {describe, it, expect, vi, beforeEach, afterEach} from "vitest"
|
|
import * as T from "../src/Tools"
|
|
|
|
describe("Tools", () => {
|
|
beforeEach(() => {
|
|
vi.clearAllMocks()
|
|
vi.useFakeTimers()
|
|
})
|
|
|
|
afterEach(() => {
|
|
vi.useRealTimers()
|
|
})
|
|
describe("Basic Utils", () => {
|
|
it("should handle ifLet", () => {
|
|
const fn = vi.fn()
|
|
T.ifLet(undefined, fn)
|
|
expect(fn).not.toHaveBeenCalled()
|
|
|
|
T.ifLet(5, fn)
|
|
expect(fn).toHaveBeenCalledWith(5)
|
|
})
|
|
|
|
it("should handle array operations", () => {
|
|
const arr = [1, 2, 3]
|
|
expect(T.first(arr)).toBe(1)
|
|
expect(T.last(arr)).toBe(3)
|
|
})
|
|
})
|
|
|
|
describe("Math Operations", () => {
|
|
it("should handle basic math operations", () => {
|
|
expect(T.add(2, 3)).toBe(5)
|
|
expect(T.sub(5, 3)).toBe(2)
|
|
expect(T.mul(2, 3)).toBe(6)
|
|
expect(T.div(6, 2)).toBe(3)
|
|
})
|
|
|
|
it("should handle nil values in math operations", () => {
|
|
expect(T.add(undefined, 3)).toBe(3)
|
|
expect(T.sub(5, undefined)).toBe(5)
|
|
expect(T.mul(undefined, undefined)).toBe(0)
|
|
})
|
|
|
|
it("should handle comparisons", () => {
|
|
expect(T.lt(2, 3)).toBe(true)
|
|
expect(T.gt(3, 2)).toBe(true)
|
|
expect(T.lte(2, 2)).toBe(true)
|
|
expect(T.gte(2, 2)).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe("Array Operations", () => {
|
|
it("should handle array transformations", () => {
|
|
expect(T.take(2, [1, 2, 3, 4])).toEqual([1, 2])
|
|
expect(T.drop(2, [1, 2, 3, 4])).toEqual([3, 4])
|
|
expect(T.uniq([1, 1, 2, 2, 3])).toEqual([1, 2, 3])
|
|
})
|
|
|
|
it("should handle chunk operations", () => {
|
|
expect(T.chunk(2, [1, 2, 3, 4])).toEqual([
|
|
[1, 2],
|
|
[3, 4],
|
|
])
|
|
expect(T.chunks(2, [1, 2, 3, 4])).toEqual([
|
|
[1, 3],
|
|
[2, 4],
|
|
])
|
|
})
|
|
|
|
it("should handle array sorting", () => {
|
|
expect(T.sort([3, 1, 2])).toEqual([1, 2, 3])
|
|
expect(T.sortBy(x => x.value, [{value: 3}, {value: 1}, {value: 2}])).toEqual([
|
|
{value: 1},
|
|
{value: 2},
|
|
{value: 3},
|
|
])
|
|
})
|
|
})
|
|
|
|
describe("Object Operations", () => {
|
|
it("should handle object transformations", () => {
|
|
const obj = {a: 1, b: 2, c: 3}
|
|
expect(T.omit(["a"], obj)).toEqual({b: 2, c: 3})
|
|
expect(T.pick(["a"], obj)).toEqual({a: 1})
|
|
})
|
|
|
|
it("should handle deep merging", () => {
|
|
const a = {x: {y: 1}}
|
|
const b = {x: {z: 2}}
|
|
expect(T.deepMergeLeft(a, b)).toEqual({x: {y: 1, z: 2}})
|
|
})
|
|
})
|
|
|
|
describe("Batch Operations", () => {
|
|
it("should handle memoization", () => {
|
|
const fn = vi.fn(x => x * 2)
|
|
const memoized = T.memoize(fn)
|
|
|
|
expect(memoized(2)).toBe(4)
|
|
expect(memoized(2)).toBe(4)
|
|
expect(fn).toHaveBeenCalledTimes(1)
|
|
})
|
|
|
|
it("should handle throttling", async () => {
|
|
const fn = vi.fn()
|
|
const throttled = T.throttle(100, fn)
|
|
|
|
throttled()
|
|
throttled()
|
|
throttled()
|
|
|
|
expect(fn).toHaveBeenCalledTimes(1)
|
|
|
|
vi.advanceTimersByTime(200)
|
|
|
|
expect(fn).toHaveBeenCalledTimes(2)
|
|
})
|
|
|
|
describe("batch", () => {
|
|
it("should collect items and process them in batches", async () => {
|
|
const processBatch = vi.fn()
|
|
const batchFn = T.batch(100, processBatch)
|
|
|
|
// Add items
|
|
batchFn("a")
|
|
batchFn("b")
|
|
batchFn("c")
|
|
|
|
// Initially the batch shouldn't be processed
|
|
expect(processBatch).toHaveBeenCalledTimes(1)
|
|
|
|
// Advance timer to trigger batch processing
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
expect(processBatch).toHaveBeenCalledTimes(2)
|
|
|
|
expect(processBatch).toHaveBeenCalledWith(["a"])
|
|
expect(processBatch).toHaveBeenCalledWith(["b", "c"])
|
|
})
|
|
|
|
it("should handle multiple batch windows", async () => {
|
|
const processBatch = vi.fn()
|
|
const batchFn = T.batch(100, processBatch)
|
|
|
|
// First batch
|
|
batchFn("a")
|
|
batchFn("b")
|
|
batchFn("c")
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
// Second batch
|
|
batchFn("d")
|
|
batchFn("e")
|
|
batchFn("f")
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
expect(processBatch).toHaveBeenCalledTimes(4)
|
|
expect(processBatch).toHaveBeenCalledWith(["a"])
|
|
expect(processBatch).toHaveBeenCalledWith(["b", "c"])
|
|
expect(processBatch).toHaveBeenCalledWith(["d"])
|
|
expect(processBatch).toHaveBeenCalledWith(["e", "f"])
|
|
})
|
|
})
|
|
|
|
describe("batcher", () => {
|
|
it("should batch requests and return results", async () => {
|
|
const executeFn = vi.fn(async (requests: number[]) => requests.map(x => x * 2))
|
|
|
|
const batchFn = T.batcher(100, executeFn)
|
|
|
|
// Create multiple concurrent requests
|
|
const promise1 = batchFn(1)
|
|
const promise2 = batchFn(2)
|
|
const promise3 = batchFn(3)
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
const results = await Promise.all([promise1, promise2, promise3])
|
|
|
|
expect(executeFn).toHaveBeenCalledTimes(1)
|
|
expect(executeFn).toHaveBeenCalledWith([1, 2, 3])
|
|
expect(results).toEqual([2, 4, 6])
|
|
})
|
|
|
|
it("should handle multiple batch windows", async () => {
|
|
const executeFn = vi.fn(async (requests: number[]) => requests.map(x => x * 2))
|
|
|
|
const batchFn = T.batcher(100, executeFn)
|
|
|
|
// First batch
|
|
const batch1Promise = Promise.all([batchFn(1), batchFn(2)])
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
const batch1Results = await batch1Promise
|
|
|
|
// Second batch
|
|
const batch2Promise = Promise.all([batchFn(3), batchFn(4)])
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
const batch2Results = await batch2Promise
|
|
|
|
expect(executeFn).toHaveBeenCalledTimes(2)
|
|
expect(batch1Results).toEqual([2, 4])
|
|
expect(batch2Results).toEqual([6, 8])
|
|
})
|
|
|
|
it.skip("should throw error if execute returns wrong number of results", async () => {
|
|
const executeFn = vi.fn(
|
|
async (requests: number[]) => [requests[0] * 2], // Return fewer results than requests
|
|
)
|
|
|
|
const batchFn = T.batcher(100, executeFn)
|
|
|
|
const promise = Promise.all([batchFn(1), batchFn(2)])
|
|
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
|
|
await expect(promise).rejects.toMatch("Execute must return a result for each request")
|
|
})
|
|
})
|
|
|
|
describe("throttleWithValue", () => {
|
|
it("should return cached value between updates", async () => {
|
|
let counter = 0
|
|
const getValue = vi.fn(() => ++counter)
|
|
const throttledGet = T.throttleWithValue(100, getValue)
|
|
|
|
// First call should execute immediately
|
|
expect(throttledGet()).toBe(1)
|
|
expect(getValue).toHaveBeenCalledTimes(1)
|
|
|
|
// Subsequent calls within throttle window should return cached value
|
|
expect(throttledGet()).toBe(1)
|
|
expect(throttledGet()).toBe(1)
|
|
expect(getValue).toHaveBeenCalledTimes(1)
|
|
|
|
// After throttle window, should update value
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
// the previous 2 called will have been batched, and the next throttledGet increase the counter to 3
|
|
expect(throttledGet()).toBe(3)
|
|
expect(getValue).toHaveBeenCalledTimes(3)
|
|
})
|
|
|
|
it("should update value at most once per throttle window", async () => {
|
|
let counter = 0
|
|
const getValue = vi.fn(() => ++counter)
|
|
const throttledGet = T.throttleWithValue(100, getValue)
|
|
|
|
// Initial value
|
|
expect(throttledGet()).toBe(1)
|
|
|
|
// Multiple calls within window
|
|
for (let i = 0; i < 4; i++) {
|
|
throttledGet()
|
|
await vi.advanceTimersByTimeAsync(20) // 20ms each, still within 100ms window
|
|
}
|
|
|
|
expect(getValue).toHaveBeenCalledTimes(1)
|
|
|
|
// After window
|
|
await vi.advanceTimersByTimeAsync(100)
|
|
// the previous called will have been batched, and the next throttledGet increase the counter to 3
|
|
expect(throttledGet()).toBe(3)
|
|
expect(getValue).toHaveBeenCalledTimes(3)
|
|
})
|
|
|
|
it("should handle zero throttle time", () => {
|
|
let counter = 0
|
|
const getValue = vi.fn(() => ++counter)
|
|
const throttledGet = T.throttleWithValue(0, getValue)
|
|
|
|
// Should update on every call
|
|
expect(throttledGet()).toBe(1)
|
|
expect(throttledGet()).toBe(2)
|
|
expect(throttledGet()).toBe(3)
|
|
expect(getValue).toHaveBeenCalledTimes(3)
|
|
})
|
|
})
|
|
})
|
|
|
|
describe("Time Utilities", () => {
|
|
it("should handle time constants", () => {
|
|
expect(T.MINUTE).toBe(60)
|
|
expect(T.HOUR).toBe(60 * 60)
|
|
expect(T.DAY).toBe(24 * 60 * 60)
|
|
})
|
|
|
|
it("should handle time calculations", () => {
|
|
const timestamp = T.now()
|
|
expect(typeof timestamp).toBe("number")
|
|
expect(T.ms(1)).toBe(1000)
|
|
})
|
|
})
|
|
|
|
describe("String Operations", () => {
|
|
it("should handle URL formatting", () => {
|
|
expect(T.stripProtocol("https://example.com")).toBe("example.com")
|
|
expect(T.displayUrl("https://www.example.com/")).toBe("example.com")
|
|
expect(T.displayDomain("example.com/path")).toBe("example.com")
|
|
|
|
// @todo returns https
|
|
// expect(T.displayDomain("https://example.com/path")).toBe("example.com")
|
|
})
|
|
|
|
it("should handle string truncation", () => {
|
|
expect(T.ellipsize("hello world", 5)).toBe("hello...")
|
|
expect(T.ellipsize("hi", 5)).toBe("hi")
|
|
})
|
|
})
|
|
|
|
describe("Collection Operations", () => {
|
|
it("should handle group operations", () => {
|
|
const items = [
|
|
{type: "a", val: 1},
|
|
{type: "a", val: 2},
|
|
{type: "b", val: 3},
|
|
]
|
|
const grouped = T.groupBy(x => x.type, items)
|
|
expect(grouped.get("a")?.length).toBe(2)
|
|
expect(grouped.get("b")?.length).toBe(1)
|
|
})
|
|
|
|
it("should handle indexing", () => {
|
|
const items = [
|
|
{id: 1, val: "a"},
|
|
{id: 2, val: "b"},
|
|
]
|
|
const indexed = T.indexBy(x => x.id, items)
|
|
expect(indexed.get(1)?.val).toBe("a")
|
|
})
|
|
})
|
|
|
|
describe("Type Checking", () => {
|
|
it("should identify plain objects", () => {
|
|
expect(T.isPojo({})).toBe(true)
|
|
expect(T.isPojo([])).toBe(false)
|
|
expect(T.isPojo(null)).toBe(false)
|
|
expect(T.isPojo(new Date())).toBe(false)
|
|
})
|
|
|
|
it("should handle deep equality", () => {
|
|
expect(T.equals({a: 1}, {a: 1})).toBe(true)
|
|
expect(T.equals({a: 1}, {a: 2})).toBe(false)
|
|
expect(T.equals([1, 2], [1, 2])).toBe(true)
|
|
expect(T.equals(new Set([1, 2]), new Set([1, 2]))).toBe(true)
|
|
})
|
|
})
|
|
})
|