@strav/testing 1.0.0-alpha.24 → 1.0.0-alpha.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strav/testing",
-  "version": "1.0.0-alpha.24",
+  "version": "1.0.0-alpha.25",
   "description": "Strav testing utilities — in-memory stream, typed fetch stub, Postgres availability probe + schema reset, bootTestApp orchestrator, stub providers.",
   "type": "module",
   "main": "./src/index.ts",
@@ -8,6 +8,7 @@
   "exports": {
     ".": "./src/index.ts",
     "./brain": "./src/brain/index.ts",
+    "./cache": "./src/cache/index.ts",
     "./postgres": "./src/postgres/index.ts"
   },
   "files": [
@@ -21,11 +22,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@strav/database": "1.0.0-alpha.24",
-    "@strav/kernel": "1.0.0-alpha.24"
+    "@strav/database": "1.0.0-alpha.25",
+    "@strav/kernel": "1.0.0-alpha.25"
   },
   "peerDependencies": {
-    "@strav/brain": "1.0.0-alpha.24",
+    "@strav/brain": "1.0.0-alpha.25",
     "@types/bun": ">=1.3.14"
   },
   "peerDependenciesMeta": {

package/src/cache/index.ts

@@ -0,0 +1,2 @@
+export { isMemcachedAvailable } from './is_memcached_available.ts'
+export { isRedisAvailable } from './is_redis_available.ts'

package/src/cache/is_memcached_available.ts

@@ -0,0 +1,75 @@
+/**
+ * Cheap connection probe over Bun's TCP socket — opens a connection,
+ * sends `version\r\n`, expects a `VERSION ...\r\n` reply. Cached for
+ * the lifetime of the test process.
+ *
+ * Returns `false` if `MEMCACHED_HOST` / `MEMCACHED_PORT` are missing
+ * OR the probe fails. Pair with
+ * `describe.skipIf(!await isMemcachedAvailable())`.
+ */
+
+let cachedAvailability: boolean | null = null
+
+export async function isMemcachedAvailable(): Promise<boolean> {
+  if (cachedAvailability !== null) return cachedAvailability
+  const host = process.env['MEMCACHED_HOST']
+  const portStr = process.env['MEMCACHED_PORT']
+  if (host === undefined || host === '' || portStr === undefined || portStr === '') {
+    cachedAvailability = false
+    return false
+  }
+  const port = Number(portStr)
+  if (!Number.isFinite(port) || port <= 0) {
+    cachedAvailability = false
+    return false
+  }
+  try {
+    cachedAvailability = await probe(host, port)
+  } catch {
+    cachedAvailability = false
+  }
+  return cachedAvailability
+}
+
+function probe(host: string, port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    let settled = false
+    const finish = (ok: boolean): void => {
+      if (settled) return
+      settled = true
+      resolve(ok)
+    }
+    const timeout = setTimeout(() => finish(false), 2_000)
+    void Bun.connect({
+      hostname: host,
+      port,
+      socket: {
+        open(socket) {
+          socket.write('version\r\n')
+        },
+        data(socket, chunk) {
+          const bytes = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+          const text = new TextDecoder().decode(bytes)
+          const ok = text.startsWith('VERSION')
+          // Settle before closing — `socket.end()` synchronously fires
+          // the `close` callback, which would beat `finish(ok)` to the
+          // settle line and report a false negative.
+          clearTimeout(timeout)
+          finish(ok)
+          socket.end()
+        },
+        error(_socket, _error) {
+          clearTimeout(timeout)
+          finish(false)
+        },
+        close() {
+          clearTimeout(timeout)
+          if (!settled) finish(false)
+        },
+      },
+    }).catch(() => {
+      clearTimeout(timeout)
+      finish(false)
+    })
+  })
+}

package/src/cache/is_redis_available.ts

@@ -0,0 +1,39 @@
+/**
+ * Cheap connection probe — opens `Bun.RedisClient` against
+ * `REDIS_URL`, sends `PING`, reports. Cached for the lifetime of the
+ * test process.
+ *
+ * Returns `false` if `REDIS_URL` is missing OR the connection / PING
+ * fails. Pair with `describe.skipIf(!await isRedisAvailable())`.
+ */
+
+import { RedisClient } from 'bun'
+
+let cachedAvailability: boolean | null = null
+
+export async function isRedisAvailable(): Promise<boolean> {
+  if (cachedAvailability !== null) return cachedAvailability
+  const url = process.env['REDIS_URL']
+  if (url === undefined || url === '') {
+    cachedAvailability = false
+    return false
+  }
+  let client: RedisClient | undefined
+  try {
+    client = new RedisClient(url)
+    // `send('PING', [])` is supported on every Bun.RedisClient build —
+    // safer than `ping()` which isn't on the typed surface.
+    const reply = await client.send('PING', [])
+    cachedAvailability = reply === 'PONG' || reply === 'OK' || typeof reply === 'string'
+    return cachedAvailability
+  } catch {
+    cachedAvailability = false
+    return false
+  } finally {
+    try {
+      client?.close()
+    } catch {
+      // Already closed / never connected — nothing to clean.
+    }
+  }
+}

package/src/index.ts

@@ -27,3 +27,7 @@ export {
   resetSchema,
   testDatabaseUrl,
 } from './postgres/index.ts'
+
+// Cache availability probes — also re-exported under
+// `@strav/testing/cache` for the same reason.
+export { isMemcachedAvailable, isRedisAvailable } from './cache/index.ts'