opticedge-cloud-utils 1.1.13 → 1.1.15

package/tests/db/mongo3.test.ts

@@ -1,149 +1,149 @@
-import {
-  connectToMongo3,
-  getDb3,
-  getCollection3,
-  __mongoClients,
-  __connectPromises,
-  connectToMongoWithUri3
-} from '../../src/db/mongo3'
-import { MongoClient, Db } from 'mongodb'
-import * as secretsModule from '../../src/secrets'
-
-jest.mock('mongodb')
-jest.mock('../../src/secrets')
-
-const mockDb = {
-  collection: jest.fn()
-} as unknown as Db
-
-const mockConnect = jest.fn()
-const mockClient = {
-  connect: mockConnect,
-  db: jest.fn().mockReturnValue(mockDb)
-} as unknown as MongoClient
-
-beforeEach(() => {
-  jest.clearAllMocks()
-  __mongoClients.clear()
-  __connectPromises.clear()
-  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
-  ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
-})
-
-describe('MongoClientManager (multi-cluster)', () => {
-  const clusterASecret = 'clusterA-uri-secret'
-  const clusterBSecret = 'clusterB-uri-secret'
-
-  it('should connect and cache client for a single cluster', async () => {
-    await connectToMongo3('test-project', clusterASecret)
-
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
-    expect(mockConnect).toHaveBeenCalled()
-
-    const db = getDb3(clusterASecret, 'test-db')
-    expect(mockClient.db).toHaveBeenCalledWith('test-db')
-    expect(db).toBe(mockDb)
-  })
-
-  it('should reuse client if already connected', async () => {
-    await connectToMongo3('test-project', clusterASecret)
-    await connectToMongo3('test-project', clusterASecret)
-
-    // getSecret and connect should only happen once
-    expect(secretsModule.getSecret).toHaveBeenCalledTimes(1)
-    expect(mockConnect).toHaveBeenCalledTimes(1)
-  })
-
-  it('should connect and cache separate clients for multiple clusters', async () => {
-    // Mock different URIs for 2 clusters
-    ;(secretsModule.getSecret as jest.Mock)
-      .mockResolvedValueOnce('mongodb://mock-uri-A')
-      .mockResolvedValueOnce('mongodb://mock-uri-B')
-
-    await connectToMongo3('test-project', clusterASecret)
-    await connectToMongo3('test-project', clusterBSecret)
-
-    // Should call getSecret + connect twice (for 2 clusters)
-    expect(secretsModule.getSecret).toHaveBeenCalledTimes(2)
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
-    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterBSecret)
-    expect(mockConnect).toHaveBeenCalledTimes(2)
-  })
-
-  it('should return a collection when client is initialized', async () => {
-    await connectToMongo3('test-project', clusterASecret)
-
-    getCollection3(clusterASecret, 'test-db', 'users')
-
-    expect(mockClient.db).toHaveBeenCalledWith('test-db')
-    expect(mockDb.collection).toHaveBeenCalledWith('users')
-  })
-
-  it('should throw error if client not initialized (getDb)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getDb3 } = require('../../src/db/mongo3')
-      expect(() => getDb3('unknown-uri-secret', 'some-db')).toThrow(
-        'Mongo client for secret "unknown-uri-secret" not initialized'
-      )
-    })
-  })
-
-  it('should throw error if client not initialized (getCollection)', () => {
-    jest.isolateModules(() => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getCollection3 } = require('../../src/db/mongo3')
-      expect(() => getCollection3('unknown-uri-secret', 'some-db', 'users')).toThrow(
-        'Mongo client for secret "unknown-uri-secret" not initialized'
-      )
-    })
-  })
-})
-
-describe('MongoClientManager (multi-cluster) 2', () => {
-  const clusterAUri = 'clusterA-uri'
-  const clusterBUri = 'clusterB-uri'
-
-  it('should connect and cache client for a single cluster', async () => {
-    jest.isolateModules(async () => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { connectToMongoWithUri3, getDb3 } = require('../../src/db/mongo3')
-      await connectToMongoWithUri3(clusterAUri)
-
-      expect(mockConnect).toHaveBeenCalled()
-
-      const db = getDb3(clusterAUri, 'test-db')
-      expect(mockClient.db).toHaveBeenCalledWith('test-db')
-      expect(db).toBe(mockDb)
-    })
-  })
-
-  it('should reuse client if already connected', async () => {
-    jest.isolateModules(async () => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
-      await connectToMongoWithUri3(clusterAUri)
-      await connectToMongoWithUri3(clusterAUri)
-      expect(mockConnect).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  it('should connect and cache separate clients for multiple clusters', async () => {
-    jest.isolateModules(async () => {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
-      await connectToMongoWithUri3(clusterAUri)
-      await connectToMongoWithUri3(clusterBUri)
-      expect(mockConnect).toHaveBeenCalledTimes(2)
-    })
-  })
-
-  it('should return a collection when client is initialized', async () => {
-    await connectToMongoWithUri3(clusterAUri)
-
-    getCollection3(clusterAUri, 'test-db', 'users')
-
-    expect(mockClient.db).toHaveBeenCalledWith('test-db')
-    expect(mockDb.collection).toHaveBeenCalledWith('users')
-  })
-})
+import {
+  connectToMongo3,
+  getDb3,
+  getCollection3,
+  __mongoClients,
+  __connectPromises,
+  connectToMongoWithUri3
+} from '../../src/db/mongo3'
+import { MongoClient, Db } from 'mongodb'
+import * as secretsModule from '../../src/secrets'
+
+jest.mock('mongodb')
+jest.mock('../../src/secrets')
+
+const mockDb = {
+  collection: jest.fn()
+} as unknown as Db
+
+const mockConnect = jest.fn()
+const mockClient = {
+  connect: mockConnect,
+  db: jest.fn().mockReturnValue(mockDb)
+} as unknown as MongoClient
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  __mongoClients.clear()
+  __connectPromises.clear()
+  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
+  ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
+})
+
+describe('MongoClientManager (multi-cluster)', () => {
+  const clusterASecret = 'clusterA-uri-secret'
+  const clusterBSecret = 'clusterB-uri-secret'
+
+  it('should connect and cache client for a single cluster', async () => {
+    await connectToMongo3('test-project', clusterASecret)
+
+    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
+    expect(mockConnect).toHaveBeenCalled()
+
+    const db = getDb3(clusterASecret, 'test-db')
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(db).toBe(mockDb)
+  })
+
+  it('should reuse client if already connected', async () => {
+    await connectToMongo3('test-project', clusterASecret)
+    await connectToMongo3('test-project', clusterASecret)
+
+    // getSecret and connect should only happen once
+    expect(secretsModule.getSecret).toHaveBeenCalledTimes(1)
+    expect(mockConnect).toHaveBeenCalledTimes(1)
+  })
+
+  it('should connect and cache separate clients for multiple clusters', async () => {
+    // Mock different URIs for 2 clusters
+    ;(secretsModule.getSecret as jest.Mock)
+      .mockResolvedValueOnce('mongodb://mock-uri-A')
+      .mockResolvedValueOnce('mongodb://mock-uri-B')
+
+    await connectToMongo3('test-project', clusterASecret)
+    await connectToMongo3('test-project', clusterBSecret)
+
+    // Should call getSecret + connect twice (for 2 clusters)
+    expect(secretsModule.getSecret).toHaveBeenCalledTimes(2)
+    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterASecret)
+    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', clusterBSecret)
+    expect(mockConnect).toHaveBeenCalledTimes(2)
+  })
+
+  it('should return a collection when client is initialized', async () => {
+    await connectToMongo3('test-project', clusterASecret)
+
+    getCollection3(clusterASecret, 'test-db', 'users')
+
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+
+  it('should throw error if client not initialized (getDb)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getDb3 } = require('../../src/db/mongo3')
+      expect(() => getDb3('unknown-uri-secret', 'some-db')).toThrow(
+        'Mongo client for secret "unknown-uri-secret" not initialized'
+      )
+    })
+  })
+
+  it('should throw error if client not initialized (getCollection)', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getCollection3 } = require('../../src/db/mongo3')
+      expect(() => getCollection3('unknown-uri-secret', 'some-db', 'users')).toThrow(
+        'Mongo client for secret "unknown-uri-secret" not initialized'
+      )
+    })
+  })
+})
+
+describe('MongoClientManager (multi-cluster) 2', () => {
+  const clusterAUri = 'clusterA-uri'
+  const clusterBUri = 'clusterB-uri'
+
+  it('should connect and cache client for a single cluster', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3, getDb3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+
+      expect(mockConnect).toHaveBeenCalled()
+
+      const db = getDb3(clusterAUri, 'test-db')
+      expect(mockClient.db).toHaveBeenCalledWith('test-db')
+      expect(db).toBe(mockDb)
+    })
+  })
+
+  it('should reuse client if already connected', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+      await connectToMongoWithUri3(clusterAUri)
+      expect(mockConnect).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  it('should connect and cache separate clients for multiple clusters', async () => {
+    jest.isolateModules(async () => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { connectToMongoWithUri3 } = require('../../src/db/mongo3')
+      await connectToMongoWithUri3(clusterAUri)
+      await connectToMongoWithUri3(clusterBUri)
+      expect(mockConnect).toHaveBeenCalledTimes(2)
+    })
+  })
+
+  it('should return a collection when client is initialized', async () => {
+    await connectToMongoWithUri3(clusterAUri)
+
+    getCollection3(clusterAUri, 'test-db', 'users')
+
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+})

