mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
* fix: Fail fast on Redis for cache and rate limits, lock migrations in Postgres * fix: Use the fail-fast Redis client for locks * fix: Require a database pool of at least two connections * chore: Rename cache Redis client to ephemeralClient
194 lines
5.6 KiB
TypeScript
194 lines
5.6 KiB
TypeScript
import Redis from "@server/storage/redis";
|
|
import { CacheHelper } from "./CacheHelper";
|
|
import { MutexLock } from "./MutexLock";
|
|
|
|
describe("CacheHelper", () => {
|
|
beforeEach(async () => {
|
|
await Redis.defaultClient.flushdb();
|
|
});
|
|
|
|
describe("setData and getData", () => {
|
|
it("should round-trip a value", async () => {
|
|
await CacheHelper.setData("test:key", { foo: "bar" }, 60);
|
|
const result = await CacheHelper.getData<{ foo: string }>("test:key");
|
|
expect(result).toEqual({ foo: "bar" });
|
|
});
|
|
|
|
it("should return undefined for a missing key", async () => {
|
|
const result = await CacheHelper.getData("test:missing");
|
|
expect(result).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("getDataOrSet", () => {
|
|
it("should coalesce concurrent same-key misses into one callback", async () => {
|
|
let calls = 0;
|
|
const callback = async () => {
|
|
calls++;
|
|
return "value";
|
|
};
|
|
|
|
const results = await Promise.all(
|
|
Array.from({ length: 10 }, () =>
|
|
CacheHelper.getDataOrSet("test:dedupe", callback, 60)
|
|
)
|
|
);
|
|
|
|
expect(calls).toEqual(1);
|
|
expect(results).toEqual(Array.from({ length: 10 }, () => "value"));
|
|
expect(await CacheHelper.getData("test:dedupe")).toEqual("value");
|
|
});
|
|
|
|
it("should return a cached falsy value without invoking the callback", async () => {
|
|
await CacheHelper.setData("test:falsy", null, 60);
|
|
|
|
let calls = 0;
|
|
const callback = async () => {
|
|
calls++;
|
|
return ["value"];
|
|
};
|
|
|
|
expect(
|
|
await CacheHelper.getDataOrSet("test:falsy", callback, 60)
|
|
).toBeNull();
|
|
expect(calls).toEqual(0);
|
|
});
|
|
|
|
it("should cache a falsy callback result and not re-invoke on the next miss", async () => {
|
|
let calls = 0;
|
|
const callback = async () => {
|
|
calls++;
|
|
return null;
|
|
};
|
|
|
|
expect(
|
|
await CacheHelper.getDataOrSet<string[] | null>(
|
|
"test:null",
|
|
callback,
|
|
60
|
|
)
|
|
).toBeNull();
|
|
expect(await CacheHelper.getData("test:null")).toBeNull();
|
|
|
|
expect(
|
|
await CacheHelper.getDataOrSet<string[] | null>(
|
|
"test:null",
|
|
callback,
|
|
60
|
|
)
|
|
).toBeNull();
|
|
expect(calls).toEqual(1);
|
|
});
|
|
|
|
it("should not cache an undefined callback result", async () => {
|
|
let calls = 0;
|
|
const callback = async () => {
|
|
calls++;
|
|
return undefined;
|
|
};
|
|
|
|
expect(
|
|
await CacheHelper.getDataOrSet("test:undef", callback, 60)
|
|
).toBeUndefined();
|
|
expect(
|
|
await CacheHelper.getDataOrSet("test:undef", callback, 60)
|
|
).toBeUndefined();
|
|
expect(calls).toEqual(2);
|
|
});
|
|
|
|
it("should call the callback again after the in-flight promise settles", async () => {
|
|
let calls = 0;
|
|
const callback = async () => {
|
|
calls++;
|
|
return calls === 1 ? undefined : "value";
|
|
};
|
|
|
|
expect(
|
|
await CacheHelper.getDataOrSet("test:retry", callback, 60)
|
|
).toBeUndefined();
|
|
expect(
|
|
await CacheHelper.getDataOrSet("test:retry", callback, 60)
|
|
).toEqual("value");
|
|
expect(calls).toEqual(2);
|
|
});
|
|
});
|
|
|
|
describe("getDataOrSet when Redis is unavailable", () => {
|
|
const { status } = Redis.ephemeralClient;
|
|
|
|
afterEach(() => {
|
|
Redis.ephemeralClient.status = status;
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
it("should return the callback result without taking a lock", async () => {
|
|
Redis.ephemeralClient.status = "reconnecting";
|
|
vi.spyOn(Redis.ephemeralClient, "get").mockRejectedValue(
|
|
new Error("Stream isn't writeable")
|
|
);
|
|
vi.spyOn(Redis.ephemeralClient, "set").mockRejectedValue(
|
|
new Error("Stream isn't writeable")
|
|
);
|
|
const acquire = vi.spyOn(MutexLock, "acquire");
|
|
|
|
const result = await CacheHelper.getDataOrSet(
|
|
"test:unavailable",
|
|
async () => "value",
|
|
60
|
|
);
|
|
|
|
expect(result).toEqual("value");
|
|
expect(acquire).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("removeData", () => {
|
|
it("should remove a single key", async () => {
|
|
await CacheHelper.setData("test:key", "value", 60);
|
|
await CacheHelper.removeData("test:key");
|
|
const result = await CacheHelper.getData("test:key");
|
|
expect(result).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
describe("clearData", () => {
|
|
it("should remove all keys matching the prefix", async () => {
|
|
await CacheHelper.setData("unfurl:team-1:https://a.com", "a", 60);
|
|
await CacheHelper.setData("unfurl:team-1:https://b.com", "b", 60);
|
|
await CacheHelper.setData("unfurl:team-2:https://c.com", "c", 60);
|
|
|
|
await CacheHelper.clearData("unfurl:team-1");
|
|
|
|
expect(
|
|
await CacheHelper.getData("unfurl:team-1:https://a.com")
|
|
).toBeUndefined();
|
|
expect(
|
|
await CacheHelper.getData("unfurl:team-1:https://b.com")
|
|
).toBeUndefined();
|
|
expect(await CacheHelper.getData("unfurl:team-2:https://c.com")).toEqual(
|
|
"c"
|
|
);
|
|
});
|
|
|
|
it("should resolve when no keys match the prefix", async () => {
|
|
await expect(CacheHelper.clearData("test:nothing")).resolves.toBe(
|
|
undefined
|
|
);
|
|
});
|
|
|
|
it("should remove more keys than a single scan page", async () => {
|
|
const count = 2500;
|
|
const pipeline = Redis.defaultClient.pipeline();
|
|
for (let i = 0; i < count; i++) {
|
|
pipeline.set(`test:bulk:${i}`, "value");
|
|
}
|
|
await pipeline.exec();
|
|
|
|
await CacheHelper.clearData("test:bulk:");
|
|
|
|
const remaining = await Redis.defaultClient.keys("test:bulk:*");
|
|
expect(remaining.length).toEqual(0);
|
|
});
|
|
});
|
|
});
|