Trophies · E2E tests

2 modules · 11 exports · 1 repository · 6 e2e tests · 7 routes

OverviewModulesRepositoriesPermissionsSearch params & storageE2E tests

• NN-ZAP
• SSendou

• Arrange data setup
• Act what the user does
• Assert what is expected

Show code of each step

e2e/trophies.spec.ts

Trophies

shows trophy wins via user page trophy display

N-ZAPtrophies.spec.ts:28

Renders/u/:identifier/u/:identifier

User page

LOLogged out

Act

1. Slow

   test.slow();

Arrange

1. Create trophy name “Wellstring Wednesday” → trophy

   const trophy = await factories.TrophyFactory.create({ name: TROPHY_NAME });

2. Play trophy tournament trophy id trophy.id → tournament

   const tournament = await playTrophyTournament(factories, {
   	trophyId: trophy.id,
   });

3. Grant user Sendou widgets id “trophies-owned”

   await factories.UserFactory.grant(ADMIN_ID, {
   	widgets: [{ id: "trophies-owned" }],
   });

NN-ZAP

User page

Act

1. Open the user page Sendou

   await userPage.goto(ADMIN_ID);

2. Get by test id “trophy-display” → display

   const display = page.getByTestId("trophy-display");

Assert

1. display is visible

   await expect(display).toBeVisible();

Act

1. Click display.getByRole("button", { name: TROPHY_NAME })

   await display.getByRole("button", { name: TROPHY_NAME }).click();

Assert

1. text “View trophy page” is visible

   await expect(page.getByText("View trophy page")).toBeVisible();

2. dialog › `a[href^='/to/${tournament.id}']` is visible

   await expect(
   	page.getByRole("dialog").locator(`a[href^='/to/${tournament.id}']`),
   ).toBeVisible();

Source

test("shows trophy wins via user page trophy display", async ({
	page,
	factories,
}) => {
	test.slow();

	const trophy = await factories.TrophyFactory.create({ name: TROPHY_NAME });
	const tournament = await playTrophyTournament(factories, {
		trophyId: trophy.id,
	});
	await factories.UserFactory.grant(ADMIN_ID, {
		widgets: [{ id: "trophies-owned" }],
	});

	await impersonate(page, NZAP_TEST_ID);

	const userPage = new UserPage(page);
	await userPage.goto(ADMIN_ID);

	const display = page.getByTestId("trophy-display");
	await expect(display).toBeVisible();
	await display.getByRole("button", { name: TROPHY_NAME }).click();

	await expect(page.getByText("View trophy page")).toBeVisible();
	await expect(
		page.getByRole("dialog").locator(`a[href^='/to/${tournament.id}']`),
	).toBeVisible();
})

browses trophy details from the trophies list

N-ZAPtrophies.spec.ts:57

Renders/trophies/trophies/:id

Trophies pageTrophy details pageTrophies pageTrophy details page

LOLogged out

Act

1. Slow

   test.slow();

Arrange

1. the trophy's series, so that the next edition of it shows a tentative tier

   Create tournament organization name “Sendou's Tournaments” owner Sendou series name “Wellstring Wednesday” description null show leaderboard false → organization

   const organization = await factories.TournamentOrganizationFactory.create(
   	{ name: ORGANIZATION_NAME, ownerId: ADMIN_ID },
   	{
   		series: [
   			{ name: TROPHY_NAME, description: null, showLeaderboard: false },
   		],
   	},
   );

2. Create trophy name “Wellstring Wednesday” → trophy

   const trophy = await factories.TrophyFactory.create({ name: TROPHY_NAME });

3. Create trophy name “Chris P. Bacon” → otherTrophy

   const otherTrophy = await factories.TrophyFactory.create({
   	name: "Chris P. Bacon",
   });

4. Play trophy tournament trophy id trophy.id organization id organization.id

   await playTrophyTournament(factories, {
   	trophyId: trophy.id,
   	organizationId: organization.id,
   });

5. Create tournament name `${TROPHY_NAME} 2` author Sendou organization id organization.id start times dateToDatabaseTimestamp(addDays(new Date(), UPCOMING_IN_DAYS)) trophy id trophy.id → upcoming

   const upcoming = await factories.TournamentFactory.create({
   	name: `${TROPHY_NAME} 2`,
   	authorId: ADMIN_ID,
   	organizationId: organization.id,
   	startTimes: [
   		dateToDatabaseTimestamp(addDays(new Date(), UPCOMING_IN_DAYS)),
   	],
   	trophyId: trophy.id,
   });