package/tests/env.test.ts

@@ -1,18 +1,18 @@
-import { getEnv } from '../src/env'
-
-describe('getEnv', () => {
-  it('returns the value of an existing env var', () => {
-    process.env.TEST_KEY = 'test-value'
-    expect(getEnv('TEST_KEY')).toBe('test-value')
-  })
-
-  it('returns fallback if env var is not set', () => {
-    delete process.env.OPTIONAL_KEY
-    expect(getEnv('OPTIONAL_KEY', 'default')).toBe('default')
-  })
-
-  it('throws error if env var is not set and no fallback provided', () => {
-    delete process.env.MISSING_KEY
-    expect(() => getEnv('MISSING_KEY')).toThrow('Missing env var MISSING_KEY')
-  })
-})
+import { getEnv } from '../src/env'
+
+describe('getEnv', () => {
+  it('returns the value of an existing env var', () => {
+    process.env.TEST_KEY = 'test-value'
+    expect(getEnv('TEST_KEY')).toBe('test-value')
+  })
+
+  it('returns fallback if env var is not set', () => {
+    delete process.env.OPTIONAL_KEY
+    expect(getEnv('OPTIONAL_KEY', 'default')).toBe('default')
+  })
+
+  it('throws error if env var is not set and no fallback provided', () => {
+    delete process.env.MISSING_KEY
+    expect(() => getEnv('MISSING_KEY')).toThrow('Missing env var MISSING_KEY')
+  })
+})

