Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/api/src/usage/usage-route.test.ts
T
2026-07-08 16:15:37 +02:00

299 lines
11 KiB
TypeScript

import { Hono } from "hono";
import type { ApiConfig } from "@hivegrid/config";
import type { LegacyApiKeySimple } from "@hivegrid/db/api-keys.server";
import { SUBSCRIPTION_FEATURE_LIMIT, type TenantApiUsageFeature } from "@hivegrid/db/usage.server";
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
import { resetApiRuntimeConfigForTests, setApiRuntimeConfigForTests } from "../config.js";
import type { ApiErrorEnv } from "../middleware/error-envelope.js";
import { getUsageRequest } from "./usage-route.js";
type UsageRouteDependencies = Parameters<typeof getUsageRequest>[1];
const TEST_API_CONFIG: ApiConfig = {
appName: "Usage Route Test API",
nodeEnv: "test",
revision: "unknown",
listen: { port: 3001 },
routing: {
appBaseDomain: "localhost:3000",
webAppHost: "app.localhost:3000",
adminAppHost: "admin.localhost:3000",
apiHost: "api.localhost:3000",
protocol: "http",
},
origins: {},
apiAccessToken: "service-secret",
jwtSecret: "usage-route-secret",
analytics: {},
mailjet: {},
lago: { timeoutMs: 10000 },
mollie: { timeoutMs: 10000 },
apiKeys: {
allowLegacyPlaintextFallback: true,
},
storage: {},
};
beforeEach(() => {
setApiRuntimeConfigForTests(TEST_API_CONFIG);
});
afterEach(() => {
resetApiRuntimeConfigForTests();
vi.restoreAllMocks();
});
function createApiKeyFixture(patch: Partial<LegacyApiKeySimple> = {}): LegacyApiKeySimple {
const tenantId = patch.tenantId ?? patch.tenant?.id ?? "tenant_usage_1";
return {
id: "api_key_usage_1",
alias: "Primary usage key",
expires: null,
tenantId,
createdByUserId: "user_usage_1",
active: true,
scopes: ["*"],
tenant: { id: tenantId, name: "Acme Usage", slug: "acme-usage", deactivatedReason: null },
...patch,
};
}
function createUsageFixture(patch: Partial<TenantApiUsageFeature> = {}): TenantApiUsageFeature {
return {
title: "Plan with {0} calls",
type: SUBSCRIPTION_FEATURE_LIMIT.monthly,
value: 100,
used: 10,
remaining: 90,
enabled: true,
message: "",
...patch,
};
}
function buildDeps(options: { apiKey?: LegacyApiKeySimple | null; usage?: TenantApiUsageFeature; ipLoggingError?: Error } = {}) {
const apiKey = options.apiKey === undefined ? createApiKeyFixture() : options.apiKey;
const mocks = {
findLegacyApiKeyByKey: vi.fn(async () => apiKey),
createLegacyApiKeyLog: vi.fn(async (data: { tenantId?: string | null }) => ({ id: "api_key_log_usage_1", tenantId: data.tenantId ?? null })),
setLegacyApiKeyLogStatus: vi.fn(async () => ({ count: 1 })),
createUniqueLegacyTenantIpAddress: vi.fn(async () => {
if (options.ipLoggingError) {
throw options.ipLoggingError;
}
return { id: "tenant_ip_usage_1" };
}),
getTenantSubscription: vi.fn(async () => null),
getTenantApiUsage: vi.fn(async () => options.usage),
};
const dependencies: UsageRouteDependencies = {
findLegacyApiKeyByKey: mocks.findLegacyApiKeyByKey as never,
createLegacyApiKeyLog: mocks.createLegacyApiKeyLog as never,
setLegacyApiKeyLogStatus: mocks.setLegacyApiKeyLogStatus as never,
createUniqueLegacyTenantIpAddress: mocks.createUniqueLegacyTenantIpAddress as never,
getTenantSubscription: mocks.getTenantSubscription as never,
getTenantApiUsage: mocks.getTenantApiUsage as never,
};
return { dependencies, mocks };
}
function buildApp(dependencies: UsageRouteDependencies) {
const app = new Hono<ApiErrorEnv>();
app.use("*", async (c, next) => {
c.set("requestId", "req_usage_route");
await next();
});
app.get("/v1/usage", (c) => getUsageRequest(c, dependencies));
return app;
}
async function requestUsage(dependencies: UsageRouteDependencies, headers: Record<string, string> = {}) {
return buildApp(dependencies).request("/v1/usage?source=test", { headers });
}
describe("getUsageRequest", () => {
test("rejects missing API keys and records an unauthenticated usage log", async () => {
const { dependencies, mocks } = buildDeps();
const response = await requestUsage(dependencies);
expect(response.status).toBe(401);
await expect(response.json()).resolves.toEqual({
error: {
code: "unauthorized",
message: "Valid API key credentials are required.",
requestId: "req_usage_route",
},
});
expect(mocks.findLegacyApiKeyByKey).not.toHaveBeenCalled();
expect(mocks.createLegacyApiKeyLog).toHaveBeenCalledWith({
tenantId: null,
apiKeyId: null,
endpoint: "/v1/usage",
ip: "",
method: "GET",
params: "source=test",
error: "Invalid API Key",
status: 401,
});
expect(mocks.setLegacyApiKeyLogStatus).not.toHaveBeenCalled();
});
test("rejects invalid API keys after lookup and records an unauthenticated usage log", async () => {
const { dependencies, mocks } = buildDeps({ apiKey: null });
const response = await requestUsage(dependencies, { "x-api-key": "invalid-secret" });
expect(response.status).toBe(401);
await expect(response.json()).resolves.toEqual({
error: {
code: "unauthorized",
message: "Valid API key credentials are required.",
requestId: "req_usage_route",
},
});
expect(mocks.findLegacyApiKeyByKey).toHaveBeenCalledWith("invalid-secret", undefined, "usage-route-secret", { allowPlaintextFallback: true });
expect(mocks.createLegacyApiKeyLog).toHaveBeenCalledWith(
expect.objectContaining({
tenantId: null,
apiKeyId: null,
endpoint: "/v1/usage",
error: "Invalid API Key",
status: 401,
}),
);
expect(mocks.setLegacyApiKeyLogStatus).not.toHaveBeenCalled();
});
test("blocks inactive tenants before usage checks", async () => {
const apiKey = createApiKeyFixture({
tenant: { id: "tenant_usage_1", name: "Acme Usage", slug: "acme-usage", deactivatedReason: "billing_past_due" },
});
const { dependencies, mocks } = buildDeps({ apiKey });
const response = await requestUsage(dependencies, { "x-api-key": "tenant-secret" });
expect(response.status).toBe(403);
await expect(response.json()).resolves.toEqual({
error: {
code: "tenant_inactive",
message: "Account is inactive.",
requestId: "req_usage_route",
},
});
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 403, error: "Account is inactive." }),
);
expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled();
expect(mocks.getTenantApiUsage).not.toHaveBeenCalled();
});
test("blocks inactive API keys before usage checks", async () => {
const { dependencies, mocks } = buildDeps({ apiKey: createApiKeyFixture({ active: false }) });
const response = await requestUsage(dependencies, { "x-api-key": "inactive-secret" });
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: {
code: "api_key_inactive",
message: "API key is inactive.",
requestId: "req_usage_route",
},
});
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 400, error: "API key is inactive." }),
);
expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled();
expect(mocks.getTenantApiUsage).not.toHaveBeenCalled();
});
test("blocks expired API keys before usage checks", async () => {
const { dependencies, mocks } = buildDeps({ apiKey: createApiKeyFixture({ expires: new Date("2020-01-01T00:00:00.000Z") }) });
const response = await requestUsage(dependencies, { "x-api-key": "expired-secret" });
expect(response.status).toBe(400);
await expect(response.json()).resolves.toEqual({
error: {
code: "api_key_expired",
message: "API key is expired.",
requestId: "req_usage_route",
},
});
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 400, error: "API key is expired." }),
);
expect(mocks.createUniqueLegacyTenantIpAddress).not.toHaveBeenCalled();
expect(mocks.getTenantApiUsage).not.toHaveBeenCalled();
});
test("swallows IP logging failures and still returns usage", async () => {
const { dependencies, mocks } = buildDeps({ ipLoggingError: new Error("ip write failed") });
const response = await requestUsage(dependencies, { "x-api-key": "valid-secret", "cf-connecting-ip": "203.0.113.10" });
expect(response.status).toBe(200);
await expect(response.json()).resolves.toEqual({ plan: "" });
expect(mocks.createUniqueLegacyTenantIpAddress).toHaveBeenCalledWith({
ip: "203.0.113.10",
fromUrl: "/v1/usage",
tenantId: "tenant_usage_1",
apiKeyId: "api_key_usage_1",
});
expect(mocks.getTenantSubscription).toHaveBeenCalledWith("tenant_usage_1");
expect(mocks.getTenantApiUsage).toHaveBeenCalledWith("tenant_usage_1", null);
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 200 }),
);
});
test("returns payment required when API usage is disabled or exhausted", async () => {
const usage = createUsageFixture({ enabled: false, remaining: 0, message: "Usage exhausted." });
const { dependencies, mocks } = buildDeps({ usage });
const response = await requestUsage(dependencies, { "x-api-key": "valid-secret" });
expect(response.status).toBe(402);
await expect(response.json()).resolves.toEqual({
error: {
code: "payment_required",
message: "API usage is disabled or exhausted.",
requestId: "req_usage_route",
},
});
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 402, error: "API usage is disabled or exhausted." }),
);
});
test("omits remaining for included-plan usage", async () => {
const usage = createUsageFixture({
title: "Included plan with {0} calls",
type: SUBSCRIPTION_FEATURE_LIMIT.included,
value: 25,
remaining: 25,
});
const { dependencies, mocks } = buildDeps({ usage });
const response = await requestUsage(dependencies, { "x-api-key": "valid-secret" });
const body = await response.json();
expect(response.status).toBe(200);
expect(body).toEqual({ plan: "Included plan with 25 calls" });
expect(body).not.toHaveProperty("remaining");
expect(mocks.setLegacyApiKeyLogStatus).toHaveBeenCalledWith(
{ id: "api_key_log_usage_1", tenantId: "tenant_usage_1" },
expect.objectContaining({ status: 200 }),
);
});
});