NN-ZAP

Trophies page

Act

1. Open the trophies page

   await trophies.goto();

Assert

1. count is more than 1

   expect(await trophies.locators.trophyLinks.count()).toBeGreaterThan(1);

Act

1. Search “Chris P”

   await trophies.search("Chris P");

Assert

1. trophy links count is 1

   await expect(trophies.locators.trophyLinks).toHaveCount(1);

Act

1. Open first → details

   const details = await trophies.openFirst();

Assert

1. the page URL is `/trophies/${otherTrophy.id}`

   await expect(page).toHaveURL(`/trophies/${otherTrophy.id}`);

Trophy details page

Assert

1. owners heading is visible

   await expect(details.locators.ownersHeading).toBeVisible();

Trophies page

Act

1. Search “Wellstring”

   await trophies.search("Wellstring");

Assert

1. tentative tier trophy.id is visible

   await expect(trophies.tentativeTier(trophy.id)).toBeVisible();

2. upcoming pill trophy.id is visible

   await expect(trophies.upcomingPill(trophy.id)).toBeVisible();

Act

1. Click tile trophy.id

   await trophies.tile(trophy.id).click();

Trophy details page

Assert

1. first owner links is visible

   await expect(details.locators.ownerLinks.first()).toBeVisible();

Act

1. Tournament row upcoming.id → upcomingRow

   const upcomingRow = details.tournamentRow(upcoming.id);

Assert

1. upcomingRow.getByText("Upcoming") is visible

   await expect(upcomingRow.getByText("Upcoming")).toBeVisible();

2. upcomingRow.getByText(`in ${UPCOMING_IN_DAYS} days`) is visible

   await expect(
   	upcomingRow.getByText(`in ${UPCOMING_IN_DAYS} days`),
   ).toBeVisible();

Source

test("browses trophy details from the trophies list", async ({
	page,
	factories,
}) => {
	test.slow();

	// the trophy's series, so that the next edition of it shows a tentative tier
	const organization = await factories.TournamentOrganizationFactory.create(
		{ name: ORGANIZATION_NAME, ownerId: ADMIN_ID },
		{
			series: [
				{ name: TROPHY_NAME, description: null, showLeaderboard: false },
			],
		},
	);

	const trophy = await factories.TrophyFactory.create({ name: TROPHY_NAME });
	const otherTrophy = await factories.TrophyFactory.create({
		name: "Chris P. Bacon",
	});

	await playTrophyTournament(factories, {
		trophyId: trophy.id,
		organizationId: organization.id,
	});
	const upcoming = await factories.TournamentFactory.create({
		name: `${TROPHY_NAME} 2`,
		authorId: ADMIN_ID,
		organizationId: organization.id,
		startTimes: [
			dateToDatabaseTimestamp(addDays(new Date(), UPCOMING_IN_DAYS)),
		],
		trophyId: trophy.id,
	});

	await impersonate(page, NZAP_TEST_ID);

	const trophies = new TrophiesPage(page);
	await trophies.goto();
	expect(await trophies.locators.trophyLinks.count()).toBeGreaterThan(1);

	await trophies.search("Chris P");
	await expect(trophies.locators.trophyLinks).toHaveCount(1);

	const details = await trophies.openFirst();
	await expect(page).toHaveURL(`/trophies/${otherTrophy.id}`);
	await expect(details.locators.ownersHeading).toBeVisible();

	await trophies.search("Wellstring");
	await expect(trophies.tentativeTier(trophy.id)).toBeVisible();
	await expect(trophies.upcomingPill(trophy.id)).toBeVisible();

	await trophies.tile(trophy.id).click();
	await expect(details.locators.ownerLinks.first()).toBeVisible();

	const upcomingRow = details.tournamentRow(upcoming.id);
	await expect(upcomingRow.getByText("Upcoming")).toBeVisible();
	await expect(
		upcomingRow.getByText(`in ${UPCOMING_IN_DAYS} days`),
	).toBeVisible();
})

submits a new trophy after agreeing to terms

Sendoutrophies.spec.ts:119

Renders/trophies/new

New trophy pagePending trophy list

Setup

Arrange

1. Create tournament organization name “Sendou's Tournaments” owner Sendou

   await factories.TournamentOrganizationFactory.create({
   	name: ORGANIZATION_NAME,
   	ownerId: ADMIN_ID,
   });

