299 lines
11 KiB
TypeScript
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 }),
|
|
);
|
|
});
|
|
});
|