forked from baron/baron-sso
402 lines
12 KiB
TypeScript
402 lines
12 KiB
TypeScript
import { expect, test } from "@playwright/test";
|
|
|
|
test.describe("Tenants Management", () => {
|
|
test.beforeEach(async ({ page }) => {
|
|
await page.addInitScript(() => {
|
|
window.localStorage.setItem("locale", "ko");
|
|
window.localStorage.setItem("admin_session", "fake-token");
|
|
(
|
|
window as Window & typeof globalThis & { _IS_TEST_MODE?: boolean }
|
|
)._IS_TEST_MODE = true;
|
|
|
|
const authority = "http://localhost:5000/oidc";
|
|
const client_id = "adminfront";
|
|
const key = `oidc.user:${authority}:${client_id}`;
|
|
const authData = {
|
|
access_token: "fake-token",
|
|
token_type: "Bearer",
|
|
profile: { sub: "admin-user", name: "Admin", role: "super_admin" },
|
|
expires_at: Math.floor(Date.now() / 1000) + 36000,
|
|
};
|
|
window.localStorage.setItem(key, JSON.stringify(authData));
|
|
});
|
|
|
|
await page.route("**/api/v1/**", async (route) => {
|
|
const url = route.request().url();
|
|
const headers = { "Access-Control-Allow-Origin": "*" };
|
|
|
|
if (url.includes("/user/me")) {
|
|
return route.fulfill({
|
|
json: {
|
|
id: "admin-user",
|
|
name: "Admin",
|
|
role: "super_admin",
|
|
manageableTenants: [],
|
|
},
|
|
headers,
|
|
});
|
|
}
|
|
if (url.includes("/admin/tenants")) {
|
|
if (
|
|
route.request().method() === "GET" &&
|
|
!url.includes("/parent-1") &&
|
|
!url.includes("/organization")
|
|
) {
|
|
return route.fulfill({
|
|
json: { items: [], total: 0, limit: 100, offset: 0 },
|
|
headers,
|
|
});
|
|
}
|
|
}
|
|
return route.fulfill({ json: { items: [], total: 0 }, headers });
|
|
});
|
|
|
|
await page.route("**/oidc/**", async (route) => {
|
|
await route.fulfill({ json: { issuer: "http://localhost:5000/oidc" } });
|
|
});
|
|
});
|
|
|
|
test("should list tenants", async ({ page }) => {
|
|
const internalTenantId = "c5839444-2de0-4a37-99b0-4f94d3de8bea";
|
|
|
|
await page.route("**/api/v1/admin/tenants**", async (route) => {
|
|
if (route.request().method() === "GET") {
|
|
await route.fulfill({
|
|
json: {
|
|
items: [
|
|
{
|
|
id: internalTenantId,
|
|
name: "Tenant A",
|
|
slug: "tenant-a",
|
|
status: "active",
|
|
type: "COMPANY",
|
|
updatedAt: new Date().toISOString(),
|
|
},
|
|
],
|
|
total: 1,
|
|
limit: 1000,
|
|
offset: 0,
|
|
},
|
|
headers: { "Access-Control-Allow-Origin": "*" },
|
|
});
|
|
} else {
|
|
await route.continue();
|
|
}
|
|
});
|
|
|
|
await page.goto("/tenants");
|
|
await expect(page.locator("h2").last()).toContainText(
|
|
/테넌트 목록|Tenants/i,
|
|
{ timeout: 20000 },
|
|
);
|
|
await expect(page.locator("table")).toContainText("Tenant A", {
|
|
timeout: 10000,
|
|
});
|
|
await expect(page.locator("table")).toContainText(internalTenantId);
|
|
});
|
|
|
|
test("should create a new tenant", async ({ page }) => {
|
|
await page.goto("/tenants/new");
|
|
await expect(page.locator("h2").last()).toContainText(/추가|Create/i, {
|
|
timeout: 20000,
|
|
});
|
|
|
|
const nameInput = page.locator('input[name="name"]').first();
|
|
await nameInput.fill("New Tenant");
|
|
|
|
const slugInput = page.locator('input[name="slug"]').first();
|
|
await slugInput.fill("new-tenant");
|
|
|
|
await page.locator("textarea").first().fill("Description");
|
|
|
|
const submitBtn = page
|
|
.locator("button")
|
|
.filter({ hasText: /생성|Create/i })
|
|
.first();
|
|
await submitBtn.click();
|
|
await expect(page).toHaveURL(/.*\/tenants$/, { timeout: 15000 });
|
|
});
|
|
|
|
test("should export and import tenant CSV without organization/user combined import", async ({
|
|
page,
|
|
browserName,
|
|
}, testInfo) => {
|
|
let exportRequested = false;
|
|
let exportUrl = "";
|
|
let importRequested = false;
|
|
let importBody = "";
|
|
|
|
await page.route("**/api/v1/admin/tenants**", async (route) => {
|
|
const url = route.request().url();
|
|
const method = route.request().method();
|
|
const headers = { "Access-Control-Allow-Origin": "*" };
|
|
|
|
if (url.includes("/export")) {
|
|
exportRequested = true;
|
|
exportUrl = url;
|
|
return route.fulfill({
|
|
body: "tenant_id,name,type,parent_tenant_id,slug,memo,email_domain\n",
|
|
contentType: "text/csv",
|
|
headers: {
|
|
...headers,
|
|
"Content-Disposition": 'attachment; filename="tenants.csv"',
|
|
},
|
|
});
|
|
}
|
|
|
|
if (url.includes("/import")) {
|
|
importRequested = true;
|
|
importBody = route.request().postData() ?? "";
|
|
return route.fulfill({
|
|
json: { created: 0, updated: 1, failed: 0, errors: [] },
|
|
headers,
|
|
});
|
|
}
|
|
|
|
if (method === "GET") {
|
|
return route.fulfill({
|
|
json: {
|
|
items: [
|
|
{
|
|
id: "tenant-alpha-id",
|
|
name: "Tenant Alpha",
|
|
slug: "tenant-alpha",
|
|
status: "active",
|
|
type: "COMPANY",
|
|
domains: [],
|
|
memberCount: 0,
|
|
updatedAt: new Date().toISOString(),
|
|
},
|
|
],
|
|
total: 1,
|
|
limit: 1000,
|
|
offset: 0,
|
|
},
|
|
headers,
|
|
});
|
|
}
|
|
|
|
return route.continue();
|
|
});
|
|
|
|
await page.goto("/tenants");
|
|
await expect(page.locator("h2").last()).toContainText(
|
|
/테넌트 목록|Tenants/i,
|
|
{ timeout: 20000 },
|
|
);
|
|
|
|
await expect(page.getByText(/조직\/사용자 통합/)).toHaveCount(0);
|
|
await expect(page.getByTestId("tenant-template-btn")).toBeVisible();
|
|
await expect(page.getByTestId("tenant-export-btn")).toBeVisible();
|
|
await expect(page.getByTestId("tenant-import-btn")).toBeVisible();
|
|
|
|
const download = page.waitForEvent("download");
|
|
await page.getByTestId("tenant-export-btn").click();
|
|
await download;
|
|
expect(exportRequested).toBe(true);
|
|
expect(exportUrl).toContain("includeIds=false");
|
|
|
|
await page.getByTestId("tenant-import-input").setInputFiles({
|
|
name: "tenants.csv",
|
|
mimeType: "text/csv",
|
|
buffer: Buffer.from(
|
|
"tenant_id,name,type,parent_tenant_id,slug,memo,email_domain\n,Tenant Alpha,COMPANY,,tenant-alpha-copy,Imported memo,imported.example.com\n",
|
|
),
|
|
});
|
|
|
|
await expect(page.getByRole("dialog")).toContainText("CSV 가져오기 확인");
|
|
await expect(page.getByTestId("tenant-import-candidate")).toContainText(
|
|
"Tenant Alpha",
|
|
);
|
|
await page.getByTestId("tenant-import-confirm-btn").click();
|
|
|
|
await expect(page.getByTestId("tenant-import-result")).toContainText(
|
|
/갱신 1|Updated 1/i,
|
|
);
|
|
expect(importRequested).toBe(true);
|
|
expect(importBody).toContain('filename="tenants.csv"');
|
|
if (browserName !== "webkit") {
|
|
if (testInfo.project.name !== "webkit") {
|
|
expect(importBody).toContain("tenant-alpha-id");
|
|
}
|
|
}
|
|
});
|
|
|
|
test("should resolve tenant CSV conflicts by choosing create and remapping parent ids", async ({
|
|
page,
|
|
}, testInfo) => {
|
|
let importBody = "";
|
|
|
|
await page.route("**/api/v1/admin/tenants**", async (route) => {
|
|
const url = route.request().url();
|
|
const method = route.request().method();
|
|
const headers = { "Access-Control-Allow-Origin": "*" };
|
|
|
|
if (url.includes("/import")) {
|
|
importBody = route.request().postData() ?? "";
|
|
return route.fulfill({
|
|
json: { created: 2, updated: 0, failed: 0, errors: [] },
|
|
headers,
|
|
});
|
|
}
|
|
|
|
if (method === "GET") {
|
|
return route.fulfill({
|
|
json: {
|
|
items: [
|
|
{
|
|
id: "staging-existing-id",
|
|
name: "Existing Parent",
|
|
slug: "parent-local",
|
|
status: "active",
|
|
type: "COMPANY",
|
|
domains: [],
|
|
memberCount: 0,
|
|
updatedAt: new Date().toISOString(),
|
|
},
|
|
],
|
|
total: 1,
|
|
limit: 1000,
|
|
offset: 0,
|
|
},
|
|
headers,
|
|
});
|
|
}
|
|
|
|
return route.continue();
|
|
});
|
|
|
|
await page.goto("/tenants");
|
|
await expect(page.locator("h2").last()).toContainText(
|
|
/테넌트 목록|Tenants/i,
|
|
{ timeout: 20000 },
|
|
);
|
|
|
|
await page.getByTestId("tenant-import-input").setInputFiles({
|
|
name: "tenants.csv",
|
|
mimeType: "text/csv",
|
|
buffer: Buffer.from(
|
|
[
|
|
"tenant_id,name,type,parent_tenant_id,slug,memo,email_domain",
|
|
"local-parent-id,Parent Tenant,COMPANY,,parent-local,,",
|
|
"local-child-id,Child Tenant,USER_GROUP,local-parent-id,child-local,,",
|
|
].join("\n"),
|
|
),
|
|
});
|
|
|
|
await expect(page.getByRole("dialog")).toContainText("CSV 가져오기 확인");
|
|
await page
|
|
.getByTestId("tenant-import-match-select-2")
|
|
.selectOption("__create__");
|
|
await page
|
|
.getByTestId("tenant-import-create-slug-2")
|
|
.fill("parent-created");
|
|
await page
|
|
.getByTestId("tenant-import-match-select-3")
|
|
.selectOption("__create__");
|
|
await page.getByTestId("tenant-import-create-slug-3").fill("child-created");
|
|
await page.getByTestId("tenant-import-confirm-btn").click();
|
|
|
|
await expect(page.getByTestId("tenant-import-result")).toContainText(
|
|
/생성 2|Created 2/i,
|
|
);
|
|
|
|
if (testInfo.project.name === "webkit") {
|
|
expect(importBody).not.toContain("local-parent-id");
|
|
expect(importBody).not.toContain("local-child-id");
|
|
return;
|
|
}
|
|
|
|
expect(importBody).not.toContain("local-parent-id");
|
|
expect(importBody).not.toContain("local-child-id");
|
|
const parentMatch = importBody.match(
|
|
/([0-9a-f-]{36}),Parent Tenant,COMPANY,,parent-created/,
|
|
);
|
|
expect(parentMatch?.[1]).toBeTruthy();
|
|
expect(importBody).toContain(
|
|
`,Child Tenant,USER_GROUP,${parentMatch?.[1]},child-created`,
|
|
);
|
|
});
|
|
|
|
test("should show validation error on empty name", async ({ page }) => {
|
|
await page.goto("/tenants/new");
|
|
await expect(page.locator("h2").last()).toContainText(/추가|Create/i, {
|
|
timeout: 20000,
|
|
});
|
|
|
|
const submitBtn = page
|
|
.locator("button")
|
|
.filter({ hasText: /생성|Create/i })
|
|
.first();
|
|
await expect(submitBtn).toBeDisabled();
|
|
|
|
await page.locator('input[name="name"]').first().fill("Valid Name");
|
|
await expect(submitBtn).not.toBeDisabled();
|
|
});
|
|
|
|
test("should show organization hierarchy and member list distinction", async ({
|
|
page,
|
|
}) => {
|
|
const mockTenants = [
|
|
{
|
|
id: "parent-1",
|
|
name: "Parent Org",
|
|
slug: "parent-slug",
|
|
status: "active",
|
|
type: "COMPANY",
|
|
memberCount: 5,
|
|
parentId: null,
|
|
},
|
|
{
|
|
id: "child-1",
|
|
name: "Child Team",
|
|
slug: "child-slug",
|
|
status: "active",
|
|
type: "USER_GROUP",
|
|
memberCount: 3,
|
|
parentId: "parent-1",
|
|
},
|
|
];
|
|
|
|
await page.route("**/api/v1/admin/tenants**", async (route) => {
|
|
const url = route.request().url();
|
|
if (url.includes("/organization")) {
|
|
await route.fulfill({
|
|
json: mockTenants,
|
|
headers: { "Access-Control-Allow-Origin": "*" },
|
|
});
|
|
} else if (url.includes("/parent-1")) {
|
|
await route.fulfill({
|
|
json: mockTenants[0],
|
|
headers: { "Access-Control-Allow-Origin": "*" },
|
|
});
|
|
} else {
|
|
await route.fulfill({
|
|
json: { items: mockTenants, total: 2, limit: 1000, offset: 0 },
|
|
headers: { "Access-Control-Allow-Origin": "*" },
|
|
});
|
|
}
|
|
});
|
|
|
|
await page.goto("/tenants/parent-1/organization");
|
|
|
|
await expect(
|
|
page.locator(".font-bold, h2").filter({ hasText: "Parent Org" }).first(),
|
|
).toBeVisible({ timeout: 20000 });
|
|
|
|
await expect(
|
|
page
|
|
.locator(".grid .font-bold, .grid .text-sm")
|
|
.filter({ hasText: "Child Team" })
|
|
.first(),
|
|
).toBeVisible();
|
|
|
|
await expect(
|
|
page
|
|
.locator("h3")
|
|
.filter({ hasText: /소속 멤버|Members|구성원 관리|Member Management/i })
|
|
.first(),
|
|
).toBeVisible();
|
|
});
|
|
});
|