SSendou

New trophy page

Act

1. Open the new trophy page

   await newTrophy.goto();

Assert

1. name input is not visible

   await isNotVisible(newTrophy.locators.nameInput);

Act

1. Agree to terms

   await newTrophy.agreeToTerms();

2. Fill form name “E2E Test Trophy” organization name “Sendou's Tournaments” model decompressFromBase64(factories.TrophyFactory.MODELS[0]) ?? ""

   await newTrophy.fillForm({
   	name: "E2E Test Trophy",
   	organizationName: ORGANIZATION_NAME,
   	model: decompressFromBase64(factories.TrophyFactory.MODELS[0]) ?? "",
   });

3. Save

   await newTrophy.save();

4. Open pending → pending

   const pending = await newTrophy.openPending();

Pending trophy list

Assert

1. row “E2E Test Trophy” is visible

   await expect(pending.row("E2E Test Trophy")).toBeVisible();

Source

test("submits a new trophy after agreeing to terms", async ({
	page,
	factories,
}) => {
	await factories.TournamentOrganizationFactory.create({
		name: ORGANIZATION_NAME,
		ownerId: ADMIN_ID,
	});

	await impersonate(page);

	const newTrophy = new NewTrophyPage(page);
	await newTrophy.goto();

	await isNotVisible(newTrophy.locators.nameInput);
	await newTrophy.agreeToTerms();

	await newTrophy.fillForm({
		name: "E2E Test Trophy",
		organizationName: ORGANIZATION_NAME,
		model: decompressFromBase64(factories.TrophyFactory.MODELS[0]) ?? "",
	});
	await newTrophy.save();

	const pending = await newTrophy.openPending();
	await expect(pending.row("E2E Test Trophy")).toBeVisible();
})

reviews pending trophies

SendouN-ZAPtrophies.spec.ts:147

Renders//trophies/new

New trophy pageNotification popoverPending trophy listNotification popoverPending trophy listNotification popoverNew trophy pagePending trophy listNotification popover

Setup

Arrange

1. Create tournament organization name “Sendou's Tournaments” owner N-ZAP → organization

   const organization = await factories.TournamentOrganizationFactory.create({
   	name: ORGANIZATION_NAME,
   	ownerId: NZAP_TEST_ID,
   });

2. approvedName = "Approved Trophy"

   const approvedName = "Approved Trophy";

3. declinedName = "Declined Trophy"

   const declinedName = "Declined Trophy";

4. For each name of approvedName, declinedName

   for (const name of [approvedName, declinedName]) {
   	await factories.TrophyFactory.createPending({
   		name,
   		organizationId: organization.id,
   		submitterUserId: NZAP_TEST_ID,
   	});
   	await factories.NotificationFactory.create({
   		notification: {
   			type: "TROPHY_SUBMITTED",
   			meta: { trophyName: name, submitterUsername: "N-ZAP" },
   		},
   		users: [{ userId: ADMIN_ID }],
   	});
   }

   1. Create pending trophy name organization id organization.id submitter N-ZAP

      await factories.TrophyFactory.createPending({
      	name,
      	organizationId: organization.id,
      	submitterUserId: NZAP_TEST_ID,
      });

   2. Create notification notification type “TROPHY_SUBMITTED” meta trophy name name submitter username “N-ZAP” users user Sendou

      await factories.NotificationFactory.create({
      	notification: {
      		type: "TROPHY_SUBMITTED",
      		meta: { trophyName: name, submitterUsername: "N-ZAP" },
      	},
      	users: [{ userId: ADMIN_ID }],
      });

SSendou

New trophy page

Act

1. Open the new trophy page

   await newTrophy.goto();

2. Open pending → pending

   const pending = await newTrophy.openPending();

Notification popover

Assert

1. bell dot is visible

   await expect(notifications.locators.bellDot).toBeVisible();

Pending trophy list

Act

1. Approve approvedName

   await pending.approve(approvedName);

Assert

1. row approvedName › text `1/${TROPHY_APPROVALS_REQUIRED} approvals` is visible

   await expect(
   	pending
   		.row(approvedName)
   		.getByText(`1/${TROPHY_APPROVALS_REQUIRED} approvals`),
   ).toBeVisible();

Notification popover

Assert

1. approving resolved that submission's notification, but the other submission still waits for a review

   bell dot is visible

   await expect(notifications.locators.bellDot).toBeVisible();

Pending trophy list

Act