package/tests/parser.test.ts

@@ -1,26 +1,26 @@
-import { toNumber } from '../src'
-
-describe('toNumber', () => {
-  it('returns the same number when input is a finite number', () => {
-    expect(toNumber(123)).toBe(123)
-    expect(toNumber(0)).toBe(0)
-  })
-
-  it('returns number when input is a numeric string', () => {
-    expect(toNumber('456')).toBe(456)
-  })
-
-  it('returns null for non-numeric strings', () => {
-    expect(toNumber('abc')).toBeNull()
-    expect(toNumber('123abc')).toBeNull()
-    expect(toNumber('')).toBeNull()
-  })
-
-  it('returns null for non-numbers', () => {
-    expect(toNumber(NaN)).toBeNull()
-    expect(toNumber(Infinity)).toBeNull()
-    expect(toNumber(undefined)).toBeNull()
-    expect(toNumber(null)).toBeNull()
-    expect(toNumber({})).toBeNull()
-  })
-})
+import { toNumber } from '../src'
+
+describe('toNumber', () => {
+  it('returns the same number when input is a finite number', () => {
+    expect(toNumber(123)).toBe(123)
+    expect(toNumber(0)).toBe(0)
+  })
+
+  it('returns number when input is a numeric string', () => {
+    expect(toNumber('456')).toBe(456)
+  })
+
+  it('returns null for non-numeric strings', () => {
+    expect(toNumber('abc')).toBeNull()
+    expect(toNumber('123abc')).toBeNull()
+    expect(toNumber('')).toBeNull()
+  })
+
+  it('returns null for non-numbers', () => {
+    expect(toNumber(NaN)).toBeNull()
+    expect(toNumber(Infinity)).toBeNull()
+    expect(toNumber(undefined)).toBeNull()
+    expect(toNumber(null)).toBeNull()
+    expect(toNumber({})).toBeNull()
+  })
+})

package/tests/regex.test.ts

