comq 0.9.0 → 0.10.1

package/source/attributes/lazy.test.js

@@ -0,0 +1,299 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { timeout } = require('@toa.io/generic')
+
+const { lazy } = require('./lazy')
+
+it('should be', async () => {
+  expect(lazy).toBeDefined()
+})
+
+// noinspection JSValidateTypes
+/** @type {jest.MockedFn<(...args: any[]) => Promise<void>>} */
+const action = jest.fn(async () => undefined)
+
+// noinspection JSValidateTypes
+/** @type {jest.MockedFn<(...args: any[]) => Promise<void>>} */
+const initialize = jest.fn(async () => undefined)
+
+const value = generate()
+
+class LazyInitialized {
+  log = []
+
+  action = lazy(this, this.#initialize, this.#action)
+
+  async #initialize () {
+    await timeout(1)
+    await initialize()
+    this.log.push('initializer')
+  }
+
+  async #action (...args) {
+    await action(...args)
+    this.log.push('action')
+
+    return value
+  }
+}
+
+let instance
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  instance = new LazyInitialized()
+})
+
+it('should call initializer before action', async () => {
+  await instance.action()
+
+  expect(instance.log).toStrictEqual(['initializer', 'action'])
+})
+
+it('should pass arguments to action', async () => {
+  const args = [generate(), generate()]
+
+  await instance.action(...args)
+
+  expect(action).toHaveBeenCalledWith(...args)
+})
+
+it('should return value', async () => {
+  const output = await instance.action()
+
+  expect(output).toStrictEqual(value)
+})
+
+it('should call initializer once', async () => {
+  await instance.action()
+  await instance.action()
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+  expect(instance.log).toStrictEqual(['initializer', 'action', 'action'])
+})
+
+it('should call initializer once on concurrent calls', async () => {
+  await Promise.all([instance.action(), instance.action()])
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+  expect(instance.log).toStrictEqual(['initializer', 'action', 'action'])
+})
+
+it('should call initializer once per instance', async () => {
+  const instance2 = new LazyInitialized()
+
+  await instance.action()
+  await instance2.action()
+
+  expect(initialize).toHaveBeenCalledTimes(2)
+})
+
+// noinspection JSValidateTypes
+/** @type {jest.MockedFn<(...args: any[]) => Promise<void>>} */
+const initialize2 = jest.fn(async () => undefined)
+
+class InitializerSet {
+  action = lazy(this, [this.#initialize1, this.#initialize2], this.#action)
+
+  async #action () {
+
+  }
+
+  async #initialize1 () {
+    await initialize()
+  }
+
+  async #initialize2 () {
+    await initialize2()
+  }
+}
+
+it('should run list of initializers', async () => {
+  const instance = new InitializerSet()
+
+  await instance.action()
+
+  expect(initialize).toHaveBeenCalled()
+  expect(initialize2).toHaveBeenCalled()
+})
+
+class InitializerIntersection {
+  do = lazy(this, [this.#initialize1, this.#initialize2], this.#do)
+
+  undo = lazy(this, this.#initialize2, this.#undo)
+
+  async #do () {
+
+  }
+
+  async #undo () {
+
+  }
+
+  async #initialize1 () {
+    await initialize()
+  }
+
+  async #initialize2 () {
+    await initialize2()
+  }
+}
+
+it('should call intersecting initializers once', async () => {
+  jest.clearAllMocks()
+
+  const instance = new InitializerIntersection()
+
+  await instance.do()
+  await instance.undo()
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+  expect(initialize2).toHaveBeenCalledTimes(1)
+})
+
+it('should call intersecting concurrent initializers once', async () => {
+  jest.clearAllMocks()
+
+  const instance = new InitializerIntersection()
+
+  await Promise.all([instance.do(), instance.undo()])
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+  expect(initialize2).toHaveBeenCalledTimes(1)
+})
+
+class InitializersWithArguments {
+  do = lazy(this, [this.#initialize1, this.#initialize2], this.#do)
+
+  async #do (a, b, c) {}
+
+  async #initialize1 () {
+    await initialize(arguments)
+  }
+
+  async #initialize2 (a, b) {
+    await initialize2(arguments)
+  }
+}
+
+it('should pass arguments to initializers if expected', async () => {
+  jest.clearAllMocks()
+
+  const instance = new InitializersWithArguments()
+
+  await instance.do(1, 2, 3)
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+
+  const args = initialize.mock.calls[0][0]
+
+  expect(args.length).toStrictEqual(0)
+
+  expect(initialize2).toHaveBeenCalledTimes(1)
+
+  const args2 = initialize2.mock.calls[0][0]
+
+  expect(args2.length).toStrictEqual(2)
+})
+
+it('should call conditions with different argument values', async () => {
+  jest.clearAllMocks()
+
+  const instance = new InitializersWithArguments()
+
+  await instance.do(1, 2, 3)
+  await instance.do(1, 2)
+  await instance.do(2, 2)
+
+  expect(initialize).toHaveBeenCalledTimes(1)
+  expect(initialize2).toHaveBeenCalledTimes(2)
+})
+
+class OrderedInitializers {
+  log = []
+
+  do = lazy(this, [this.#initialize1, this.#initialize2], async () => undefined)
+
+  async #initialize1 () {
+    await timeout(1)
+    this.log.push(1)
+  }
+
+  async #initialize2 (_0, _1) {
+    this.log.push(2)
+  }
+}
+
+it('should call initializers sequentially', async () => {
+  const instance = new OrderedInitializers()
+
+  await instance.do()
+
+  expect(instance.log).toStrictEqual([1, 2])
+})
+
+it('should override argument values', async () => {
+  const method = /** @type {Function} */ jest.fn()
+
+  class Test {
+    do = lazy(this, this.#update, method)
+
+    #update (foo, bar) {
+      return [foo + ' updated', bar + ' updated']
+    }
+  }
+
+  const test = new Test()
+  const foo = generate()
+  const bar = generate()
+
+  await test.do(foo, bar)
+
+  expect(method).toHaveBeenCalledWith(foo + ' updated', bar + ' updated')
+})
+
+it('should partially override argument values', async () => {
+  const method = /** @type {Function} */ jest.fn()
+
+  class Test {
+    do = lazy(this, this.#update, method)
+
+    #update (foo, _) {
+      return [foo + ' updated']
+    }
+  }
+
+  const test = new Test()
+  const foo = generate()
+  const bar = generate()
+
+  await test.do(foo, bar)
+
+  expect(method).toHaveBeenCalledWith(foo + ' updated', bar)
+})
+
+describe('reset', () => {
+  it('should be', async () => {
+    expect(lazy.reset).toBeDefined()
+  })
+
+  it('should reset initialization', async () => {
+    const instance = new InitializerIntersection()
+
+    await instance.do()
+    await instance.undo()
+
+    expect(initialize).toHaveBeenCalledTimes(1)
+    expect(initialize2).toHaveBeenCalledTimes(1)
+
+    lazy.reset(instance)
+
+    await instance.do()
+    await instance.undo()
+
+    expect(initialize).toHaveBeenCalledTimes(2)
+    expect(initialize2).toHaveBeenCalledTimes(2)
+  })
+})

