@jskit-ai/google-rewarded-core 0.1.1

package/test/requireGoogleRewardedUnlock.test.js

@@ -0,0 +1,274 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { requireGoogleRewardedUnlock } from "../src/server/support/requireGoogleRewardedUnlock.js";
+
+function createGoogleRewardedService(gateState) {
+  const calls = [];
+  return {
+    calls,
+    async getCurrentState(input, options = {}) {
+      calls.push({
+        input,
+        options
+      });
+      return gateState;
+    }
+  };
+}
+
+const REQUEST_CONTEXT = Object.freeze({
+  actor: {
+    id: "7"
+  }
+});
+
+test("requireGoogleRewardedUnlock 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 googleRewardedService = createGoogleRewardedService(gateState);
+
+  const result = await requireGoogleRewardedUnlock(
+    googleRewardedService,
+    {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha"
+    },
+    {
+      context: REQUEST_CONTEXT
+    }
+  );
+
+  assert.equal(result, gateState);
+  assert.deepEqual(googleRewardedService.calls[0], {
+    input: {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha",
+      surface: "app"
+    },
+    options: {
+      context: REQUEST_CONTEXT
+    }
+  });
+});
+
+test("requireGoogleRewardedUnlock 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 googleRewardedService = createGoogleRewardedService(gateState);
+
+  const result = await requireGoogleRewardedUnlock(
+    googleRewardedService,
+    {
+      gateKey: "progress-logging",
+      workspaceSlug: "alpha"
+    },
+    {
+      context: REQUEST_CONTEXT
+    }
+  );
+
+  assert.equal(result, gateState);
+});
+
+test("requireGoogleRewardedUnlock 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 googleRewardedService = createGoogleRewardedService(gateState);
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      googleRewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT,
+        requireConfigured: true
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "google_rewarded_not_configured");
+      assert.equal(error.details.rewardedGate, gateState);
+      return true;
+    }
+  );
+});
+
+test("requireGoogleRewardedUnlock 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 googleRewardedService = createGoogleRewardedService(gateState);
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      googleRewardedService,
+      {
+        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, "google_rewarded_unlock_required");
+      assert.equal(error.message, "Watch a rewarded ad before logging progress.");
+      assert.equal(error.details.rewardedGate, gateState);
+      return true;
+    }
+  );
+});
+
+test("requireGoogleRewardedUnlock rejects cooldown and daily-limit states", async () => {
+  const cooldownService = createGoogleRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: false,
+    blocked: false,
+    reason: "cooldown-active",
+    unlock: null
+  });
+  const dailyLimitService = createGoogleRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    surface: "app",
+    enabled: true,
+    available: false,
+    blocked: false,
+    reason: "daily-limit-reached",
+    unlock: null
+  });
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      cooldownService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 423);
+      assert.equal(error.code, "google_rewarded_cooldown_active");
+      return true;
+    }
+  );
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      dailyLimitService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 423);
+      assert.equal(error.code, "google_rewarded_daily_limit_reached");
+      return true;
+    }
+  );
+});
+
+test("requireGoogleRewardedUnlock fails closed when the rewarded service returns an invalid gate state", async () => {
+  const googleRewardedService = createGoogleRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha"
+  });
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      googleRewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "google_rewarded_gate_state_invalid");
+      assert.deepEqual(error.details.rewardedGate, {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      });
+      return true;
+    }
+  );
+});
+
+test("requireGoogleRewardedUnlock fails closed when a non-blocking gate state has no explicit reason", async () => {
+  const googleRewardedService = createGoogleRewardedService({
+    gateKey: "progress-logging",
+    workspaceSlug: "alpha",
+    enabled: false,
+    blocked: false
+  });
+
+  await assert.rejects(
+    () => requireGoogleRewardedUnlock(
+      googleRewardedService,
+      {
+        gateKey: "progress-logging",
+        workspaceSlug: "alpha"
+      },
+      {
+        context: REQUEST_CONTEXT
+      }
+    ),
+    (error) => {
+      assert.equal(error.statusCode, 503);
+      assert.equal(error.code, "google_rewarded_gate_state_invalid");
+      return true;
+    }
+  );
+});

package/test/routes.test.js

@@ -0,0 +1,248 @@
+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
+      });
+    }
+  };
+
+  const app = {
+    make(token) {
+      if (token !== "jskit.http.router") {
+        throw new Error(`Unexpected token: ${String(token)}`);
+      }
+      return router;
+    }
+  };
+
+  registerRoutes(app);
+  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/google-rewarded/current"
+  });
+  const startRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-rewarded/start"
+  });
+  const grantRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-rewarded/grant"
+  });
+  const closeRoute = findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-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 === "google-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 === "google-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 === "google-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/google-rewarded/current"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        query: {
+          gateKey: "progress-logging"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-rewarded/start"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          gateKey: "progress-logging"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-rewarded/grant"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          sessionId: "41"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  await findRoute(routes, {
+    method: "POST",
+    path: "/api/w/:workspaceSlug/google-rewarded/close"
+  }).handler(
+    createActionRequest({
+      input: {
+        params: {
+          workspaceSlug: "Alpha"
+        },
+        body: {
+          sessionId: "41"
+        }
+      },
+      executeAction
+    }),
+    createReplyDouble()
+  );
+
+  assert.deepEqual(calls[0], {
+    actionId: "google-rewarded.current.read",
+    input: {
+      workspaceSlug: "alpha",
+      gateKey: "progress-logging"
+    }
+  });
+  assert.deepEqual(calls[1], {
+    actionId: "google-rewarded.start",
+    input: {
+      workspaceSlug: "alpha",
+      gateKey: "progress-logging"
+    }
+  });
+  assert.deepEqual(calls[2], {
+    actionId: "google-rewarded.grant",
+    input: {
+      workspaceSlug: "alpha",
+      sessionId: "41"
+    }
+  });
+  assert.deepEqual(calls[3], {
+    actionId: "google-rewarded.close",
+    input: {
+      workspaceSlug: "alpha",
+      sessionId: "41"
+    }
+  });
+});