Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

fix tests

Thiago Araujo da Silva2322bdbd439e
diff --git a/backend/src/services/event-outbox/event-definition.test.ts b/backend/src/services/event-outbox/event-definition.test.ts
index eb340b05a7..95dd64a917 100644
--- a/backend/src/services/event-outbox/event-definition.test.ts
+++ b/backend/src/services/event-outbox/event-definition.test.ts
@@ -12,12 +12,8 @@ const ExampleEvent = defineEvent({
});
describe("defineEvent", () => {
- test("names the event by the ADR convention", () => {
- expect(ExampleEvent.type).toBe("com.infisical.secrets.secret-import.modified.v2");
- });
-
// The outbox validates every emitted event; a definition must never produce one it rejects.
- test("builds an input the outbox accepts, with a UUID of its own", () => {
+ test("names the event by the ADR convention and builds an input the outbox accepts", () => {
const input = ExampleEvent.build({ secretImportId: "import-1" });
expect(input).toEqual({
diff --git a/backend/src/services/event-outbox/event-outbox-service.test.ts b/backend/src/services/event-outbox/event-outbox-service.test.ts
index a5707cffa4..fa652c423d 100644
--- a/backend/src/services/event-outbox/event-outbox-service.test.ts
+++ b/backend/src/services/event-outbox/event-outbox-service.test.ts
@@ -154,22 +154,16 @@ describe("event outbox emit", () => {
expect(rejectedMetrics).toEqual([{ eventType: "approval.workflow.request_opened", reason: "data_too_large" }]);
});
- test("when the id is not a UUID", async () => {
+ test.each([
+ ["the id is not a UUID", { id: "reminder-1" }, "approval.workflow.request_opened"],
+ ["the type is not a dot-namespaced key", { type: "Not A Key" }, "Not A Key"]
+ ])("when %s", async (_, override, reportedType) => {
const { service, inserted } = buildService([makeConsumer()]);
- await expect(service.emit([makeEvent({ id: "reminder-1" })], TX)).rejects.toThrow();
+ await expect(service.emit([makeEvent(override)], TX)).rejects.toThrow();
expect(inserted).toHaveLength(0);
- expect(rejectedMetrics).toEqual([{ eventType: "approval.workflow.request_opened", reason: "invalid_event" }]);
- });
-
- test("when the envelope is malformed", async () => {
- const { service, inserted } = buildService([makeConsumer()]);
-
- await expect(service.emit([makeEvent({ type: "Not A Key" })], TX)).rejects.toThrow();
-
- expect(inserted).toHaveLength(0);
- expect(rejectedMetrics).toEqual([{ eventType: "Not A Key", reason: "invalid_event" }]);
+ expect(rejectedMetrics).toEqual([{ eventType: reportedType, reason: "invalid_event" }]);
});
test("without writing the well-formed events emitted with it", async () => {
diff --git a/backend/src/services/folder-commit/folder-commit-service.test.ts b/backend/src/services/folder-commit/folder-commit-service.test.ts
index 7f2db6c47b..4303fb628d 100644
--- a/backend/src/services/folder-commit/folder-commit-service.test.ts
+++ b/backend/src/services/folder-commit/folder-commit-service.test.ts
@@ -8,11 +8,14 @@ import { TSecretFolderVersions, TSecretVersionsV2 } from "@app/db/schemas";
import { BadRequestError, NotFoundError } from "@app/lib/errors";
import { ActorType } from "../auth/auth-type";
+import { FolderModifiedEventV1 } from "../secret-folder/secret-folder-events";
+import { SecretModifiedEventV1 } from "../secret-v2-bridge/secret-events";
import {
ChangeType,
CommitType,
folderCommitServiceFactory,
ResourceChange,
+ ResourceType,
TFolderCommitServiceFactory
} from "./folder-commit-service";
@@ -116,6 +119,7 @@ describe("folderCommitServiceFactory", () => {
const mockFolderVersionDAL = {
findLatestFolderVersions: vi.fn().mockResolvedValue({}),
+ findLatestVersion: vi.fn().mockResolvedValue(null),
findById: vi.fn().mockResolvedValue({}),
deleteById: vi.fn().mockResolvedValue({}),
create: vi.fn().mockResolvedValue({}),
@@ -749,5 +753,94 @@ describe("folderCommitServiceFactory", () => {
// Check that we got the right counts
expect(result.totalChanges).toEqual(2);
});
+
+ // A rollback rewrites secrets and folders without going through their services, so the events are
+ // emitted here. The folder paths are read before the writes because an update can rename a folder.
+ it("emits secret and folder events for what the rollback changed, in the transaction", async () => {
+ const folderId = "folder-id";
+ const projectId = "project-id";
+ const tx = {} as Knex;
+ const locations: Record<string, { path: string; environmentSlug: string }> = {
+ [folderId]: { path: "/app", environmentSlug: "dev" },
+ "folder-1": { path: "/app/old", environmentSlug: "dev" },
+ "folder-2": { path: "/app/gone", environmentSlug: "dev" }
+ };
+
+ mockFolderDAL.findById.mockResolvedValue({ id: folderId, envId: "env-1", projectId });
+ mockFolderDAL.findSecretPathByFolderIds.mockImplementation((_, ids: string[]) =>
+ Promise.resolve(ids.map((id) => locations[id]))
+ );
+ mockFolderDAL.updateById.mockResolvedValue({});
+ mockFolderDAL.deleteById.mockResolvedValue({});
+ mockFolderDAL.findByParentId.mockResolvedValue([]);
+ mockProjectDAL.findById.mockResolvedValue(null);
+ mockSecretVersionV2BridgeDAL.findByIdsWithLatestVersion.mockResolvedValue({
+ "secret-1": { secretId: "secret-1", type: "shared" }
+ });
+ mockSecretVersionV2BridgeDAL.findLatestVersionMany.mockResolvedValue({});
+ mockSecretVersionV2BridgeDAL.findLatestVersionByFolderId.mockResolvedValue([]);
+ mockSecretV2BridgeDAL.deleteById.mockResolvedValue({});
+ mockFolderVersionDAL.findByIdsWithLatestVersion.mockResolvedValue({
+ "folder-1": { folderId: "folder-1", name: "renamed", envId: "env-1", version: 1 }
+ });
+ mockFolderVersionDAL.create.mockResolvedValue({ id: "folder-version-2" });
+ mockFolderVersionDAL.findLatestVersion.mockResolvedValue(null);
+ mockFolderVersionDAL.find.mockResolvedValue({});
+ mockFolderCommitDAL.findLatestCommit.mockResolvedValue({ id: "latest-commit-id", folderId });
+ mockFolderCommitDAL.create.mockResolvedValue({ id: "new-commit-id" });
+ mockFolderCheckpointDAL.findLatestByFolderId.mockResolvedValue(null);
+
+ await folderCommitService.applyFolderStateDifferences({
+ differences: [
+ { id: "secret-1", versionId: "sv-1", changeType: ChangeType.DELETE, type: ResourceType.SECRET },
+ { id: "folder-1", versionId: "fv-1", changeType: ChangeType.UPDATE, type: ResourceType.FOLDER },
+ { id: "folder-2", versionId: "fv-2", changeType: ChangeType.DELETE, type: ResourceType.FOLDER }
+ ] as ResourceChange[],
+ actorInfo: { actorType: ActorType.USER, actorId: "user-id", message: "Rolling back" },
+ folderId,
+ projectId,
+ reconstructNewFolders: false,
+ tx
+ });
+
+ const calls = mockEventEmitter.emit.mock.calls as [{ type: string; data: unknown }[], unknown][];
+ expect(calls.every(([, emitTx]) => emitTx === tx)).toBe(true);
+ expect(calls.flatMap(([events]) => events)).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ type: SecretModifiedEventV1.type,
+ data: {
+ secretId: "secret-1",
+ projectId,
+ environment: "dev",
+ secretPath: "/app",
+ modificationType: "deleted"
+ }
+ }),
+ expect.objectContaining({
+ type: FolderModifiedEventV1.type,
+ data: {
+ folderId: "folder-1",
+ projectId,
+ environment: "dev",
+ secretPath: "/app/renamed",
+ modificationType: "updated",
+ previous: { secretPath: "/app/old" }
+ }
+ }),
+ expect.objectContaining({
+ type: FolderModifiedEventV1.type,
+ data: {
+ folderId: "folder-2",
+ projectId,
+ environment: "dev",
+ secretPath: "/app/gone",
+ modificationType: "deleted"
+ }
+ })
+ ])
+ );
+ expect(calls.flatMap(([events]) => events)).toHaveLength(3);
+ });
});
});
diff --git a/backend/src/services/reminder/reminder-service.test.ts b/backend/src/services/reminder/reminder-service.test.ts
index f3918974c0..a06533a68a 100644
--- a/backend/src/services/reminder/reminder-service.test.ts
+++ b/backend/src/services/reminder/reminder-service.test.ts
@@ -120,19 +120,6 @@ describe("reminder dispatch", () => {
]);
});
- // An id derived from reminder + date would make the outbox drop a reminder moved back onto a date it
- // already fired on.
- test("gives every firing its own event id, even for a date the reminder already fired on", async () => {
- const first = buildService({ due: [reminder()] });
- const movedBack = buildService({ due: [reminder()] });
-
- await first.service.dispatchDueReminders({ now });
- await movedBack.service.dispatchDueReminders({ now });
-
- expect(first.emitted[0].id).toMatch(/^[0-9a-f-]{36}$/);
- expect(movedBack.emitted[0].id).not.toBe(first.emitted[0].id);
- });
-
test("deletes a one-time reminder once its event is emitted", async () => {
const { service, emitted, deletes, updates } = buildService({ due: [reminder({ repeatDays: null })] });
await service.dispatchDueReminders({ now });