1. Decline declinedName, “Does not meet the requirements”

   await pending.decline(declinedName, "Does not meet the requirements");

Assert

1. row declinedName is not visible

   await isNotVisible(pending.row(declinedName));

Notification popover

Assert

1. with the last pending submission reviewed nothing needs attention anymore

   bell dot is hidden

   await expect(notifications.locators.bellDot).toBeHidden();

New trophy page

Act

1. Open reviewed → reviewed

   const reviewed = await newTrophy.openReviewed();

Pending trophy list

Assert

1. row declinedName is visible

   await expect(reviewed.row(declinedName)).toBeVisible();

2. row declinedName › text “Declined by Sendou” is visible

   await expect(
   	reviewed.row(declinedName).getByText("Declined by Sendou"),
   ).toBeVisible();

NN-ZAP

Act

1. Go to “/”

   await navigate({ page, url: "/" });

Notification popover

Act

1. Open

   await notifications.open();

Assert

1. notification `Your trophy ${declinedName} was declined` is visible

   await expect(
   	notifications.notification(`Your trophy ${declinedName} was declined`),
   ).toBeVisible();

Source

test("reviews pending trophies", async ({ page, factories }) => {
	const organization = await factories.TournamentOrganizationFactory.create({
		name: ORGANIZATION_NAME,
		ownerId: NZAP_TEST_ID,
	});

	const approvedName = "Approved Trophy";
	const declinedName = "Declined Trophy";
	for (const name of [approvedName, declinedName]) {
		await factories.TrophyFactory.createPending({
			name,
			organizationId: organization.id,
			submitterUserId: NZAP_TEST_ID,
		});
		await factories.NotificationFactory.create({
			notification: {
				type: "TROPHY_SUBMITTED",
				meta: { trophyName: name, submitterUsername: "N-ZAP" },
			},
			users: [{ userId: ADMIN_ID }],
		});
	}

	await impersonate(page);

	const newTrophy = new NewTrophyPage(page);
	await newTrophy.goto();

	const pending = await newTrophy.openPending();

	const notifications = new NotificationPopover(page);
	await expect(notifications.locators.bellDot).toBeVisible();

	await pending.approve(approvedName);
	await expect(
		pending
			.row(approvedName)
			.getByText(`1/${TROPHY_APPROVALS_REQUIRED} approvals`),
	).toBeVisible();

	// approving resolved that submission's notification, but the other
	// submission still waits for a review
	await expect(notifications.locators.bellDot).toBeVisible();

	await pending.decline(declinedName, "Does not meet the requirements");
	await isNotVisible(pending.row(declinedName));

	// with the last pending submission reviewed nothing needs attention anymore
	await expect(notifications.locators.bellDot).toBeHidden();

	const reviewed = await newTrophy.openReviewed();
	await expect(reviewed.row(declinedName)).toBeVisible();
	await expect(
		reviewed.row(declinedName).getByText("Declined by Sendou"),
	).toBeVisible();

	// declining notified the submitter
	await impersonate(page, NZAP_TEST_ID);
	await navigate({ page, url: "/" });

	await notifications.open();

	await expect(
		notifications.notification(`Your trophy ${declinedName} was declined`),
	).toBeVisible();
})

backfills a trophy to the winners of a past tournament

Sendoutrophies.spec.ts:214

Renders/trophies/trophies/:id/trophies/new

New trophy pageTrophy backfill sectionTrophies pageTrophy details page

LOLogged out

Act

1. Slow

   test.slow();

Arrange

1. seriesName = "Wellstring"

   const seriesName = "Wellstring";

2. Create tournament organization name “Sendou's Tournaments” owner Sendou series name seriesName description null show leaderboard false → organization

   const organization = await factories.TournamentOrganizationFactory.create(
   	{ name: ORGANIZATION_NAME, ownerId: ADMIN_ID },
   	{
   		series: [
   			{ name: seriesName, description: null, showLeaderboard: false },
   		],
   	},
   );

3. Create trophy name “Wellstring Wednesday” organization id organization.id manager Sendou → trophy

   const trophy = await factories.TrophyFactory.create({
   	name: TROPHY_NAME,
   	organizationId: organization.id,
   	managerId: ADMIN_ID,
   });

4. awardedName = `${TROPHY_NAME} 1`

   const awardedName = `${TROPHY_NAME} 1`;

5. skippedName = `${TROPHY_NAME} 2`

   const skippedName = `${TROPHY_NAME} 2`;

