@jskit-ai/rewarded-core 0.1.120

package/test/requireRewardedUnlock.test.js

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { requireRewardedUnlock } from "../src/server/support/requireRewardedUnlock.js";
+
+function createRewardedService(gateState) {
+  const calls = [];
+  return {
+    calls,
+    async getCurrentState(input, options = {}) {
+      calls.push({
+        input,
+        options
+      });
+      return gateState;
+    }
+  };
+}
+
+const REQUEST_CONTEXT = Object.freeze({
+  actor: {
+    id: "7"
+  }
+});
+
+test("requireRewardedUnlock allows an already unlocked gate", async () => {
+  const gateState = {
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: true,
+    blocked: false,
+    reason: "already-unlocked",
+    unlock: {
+      id: "31"
+    }
+  };
+  const rewardedService = createRewardedService(gateState);
+
+  const result = await requireRewardedUnlock(
+    rewardedService,
+    {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha"
+    },
+    {
+      context: REQUEST_CONTEXT
+    }
+  );
+
+  assert.equal(result, gateState);
+  assert.deepEqual(rewardedService.calls[0], {
+    input: {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha",
+      surface: "app"
+    },
+    options: {
+      context: REQUEST_CONTEXT
+    }
+  });
+});
+
+test("requireRewardedUnlock bypasses missing configuration by default", async () => {
+  const gateState = {
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: false,
+    available: false,
+    blocked: false,
+    reason: "rule-not-configured",
+    unlock: null
+  };
+  const rewardedService = createRewardedService(gateState);
+
+  const result = await requireRewardedUnlock(
+    rewardedService,
+    {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha"
+    },
+    {
+      context: REQUEST_CONTEXT
+    }
+  );
+
+  assert.equal(result, gateState);
+});
+
+test("requireRewardedUnlock can fail closed when configuration is required", async () => {
+  const gateState = {
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: false,
+    available: false,
+    blocked: false,
+    reason: "provider-not-configured",
+    unlock: null
+  };
+  const rewardedService = createRewardedService(gateState);
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      rewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT,
+        requireConfigured: true
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "rewarded_not_configured");
+      assert.equal(error.details.rewardedGate, gateState);
+      return true;
+    }
+  );
+});
+
+test("requireRewardedUnlock rejects when a reward is still required", async () => {
+  const gateState = {
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: true,
+    blocked: true,
+    reason: "reward-required",
+    unlock: null
+  };
+  const rewardedService = createRewardedService(gateState);
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      rewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT,
+        errorMessage: "Watch a rewarded ad before logging progress."
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 423);
+      assert.equal(error.code, "rewarded_unlock_required");
+      assert.equal(error.message, "Watch a rewarded ad before logging progress.");
+      assert.equal(error.details.rewardedGate, gateState);
+      return true;
+    }
+  );
+});
+
+test("requireRewardedUnlock rejects cooldown and daily-limit states", async () => {
+  const cooldownService = createRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: false,
+    blocked: false,
+    reason: "cooldown-active",
+    unlock: null
+  });
+  const dailyLimitService = createRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: false,
+    blocked: false,
+    reason: "daily-limit-reached",
+    unlock: null
+  });
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      cooldownService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 423);
+      assert.equal(error.code, "rewarded_cooldown_active");
+      return true;
+    }
+  );
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      dailyLimitService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 423);
+      assert.equal(error.code, "rewarded_daily_limit_reached");
+      return true;
+    }
+  );
+});
+
+test("requireRewardedUnlock fails closed when the rewarded service returns an invalid gate state", async () => {
+  const rewardedService = createRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha"
+  });
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      rewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "rewarded_gate_state_invalid");
+      assert.deepEqual(error.details.rewardedGate, {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      });
+      return true;
+    }
+  );
+});
+
+test("requireRewardedUnlock fails closed when a non-blocking gate state has no explicit reason", async () => {
+  const rewardedService = createRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    enabled: false,
+    blocked: false
+  });
+
+  await assert.rejects(
+    () => requireRewardedUnlock(
+      rewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "rewarded_gate_state_invalid");
+      return true;
+    }
+  );
+});

package/test/routes.test.js

