1045 lines
38 KiB
TypeScript
1045 lines
38 KiB
TypeScript
import type {Locator, Page} from "@playwright/test"
|
|
import {DAY, HOUR, MINUTE, MONTH, now} from "@welshman/lib"
|
|
import {Article} from "@welshman/domain"
|
|
import {
|
|
DEFAULT_BLOSSOM_ORIGIN,
|
|
dialog,
|
|
expect,
|
|
getHosting,
|
|
gifFile,
|
|
makeTestUser,
|
|
menuButton,
|
|
mockBlossom,
|
|
openMessageMenu,
|
|
roomPath,
|
|
spacePath,
|
|
test,
|
|
users,
|
|
} from "../harness"
|
|
|
|
const ICON = gifFile("icon.gif")
|
|
|
|
// `free` is what RelayForm starts on. PricingTable names a plan by its member limit.
|
|
const PLANS = [
|
|
{id: "free", name: "Free", amount: 0, hidden: false, members: 50, blossom: false, livekit: false},
|
|
{
|
|
id: "basic",
|
|
name: "Basic",
|
|
amount: 500,
|
|
hidden: false,
|
|
// Plan["members"] is number | null upstream, and null is how the hosting API spells unlimited.
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
members: null,
|
|
blossom: true,
|
|
livekit: true,
|
|
},
|
|
]
|
|
|
|
// Every field RelayDetailCard reads is present, since it calls .trim() and .replace() on several.
|
|
const hostedRelay = (overrides: Record<string, unknown> = {}) => ({
|
|
id: "relay-1",
|
|
tenant_pubkey: users.alice.pubkey,
|
|
subdomain: "space",
|
|
zooid_domain: "test",
|
|
plan_id: "free",
|
|
status: "active",
|
|
sync_error: "",
|
|
synced: now(),
|
|
custom_domain: "",
|
|
custom_domain_verified: 0,
|
|
info_name: "Space",
|
|
info_icon: "",
|
|
info_description: "",
|
|
policy_public_read: 0,
|
|
policy_public_write: 0,
|
|
policy_public_join: 1,
|
|
policy_strip_signatures: 0,
|
|
groups_enabled: 1,
|
|
management_enabled: 1,
|
|
blossom_enabled: 0,
|
|
livekit_enabled: 0,
|
|
push_enabled: 1,
|
|
...overrides,
|
|
})
|
|
|
|
// Tippy leaves a menu in the dom when it hides. Exact, since "Edit role" and "Edit roles" differ.
|
|
const menuItem = (page: Page, name: string) =>
|
|
page.getByRole("button", {name, exact: true}).filter({visible: true})
|
|
|
|
// That button is labeled with the space's name and its host, and only the host survives a rename.
|
|
const openSpaceMenu = (page: Page) => page.getByRole("button", {name: /space\.test/}).click()
|
|
|
|
// The card's aria-label is baked at first render, so the card is found by the name it shows.
|
|
const memberCard = (page: Page, name: string) =>
|
|
page.locator(".card-interactive").filter({hasText: name})
|
|
|
|
// Exact, because several permission names are a substring of another: "Ban members" of "Unban members".
|
|
const permission = (scope: Locator, name: string) =>
|
|
scope.getByRole("checkbox", {name, exact: true})
|
|
|
|
const openEventMenu = (card: Locator) => menuButton(card).click()
|
|
|
|
const articleCard = (page: Page, title: string) =>
|
|
page.locator('[data-component="ArticleItem"]').filter({hasText: title})
|
|
|
|
// A FieldInline puts its control in the div immediately after its label.
|
|
const setting = (page: Page, label: string) =>
|
|
page.locator("label").filter({hasText: label}).locator("xpath=following-sibling::div")
|
|
|
|
const settingToggle = (page: Page, label: string) => setting(page, label).getByRole("checkbox")
|
|
|
|
test("US-092 edit a space's profile and featured content", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.bob, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const admin = await as(users.admin, spacePath(url) + "/about")
|
|
|
|
await mockBlossom(admin.context(), {server: DEFAULT_BLOSSOM_ORIGIN})
|
|
|
|
await openSpaceMenu(admin)
|
|
await menuItem(admin, "Edit Space").click()
|
|
|
|
const editor = dialog(admin, "Edit this Space")
|
|
|
|
await editor.getByRole("button", {name: "Add an image"}).click()
|
|
|
|
// The upload's file input is hidden inside its own label, so the chooser opens by clicking it.
|
|
const picker = dialog(admin, "Add an image")
|
|
const chooser = admin.waitForEvent("filechooser")
|
|
|
|
await picker.locator('label:has(input[type="file"])').click()
|
|
await (await chooser).setFiles(ICON)
|
|
|
|
await expect(editor.getByText("Selected:")).toBeVisible()
|
|
|
|
await editor.locator('input[type="text"]').fill("Harbor")
|
|
await editor.locator("textarea").fill("Where the fleet ties up.")
|
|
await editor.getByRole("button", {name: "Save Changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Your changes have been saved!")
|
|
|
|
// All three come back off the relay's own nip-11 document
|
|
await expect(admin.getByRole("heading", {name: "Harbor"})).toBeVisible()
|
|
await expect(admin.getByText("Where the fleet ties up.")).toBeVisible()
|
|
await expect(admin.locator(`img[src^="${DEFAULT_BLOSSOM_ORIGIN}"]`).first()).toBeVisible()
|
|
|
|
const featured = admin
|
|
.locator(".card")
|
|
.filter({has: admin.getByRole("heading", {name: "Featured"})})
|
|
|
|
await featured.getByRole("button").first().click()
|
|
|
|
const featuredEditor = dialog(admin, "Featured Content")
|
|
|
|
await featuredEditor.getByRole("button", {name: "Add content"}).click()
|
|
await featuredEditor.getByPlaceholder("URL or nevent...").fill("Read the harbor rules first")
|
|
await featuredEditor.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Featured content updated!")
|
|
await expect(featured.getByText("Read the harbor rules first")).toBeVisible()
|
|
|
|
// What admin published reaches every visitor
|
|
const bob = await as(users.bob, spacePath(url) + "/about")
|
|
|
|
await expect(bob.getByRole("heading", {name: "Harbor"})).toBeVisible()
|
|
|
|
const bobsFeatured = bob
|
|
.locator(".card")
|
|
.filter({has: bob.getByRole("heading", {name: "Featured"})})
|
|
|
|
await expect(bobsFeatured.getByText("Read the harbor rules first")).toBeVisible()
|
|
})
|
|
|
|
test("US-093 create roles and assign them", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.bob, "general")
|
|
space.join(user.carol, "general")
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
space.profile(user.carol, {name: "Carol Cutter"})
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const admin = await as(users.admin, spacePath(url) + "/directory")
|
|
|
|
await expect(memberCard(admin, "Bob Barnacle")).toBeVisible()
|
|
|
|
await admin.getByRole("button", {name: "More options"}).click()
|
|
await menuItem(admin, "Manage Roles").click()
|
|
|
|
const roles = dialog(admin, "Manage Roles")
|
|
|
|
await roles.getByRole("button", {name: "Create Role"}).click()
|
|
|
|
const roleForm = dialog(admin, "Create Role")
|
|
|
|
await roleForm.getByPlaceholder("Moderator").fill("Deckhand")
|
|
await roleForm.locator("textarea").fill("Keeps the decks in order.")
|
|
await roleForm.getByRole("slider").fill("200")
|
|
await roleForm.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Role created!")
|
|
await expect(roles.locator(".role-badge")).toHaveText("Deckhand")
|
|
|
|
// Editing the label rewrites the role rather than adding a second one
|
|
await roles.locator(".card").filter({hasText: "Deckhand"}).getByRole("button").last().click()
|
|
await menuItem(admin, "Edit role").click()
|
|
|
|
const roleEditor = dialog(admin, "Edit Role")
|
|
|
|
await roleEditor.getByPlaceholder("Moderator").fill("Bosun")
|
|
await roleEditor.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Role updated!")
|
|
await expect(roles.locator(".role-badge")).toHaveText("Bosun")
|
|
|
|
// Handed out from the role's own menu...
|
|
await roles.locator(".card").filter({hasText: "Bosun"}).getByRole("button").last().click()
|
|
await menuItem(admin, "Add members").click()
|
|
|
|
const addMembers = dialog(admin, "Add to Bosun")
|
|
|
|
await addMembers.getByPlaceholder("Search for profiles...").fill("Bob")
|
|
await admin.locator(".tiptap-suggestions").getByRole("button", {name: users.bob.pubkey}).click()
|
|
await addMembers.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Members assigned!")
|
|
|
|
await roles.getByRole("button", {name: "Go back"}).click()
|
|
|
|
await expect(memberCard(admin, "Bob Barnacle").locator(".role-badge")).toHaveText("Bosun")
|
|
|
|
// ...or from a member's own card
|
|
await memberCard(admin, "Carol Cutter").getByRole("button").last().click()
|
|
await menuItem(admin, "Edit roles").click()
|
|
|
|
const carolsRoles = dialog(admin, "Edit Member")
|
|
|
|
await carolsRoles.getByRole("checkbox").check()
|
|
await carolsRoles.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Roles updated!")
|
|
await expect(memberCard(admin, "Carol Cutter").locator(".role-badge")).toHaveText("Bosun")
|
|
|
|
await admin.getByRole("button", {name: "More options"}).click()
|
|
await menuItem(admin, "Manage Roles").click()
|
|
await roles.locator(".card").filter({hasText: "Bosun"}).getByRole("button").last().click()
|
|
await menuItem(admin, "Delete role").click()
|
|
|
|
await dialog(admin, "Delete Role").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Role deleted!")
|
|
|
|
await roles.getByRole("button", {name: "Go back"}).click()
|
|
|
|
await expect(memberCard(admin, "Bob Barnacle")).toBeVisible()
|
|
await expect(memberCard(admin, "Carol Cutter").locator(".role-badge")).toHaveCount(0)
|
|
})
|
|
|
|
test("US-094 invite people to a space", async ({seed, as}) => {
|
|
const newcomer = makeTestUser("newcomer")
|
|
|
|
const scenario = await seed(({relay, user, at}) => {
|
|
const space = relay("space")
|
|
const other = relay("other")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.bob, "general")
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
|
|
// Somebody who belongs to a different space, so adding her here is a change to this one.
|
|
other.room("lounge", {name: "Lounge"})
|
|
other.join(user.admin, "lounge")
|
|
other.join(newcomer, "lounge")
|
|
other.profile(newcomer, {name: "Nadia Newcomer"})
|
|
other.message(newcomer, "lounge", "hello from the lounge", at(2, HOUR))
|
|
})
|
|
|
|
const other = scenario.space("other")
|
|
|
|
// The invite dialog's search reads the profiles this client already holds.
|
|
const page = await as(users.admin, roomPath(other.url, "lounge"))
|
|
|
|
await expect(page.getByText("Nadia Newcomer").first()).toBeVisible()
|
|
|
|
// In-app navigation rather than a reload, which would empty the repository she was loaded into
|
|
await page.locator('.primary-nav [data-tip^="space"]').click()
|
|
await openSpaceMenu(page)
|
|
await menuItem(page, "Create Invite").click()
|
|
|
|
const invite = dialog(page, "Create an Invite")
|
|
|
|
await expect(invite.locator("input[readonly]")).toHaveValue(/\/join\?r=space\.test&c=.+/)
|
|
|
|
await invite.getByPlaceholder("Search for profiles...").fill("Nadia")
|
|
await page.locator(".tiptap-suggestions").getByRole("button", {name: newcomer.pubkey}).click()
|
|
await invite.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Members have successfully been added!")
|
|
|
|
await page.locator(".secondary-nav").getByRole("link", {name: "Directory"}).click()
|
|
|
|
await expect(memberCard(page, "Nadia Newcomer")).toBeVisible()
|
|
|
|
// A room's own invite carries the space's claim and that room's join code alongside it
|
|
await page.locator(".space-menu__scroll").getByRole("link", {name: "General"}).click()
|
|
await page.locator('[data-component="PageBar"]').getByRole("button").last().click()
|
|
await page.getByRole("button", {name: "Create invite"}).click()
|
|
|
|
await expect(dialog(page, "Create a Room Invite").locator("input[readonly]")).toHaveValue(
|
|
/\/join\?r=space\.test&c=[^&]+&h=general&code=.+/,
|
|
)
|
|
})
|
|
|
|
test("US-095 remove, ban, and restore members", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.bob, "general")
|
|
space.join(user.carol, "general")
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
space.profile(user.carol, {name: "Carol Cutter"})
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const admin = await as(users.admin, spacePath(url) + "/directory")
|
|
|
|
await memberCard(admin, "Bob Barnacle").getByRole("button").last().click()
|
|
await menuItem(admin, "Remove member").click()
|
|
|
|
await dialog(admin, "Remove Member").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Member has successfully been removed!")
|
|
await expect(memberCard(admin, "Bob Barnacle")).toHaveCount(0)
|
|
|
|
await memberCard(admin, "Carol Cutter").getByRole("button").last().click()
|
|
await menuItem(admin, "Ban member").click()
|
|
|
|
await dialog(admin, "Ban Member").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Member has successfully been banned!")
|
|
await expect(memberCard(admin, "Carol Cutter")).toHaveCount(0)
|
|
|
|
await admin.getByRole("button", {name: "More options"}).click()
|
|
await menuItem(admin, "Banned Members").click()
|
|
|
|
const banned = dialog(admin, "Banned users")
|
|
|
|
await banned.locator(".card").filter({hasText: "Carol Cutter"}).getByRole("button").last().click()
|
|
await menuItem(admin, "Restore User").click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText(
|
|
"User has successfully been restored to membership!",
|
|
)
|
|
await expect(memberCard(admin, "Carol Cutter")).toBeVisible()
|
|
})
|
|
|
|
test("US-096 moderate messages and posts", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user, at}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.alice, "general")
|
|
space.join(user.bob, "general")
|
|
space.join(user.carol, "general")
|
|
space.profile(user.alice, {name: "Alice Anchor"})
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
space.message(user.alice, "general", "the hull is patched", at(2, HOUR))
|
|
space.message(user.bob, "general", "aye captain", at(90, MINUTE))
|
|
|
|
space.event(
|
|
user.bob,
|
|
() =>
|
|
space
|
|
.kind(Article)
|
|
.writer()
|
|
.setIdentifier("charting-the-reef")
|
|
.setTitle("Charting the Reef")
|
|
.setSummary("Where the shallows are.")
|
|
.setPublishedAt(at(3, HOUR))
|
|
.setContent("Mind the coral.")
|
|
.renderTemplate(),
|
|
at(3, HOUR),
|
|
)
|
|
|
|
// A second article, so a page with the deleted one missing is still a page that loaded
|
|
space.event(
|
|
user.alice,
|
|
() =>
|
|
space
|
|
.kind(Article)
|
|
.writer()
|
|
.setIdentifier("tides-and-timetables")
|
|
.setTitle("Tides and Timetables")
|
|
.setSummary("When to sail.")
|
|
.setPublishedAt(at(4, HOUR))
|
|
.setContent("Slack water is best.")
|
|
.renderTemplate(),
|
|
at(4, HOUR),
|
|
)
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
|
|
// An author gets a delete on their own content
|
|
const alice = await as(users.alice, roomPath(url, "general"))
|
|
|
|
await openMessageMenu(alice, "the hull is patched")
|
|
|
|
await expect(menuItem(alice, "Delete Message")).toBeVisible()
|
|
|
|
// Everybody else gets a report instead
|
|
const bob = await as(users.bob, roomPath(url, "general"))
|
|
|
|
await openMessageMenu(bob, "the hull is patched")
|
|
await menuItem(bob, "Report Content").click()
|
|
|
|
const report = dialog(bob, "Report Content")
|
|
|
|
await report.getByRole("combobox").selectOption("Spam")
|
|
await report.getByRole("button", {name: "Send Report"}).click()
|
|
|
|
await expect(bob.getByRole("alert")).toContainText("Your report has been sent!")
|
|
|
|
// An admin gets a delete on anything, authored by them or not
|
|
const admin = await as(users.admin, roomPath(url, "general"))
|
|
|
|
await expect(admin.getByText("aye captain")).toBeVisible()
|
|
|
|
await openMessageMenu(admin, "aye captain")
|
|
await menuItem(admin, "Delete Message").click()
|
|
|
|
await dialog(admin, "Delete Message").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Event has successfully been deleted!")
|
|
|
|
await admin.goto(spacePath(url) + "/articles")
|
|
await openEventMenu(articleCard(admin, "Charting the Reef"))
|
|
await menuItem(admin, "Delete Article").click()
|
|
|
|
await dialog(admin, "Delete Article").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Event has successfully been deleted!")
|
|
|
|
// A viewer arriving after the fact reads the space as the relay now holds it
|
|
const carol = await as(users.carol, roomPath(url, "general"))
|
|
|
|
await expect(carol.getByText("the hull is patched")).toBeVisible()
|
|
await expect(carol.getByText("aye captain")).toHaveCount(0)
|
|
|
|
await carol.goto(spacePath(url) + "/articles")
|
|
|
|
await expect(articleCard(carol, "Tides and Timetables")).toBeVisible()
|
|
await expect(articleCard(carol, "Charting the Reef")).toHaveCount(0)
|
|
})
|
|
|
|
test("US-097 work through the action-items queue", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user, at}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
// A room the relay will not admit anyone to on their own say-so, so a join request stays pending.
|
|
space.room("vault", {name: "Vault", closed: true, private: true})
|
|
space.join(user.admin, "general", "vault")
|
|
space.join(user.alice, "general")
|
|
space.join(user.bob, "general")
|
|
space.join(user.carol, "general")
|
|
space.profile(user.alice, {name: "Alice Anchor"})
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
space.profile(user.carol, {name: "Carol Cutter"})
|
|
space.message(user.alice, "general", "the hull is patched", at(2, HOUR))
|
|
space.message(user.alice, "general", "the sails are torn", at(90, MINUTE))
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const admin = await as(users.admin, spacePath(url) + "/about")
|
|
|
|
const report = async (page: Page, text: string, reason: string) => {
|
|
await openMessageMenu(page, text)
|
|
await menuItem(page, "Report Content").click()
|
|
|
|
const form = dialog(page, "Report Content")
|
|
|
|
await form.getByRole("combobox").selectOption(reason)
|
|
await form.getByRole("button", {name: "Send Report"}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Your report has been sent!")
|
|
}
|
|
|
|
const askToJoinVault = async (page: Page) => {
|
|
await page.goto(roomPath(url, "vault"))
|
|
await page.getByRole("button", {name: "Join Room"}).click()
|
|
|
|
await expect(page.getByRole("button", {name: "Access Pending"})).toBeVisible()
|
|
}
|
|
|
|
const bob = await as(users.bob, roomPath(url, "general"))
|
|
|
|
await expect(bob.getByText("the hull is patched")).toBeVisible()
|
|
|
|
await report(bob, "the hull is patched", "Spam")
|
|
await askToJoinVault(bob)
|
|
|
|
const carol = await as(users.carol, roomPath(url, "general"))
|
|
|
|
await expect(carol.getByText("the sails are torn")).toBeVisible()
|
|
|
|
await report(carol, "the sails are torn", "Other")
|
|
await askToJoinVault(carol)
|
|
|
|
await openSpaceMenu(admin)
|
|
await admin.getByRole("button", {name: /^Action Items/}).click()
|
|
|
|
const queue = dialog(admin, "Action Items")
|
|
const item = (text: string, kind: string) =>
|
|
queue.locator(".card").filter({hasText: text}).filter({hasText: kind})
|
|
|
|
// Each report names its reporter, its reason and the message it was filed against
|
|
const spamReport = item("Bob Barnacle", "Reported this event")
|
|
|
|
await expect(spamReport).toContainText('as "spam"')
|
|
await expect(spamReport).toContainText("the hull is patched")
|
|
|
|
const otherReport = item("Carol Cutter", "Reported this event")
|
|
|
|
await expect(otherReport).toContainText('as "other"')
|
|
await expect(otherReport).toContainText("the sails are torn")
|
|
|
|
// ...and each join request names its requester and the room they asked for
|
|
const carolsRequest = item("Carol Cutter", "requested membership")
|
|
const bobsRequest = item("Bob Barnacle", "requested membership")
|
|
|
|
await expect(carolsRequest).toContainText("requested membership in #Vault")
|
|
await expect(bobsRequest).toContainText("requested membership in #Vault")
|
|
|
|
await carolsRequest.getByRole("button", {name: "Accept"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Member has been added to the room!")
|
|
await expect(carolsRequest).toHaveCount(0)
|
|
|
|
await bobsRequest.getByRole("button", {name: "Dismiss"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Join request has been dismissed.")
|
|
await expect(bobsRequest).toHaveCount(0)
|
|
|
|
// Removing content deletes the message the report was filed against...
|
|
await spamReport.getByRole("button").first().click()
|
|
await menuItem(admin, "Remove Content").click()
|
|
|
|
await dialog(admin, "Remove Content").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Content has successfully been deleted!")
|
|
await expect(spamReport).toHaveCount(0)
|
|
|
|
// ...while dismissing only clears the report
|
|
await otherReport.getByRole("button").first().click()
|
|
await menuItem(admin, "Dismiss Report").click()
|
|
|
|
await expect(otherReport).toHaveCount(0)
|
|
|
|
// Accepting granted membership, dismissing did not
|
|
await admin.goto(roomPath(url, "vault"))
|
|
await admin.locator('[data-component="PageBar"]').getByRole("button").last().click()
|
|
await admin.getByRole("button", {name: "View All"}).click()
|
|
|
|
const members = dialog(admin, "Members")
|
|
|
|
await expect(members.getByText("Carol Cutter")).toBeVisible()
|
|
await expect(members.getByText("Bob Barnacle")).toHaveCount(0)
|
|
|
|
// The removed message is gone from the space, the dismissed one is not
|
|
const alice = await as(users.alice, roomPath(url, "general"))
|
|
|
|
await expect(alice.getByText("the sails are torn")).toBeVisible()
|
|
await expect(alice.getByText("the hull is patched")).toHaveCount(0)
|
|
})
|
|
|
|
test("US-130 share out admin permissions", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.bob, "general")
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const admin = await as(users.admin, spacePath(url) + "/directory")
|
|
|
|
await memberCard(admin, "Bob Barnacle").getByRole("button").last().click()
|
|
await menuItem(admin, "Edit permissions").click()
|
|
|
|
const permissions = dialog(admin, "Edit Permissions")
|
|
|
|
await permission(permissions, "Ban members").check()
|
|
await permission(permissions, "List banned members").check()
|
|
await permissions.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Permissions updated!")
|
|
|
|
await admin.getByRole("button", {name: "More options"}).click()
|
|
await menuItem(admin, "Admins").click()
|
|
|
|
const admins = dialog(admin, "Admins")
|
|
|
|
await expect(
|
|
admins.locator(".card").filter({hasText: "Bob Barnacle"}).locator(".badge"),
|
|
).toHaveText(["Ban members", "List banned members"])
|
|
|
|
await admins.getByRole("button", {name: "Go back"}).click()
|
|
|
|
// bob holds two methods now, so he gets the one control they cover and nothing else
|
|
const bob = await as(users.bob, spacePath(url) + "/directory")
|
|
|
|
await bob.getByRole("button", {name: "More options"}).click()
|
|
|
|
await expect(menuItem(bob, "Banned Members")).toBeVisible()
|
|
await expect(menuItem(bob, "Admins")).toHaveCount(0)
|
|
|
|
await memberCard(admin, "Bob Barnacle").getByRole("button").last().click()
|
|
await menuItem(admin, "Edit permissions").click()
|
|
await permission(permissions, "Ban members").uncheck()
|
|
await permission(permissions, "List banned members").uncheck()
|
|
await permissions.getByRole("button", {name: "Save changes"}).click()
|
|
|
|
await expect(admin.getByRole("alert")).toContainText("Permissions updated!")
|
|
|
|
await admin.getByRole("button", {name: "More options"}).click()
|
|
await menuItem(admin, "Admins").click()
|
|
|
|
await expect(admins.getByText("Nobody else has been given management permissions.")).toBeVisible()
|
|
})
|
|
|
|
test("US-098 browse and create hosted spaces", async ({seed, as}) => {
|
|
await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
const other = relay("other")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
other.room("lounge", {name: "Lounge"})
|
|
other.join(user.alice, "lounge")
|
|
})
|
|
|
|
const page = await as(users.alice, "/settings/hosting", {
|
|
hosting: {plans: PLANS},
|
|
// A space created here is opened at wss://<subdomain>.<domain>/, which has to name a tenant.
|
|
env: {VITE_HOSTING_RELAY_DOMAIN: "test"},
|
|
})
|
|
|
|
await page.getByRole("button", {name: "Create a Space"}).click()
|
|
|
|
const form = dialog(page, "New Space")
|
|
|
|
await form.getByPlaceholder("My Space").fill("Space")
|
|
|
|
// The subdomain follows the name until it is edited
|
|
await expect(form.getByPlaceholder("my-space")).toHaveValue("space")
|
|
|
|
await form.getByRole("button").filter({hasText: "Up to 50 members"}).click()
|
|
await form.getByRole("button", {name: "Create Space", exact: true}).click()
|
|
|
|
await expect(page).toHaveURL(/\/spaces\/space\.test\/admin/)
|
|
await expect(page.getByRole("heading", {name: "Space", exact: true})).toBeVisible()
|
|
|
|
await page.goto("/settings/hosting")
|
|
|
|
const listed = page.locator(".card").filter({hasText: "space.test"}).first()
|
|
|
|
await expect(listed).toContainText("Active")
|
|
await expect(listed).toContainText("Free")
|
|
|
|
// A paid plan has to be paid for, so creation hands straight over to payment
|
|
await page.getByRole("button", {name: "Create a Space"}).click()
|
|
await form.getByPlaceholder("My Space").fill("Other")
|
|
await form.getByRole("button").filter({hasText: "Unlimited members"}).click()
|
|
await form.getByRole("button", {name: "Create Space", exact: true}).click()
|
|
|
|
await expect(page).toHaveURL(/\/spaces\/other\.test\/admin/)
|
|
await expect(page.getByRole("heading", {name: "Set Up Payments"})).toBeVisible()
|
|
})
|
|
|
|
test("US-099 configure a hosted relay", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
space.join(user.bob, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const relayRecord = hostedRelay({
|
|
activity: [
|
|
{
|
|
id: "activity-1",
|
|
tenant_pubkey: users.alice.pubkey,
|
|
created_at: scenario.at(1, DAY),
|
|
activity_type: "create_relay",
|
|
resource_type: "relay",
|
|
resource_id: "relay-1",
|
|
},
|
|
],
|
|
})
|
|
|
|
const alice = await as(users.alice, spacePath(url) + "/admin", {
|
|
hosting: {plans: PLANS, relays: [relayRecord]},
|
|
})
|
|
|
|
await expect(alice.getByRole("heading", {name: "Space", exact: true})).toBeVisible()
|
|
await expect(alice.getByText("Relay created")).toBeVisible()
|
|
|
|
await alice.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(alice, "Edit details").click()
|
|
|
|
const editor = dialog(alice, "Edit Space")
|
|
|
|
await editor.getByPlaceholder("My Space").fill("Harbor")
|
|
await editor.locator("textarea").fill("Where the fleet ties up.")
|
|
await editor.getByRole("button", {name: "Save Changes"}).click()
|
|
|
|
await expect(alice.getByRole("heading", {name: "Harbor", exact: true})).toBeVisible()
|
|
await expect(alice.getByText("Where the fleet ties up.")).toBeVisible()
|
|
|
|
const publicRead = settingToggle(alice, "Public read")
|
|
|
|
await expect(publicRead).not.toBeChecked()
|
|
|
|
await publicRead.click()
|
|
|
|
await expect(publicRead).toBeChecked()
|
|
|
|
await alice.reload()
|
|
|
|
await expect(settingToggle(alice, "Public read")).toBeChecked()
|
|
|
|
// The free plan doesn't include either of these
|
|
await expect(settingToggle(alice, "Media storage")).toBeDisabled()
|
|
await expect(settingToggle(alice, "LiveKit support")).toBeDisabled()
|
|
|
|
// A member of the space who doesn't own it has nothing to manage here
|
|
const bob = await as(users.bob, spacePath(url) + "/admin")
|
|
|
|
await expect(bob.getByRole("link", {name: "Go to Hosting settings"})).toBeVisible()
|
|
})
|
|
|
|
test("US-100 change a hosted relay's plan", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const page = await as(users.alice, spacePath(url) + "/admin", {
|
|
hosting: {plans: PLANS, relays: [hostedRelay()]},
|
|
})
|
|
|
|
await expect(setting(page, "Current plan")).toHaveText("Free")
|
|
|
|
await page.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(page, "Change plan").click()
|
|
|
|
const plans = dialog(page, "Change plan")
|
|
|
|
await plans.getByRole("button").filter({hasText: "Unlimited members"}).click()
|
|
await plans.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Plan updated.")
|
|
|
|
// Nothing is on file to charge, so the upgrade hands over to payment setup
|
|
await expect(page.getByRole("heading", {name: "Set Up Payments"})).toBeVisible()
|
|
|
|
await page.getByRole("button", {name: "Set up later"}).click()
|
|
|
|
await expect(setting(page, "Current plan")).toHaveText("Basic")
|
|
|
|
// The paid plan unlocks both gated features
|
|
const blossom = settingToggle(page, "Media storage")
|
|
const livekit = settingToggle(page, "LiveKit support")
|
|
|
|
await blossom.click()
|
|
await livekit.click()
|
|
|
|
await expect(blossom).toBeChecked()
|
|
await expect(livekit).toBeChecked()
|
|
|
|
await page.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(page, "Change plan").click()
|
|
await plans.getByRole("button").filter({hasText: "Up to 50 members"}).click()
|
|
await plans.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Plan updated.")
|
|
await expect(setting(page, "Current plan")).toHaveText("Free")
|
|
await expect(settingToggle(page, "Media storage")).not.toBeChecked()
|
|
await expect(settingToggle(page, "LiveKit support")).not.toBeChecked()
|
|
})
|
|
|
|
test("US-101 point a custom domain at a hosted relay", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
const other = relay("other")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
|
|
// Where the space ends up once the domain verifies.
|
|
other.room("general", {name: "General"})
|
|
other.join(user.alice, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const page = await as(users.alice, spacePath(url) + "/admin", {
|
|
hosting: {plans: PLANS, relays: [hostedRelay()]},
|
|
})
|
|
|
|
await page.getByRole("button", {name: "Add domain"}).click()
|
|
|
|
const domainForm = dialog(page, "Custom domain")
|
|
|
|
await domainForm.getByPlaceholder("relay.example.com").fill("relay.other.test")
|
|
await domainForm.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Custom domain saved.")
|
|
await expect(page.getByText("relay.other.test", {exact: true})).toBeVisible()
|
|
await expect(page.getByText("Pending", {exact: true})).toBeVisible()
|
|
await expect(page.getByText("relay.other.test CNAME space.test")).toBeVisible()
|
|
|
|
// A bare domain can't take a CNAME, so it's shown as an ALIAS at the same target
|
|
await page.getByRole("button", {name: "Manage"}).click()
|
|
await domainForm.getByPlaceholder("relay.example.com").fill("other.test")
|
|
await domainForm.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(page.getByText("other.test", {exact: true})).toBeVisible()
|
|
await expect(page.getByText("other.test ALIAS space.test")).toBeVisible()
|
|
|
|
getHosting(page.context()).setRelay("relay-1", {custom_domain_verified: 1})
|
|
|
|
await page.getByRole("button", {name: "Verify DNS record"}).click()
|
|
|
|
await expect(page.getByRole("alert")).toContainText("Custom domain verified.")
|
|
await expect(page.getByText("Verified", {exact: true})).toBeVisible()
|
|
|
|
// The space is now reached through the domain its owner controls
|
|
await expect(page.getByRole("link", {name: "wss://other.test"})).toBeVisible()
|
|
await expect(page).toHaveURL(/\/spaces\/other\.test\/admin/)
|
|
})
|
|
|
|
test("US-102 pause a relay and settle the bill", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const paidPeriod = {start: scenario.at(2, MONTH), end: scenario.at(1, MONTH)}
|
|
const openPeriod = {start: scenario.at(1, MONTH), end: scenario.startedAt}
|
|
|
|
const page = await as(users.alice, spacePath(url) + "/admin", {
|
|
hosting: {
|
|
plans: PLANS,
|
|
relays: [hostedRelay({plan_id: "basic"})],
|
|
// Declared oldest first, which is not the order payment history reads in. null is "not yet".
|
|
/* eslint-disable no-restricted-syntax */
|
|
invoices: [
|
|
{
|
|
id: "invoice-paid",
|
|
tenant_pubkey: users.alice.pubkey,
|
|
amount: 500,
|
|
period_start: paidPeriod.start,
|
|
period_end: paidPeriod.end,
|
|
created_at: paidPeriod.start,
|
|
paid_at: paidPeriod.end,
|
|
voided_at: null,
|
|
method: "nwc",
|
|
},
|
|
{
|
|
id: "invoice-open",
|
|
tenant_pubkey: users.alice.pubkey,
|
|
amount: 900,
|
|
period_start: openPeriod.start,
|
|
period_end: openPeriod.end,
|
|
created_at: openPeriod.start,
|
|
paid_at: null,
|
|
voided_at: null,
|
|
method: null,
|
|
},
|
|
],
|
|
/* eslint-enable no-restricted-syntax */
|
|
},
|
|
})
|
|
|
|
await expect(page.getByText("Active", {exact: true})).toBeVisible()
|
|
|
|
await page.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(page, "Deactivate").click()
|
|
|
|
await dialog(page, "Deactivate relay?").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(page.getByText("Inactive", {exact: true})).toBeVisible()
|
|
|
|
await page.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(page, "Reactivate").click()
|
|
|
|
await dialog(page, "Reactivate relay?").getByRole("button", {name: "Confirm"}).click()
|
|
|
|
await expect(page.getByText("Active", {exact: true})).toBeVisible()
|
|
|
|
await page.goto("/settings/hosting")
|
|
|
|
const banner = page.getByText(
|
|
"You have an unpaid invoice. Pay it now to keep your relays running.",
|
|
)
|
|
|
|
await expect(banner).toBeVisible()
|
|
|
|
await page.getByRole("button", {name: "Pay now"}).first().click()
|
|
|
|
const payment = dialog(page, "Pay invoice")
|
|
|
|
await expect(payment.getByText("$9.00")).toBeVisible()
|
|
|
|
getHosting(page.context()).setInvoice("invoice-open", {paid_at: now(), method: "nwc"})
|
|
|
|
await payment.getByRole("button", {name: "Check payment"}).click()
|
|
|
|
await expect(payment.getByText("Payment confirmed!")).toBeVisible()
|
|
|
|
await payment.getByRole("button", {name: "Done"}).click()
|
|
|
|
await expect(banner).toHaveCount(0)
|
|
|
|
// With the balance settled, the standing prompt is to keep it that way
|
|
await page.getByRole("button", {name: "Set up autopay"}).click()
|
|
|
|
const autopay = dialog(page, "Set Up Payments")
|
|
|
|
await autopay
|
|
.getByPlaceholder("nostr+walletconnect://")
|
|
.fill(`nostr+walletconnect://${users.alice.pubkey}?relay=${url}&secret=abc`)
|
|
await autopay.getByRole("button", {name: "Save", exact: true}).click()
|
|
|
|
await expect(autopay.getByText("Wallet connected!")).toBeVisible()
|
|
|
|
await autopay.getByRole("button", {name: "Done"}).click()
|
|
|
|
await expect(page.getByRole("listitem").filter({hasText: "Lightning (NWC)"})).toContainText(
|
|
"Connected",
|
|
)
|
|
|
|
// Payment history, newest first
|
|
const history = page.locator(".card").filter({hasText: "Payment History"}).first()
|
|
const invoices = history.getByRole("listitem")
|
|
|
|
await expect(invoices.first()).toContainText("$9.00")
|
|
await expect(invoices.nth(1)).toContainText("$5.00")
|
|
})
|
|
|
|
test("US-122 export and import a hosted relay's data", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user}) => {
|
|
const space = relay("space")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.alice, "general")
|
|
})
|
|
|
|
const {url} = scenario.space("space")
|
|
const dump = '{"id":"a","sig":"a"}\n{"id":"b","sig":"b"}\n'
|
|
const page = await as(users.alice, spacePath(url) + "/admin", {
|
|
hosting: {plans: PLANS, relays: [hostedRelay({events: dump})]},
|
|
})
|
|
|
|
await page.getByRole("button", {name: "Relay actions"}).click()
|
|
await menuItem(page, "Import / export data").click()
|
|
|
|
const modal = dialog(page, "Relay data")
|
|
const download = page.waitForEvent("download")
|
|
|
|
await modal.getByRole("button", {name: "Download events"}).click()
|
|
|
|
expect((await download).suggestedFilename()).toBe("space.jsonl")
|
|
|
|
await modal.locator("input[type=file]").setInputFiles({
|
|
name: "events.jsonl",
|
|
mimeType: "application/x-ndjson",
|
|
buffer: Buffer.from('{"id":"c","sig":"c"}\nnot an event\n'),
|
|
})
|
|
|
|
await modal.getByRole("button", {name: "Import events"}).click()
|
|
|
|
// The relay keeps what it could verify and says which line it refused
|
|
await expect(modal.getByText("Imported 1 event, skipped 1.")).toBeVisible()
|
|
await expect(modal.getByText("line 2: invalid event")).toBeVisible()
|
|
})
|
|
|
|
// delegated.test grants every member one management method, so `supportedmethods` differs by user.
|
|
const openDelegatedMenu = (page: Page) =>
|
|
page.getByRole("button", {name: /delegated\.test/}).click()
|
|
|
|
test("US-127 a member holding one method gets only that control", async ({seed, as}) => {
|
|
const scenario = await seed(({relay, user, at}) => {
|
|
const space = relay("delegated")
|
|
|
|
space.room("general", {name: "General"})
|
|
space.join(user.admin, "general")
|
|
space.join(user.alice, "general")
|
|
space.join(user.bob, "general")
|
|
space.profile(user.alice, {name: "Alice Anchor"})
|
|
space.profile(user.bob, {name: "Bob Barnacle"})
|
|
space.message(user.bob, "general", "aye captain", at(2, HOUR))
|
|
})
|
|
|
|
const {url} = scenario.space("delegated")
|
|
|
|
// alice holds allowpubkey, which covers the join requests in the queue and nothing else
|
|
const alice = await as(users.alice, roomPath(url, "general"))
|
|
|
|
await expect(alice.getByText("aye captain")).toBeVisible()
|
|
|
|
await openMessageMenu(alice, "aye captain")
|
|
|
|
await expect(menuItem(alice, "Report Content")).toBeVisible()
|
|
await expect(alice.getByRole("button", {name: "Delete Message", exact: true})).toHaveCount(0)
|
|
|
|
await alice.goto(spacePath(url) + "/directory")
|
|
|
|
await expect(alice.getByRole("button", {name: "Invite people"})).toBeVisible()
|
|
await expect(alice.getByRole("button", {name: "More options"})).toHaveCount(0)
|
|
|
|
await openDelegatedMenu(alice)
|
|
|
|
await expect(alice.getByRole("button", {name: /^Action Items/})).toBeVisible()
|
|
await expect(alice.getByRole("button", {name: "Edit Space", exact: true})).toHaveCount(0)
|
|
|
|
// admin owns the relay, so every method comes back and every control is there
|
|
const admin = await as(users.admin, roomPath(url, "general"))
|
|
|
|
await openMessageMenu(admin, "aye captain")
|
|
|
|
await expect(menuItem(admin, "Delete Message")).toBeVisible()
|
|
|
|
await admin.goto(spacePath(url) + "/directory")
|
|
|
|
await expect(admin.getByRole("button", {name: "More options"})).toBeVisible()
|
|
|
|
await openDelegatedMenu(admin)
|
|
|
|
await expect(menuItem(admin, "Edit Space")).toBeVisible()
|
|
})
|