package/source/attributes/memo.js

@@ -0,0 +1,13 @@
+'use strict'
+
+function memo (fn) {
+  return (...args) => {
+    if (fn[MEMO] === undefined) fn[MEMO] = fn(...args)
+
+    return fn[MEMO]
+  }
+}
+
+const MEMO = Symbol('memo')
+
+exports.memo = memo

package/source/attributes/memo.test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const { memo } = require('./memo')
+
+let fn
+let memoized
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  fn = jest.fn(() => Math.random())
+  memoized = memo(fn)
+})
+
+it('should return value', async () => {
+  const value = memoized()
+
+  expect(value).toBe(fn.mock.results[0].value)
+})
+
+it('should pass arguments', async () => {
+  const args = [1, 2, 3]
+
+  memoized(...args)
+
+  expect(fn).toHaveBeenCalledWith(...args)
+})
+
+it('should memoize value', async () => {
+  const one = memoized()
+  const two = memoized()
+
+  expect(fn).toHaveBeenCalledTimes(1)
+  expect(one).toBe(fn.mock.results[0].value)
+  expect(two).toBe(fn.mock.results[0].value)
+})

package/source/attributes/recall.js

@@ -0,0 +1,42 @@
+'use strict'
+
+function recall (context, method = undefined) {
+  if (method === undefined) return replay(context)
+  else return recorder(context, method)
+}
+
+const recorder = (context, method) => async function (...args) {
+  if (context[METHODS] === undefined) context[METHODS] = []
+
+  if (method[CALLS] === undefined) {
+    context[METHODS].push(method)
+    method[CALLS] = []
+  }
+
+  const result = await method.apply(context, args)
+
+  method[CALLS].push(args)
+
+  return result
+}
+
+async function replay (context) {
+  if (context[METHODS] === undefined) return
+
+  const promises = []
+
+  for (const method of context[METHODS]) {
+    for (const args of method[CALLS]) {
+      const promise = method.apply(context, args)
+
+      promises.push(promise)
+    }
+  }
+
+  await Promise.all(promises)
+}
+
+const METHODS = Symbol('context methods')
+const CALLS = Symbol('method calls')
+
+exports.recall = recall