6. Play trophy tournament organization id organization.id name awardedName → awarded

   const awarded = await playTrophyTournament(factories, {
   	organizationId: organization.id,
   	name: awardedName,
   });

7. Play trophy tournament organization id organization.id name skippedName → skipped

   const skipped = await playTrophyTournament(factories, {
   	organizationId: organization.id,
   	name: skippedName,
   });

SSendou

New trophy page

Act

1. Open the new trophy page

   await newTrophy.goto();

2. Open backfill → backfill

   const backfill = await newTrophy.openBackfill();

Trophy backfill section

Act

1. Select trophy “Wellstring Wednesday”

   await backfill.selectTrophy(TROPHY_NAME);

2. Select series seriesName

   await backfill.selectSeries(seriesName);

3. Toggle tournament awardedName

   await backfill.toggleTournament(awardedName);

4. Toggle winner tournament name awardedName username “Sendou”

   await backfill.toggleWinner({
   	tournamentName: awardedName,
   	username: "Sendou",
   });

5. Award

   await backfill.award();

Assert

1. an awarded tournament can't be backfilled again

   tournament awardedName is not visible

   await isNotVisible(backfill.tournament(awardedName));

2. tournament skippedName is visible

   await expect(backfill.tournament(skippedName)).toBeVisible();

Trophies page

Act

1. Go to trophy trophy.id → details

   const details = await new TrophiesPage(page).gotoTrophy(trophy.id);

Trophy details page

Assert

1. tournament row awarded.id is visible

   await expect(details.tournamentRow(awarded.id)).toBeVisible();

2. tournament row skipped.id is not visible

   await isNotVisible(details.tournamentRow(skipped.id));

3. owner “N-ZAP” is visible

   await expect(details.owner("N-ZAP")).toBeVisible();

4. owner “Sendou” is not visible

   await isNotVisible(details.owner("Sendou"));

Source

test("backfills a trophy to the winners of a past tournament", async ({
	page,
	factories,
}) => {
	test.slow();

	const seriesName = "Wellstring";
	const organization = await factories.TournamentOrganizationFactory.create(
		{ name: ORGANIZATION_NAME, ownerId: ADMIN_ID },
		{
			series: [
				{ name: seriesName, description: null, showLeaderboard: false },
			],
		},
	);
	const trophy = await factories.TrophyFactory.create({
		name: TROPHY_NAME,
		organizationId: organization.id,
		managerId: ADMIN_ID,
	});

	const awardedName = `${TROPHY_NAME} 1`;
	const skippedName = `${TROPHY_NAME} 2`;
	const awarded = await playTrophyTournament(factories, {
		organizationId: organization.id,
		name: awardedName,
	});
	const skipped = await playTrophyTournament(factories, {
		organizationId: organization.id,
		name: skippedName,
	});

	await impersonate(page);

	const newTrophy = new NewTrophyPage(page);
	await newTrophy.goto();

	const backfill = await newTrophy.openBackfill();
	await backfill.selectTrophy(TROPHY_NAME);
	await backfill.selectSeries(seriesName);

	await backfill.toggleTournament(awardedName);
	await backfill.toggleWinner({
		tournamentName: awardedName,
		username: "Sendou",
	});
	await backfill.award();

	// an awarded tournament can't be backfilled again
	await isNotVisible(backfill.tournament(awardedName));
	await expect(backfill.tournament(skippedName)).toBeVisible();

	const details = await new TrophiesPage(page).gotoTrophy(trophy.id);
	await expect(details.tournamentRow(awarded.id)).toBeVisible();
	await isNotVisible(details.tournamentRow(skipped.id));
	await expect(details.owner("N-ZAP")).toBeVisible();
	await isNotVisible(details.owner("Sendou"));
})

awards X Power trophies per weapon category

N-ZAPtrophies.spec.ts:273

Renders/trophies/trophies/:id/u/:identifier/u/:identifier

Trophies pageTrophy details pageUser page

Setup

Arrange

1. SPLATTERSHOT = 40

   const SPLATTERSHOT = 40;

2. SPLASH_O_MATIC = 20

   const SPLASH_O_MATIC = 20;

3. SPLAT_CHARGER = 2010

   const SPLAT_CHARGER = 2010;

