Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -20,12 +20,16 @@ vi.mock("./services/.server/urlService", async () => {
});
vi.mock("./session.server", () => ({
getUserInfo: vi.fn(),
getValidatedServerSession: vi.fn(),
}));
vi.mock("./db.server", () => ({
db: {
adminUser: {
findUnique: vi.fn(),
},
adminUserRole: {
findFirst: vi.fn(),
},
user: {
findUnique: vi.fn(),
},
@@ -43,8 +47,8 @@ import { getTenantUserType } from "./db/tenants.db.server";
import { db } from "./db.server";
import { getUserRoleInTenant } from "./db/permissions/userRoles.db.server";
import { getTenantIdFromUrl } from "./services/.server/urlService";
import { getUserInfo } from "./session.server";
import { requireAuth } from "./loaders.middleware";
import { getUserInfo, getValidatedServerSession } from "./session.server";
import { requireAuth, requireSuperAdmin } from "./loaders.middleware";
const env = {
APP_BASE_DOMAIN: "localhost:3000",
@@ -85,15 +89,15 @@ describe("requireAuth tenant-source routing", () => {
vi.mocked(getUserInfo).mockResolvedValue(userSession);
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant-1");
vi.mocked(getTenantUserType).mockResolvedValue({ status: 2, type: 1 });
vi.mocked(db.adminUser.findUnique).mockReset();
vi.mocked(db.adminUser.findUnique).mockResolvedValue(null);
vi.mocked(db.user.findUnique).mockResolvedValue({ admin: false });
vi.mocked(db.adminUserRole.findFirst).mockResolvedValue(null);
vi.mocked(getValidatedServerSession).mockResolvedValue(null);
vi.mocked(getUserRoleInTenant).mockResolvedValue(null);
});
it("requires tenant membership for app-host tenant route params", async () => {
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } })).resolves.toEqual(
userSession,
);
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } })).resolves.toEqual(userSession);
expect(getTenantIdFromUrl).toHaveBeenCalledWith({ tenant: "acme" });
expect(getTenantUserType).toHaveBeenCalledWith("user-1", "tenant-1");
@@ -105,48 +109,75 @@ describe("requireAuth tenant-source routing", () => {
await expectUnauthorized(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } }));
expect(getTenantUserType).toHaveBeenCalledWith("user-1", "tenant-1");
expect(db.adminUser.findUnique).toHaveBeenCalledWith({ where: { userId: "user-1" } });
expect(db.user.findUnique).toHaveBeenCalledWith({ where: { id: "user-1" }, select: { admin: true } });
expect(db.adminUserRole.findFirst).not.toHaveBeenCalled();
});
it("allows AdminUser operators to inspect app-host tenant requests without membership", async () => {
it("does not treat AdminUser console identity as tenant authorization", async () => {
vi.mocked(getTenantUserType).mockResolvedValueOnce(null);
vi.mocked(db.adminUser.findUnique).mockResolvedValueOnce({ userId: "user-1" });
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } })).resolves.toEqual(userSession);
await expectUnauthorized(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } }));
expect(getTenantUserType).toHaveBeenCalledWith("user-1", "tenant-1");
expect(db.adminUser.findUnique).toHaveBeenCalledWith({ where: { userId: "user-1" } });
expect(db.user.findUnique).toHaveBeenCalledWith({ where: { id: "user-1" }, select: { admin: true } });
expect(getValidatedServerSession).not.toHaveBeenCalled();
});
it("allows user.admin operators to inspect app-host tenant requests without membership", async () => {
it("does not allow the global SuperAdmin RBAC role to bypass tenant membership", async () => {
vi.mocked(getTenantUserType).mockResolvedValueOnce(null);
vi.mocked(db.user.findUnique).mockResolvedValueOnce({ admin: true });
vi.mocked(db.adminUserRole.findFirst).mockResolvedValueOnce({ adminUserId: "user-1" } as never);
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } })).resolves.toEqual(userSession);
await expectUnauthorized(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/acme/dashboard"), params: { tenant: "acme" } }));
expect(getTenantUserType).toHaveBeenCalledWith("user-1", "tenant-1");
expect(db.adminUser.findUnique).toHaveBeenCalledWith({ where: { userId: "user-1" } });
expect(db.user.findUnique).toHaveBeenCalledWith({ where: { id: "user-1" }, select: { admin: true } });
expect(db.adminUserRole.findFirst).not.toHaveBeenCalled();
});
it("keeps admin-host paths on the super-admin branch", async () => {
vi.mocked(db.adminUser.findUnique).mockResolvedValueOnce({ userId: "user-1" });
it("allows AdminUser identities onto the admin host without labeling them SuperAdmin", async () => {
vi.mocked(getValidatedServerSession).mockResolvedValueOnce({
id: "admin-session-1",
adminUserId: "user-1",
adminUser: { id: "user-1", status: "active" },
} as never);
await expect(requireAuth({ request: makeRequest(env.ADMIN_APP_HOST, "/settings"), params: {} })).resolves.toEqual({
...userSession,
isSuperAdmin: { userId: "user-1" },
adminIdentity: { id: "user-1", status: "active" },
});
expect(db.adminUser.findUnique).toHaveBeenCalledWith({ where: { userId: "user-1" } });
expect(getValidatedServerSession).toHaveBeenCalled();
expect(getTenantUserType).not.toHaveBeenCalled();
});
it("allows Authentik staff but rejects an identity whose allowed groups were removed", async () => {
vi.mocked(getValidatedServerSession).mockResolvedValueOnce({
id: "admin-session-1",
adminUserId: "user-1",
adminUser: { id: "user-1", status: "active", authentikGroups: ["hivegrid-staff"] },
} as never);
await expect(requireAuth({ request: makeRequest(env.ADMIN_APP_HOST, "/settings"), params: {} })).resolves.toMatchObject({
userId: "user-1",
});
vi.mocked(getValidatedServerSession).mockResolvedValueOnce(null);
await expectUnauthorized(requireAuth({ request: makeRequest(env.ADMIN_APP_HOST, "/settings"), params: {} }));
});
it("requires the global SuperAdmin role for explicit SuperAdmin guards", async () => {
await expectUnauthorized(requireSuperAdmin({ request: makeRequest(env.ADMIN_APP_HOST, "/settings") }));
vi.mocked(getValidatedServerSession).mockResolvedValue({
id: "admin-session-1",
adminUserId: "user-1",
adminUser: { id: "user-1", status: "active" },
} as never);
vi.mocked(db.adminUserRole.findFirst).mockResolvedValueOnce({ adminUserId: "user-1" } as never);
await expect(requireSuperAdmin({ request: makeRequest(env.ADMIN_APP_HOST, "/settings") })).resolves.toMatchObject({
userId: "user-1",
isSuperAdmin: true,
});
});
it("does not classify admin-prefixed non-admin paths as admin host routes", async () => {
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/adminish/dashboard"), params: { tenant: "adminish" } })).resolves.toEqual(
userSession,
);
await expect(requireAuth({ request: makeRequest(env.WEB_APP_HOST, "/adminish/dashboard"), params: { tenant: "adminish" } })).resolves.toEqual(userSession);
expect(getTenantIdFromUrl).toHaveBeenCalledWith({ tenant: "adminish" });
expect(getTenantUserType).toHaveBeenCalledWith("user-1", "tenant-1");