Files
outline/server/queues/tasks/SyncUserGroupsTask.test.ts
T
Tom MoorandClaude Fable 5.1 abc47b442a feat: Sync group descriptions and re-sync groups on SSO validation (#13889)
* feat: Sync group descriptions and re-sync groups on SSO validation

- Sync group descriptions from group sync providers alongside names
- Lock name and description edits for externally synced groups at the
  API layer and in the edit dialog
- Move group sync into a SyncUserGroupsTask, scheduled from login and
  from ValidateSSOAccessTask after a fresh provider validation
- Add authenticationProviders.startGroupSync for providers that require
  an admin consent flow before group sync can be enabled

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* fix: Make group sync setup generic and deduplicate sync jobs

- Expose groupSyncRequiresSetup from the provider list and use it in the
  settings scene instead of checking for the azure provider name
- Rename the setup redirect query param to groupSync
- Give SyncUserGroupsTask a job id per user authentication so concurrent
  syncs for the same authentication are not queued twice

* Use existing hook

---------

Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-25 19:49:26 -04:00

118 lines
3.4 KiB
TypeScript

import { vi } from "vitest";
import {
AuthenticationProvider,
Group,
GroupUser,
UserAuthentication,
} from "@server/models";
import { buildUser } from "@server/test/factories";
import { mockTaskSchedule } from "@server/test/support";
import { PluginManager } from "@server/utils/PluginManager";
import SyncUserGroupsTask from "./SyncUserGroupsTask";
async function setup() {
const user = await buildUser();
const authenticationProvider = (await AuthenticationProvider.findOne({
where: { teamId: user.teamId },
}))!;
await authenticationProvider.update({
settings: { groupSyncEnabled: true },
});
const authentication = (await UserAuthentication.findOne({
where: { userId: user.id },
}))!;
await authentication.update({ accessToken: "access-token" });
const fetchUserGroups = vi
.fn()
.mockResolvedValue([{ id: "ext-1", name: "Engineering" }]);
vi.spyOn(PluginManager, "getGroupSyncProvider").mockReturnValue({
useGroupClaim: false,
fetchUserGroups,
});
return { user, authentication, fetchUserGroups };
}
describe("SyncUserGroupsTask", () => {
const schedule = mockTaskSchedule();
afterEach(() => {
vi.restoreAllMocks();
});
it("should schedule with a job id unique to the user authentication", async () => {
const { authentication } = await setup();
await new SyncUserGroupsTask().schedule({
userAuthenticationId: authentication.id,
});
expect(schedule).toHaveBeenCalledWith(
{ userAuthenticationId: authentication.id },
{ jobId: `sync-user-groups:${authentication.id}` }
);
});
it("should sync groups using the stored access token", async () => {
const { user, authentication, fetchUserGroups } = await setup();
await new SyncUserGroupsTask().perform({
userAuthenticationId: authentication.id,
});
expect(fetchUserGroups).toHaveBeenCalledWith("access-token", {
groupSyncEnabled: true,
});
const group = await Group.findOne({
where: { teamId: user.teamId, name: "Engineering" },
});
expect(group).not.toBeNull();
const membership = await GroupUser.findOne({
where: { groupId: group!.id, userId: user.id },
});
expect(membership).not.toBeNull();
});
it("should not sync groups for suspended users", async () => {
const { user, authentication, fetchUserGroups } = await setup();
await user.update({ suspendedAt: new Date() });
await new SyncUserGroupsTask().perform({
userAuthenticationId: authentication.id,
});
expect(fetchUserGroups).not.toHaveBeenCalled();
});
it("should not sync groups when group sync is disabled", async () => {
const { user, authentication, fetchUserGroups } = await setup();
const authenticationProvider = (await AuthenticationProvider.findOne({
where: { teamId: user.teamId },
}))!;
await authenticationProvider.update({
settings: { groupSyncEnabled: false },
});
await new SyncUserGroupsTask().perform({
userAuthenticationId: authentication.id,
});
expect(fetchUserGroups).not.toHaveBeenCalled();
});
it("should throw when the provider fails so the task is retried", async () => {
const { authentication, fetchUserGroups } = await setup();
fetchUserGroups.mockRejectedValue(new Error("provider unavailable"));
await expect(
new SyncUserGroupsTask().perform({
userAuthenticationId: authentication.id,
})
).rejects.toThrow("provider unavailable");
});
});