package/source/attributes/recall.test.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { recall } = require('./recall')
+
+it('should be', async () => {
+  expect(recall).toBeDefined()
+})
+
+const context = { foo: generate() }
+
+/** @type {jest.MockedFn<(...args: any[]) => any>} */
+let method
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  method = /** @type {jest.MockedFn<(...args: any[]) => any>} */
+    jest.fn(function () { return this.foo })
+})
+
+it('should return function', async () => {
+  const func = recall(context, method)
+
+  expect(func).toBeInstanceOf(Function)
+})
+
+it('should return result', async () => {
+  const func = recall(context, method)
+  const output = await func()
+
+  expect(output).toStrictEqual(await method.mock.results[0].value)
+})
+
+it('should call method within the context', async () => {
+  const func = recall(context, method)
+  const output = await func()
+
+  expect(output).toStrictEqual(context.foo)
+})
+
+it('should pass arguments', async () => {
+  const args = [generate(), generate()]
+  const func = recall(context, method)
+
+  await func(...args)
+
+  expect(method).toHaveBeenCalledWith(...args)
+})
+
+it('should re-call', async () => {
+  const args1 = [generate(), generate()]
+  const args2 = [generate(), generate(), generate()]
+  const func = recall(context, method)
+
+  await func(...args1)
+  await func(...args2)
+
+  method.mockClear()
+
+  expect(method).not.toHaveBeenCalled()
+
+  await recall(context)
+
+  expect(method).toHaveBeenCalledWith(...args1)
+  expect(method).toHaveBeenCalledWith(...args2)
+})
+
+it('should not trow on empty re-call', async () => {
+  await expect(recall(context)).resolves.not.toThrow()
+})
+
+it('should not re-call those thrown exceptions', async () => {
+  expect.assertions(2)
+
+  method.mockImplementationOnce(async () => 1)
+  method.mockImplementationOnce(async () => { throw new Error() })
+
+  const func = recall(context, method)
+
+  await func()
+
+  try {
+    await func()
+  } catch (e) {
+    expect(e).toBeDefined()
+  }
+
+  await recall(context)
+
+  expect(method).toHaveBeenCalledTimes(3)
+})

package/source/attributes/track.js

@@ -0,0 +1,32 @@
+'use strict'
+
+function track (context, method = undefined) {
+  if (method === undefined) return promises(context)
+
+  context[KEY] ??= new Set()
+
+  const tracking = context[KEY]
+
+  return async function (...args) {
+    const promise = method.apply(this, args)
+
+    tracking.add(promise)
+    promise.catch(noop).finally(() => tracking.delete(promise))
+
+    return promise
+  }
+}
+
+function promises (context) {
+  if (context[KEY] === undefined) return
+
+  const promises = context[KEY]
+
+  return Promise.all(promises)
+}
+
+const KEY = Symbol('context tracking key')
+
+const noop = () => undefined
+
+exports.track = track

package/source/attributes/track.test.js

@@ -0,0 +1,133 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { promex } = require('@toa.io/generic')
+
+const { track } = require('./track')
+
+it('should be', async () => {
+  expect(track).toBeDefined()
+})
+
+let done
+let undone
+
+const method1 = /** @type {jest.MockedFn<(a: string, b: string) => Promise>} */
+  jest.fn(async function () {
+    // should execute in context
+    expect(this.ok).toStrictEqual(1)
+
+    return done
+  })
+
+const method2 = /** @type {jest.MockedFn<(a: string, b: string) => Promise>} */
+  jest.fn(async function () { return undone })
+
+class Test {
+  ok = 1
+  do = track(this, method1)
+  undo = track(this, method2)
+}
+
+/** @type {Test} */
+let test
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  done = promex()
+  undone = promex()
+  test = new Test()
+})
+
+it('should return function', async () => {
+  expect(test.do).toBeInstanceOf(Function)
+})
+
+it('should execute method', async () => {
+  const result = generate()
+
+  done.resolve(result)
+
+  const args = [generate(), generate()]
+
+  const output = await test.do(...args)
+
+  expect(method1).toHaveBeenCalledWith(...args)
+  expect(output).toStrictEqual(result)
+})
+
+it('should track method execution', async () => {
+  expect.assertions(2)
+
+  setImmediate(async () => {
+    setImmediate(() => {
+      done.resolve()
+
+      expect(finished).toStrictEqual(false)
+
+      setImmediate(() => {
+        expect(finished).toStrictEqual(true)
+      })
+    })
+
+    let finished = false
+
+    await track(test)
+
+    finished = true
+  })
+
+  await test.do()
+})
+
+it('should track multiple methods', async () => {
+  expect.assertions(3 + 1) // + method1
+
+  setImmediate(async () => {
+    setImmediate(() => {
+      done.resolve()
+
+      expect(finished).toStrictEqual(false)
+
+      setImmediate(() => {
+        undone.resolve()
+
+        expect(finished).toStrictEqual(false)
+        setImmediate(() => expect(finished).toStrictEqual(true))
+      })
+    })
+
+    let finished = false
+
+    await track(test)
+
+    finished = true
+  })
+
+  await Promise.all([test.do(), test.undo()])
+})
+
+it('should resolve if methods haven\'t been called', async () => {
+  await track(this)
+})
+
+it('should handle exceptions', async () => {
+  expect.assertions(2)
+
+  const exception = new Error(generate())
+
+  class Bad {
+    do = track(this, async () => { throw exception })
+  }
+
+  const b = new Bad()
+
+  try {
+    await b.do()
+  } catch (e) {
+    expect(e).toStrictEqual(exception)
+  }
+
+  await expect(track(b)).resolves.not.toThrow()
+})