@@ -1,69 +1,69 @@
-// tests/regex.test.ts
-import { escapeForRegex } from '../src/regex'
-
-describe('escapeForRegex', () => {
-  it('escapes regex special characters (including backslash)', () => {
-    const input = 'Pikachu.$^*+?()[]{}|\\'
-    const expected = 'Pikachu\\.\\$\\^\\*\\+\\?\\(\\)\\[\\]\\{\\}\\|\\\\'
-    expect(escapeForRegex(input)).toBe(expected)
-  })
-
-  it('replaces whitespace runs with \\s+ and escapes other metachars', () => {
-    const input = 'Charizard (Holo   Rare)' // multiple spaces inside
-    const expected = 'Charizard\\s+\\(Holo\\s+Rare\\)'
-    expect(escapeForRegex(input)).toBe(expected)
-  })
-
-  it('leaves plain alphanumerics unchanged', () => {
-    const input = 'Charmander123'
-    expect(escapeForRegex(input)).toBe('Charmander123')
-  })
-
-  it('converts tabs and single spaces to \\s+ and escapes dots', () => {
-    const input = 'Lt. Surge\tPikachu'
-    const expected = 'Lt\\.\\s+Surge\\s+Pikachu'
-    expect(escapeForRegex(input)).toBe(expected)
-  })
-
-  it('truncates input when maxLength is passed', () => {
-    const long = 'a'.repeat(200)
-    // override maxLength to 50 for this test
-    expect(escapeForRegex(long, 50)).toBe('a'.repeat(50))
-  })
-
-  it('applies default cap of 100 characters when input is longer and contains no metachars', () => {
-    const long = 'b'.repeat(150)
-    const out = escapeForRegex(long) // default cap = 100
-    expect(out).toBe('b'.repeat(100))
-    expect(out.length).toBe(100)
-  })
-
-  it('handles empty string', () => {
-    expect(escapeForRegex('')).toBe('')
-  })
-
-  // -----------------------------
-  // NEW: coverage for safeStr branch
-  // -----------------------------
-  it('handles undefined input (covers input ?? "")', () => {
-    // call with undefined; TypeScript may complain so cast to any in test
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(escapeForRegex(undefined as any)).toBe('')
-  })
-
-  it('handles null input (covers input ?? "")', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(escapeForRegex(null as any)).toBe('')
-  })
-
-  it('coerces non-string input to string and escapes metachars if present', () => {
-    // number becomes "42"
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect(escapeForRegex(42 as any)).toBe('42')
-
-    // object coerces to "[object Object]" and special chars will be escaped if present
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const objInput = { toString: () => 'X(1) Y' } as any
-    expect(escapeForRegex(objInput)).toBe('X\\(1\\)\\s+Y')
-  })
-})
+// tests/regex.test.ts
+import { escapeForRegex } from '../src/regex'
+
+describe('escapeForRegex', () => {
+  it('escapes regex special characters (including backslash)', () => {
+    const input = 'Pikachu.$^*+?()[]{}|\\'
+    const expected = 'Pikachu\\.\\$\\^\\*\\+\\?\\(\\)\\[\\]\\{\\}\\|\\\\'
+    expect(escapeForRegex(input)).toBe(expected)
+  })
+
+  it('replaces whitespace runs with \\s+ and escapes other metachars', () => {
+    const input = 'Charizard (Holo   Rare)' // multiple spaces inside
+    const expected = 'Charizard\\s+\\(Holo\\s+Rare\\)'
+    expect(escapeForRegex(input)).toBe(expected)
+  })
+
+  it('leaves plain alphanumerics unchanged', () => {
+    const input = 'Charmander123'
+    expect(escapeForRegex(input)).toBe('Charmander123')
+  })
+
+  it('converts tabs and single spaces to \\s+ and escapes dots', () => {
+    const input = 'Lt. Surge\tPikachu'
+    const expected = 'Lt\\.\\s+Surge\\s+Pikachu'
+    expect(escapeForRegex(input)).toBe(expected)
+  })
+
+  it('truncates input when maxLength is passed', () => {
+    const long = 'a'.repeat(200)
+    // override maxLength to 50 for this test
+    expect(escapeForRegex(long, 50)).toBe('a'.repeat(50))
+  })
+
+  it('applies default cap of 100 characters when input is longer and contains no metachars', () => {
+    const long = 'b'.repeat(150)
+    const out = escapeForRegex(long) // default cap = 100
+    expect(out).toBe('b'.repeat(100))
+    expect(out.length).toBe(100)
+  })
+
+  it('handles empty string', () => {
+    expect(escapeForRegex('')).toBe('')
+  })
+
+  // -----------------------------
+  // NEW: coverage for safeStr branch
+  // -----------------------------
+  it('handles undefined input (covers input ?? "")', () => {
+    // call with undefined; TypeScript may complain so cast to any in test
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(undefined as any)).toBe('')
+  })
+
+  it('handles null input (covers input ?? "")', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(null as any)).toBe('')
+  })
+
+  it('coerces non-string input to string and escapes metachars if present', () => {
+    // number becomes "42"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(42 as any)).toBe('42')
+
+    // object coerces to "[object Object]" and special chars will be escaped if present
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const objInput = { toString: () => 'X(1) Y' } as any
+    expect(escapeForRegex(objInput)).toBe('X\\(1\\)\\s+Y')
+  })
+})