4. For each [weaponSplId, power, region] of SPLATTERSHOT, 3550, “WEST”, SPLATTERSHOT, 3510, “JPN”, SPLASH_O_MATIC, 3120, “WEST”, SPLAT_CHARGER, 3050, “WEST”

   for (const [weaponSplId, power, region] of [
   	[SPLATTERSHOT, 3550, "WEST"],
   	[SPLATTERSHOT, 3510, "JPN"],
   	[SPLASH_O_MATIC, 3120, "WEST"],
   	[SPLAT_CHARGER, 3050, "WEST"],
   ] as const) {
   	await factories.XRankPlacementFactory.create({
   		playerUserId: NZAP_TEST_ID,
   		weaponSplId,
   		power,
   		region,
   	});
   }

   1. Create X rank placement player N-ZAP weaponSplId power region

      await factories.XRankPlacementFactory.create({
      	playerUserId: NZAP_TEST_ID,
      	weaponSplId,
      	power,
      	region,
      });

5. Create xp trophies trophy

   await factories.TrophyFactory.createXpTrophies();

6. Grant user N-ZAP widgets id “trophies-owned”

   await factories.UserFactory.grant(NZAP_TEST_ID, {
   	widgets: [{ id: "trophies-owned" }],
   });

NN-ZAP

Trophies page

Act

1. Open the trophies page

   await trophies.goto();

2. Open xp trophy “3500 X Power Shooters” → details

   const details = await trophies.openXpTrophy("3500 X Power Shooters");

Trophy details page

Assert

1. owner “N-ZAP” is visible

   await expect(details.owner("N-ZAP")).toBeVisible();

2. the Splash-o-matic placement fell short of 3500

   weapon counts count is 1

   await expect(details.locators.weaponCounts).toHaveCount(1);

User page

Act

1. Open the user page N-ZAP

   await userPage.goto(NZAP_TEST_ID);

Assert

1. trophy display › button count is 2

   await expect(
   	userPage.locators.trophyDisplay.getByRole("button"),
   ).toHaveCount(2);

2. reached in both divisions, Takoroka is the one shown

   trophy division “3500 X Power Shooters”, “Takoroka” is visible

   await expect(
   	userPage.trophyDivision("3500 X Power Shooters", "Takoroka"),
   ).toBeVisible();

3. trophy division “3000 X Power Chargers”, “Tentatek” is visible

   await expect(
   	userPage.trophyDivision("3000 X Power Chargers", "Tentatek"),
   ).toBeVisible();

Act

1. Open trophy “3500 X Power Shooters”

   await userPage.openTrophy("3500 X Power Shooters");

Assert

1. trophy placement rows count is 3

   await expect(userPage.locators.trophyPlacementRows).toHaveCount(3);

Source

test("awards X Power trophies per weapon category", async ({
	page,
	factories,
}) => {
	const SPLATTERSHOT = 40;
	const SPLASH_O_MATIC = 20;
	const SPLAT_CHARGER = 2010;
	for (const [weaponSplId, power, region] of [
		[SPLATTERSHOT, 3550, "WEST"],
		[SPLATTERSHOT, 3510, "JPN"],
		[SPLASH_O_MATIC, 3120, "WEST"],
		[SPLAT_CHARGER, 3050, "WEST"],
	] as const) {
		await factories.XRankPlacementFactory.create({
			playerUserId: NZAP_TEST_ID,
			weaponSplId,
			power,
			region,
		});
	}
	await factories.TrophyFactory.createXpTrophies();
	await factories.UserFactory.grant(NZAP_TEST_ID, {
		widgets: [{ id: "trophies-owned" }],
	});

	await impersonate(page, NZAP_TEST_ID);

	const trophies = new TrophiesPage(page);
	await trophies.goto();
	const details = await trophies.openXpTrophy("3500 X Power Shooters");

	await expect(details.owner("N-ZAP")).toBeVisible();

	// the Splash-o-matic placement fell short of 3500
	await expect(details.locators.weaponCounts).toHaveCount(1);

	const userPage = new UserPage(page);
	await userPage.goto(NZAP_TEST_ID);
	await expect(
		userPage.locators.trophyDisplay.getByRole("button"),
	).toHaveCount(2);

	// reached in both divisions, Takoroka is the one shown
	await expect(
		userPage.trophyDivision("3500 X Power Shooters", "Takoroka"),
	).toBeVisible();
	await expect(
		userPage.trophyDivision("3000 X Power Chargers", "Tentatek"),
	).toBeVisible();

	await userPage.openTrophy("3500 X Power Shooters");
	await expect(userPage.locators.trophyPlacementRows).toHaveCount(3);
})