testCacheAndRedisExtended.js

import BosBase from "bosbase";

function createStubClient() {
  const pb = new BosBase("https://cache.test");
  const calls = [];

  pb.send = async (path, options = {}) => {
    calls.push({ path, options });

    // Cache endpoints
    if (path === "/api/cache") {
      if (options.method === "GET") {
        return { items: [{ name: "demo", sizeBytes: 1024, defaultTTLSeconds: 60, readTimeoutMs: 50 }] };
      }
      if (options.method === "POST") {
        return {
          name: options.body?.name,
          sizeBytes: options.body?.sizeBytes ?? 0,
          defaultTTLSeconds: options.body?.defaultTTLSeconds ?? 0,
          readTimeoutMs: options.body?.readTimeoutMs ?? 0,
        };
      }
    }

    if (path.startsWith("/api/cache/") && options.method === "PATCH") {
      const name = decodeURIComponent(path.split("/").pop() || "");
      return { name, ...options.body };
    }

    if (path.startsWith("/api/cache/") && options.method === "DELETE") {
      return {};
    }

    if (path.includes("/entries/")) {
      const key = decodeURIComponent(path.split("/").pop() || "");
      return {
        cache: "demo",
        key,
        value: options.body?.value ?? "unset",
        ttlSeconds: options.body?.ttlSeconds,
        source: "cache",
      };
    }

    // Redis endpoints
    if (path === "/api/redis/keys") {
      if (options.method === "GET") {
        return { cursor: "0", items: [{ key: "demo" }] };
      }
      if (options.method === "POST") {
        return {
          key: options.body?.key,
          value: options.body?.value,
          ttlSeconds: options.body?.ttlSeconds,
        };
      }
    }

    if (path.startsWith("/api/redis/keys/")) {
      const key = decodeURIComponent(path.split("/").pop() || "");
      if (options.method === "GET" || !options.method) {
        return { key, value: "existing", ttlSeconds: 30 };
      }
      if (options.method === "PUT") {
        return { key, value: options.body?.value, ttlSeconds: options.body?.ttlSeconds };
      }
      if (options.method === "DELETE") {
        return {};
      }
    }

    throw new Error(`Unexpected request: ${path} ${options.method || ""}`);
  };

  return { pb, calls };
}

async function main() {
  const { pb, calls } = createStubClient();

  try {
    console.log("[INFO] Testing CacheService full entry lifecycle...");
    const cacheList = await pb.caches.list();
    if (!Array.isArray(cacheList) || cacheList.length !== 1 || cacheList[0].name !== "demo") {
      throw new Error("caches.list did not return stubbed cache list");
    }

    const created = await pb.caches.create({ name: "demo", sizeBytes: 2048, defaultTTLSeconds: 10 });
    if (created.name !== "demo" || created.sizeBytes !== 2048) {
      throw new Error("caches.create did not echo configuration");
    }

    const updated = await pb.caches.update("demo", { defaultTTLSeconds: 120 });
    if (updated.defaultTTLSeconds !== 120) {
      throw new Error("caches.update did not persist TTL change");
    }

    const entry = await pb.caches.setEntry("demo", "greeting", { text: "hello" }, 90);
    if (entry.key !== "greeting" || entry.value?.text !== "hello" || entry.ttlSeconds !== 90) {
      throw new Error("caches.setEntry did not preserve key/value/ttl");
    }

    const fetched = await pb.caches.getEntry("demo", "greeting");
    if (fetched.key !== "greeting") {
      throw new Error("caches.getEntry did not fetch expected key");
    }

    const renewed = await pb.caches.renewEntry("demo", "greeting", 180);
    if (renewed.ttlSeconds !== 180) {
      throw new Error("caches.renewEntry did not update ttlSeconds");
    }

    const deleteEntryResult = await pb.caches.deleteEntry("demo", "greeting");
    if (deleteEntryResult !== true) {
      throw new Error("caches.deleteEntry did not resolve to true");
    }

    const deleteCacheResult = await pb.caches.delete("demo");
    if (deleteCacheResult !== true) {
      throw new Error("caches.delete did not resolve to true");
    }

    const cachePaths = calls.filter((c) => c.path.startsWith("/api/cache"));
    const entryPath = cachePaths.find((c) => c.path.includes("/entries/greeting"));
    if (!entryPath || !entryPath.path.endsWith("greeting")) {
      throw new Error("Cache entry paths were not encoded correctly");
    }
    console.log("[SUCCESS] CacheService CRUD + entry helpers verified");

    console.log("[INFO] Testing RedisService key CRUD helpers...");
    const redisList = await pb.redis.listKeys({ count: 1 });
    if (!redisList?.items?.length) {
      throw new Error("redis.listKeys did not return stubbed list");
    }

    const createdKey = await pb.redis.createKey({ key: "session:1", value: { user: "u1" }, ttlSeconds: 45 });
    if (createdKey.key !== "session:1" || createdKey.ttlSeconds !== 45) {
      throw new Error("redis.createKey did not return key with ttlSeconds");
    }

    const fetchedKey = await pb.redis.getKey("session:1");
    if (fetchedKey.key !== "session:1") {
      throw new Error("redis.getKey did not fetch expected key");
    }

    const updatedKey = await pb.redis.updateKey("session:1", { value: { user: "u2" }, ttlSeconds: 99 });
    if (updatedKey.value?.user !== "u2" || updatedKey.ttlSeconds !== 99) {
      throw new Error("redis.updateKey did not apply updates");
    }

    const deleteKeyResult = await pb.redis.deleteKey("session:1");
    if (deleteKeyResult !== true) {
      throw new Error("redis.deleteKey did not resolve to true");
    }

    const redisCalls = calls.filter((c) => c.path.startsWith("/api/redis/keys"));
    const updateCall = redisCalls.find((c) => c.options.method === "PUT");
    if (!updateCall || !updateCall.path.endsWith("session%3A1")) {
      throw new Error("Redis key paths were not URL encoded");
    }
    console.log("[SUCCESS] RedisService key CRUD helpers verified");

    console.log("\n========== Cache and Redis helper coverage completed ==========");
  } catch (error) {
    console.error("[ERROR] Cache/Redis helper coverage failed:");
    console.error(error?.stack || error);
    process.exit(1);
  }
}

main();