mybase 1.1.51 → 1.2.2

package/mybase.test.ts

@@ -0,0 +1,647 @@
+// @ts-nocheck — jest mocks stay loosely typed; assertions are unchanged
+//#region imports
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import * as net from 'net'
+import { afterEach, describe, expect, it, jest } from '@jest/globals'
+import type { AddressInfo } from 'net'
+//#endregion
+
+jest.mock('@maxmind/geoip2-node', () => ({
+  Reader: {
+    open: jest.fn().mockImplementation((..._args: unknown[]) =>
+      Promise.resolve({ kind: 'mock-reader' })
+    ),
+  },
+}), { virtual: true })
+
+jest.mock('ip-range-check', () => {
+  const fn = jest.requireActual('ip-range-check')
+  return { __esModule: true, default: fn }
+})
+
+//#region module under test
+import {
+  encryptAES_CBC_NOIV,
+  decryptAES_CBC_NOIV,
+  ip2int,
+  int2ip,
+  canReadAndWrite,
+  softexit,
+  randomString,
+  randomBase32,
+  randomAuthcode,
+  validAuthcode,
+  vaultRead,
+  vaultFill,
+  isLocal,
+  isObject,
+  maxmindOpen,
+  validHPassword,
+  validEmail,
+  validHostname,
+  validHostname2,
+  validIp,
+  validIpNative,
+  validUUID4,
+  getTemp,
+  getMysql,
+  sqlQuery,
+  validURL,
+  randomIP,
+  wait,
+  validTime,
+  removeDoubleSlashes,
+  array_shuffle,
+  object_shuffle,
+  isMochaRunning,
+  portCheck_tcp,
+  asJSON,
+  ensureProperty,
+  arrayRandomItem,
+  promiseTimeout,
+  utcnow,
+  Geoip2Paths,
+  randomHPassword,
+  isURL,
+  hash_sha512,
+  isReservedLANIP,
+  isLANIp,
+  isLoopbackIP,
+  MaxRuntimeHours,
+} from './mybase.js'
+//#endregion
+
+
+describe('mybase', () => {
+  afterEach(() => {
+    jest.restoreAllMocks()
+    jest.clearAllMocks()
+    jest.useRealTimers()
+  })
+
+  describe('hash_sha512', () => {
+    it('hashes strings', () => {
+      const h = hash_sha512('x') as string
+      expect(h).toHaveLength(128)
+      expect(/^[a-f0-9]+$/i.test(h)).toBe(true)
+    })
+    it('returns false for non-string', () => {
+      expect(hash_sha512(null as unknown as string)).toBe(false)
+      expect(hash_sha512(1 as unknown as string)).toBe(false)
+    })
+  })
+
+  describe('isLoopbackIP / isLANIp', () => {
+    it('isLoopbackIP handles loopback and rejects invalid', () => {
+      expect(isLoopbackIP('127.0.0.1')).toBe(true)
+      expect(isLoopbackIP('::1')).toBe(true)
+      expect(isLoopbackIP('::ffff:127.0.0.1')).toBe(true)
+      expect(isLoopbackIP('8.8.8.8')).toBeNull()
+      expect(isLoopbackIP('not-an-ip')).toBe(false)
+    })
+    it('isLANIp handles private ranges', () => {
+      expect(isLANIp('10.0.0.1')).toBe(true)
+      expect(isLANIp('192.168.1.1')).toBe(true)
+      expect(isLANIp('8.8.8.8')).toBeNull()
+      expect(isLANIp('bad')).toBe(false)
+    })
+  })
+
+  describe('validHPassword / randomHPassword', () => {
+    it('validates 128-char hex', () => {
+      expect(validHPassword('')).toBeFalsy()
+      expect(validHPassword('ab')).toBe(false)
+      const good = 'a'.repeat(128)
+      expect(validHPassword(good)).toBe(true)
+      expect(validHPassword('g'.repeat(128))).toBe(false)
+    })
+    it('randomHPassword returns valid hash', () => {
+      const h = randomHPassword(8)
+      expect(validHPassword(h)).toBe(true)
+    })
+  })
+
+  describe('validEmail', () => {
+    it('validates via validator', () => {
+      expect(validEmail('a@b.co')).toBe(true)
+      expect(validEmail('not-email')).toBe(false)
+      expect(validEmail(null as unknown as string)).toBe(false)
+    })
+  })
+
+  describe('arrayRandomItem', () => {
+    it('picks from array or returns default', () => {
+      jest.spyOn(Math, 'random').mockReturnValue(0.99)
+      expect(arrayRandomItem([1, 2, 3], 'd')).toBe(3)
+      expect(arrayRandomItem('nope' as unknown as unknown[], 'd')).toBe('d')
+    })
+  })
+
+  describe('utcnow', () => {
+    it('returns unix seconds', () => {
+      jest.spyOn(Date, 'now').mockReturnValue(1_700_000_000_123)
+      expect(utcnow()).toBe(1_700_000_000)
+    })
+  })
+
+  describe('validIp (deprecated)', () => {
+    it('matches dotted quads and warns', () => {
+      const spy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      expect(validIp('192.168.0.1')).toBe(true)
+      expect(validIp('999.1.1.1')).toBe(false)
+      expect(validIp(null as unknown as string)).toBe(false)
+      expect(spy).toHaveBeenCalled()
+      spy.mockRestore()
+    })
+  })
+
+  describe('Geoip2Paths', () => {
+    it('returns path map with boolean or string entries', () => {
+      const paths = Geoip2Paths()
+      expect(paths).toEqual(
+        expect.objectContaining({
+          country: expect.anything(),
+          city: expect.anything(),
+          isp: expect.anything(),
+          ct: expect.anything(),
+        })
+      )
+    })
+  })
+
+  describe('validIpNative / randomIP / int2ip / ip2int', () => {
+    it('validIpNative uses net.isIP', () => {
+      expect(validIpNative('1.1.1.1')).toBe(true)
+      expect(validIpNative('::1')).toBe(true)
+      expect(validIpNative('nope')).toBe(false)
+    })
+    it('randomIP returns dotted quad', () => {
+      expect(randomIP()).toMatch(/^\d+\.\d+\.\d+\.\d+$/)
+    })
+    it('int2ip / ip2int roundtrip for sample', () => {
+      const ip = '10.20.30.40'
+      expect(int2ip(ip2int(ip))).toBe(ip)
+    })
+  })
+
+  describe('isURL', () => {
+    it('parses valid URL strings', () => {
+      const u = isURL('https://example.com/path') as URL
+      expect(u.hostname).toBe('example.com')
+      expect(isURL(1 as unknown as string)).toBe(false)
+      expect(isURL('not a url')).toBe(false)
+    })
+  })
+
+  describe('validTime', () => {
+    it('accepts 10-digit positive unix time', () => {
+      expect(validTime('1234567890')).toBe(1234567890)
+      expect(validTime('123')).toBe(false)
+      expect(validTime('')).toBe(false)
+    })
+  })
+
+  describe('validURL', () => {
+    it('delegates to @7c/validurl', () => {
+      expect(validURL('https://example.com')).toBe(true)
+      expect(validURL('')).toBe(false)
+    })
+  })
+
+  describe('asJSON', () => {
+    it('parses or returns false', () => {
+      expect(asJSON('{"a":1}')).toEqual({ a: 1 })
+      expect(asJSON('')).toBe(false)
+      expect(asJSON(null as unknown as string)).toBe(false)
+      expect(asJSON('{bad')).toBe(false)
+    })
+  })
+
+  describe('isObject', () => {
+    it('plain objects only', () => {
+      expect(isObject({})).toBe(true)
+      expect(isObject(null)).toBe(false)
+      expect(isObject([])).toBe(false)
+    })
+  })
+
+  describe('getMysql', () => {
+    it('resolves client on connect success with keep_pinging', async () => {
+      jest.useFakeTimers()
+      const ping = jest.fn((cb: (e: Error | null) => void) => cb(null))
+      const client = {
+        ping,
+        connect: jest.fn((cb: (e: Error | null) => void) => cb(null)),
+      }
+      const mysqlClass = { createConnection: jest.fn(() => client) }
+      const p = getMysql(mysqlClass as never, {
+        host: 'h',
+        login: 'u',
+        password: 'p',
+        db: 'd',
+      }, true)
+      const c = await p
+      expect(c).toBe(client)
+      jest.advanceTimersByTime(30_000)
+      await Promise.resolve()
+      expect(ping).toHaveBeenCalled()
+    })
+    it('rejects on connect error', async () => {
+      const client = {
+        ping: jest.fn(),
+        connect: jest.fn((cb: (e: Error | null) => void) => cb(new Error('e'))),
+      }
+      const mysqlClass = { createConnection: jest.fn(() => client) }
+      await expect(getMysql(mysqlClass as never, {
+        host: 'h',
+        login: 'u',
+        password: 'p',
+        db: 'd',
+      }, false)).rejects.toThrow('e')
+    })
+    it('omit keep_pinging skips interval', async () => {
+      jest.useFakeTimers()
+      const ping = jest.fn()
+      const client = {
+        ping,
+        connect: jest.fn((cb: (e: Error | null) => void) => cb(null)),
+      }
+      const mysqlClass = { createConnection: jest.fn(() => client) }
+      await getMysql(mysqlClass as never, {
+        host: 'h',
+        port: 3307,
+        login: 'u',
+        password: 'p',
+        db: 'd',
+      }, false)
+      jest.advanceTimersByTime(60_000)
+      expect(ping).not.toHaveBeenCalled()
+    })
+    it('pinger logs when ping returns error', async () => {
+      jest.useFakeTimers()
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      const ping = jest.fn((cb: (e: Error | null) => void) => cb(Object.assign(new Error('p'), { code: 'PROTO' })))
+      const client = {
+        ping,
+        connect: jest.fn((cb: (e: Error | null) => void) => cb(null)),
+      }
+      const mysqlClass = { createConnection: jest.fn(() => client) }
+      await getMysql(mysqlClass as never, {
+        host: 'h',
+        login: 'u',
+        password: 'p',
+        db: 'd',
+      }, true)
+      jest.advanceTimersByTime(30_000)
+      expect(logSpy.mock.calls.some((c) => String(c[0]).includes('could not ping mysql'))).toBe(true)
+      logSpy.mockRestore()
+    })
+  })
+
+  describe('fileCacheIsValid (via vaultRead)', () => {
+    it('uses fresh cache when file recent', async () => {
+      const vault = { read: jest.fn() }
+      const key = `__cache_hit_${randomString(8)}__`
+      const cacheKey = path.join('/var/tmp/vault-cache', hash_sha512(`undefined/${key}`) as string)
+      fs.mkdirSync(path.dirname(cacheKey), { recursive: true })
+      fs.writeFileSync(cacheKey, JSON.stringify({ ok: true }))
+      const recent = new Date()
+      fs.utimesSync(cacheKey, recent, recent)
+      const data = await vaultRead(vault as never, key, 60)
+      expect(data).toEqual({ ok: true })
+      expect(vault.read).not.toHaveBeenCalled()
+      fs.unlinkSync(cacheKey)
+    })
+  })
+
+  describe('vaultRead', () => {
+    it('resolves vault data and can write cache', async () => {
+      const key = `__vault_ok_${randomString(8)}__`
+      const vault = {
+        read: jest.fn().mockResolvedValue({ data: { secret: 1 } }),
+      }
+      const data = await vaultRead(vault as never, key, 0)
+      expect(data).toEqual({ secret: 1 })
+      expect(vault.read).toHaveBeenCalledWith(key)
+    })
+    it('rejects when no data', async () => {
+      const vault = { read: jest.fn().mockResolvedValue({}) }
+      await expect(vaultRead(vault as never, 'k', 0)).rejects.toEqual({})
+    })
+    it('on error falls back to cache when present', async () => {
+      const key = `__vault_fb_${randomString(8)}__`
+      const payload = { from: 'cache' }
+      const cacheKey = path.join('/var/tmp/vault-cache', hash_sha512(`undefined/${key}`) as string)
+      fs.mkdirSync(path.dirname(cacheKey), { recursive: true })
+      fs.writeFileSync(cacheKey, JSON.stringify(payload))
+      const vault = { read: jest.fn().mockRejectedValue(new Error('network')) }
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      const data = await vaultRead(vault as never, key, 10)
+      expect(data).toEqual(payload)
+      logSpy.mockRestore()
+      fs.unlinkSync(cacheKey)
+    })
+    it('rejects when error and cache missing', async () => {
+      const vault = { read: jest.fn().mockRejectedValue(new Error('fail')) }
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      await expect(vaultRead(vault as never, `__missing_${randomString(8)}__`, 10)).rejects.toThrow('fail')
+      logSpy.mockRestore()
+    })
+    it('when error and cache file has invalid JSON, logs parse error and rejects', async () => {
+      const key = `__vault_badjson_${randomString(8)}__`
+      const cacheKey = path.join('/var/tmp/vault-cache', hash_sha512(`undefined/${key}`) as string)
+      fs.mkdirSync(path.dirname(cacheKey), { recursive: true })
+      fs.writeFileSync(cacheKey, 'not-json')
+      const vault = { read: jest.fn().mockRejectedValue(new Error('vault down')) }
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      await expect(vaultRead(vault as never, key, 0)).rejects.toThrow('vault down')
+      expect(logSpy.mock.calls.some((args) => String(args[0]).includes('not valid JSON') || String(args[0]).includes('SyntaxError'))).toBe(true)
+      logSpy.mockRestore()
+      fs.unlinkSync(cacheKey)
+    })
+  })
+
+  describe('vaultFill', () => {
+    it('replaces vault@ strings and nested objects', async () => {
+      const vault = {
+        read: jest.fn().mockImplementation((k: string) =>
+          Promise.resolve({ data: { v: k, __vaultkey: k, __vaultfilled: 1 } })
+        ),
+      }
+      const cfg = {
+        a: 'vault@secret/db',
+        nested: { __vaultkey: 'secret/db', x: 1 },
+      }
+      await vaultFill(vault as never, cfg, true, true)
+      expect(typeof cfg.a).toBe('object')
+      expect(cfg.nested).toHaveProperty('v', 'secret/db')
+    })
+    it('ignoreError stores false when read fails', async () => {
+      const vault = { read: jest.fn().mockRejectedValue(new Error('x')) }
+      const cfg = { a: 'vault@missing/key' }
+      await vaultFill(vault as never, cfg, false, false)
+      expect(cfg.a).toBe(false)
+    })
+    it('ignoreError true leaves vault@ value undefined when read fails', async () => {
+      const vault = { read: jest.fn().mockRejectedValue(new Error('x')) }
+      const cfg = { a: 'vault@bad/key' }
+      await vaultFill(vault as never, cfg, true, false)
+      expect(cfg.a).toBeUndefined()
+    })
+    it('keepCache false overwrites __vaultkey object even when result missing', async () => {
+      const vault = {
+        read: jest.fn().mockResolvedValue({ data: { z: 1 } }),
+      }
+      const cfg = { block: { __vaultkey: 'secret/x', keep: true } }
+      await vaultFill(vault as never, cfg, false, false)
+      expect(cfg.block).toMatchObject({ z: 1, __vaultkey: 'secret/x' })
+    })
+    it('fills vault@ strings nested in arrays', async () => {
+      const vault = {
+        read: jest.fn().mockResolvedValue({ data: { val: 99 } }),
+      }
+      const cfg = { items: ['vault@arr/key'] }
+      await vaultFill(vault as never, cfg, false, false)
+      expect(cfg.items[0]).toMatchObject({ val: 99, __vaultkey: 'arr/key' })
+    })
+  })
+
+  describe('maxmindOpen', () => {
+    it('resolves reader', async () => {
+      const r = await maxmindOpen('/tmp/fake.mmdb')
+      expect(r).toEqual({ kind: 'mock-reader' })
+    })
+    it('rejects when Reader.open rejects', async () => {
+      const geo = require('@maxmind/geoip2-node') as { Reader: { open: jest.Mock } }
+      geo.Reader.open.mockRejectedValueOnce(new Error('open-fail'))
+      await expect(maxmindOpen('/bad')).rejects.toThrow('open-fail')
+    })
+  })
+
+  describe('isLocal', () => {
+    it('is true iff os.type() is Darwin', () => {
+      expect(isLocal()).toBe(os.type() === 'Darwin')
+    })
+  })
+
+  describe('randomBase32', () => {
+    it('respects length', () => {
+      expect(randomBase32(4)).toHaveLength(4)
+    })
+  })
+
+  describe('validAuthcode / randomAuthcode', () => {
+    it('random passes validation', () => {
+      for (let i = 0; i < 20; i++) {
+        const code = randomAuthcode()
+        expect(validAuthcode(code)).toBe(true)
+      }
+    })
+    it('rejects malformed', () => {
+      expect(validAuthcode('')).toBe(false)
+      expect(validAuthcode('abcdefghijkl')).toBe(false)
+      expect(validAuthcode('x-xx-xx-xx-xx')).toBe(false)
+    })
+  })
+
+  describe('array_shuffle / object_shuffle', () => {
+    it('shuffles in place and object keys', () => {
+      jest.spyOn(Math, 'random').mockReturnValue(0.42)
+      const a = [1, 2, 3]
+      array_shuffle(a)
+      expect(a).toHaveLength(3)
+      const o = object_shuffle({ a: 1, b: 2 })
+      expect(Object.keys(o).sort()).toEqual(['a', 'b'])
+    })
+  })
+
+  describe('randomString', () => {
+    it('default charset length', () => {
+      expect(randomString(5)).toHaveLength(5)
+    })
+  })
+
+  describe('canReadAndWrite', () => {
+    it('resolves when directory rw', async () => {
+      const dir = path.join(os.tmpdir(), `rw_${randomString(6)}`)
+      await expect(canReadAndWrite(dir)).resolves.toBe(true)
+      fs.rmSync(dir, { recursive: true, force: true })
+    })
+    it('creates directory when missing (ENOENT)', async () => {
+      const dir = path.join(os.tmpdir(), `rw_new_${randomString(10)}`)
+      expect(fs.existsSync(dir)).toBe(false)
+      await expect(canReadAndWrite(dir)).resolves.toBe(true)
+      expect(fs.existsSync(dir)).toBe(true)
+      fs.rmSync(dir, { recursive: true, force: true })
+    })
+  })
+
+  describe('softexit', () => {
+    it('schedules process.exit', () => {
+      jest.useFakeTimers()
+      const exit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never)
+      const log = jest.spyOn(console, 'log').mockImplementation(() => {})
+      softexit('bye', 2, 3)
+      jest.advanceTimersByTime(2000)
+      expect(exit).toHaveBeenCalledWith(3)
+      log.mockRestore()
+      exit.mockRestore()
+    })
+  })
+
+  describe('validHostname', () => {
+    it('valid labels', () => {
+      expect(validHostname('a.b.com')).toBe(true)
+      expect(validHostname('')).toBe(false)
+      expect(validHostname('a'.repeat(300))).toBe(false)
+    })
+    it('accepts hostname with trailing dot (strips for label check)', () => {
+      expect(validHostname('example.com.')).toBe(true)
+    })
+  })
+
+  describe('validHostname2', () => {
+    it('allows IPs and hostnames', () => {
+      expect(validHostname2('1.2.3.4')).toBe(true)
+      expect(validHostname2('[::1]')).toBe(true)
+      expect(validHostname2('42')).toBe(false)
+      expect(validHostname2('12345')).toBe(false)
+      expect(validHostname2('')).toBe(false)
+    })
+  })
+
+  describe('removeDoubleSlashes', () => {
+    it('collapses path slashes', () => {
+      expect(removeDoubleSlashes('http://host//a//b')).toBe('http://host/a/b')
+      expect(removeDoubleSlashes(1 as unknown as string)).toBe(false)
+    })
+  })
+
+  describe('getTemp', () => {
+    it('returns tmpdir and joins filename', () => {
+      const t = getTemp()
+      expect(typeof t).toBe('string')
+      expect(getTemp('x.txt')).toBe(path.join(t, 'x.txt'))
+    })
+  })
+
+  describe('sqlQuery', () => {
+    it('resolves rows', async () => {
+      const res = { rows: [] }
+      const handle = {
+        query: jest.fn((q: string, v: unknown[], cb: (e: Error | null, r: unknown) => void) => cb(null, res)),
+      }
+      await expect(sqlQuery(handle as never, 'SELECT 1', [])).resolves.toBe(res)
+    })
+    it('rejects on error', async () => {
+      const handle = {
+        query: jest.fn((_q: string, _v: unknown[], cb: (e: Error | null) => void) => cb(new Error('sql'))),
+      }
+      await expect(sqlQuery(handle as never, 'x', [])).rejects.toThrow('sql')
+    })
+  })
+
+  describe('wait', () => {
+    it('delays', async () => {
+      jest.useFakeTimers()
+      const p = wait(0.01)
+      jest.advanceTimersByTime(20)
+      await p
+    })
+  })
+
+  describe('isMochaRunning', () => {
+    it('returns boolean', () => {
+      expect(typeof isMochaRunning()).toBe('boolean')
+    })
+  })
+
+  describe('validUUID4', () => {
+    it('v4 pattern', () => {
+      expect(validUUID4('550e8400-e29b-41d4-a716-446655440000')).toBe(true)
+      expect(validUUID4('550e8400-e29b-31d4-a716-446655440000')).toBe(false)
+    })
+  })
+
+  describe('promiseTimeout', () => {
+    it('times out', async () => {
+      await expect(promiseTimeout(5, new Promise(() => {}))).rejects.toBe('TIMEDOUT')
+    })
+    it('resolves fast promise', async () => {
+      await expect(promiseTimeout(1000, Promise.resolve('ok'))).resolves.toBe('ok')
+    })
+  })
+
+  describe('portCheck_tcp', () => {
+    it('true when port accepts', async () => {
+      const srv = net.createServer()
+      await new Promise<void>((resolve) => srv.listen(0, '127.0.0.1', resolve))
+      const addr = srv.address() as AddressInfo
+      const ok = await portCheck_tcp(addr.port, { host: '127.0.0.1', timeout: 2000 })
+      expect(ok).toBe(true)
+      await new Promise<void>((resolve) => srv.close(() => resolve()))
+    })
+    it('false when connection fails', async () => {
+      const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+      const closed = await portCheck_tcp(43_321, { host: '127.0.0.1', timeout: 200 })
+      expect(closed).toBe(false)
+      logSpy.mockRestore()
+    })
+  })
+
+  describe('ensureProperty', () => {
+    it('walks dotted path', () => {
+      const o = { a: { b: { c: 7 } } }
+      expect(ensureProperty(o, 'a.b.c', 0)).toBe(7)
+      expect(ensureProperty(o, 'a.b.missing', 9)).toBe(9)
+    })
+  })
+
+  describe('AES', () => {
+    it('roundtrips', () => {
+      const key = '0123456789abcdef'
+      const plain = 'hello'
+      const enc = encryptAES_CBC_NOIV(plain, key) as string
+      expect(decryptAES_CBC_NOIV(enc, key)).toBe(plain)
+    })
+    it('errors return false', () => {
+      expect(encryptAES_CBC_NOIV('x', 'short')).toBe(false)
+      expect(decryptAES_CBC_NOIV('zz', '0123456789abcdef')).toBe(false)
+    })
+  })
+
+  describe('MaxRuntimeHours', () => {
+    it('exits after delay', () => {
+      jest.useFakeTimers()
+      const exit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never)
+      const log = jest.spyOn(console, 'log').mockImplementation(() => {})
+      MaxRuntimeHours(0.000_001)
+      jest.advanceTimersByTime(10)
+      expect(exit).toHaveBeenCalledWith(0)
+      log.mockRestore()
+      exit.mockRestore()
+    })
+  })
+
+  describe('isReservedLANIP', () => {
+    it('detects reserved IPv4', () => {
+      expect(isReservedLANIP('10.0.0.1')).toBe(true)
+      expect(isReservedLANIP('8.8.8.8')).toBe(false)
+    })
+    it('handles IPv6 with ip6.normalize', () => {
+      expect(isReservedLANIP('fd00::1')).toBe(true)
+    })
+  })
+
+  describe('Date.prototype.yyyymmdd (side effect)', () => {
+    it('formats local calendar date', () => {
+      const d = new Date(2024, 0, 5, 12, 0, 0)
+      const y = d.getFullYear()
+      const m = `${d.getMonth() + 1}`.padStart(2, '0')
+      const day = `${d.getDate()}`.padStart(2, '0')
+      expect((d as Date & { yyyymmdd(): string }).yyyymmdd()).toBe(`${y}${m}${day}`)
+    })
+  })
+})