@@ -0,0 +1,239 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { registerRoutes } from "../src/server/registerRoutes.js";
+
+function createReplyDouble() {
+  return {
+    statusCode: 200,
+    payload: null,
+    code(value) {
+      this.statusCode = value;
+      return this;
+    },
+    send(value) {
+      this.payload = value;
+      return this;
+    }
+  };
+}
+
+function findRoute(routes, { method, path }) {
+  return routes.find((route) => route.method === method && route.path === path) || null;
+}
+
+function mountRoutes() {
+  const registeredRoutes = [];
+  const router = {
+    register(method, path, route, handler) {
+      registeredRoutes.push({
+        ...route,
+        method,
+        path,
+        handler
+      });
+    }
+  };
+
+  registerRoutes(router);
+  return registeredRoutes;
+}
+
+function createActionRequest({ input = {}, executeAction }) {
+  return {
+    input,
+    executeAction
+  };
+}
+
+test("google rewarded workflow routes mount with explicit request and response contracts", () => {
+  const routes = mountRoutes();
+  const currentRoute = findRoute(routes, {
+    method: "GET",
+    path: "/api/w/:workspaceSlug/rewarded/current"
+  });
+  const startRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/start"
+  });
+  const grantRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/grant"
+  });
+  const closeRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/close"
+  });
+
+  assert.equal(currentRoute?.auth, "required");
+  assert.equal(currentRoute?.visibility, "workspace_user");
+  assert.equal(currentRoute?.surface, "app");
+  assert.equal(typeof currentRoute?.query?.schema, "object");
+  assert.equal(currentRoute?.responses?.[200]?.transportSchema?.properties?.blocked?.["x-json-rest-schema"]?.castType, "boolean");
+
+  assert.equal(startRoute?.auth, "required");
+  assert.equal(startRoute?.visibility, "workspace_user");
+  assert.equal(typeof startRoute?.body?.schema, "object");
+  assert.equal(startRoute?.responses?.[200]?.transportSchema?.properties?.session?.anyOf?.[1]?.type, "null");
+
+  assert.equal(grantRoute?.responses?.[200]?.transportSchema?.properties?.unlocked?.["x-json-rest-schema"]?.castType, "boolean");
+  assert.equal(closeRoute?.responses?.[200]?.transportSchema?.properties?.closed?.["x-json-rest-schema"]?.castType, "boolean");
+});
+
+test("google rewarded workflow route handlers build action input from request.input", async () => {
+  const routes = mountRoutes();
+  const calls = [];
+  const executeAction = async (payload) => {
+    calls.push(payload);
+    if (payload.actionId === "rewarded.current.read") {
+      return {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha",
+        surface: "app",
+        enabled: true,
+        available: true,
+        blocked: true,
+        reason: "reward-required",
+        rule: null,
+        providerConfig: null,
+        unlock: null,
+        cooldownUntil: null,
+        dailyLimitRemaining: null
+      };
+    }
+    if (payload.actionId === "rewarded.start") {
+      return {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha",
+        surface: "app",
+        enabled: true,
+        available: true,
+        blocked: true,
+        reason: "reward-required",
+        rule: null,
+        providerConfig: null,
+        unlock: null,
+        cooldownUntil: null,
+        dailyLimitRemaining: null,
+        session: null
+      };
+    }
+    if (payload.actionId === "rewarded.grant") {
+      return {
+        unlocked: true,
+        workspaceSlug: "alpha",
+        gateKey: "progress-logging",
+        unlock: null,
+        session: null
+      };
+    }
+    return {
+      closed: true,
+      workspaceSlug: "alpha",
+      gateKey: "progress-logging",
+      session: null,
+      reason: null
+    };
+  };
+
+  await findRoute(routes, {
+    method: "GET",
+    path: "/api/w/:workspaceSlug/rewarded/current"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        query: {
+          gateKey: "progress-logging"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/start"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          gateKey: "progress-logging"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/grant"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          sessionId: "41"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/rewarded/close"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          sessionId: "41"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  assert.deepEqual(calls[0], {
+    actionId: "rewarded.current.read",
+    input: {
+      workspaceSlug: "alpha",
+      gateKey: "progress-logging"
+    }
+  });
+  assert.deepEqual(calls[1], {
+    actionId: "rewarded.start",
+    input: {
+      workspaceSlug: "alpha",
+      gateKey: "progress-logging"
+    }
+  });
+  assert.deepEqual(calls[2], {
+    actionId: "rewarded.grant",
+    input: {
+      workspaceSlug: "alpha",
+      sessionId: "41"
+    }
+  });
+  assert.deepEqual(calls[3], {
+    actionId: "rewarded.close",
+    input: {
+      workspaceSlug: "alpha",
+      sessionId: "41"
+    }
+  });
+});