Files
cal.diy/packages/features/booking-audit/lib/actions/__tests__/ReassignmentAuditActionService.test.ts
T
Eunjae LeeandClaude Opus 4.6 98b6d63164 refactor: apply biome formatting to packages/features (#27844)
* refactor: apply biome formatting to packages/features (batch 1 - small subdirs)

Format small subdirectories in packages/features: di, flags, holidays, oauth,
settings, users, assignment-reason, selectedCalendar, hashedLink, host, form,
form-builder, availability, data-table, pbac, schedules, troubleshooter,
eventtypes, calendar-subscription, and root-level files.

Also includes straggler apps/web BookEventForm.tsx.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: apply biome formatting to packages/features (batch 2 - medium subdirs)

Format medium subdirectories in packages/features: auth, credentials,
calendars, routing-forms, routing-trace, attributes, watchlist, calAIPhone,
tasker, and webhooks.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: apply biome formatting to packages/features (batch 3 - bookings + insights)

Format bookings and insights subdirectories in packages/features.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: apply biome formatting to packages/features (batch 4 - ee)

Format packages/features/ee subdirectory covering billing, workflows,
organizations, teams, managed-event-types, round-robin, dsync,
integration-attribute-sync, and payments.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: apply biome formatting to packages/features (batch 5 - booking-audit part 1)

Format booking-audit di, actions, common, dto, repository, and types
subdirectories in packages/features/booking-audit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor: apply biome formatting to packages/features (batch 6 - booking-audit part 2)

Format booking-audit service subdirectory in packages/features/booking-audit.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
2026-02-11 15:47:14 +01:00

451 lines
14 KiB
TypeScript

import { beforeEach, describe, expect, it } from "vitest";
import { ReassignmentAuditActionService } from "../ReassignmentAuditActionService";
import { createMockEnrichmentDataStore, verifyDataRequirementsContract } from "./contractVerification";
describe("ReassignmentAuditActionService", () => {
let service: ReassignmentAuditActionService;
beforeEach(() => {
service = new ReassignmentAuditActionService();
});
describe("getVersionedData", () => {
it("should wrap fields with version number", () => {
const fields = {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual" as const,
};
const result = service.getVersionedData(fields);
expect(result).toEqual({
version: 1,
fields,
});
});
it("should handle roundRobin reassignment type with attendee update", () => {
const fields = {
organizerUuid: { old: "fixed-host", new: "fixed-host" },
hostAttendeeUpdated: {
id: 123,
withUserUuid: { old: "old-rr-host", new: "new-rr-host" },
},
reassignmentReason: null,
reassignmentType: "roundRobin" as const,
};
const result = service.getVersionedData(fields);
expect(result).toEqual({
version: 1,
fields,
});
});
it("should handle null reassignment reason", () => {
const fields = {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: null,
reassignmentType: "manual" as const,
};
const result = service.getVersionedData(fields);
expect(result).toEqual({
version: 1,
fields,
});
});
});
describe("parseStored", () => {
it("should parse valid stored data", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const result = service.parseStored(storedData);
expect(result.version).toBe(1);
expect(result.fields).toEqual({
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
});
});
it("should throw error for invalid data", () => {
const invalidData = {
version: 1,
fields: {
reassignmentReason: "Host unavailable",
},
};
expect(() => service.parseStored(invalidData)).toThrow();
});
});
describe("getVersion", () => {
it("should return version from stored data", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: null,
reassignmentType: "manual",
},
};
const result = service.getVersion(storedData);
expect(result).toBe(1);
});
});
describe("migrateToLatest", () => {
it("should return data as-is for V1 (no migration needed)", () => {
const fields = {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual" as const,
};
const result = service.migrateToLatest(fields);
expect(result.isMigrated).toBe(false);
expect(result.latestData).toEqual(fields);
});
});
describe("getDataRequirements", () => {
it("should return userUuids for organizer change", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const result = service.getDataRequirements(storedData);
expect(result.userUuids).toContain("organizer-new");
expect(result.userUuids).toContain("organizer-old");
});
it("should return userUuids for attendee update", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "fixed-host", new: "fixed-host" },
hostAttendeeUpdated: {
id: 123,
withUserUuid: { old: "old-rr-host", new: "new-rr-host" },
},
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const result = service.getDataRequirements(storedData);
expect(result.userUuids).toContain("new-rr-host");
expect(result.userUuids).toContain("old-rr-host");
});
});
describe("getDisplayTitle", () => {
it("should return translation key with host name for manual reassignment (organizer changed)", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const dbStore = createMockEnrichmentDataStore(
{
users: [
{ id: 1, uuid: "organizer-new", name: "New Host", email: "new@example.com", avatarUrl: null },
{ id: 2, uuid: "organizer-old", name: "Old Host", email: "old@example.com", avatarUrl: null },
],
},
{ userUuids: ["organizer-new", "organizer-old"] }
);
const result = await service.getDisplayTitle({ storedData, dbStore, userTimeZone: "UTC" });
expect(result).toEqual({
key: "booking_audit_action.booking_reassigned_to_host",
params: { host: "New Host" },
});
});
it("should return host name when attendee was updated (fixed-host scenario)", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "fixed-host", new: "fixed-host" },
hostAttendeeUpdated: {
id: 123,
withUserUuid: { old: "old-rr-host", new: "new-rr-host" },
},
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const dbStore = createMockEnrichmentDataStore(
{
users: [
{ id: 1, uuid: "new-rr-host", name: "New RR Host", email: "newrr@example.com", avatarUrl: null },
{ id: 2, uuid: "old-rr-host", name: "Old RR Host", email: "oldrr@example.com", avatarUrl: null },
],
},
{ userUuids: ["new-rr-host", "old-rr-host"] }
);
const result = await service.getDisplayTitle({ storedData, dbStore, userTimeZone: "UTC" });
expect(result).toEqual({
key: "booking_audit_action.booking_reassigned_to_host",
params: { host: "New RR Host" },
});
});
it("should return 'Unknown' when user not found", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const dbStore = createMockEnrichmentDataStore(
{ users: [] },
{ userUuids: ["organizer-new", "organizer-old"] }
);
const result = await service.getDisplayTitle({ storedData, dbStore, userTimeZone: "UTC" });
expect(result).toEqual({
key: "booking_audit_action.booking_reassigned_to_host",
params: { host: "Unknown" },
});
});
it("should return 'Unknown' when user has no name", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: null,
reassignmentType: "manual",
},
};
const dbStore = createMockEnrichmentDataStore(
{
users: [
{ id: 1, uuid: "organizer-new", name: null, email: "new@example.com", avatarUrl: null },
{ id: 2, uuid: "organizer-old", name: "Old Host", email: "old@example.com", avatarUrl: null },
],
},
{ userUuids: ["organizer-new", "organizer-old"] }
);
const result = await service.getDisplayTitle({ storedData, dbStore, userTimeZone: "UTC" });
expect(result).toEqual({
key: "booking_audit_action.booking_reassigned_to_host",
params: { host: "Unknown" },
});
});
});
describe("getDisplayJson", () => {
it("should return display data for manual reassignment (organizer changed)", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const result = service.getDisplayJson({ storedData, userTimeZone: "UTC" });
expect(result).toEqual({
newOrganizerUuid: "organizer-new",
previousOrganizerUuid: "organizer-old",
reassignmentReason: "Host unavailable",
});
});
it("should return display data for fixed-host reassignment (attendee updated)", () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "fixed-host-uuid", new: "fixed-host-uuid" },
hostAttendeeUpdated: {
id: 123,
withUserUuid: { old: "old-rr-host-uuid", new: "new-rr-host-uuid" },
},
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const result = service.getDisplayJson({ storedData, userTimeZone: "UTC" });
expect(result).toEqual({
newOrganizerUuid: "fixed-host-uuid",
previousOrganizerUuid: "fixed-host-uuid",
hostAttendeeIdUpdated: 123,
hostAttendeeUserUuidNew: "new-rr-host-uuid",
hostAttendeeUserUuidOld: "old-rr-host-uuid",
reassignmentReason: null,
});
});
});
describe("getDisplayFields", () => {
it("should return assignment type field for manual reassignment", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const dbStore = createMockEnrichmentDataStore(
{
users: [
{
id: 1,
uuid: "organizer-old",
name: "Previous Host",
email: "old@example.com",
avatarUrl: null,
},
{ id: 2, uuid: "organizer-new", name: "New Host", email: "new@example.com", avatarUrl: null },
],
},
{ userUuids: ["organizer-old", "organizer-new"] }
);
const result = await service.getDisplayFields({ storedData, dbStore });
expect(result).toEqual([
{
labelKey: "booking_audit_action.assignment_type",
valueKey: "booking_audit_action.assignment_type_manual",
},
{
labelKey: "booking_audit_action.previous_assignee",
valueKey: "Previous Host",
},
]);
});
it("should return assignment type field for round robin reassignment", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const dbStore = createMockEnrichmentDataStore(
{
users: [
{
id: 1,
uuid: "organizer-old",
name: "Previous Host",
email: "old@example.com",
avatarUrl: null,
},
{ id: 2, uuid: "organizer-new", name: "New Host", email: "new@example.com", avatarUrl: null },
],
},
{ userUuids: ["organizer-old", "organizer-new"] }
);
const result = await service.getDisplayFields({ storedData, dbStore });
expect(result).toEqual([
{
labelKey: "booking_audit_action.assignment_type",
valueKey: "booking_audit_action.assignment_type_round_robin",
},
{
labelKey: "booking_audit_action.previous_assignee",
valueKey: "Previous Host",
},
]);
});
});
describe("TYPE constant", () => {
it("should have correct type value", () => {
expect(ReassignmentAuditActionService.TYPE).toBe("REASSIGNMENT");
});
});
describe("getDataRequirements contract verification", () => {
it("should declare exactly the userUuids accessed for organizer change", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "organizer-old", new: "organizer-new" },
reassignmentReason: "Host unavailable",
reassignmentType: "manual",
},
};
const { errors, accessedData } = await verifyDataRequirementsContract(service, storedData);
expect(errors).toEqual([]);
expect(accessedData.userUuids.size).toBe(2);
});
it("should declare exactly the userUuids accessed for attendee update", async () => {
const storedData = {
version: 1,
fields: {
organizerUuid: { old: "fixed-host", new: "fixed-host" },
hostAttendeeUpdated: {
id: 123,
withUserUuid: { old: "old-rr-host", new: "new-rr-host" },
},
reassignmentReason: null,
reassignmentType: "roundRobin",
},
};
const { errors, accessedData } = await verifyDataRequirementsContract(service, storedData);
expect(errors).toEqual([]);
expect(accessedData.userUuids.size).toBe(2);
});
});
});