[full-ci][tests-only] test: migrate groups.feature to playwright

.drone.star

@@ -147,7 +147,6 @@ config = {
                 "cucumber/features/admin-settings/users.feature:131",
                 "cucumber/features/admin-settings/users.feature:185",
                 "cucumber/features/admin-settings/spaces.feature",
-                "cucumber/features/admin-settings/groups.feature",
                 "cucumber/features/keycloak",
             ],
             "extraServerEnvironment": {

tests/e2e-playwright/specs/admin-settings/groups.spec.ts

@@ -0,0 +1,121 @@
+import { test, expect } from '@playwright/test'
+import { config } from '../../../e2e/config.js'
+import { ActorsEnvironment, UsersEnvironment } from '../../../e2e/support/environment'
+import { setAccessAndRefreshToken } from '../../helpers/setAccessAndRefreshToken'
+import * as ui from '../../steps/ui/index'
+import * as api from '../../steps/api/api'
+
+test.describe('groups management', () => {
+  let actorsEnvironment
+  const usersEnvironment = new UsersEnvironment()
+
+  test.beforeEach(async ({ browser }) => {
+    actorsEnvironment = new ActorsEnvironment({
+      context: {
+        acceptDownloads: config.acceptDownloads,
+        reportDir: config.reportDir,
+        tracingReportDir: config.tracingReportDir,
+        reportHar: config.reportHar,
+        reportTracing: config.reportTracing,
+        reportVideo: config.reportVideo,
+        failOnUncaughtConsoleError: config.failOnUncaughtConsoleError
+      },
+      browser: browser
+    })
+
+    await setAccessAndRefreshToken(usersEnvironment)
+    await ui.logInUser({ usersEnvironment, actorsEnvironment, stepUser: 'Admin' })
+  })
+
+  test.afterEach(async () => {
+    const admin = usersEnvironment.getUser({ key: 'Admin' })
+    await api.cleanUpGroup(admin)
+    await ui.logOutUser({ actorsEnvironment, stepUser: 'Admin' })
+  })
+
+  test('admin creates group', async () => {
+    await ui.openApplication({ actorsEnvironment, stepUser: 'Admin', name: 'admin-settings' })
+    await ui.navigateToGroupsManagementPage({ actorsEnvironment, stepUser: 'Admin' })
+    await ui.createGroups({
+      actorsEnvironment,
+      stepUser: 'Admin',
+      groupIds: ['sales', 'security']
+    })
+    expect(
+      await ui.checkGroupsPresenceById({
+        actorsEnvironment,
+        stepUser: 'Admin',
+        expectedGroupIds: ['sales', 'security']
+      })
+    ).toBeTruthy()
+  })
+
+  test('admin deletes group', async () => {
+    await api.createGroups({
+      groupIds: ['sales', 'security', 'finance'],
+      admin: usersEnvironment.getUser({ key: 'Admin' })
+    })
+    await ui.openApplication({ actorsEnvironment, stepUser: 'Admin', name: 'admin-settings' })
+    await ui.navigateToGroupsManagementPage({ actorsEnvironment, stepUser: 'Admin' })
+    await ui.deleteGroups({
+      actorsEnvironment,
+      stepUser: 'Admin',
+      actionType: 'context menu',
+      groupsToBeDeleted: ['sales']
+    })
+
+    expect(
+      await ui.checkGroupsPresenceById({
+        actorsEnvironment,
+        stepUser: 'Admin',
+        expectedGroupIds: ['sales']
+      })
+    ).toBeFalsy()
+
+    await ui.deleteGroups({
+      actorsEnvironment,
+      stepUser: 'Admin',
+      actionType: 'batch actions',
+      groupsToBeDeleted: ['security', 'finance']
+    })
+
+    expect(
+      await ui.checkGroupsPresenceById({
+        actorsEnvironment,
+        stepUser: 'Admin',
+        expectedGroupIds: ['security', 'finance']
+      })
+    ).toBeFalsy()
+  })
+
+  test('edit groups', async () => {
+    await api.createGroups({
+      groupIds: ['sales'],
+      admin: usersEnvironment.getUser({ key: 'Admin' })
+    })
+    await ui.openApplication({ actorsEnvironment, stepUser: 'Admin', name: 'admin-settings' })
+    await ui.navigateToGroupsManagementPage({ actorsEnvironment, stepUser: 'Admin' })
+    await ui.changeGroup({
+      actorsEnvironment,
+      stepUser: 'Admin',
+      key: 'sales',
+      attribute: 'displayName',
+      value: 'a renamed group',
+      action: 'context-menu'
+    })
+    expect(
+      await ui.groupDisplayNameExists({
+        actorsEnvironment,
+        stepUser: 'Admin',
+        groupDisplayName: 'sales'
+      })
+    ).toBeFalsy()
+    expect(
+      await ui.groupDisplayNameExists({
+        actorsEnvironment,
+        stepUser: 'Admin',
+        groupDisplayName: 'a renamed group'
+      })
+    ).toBeTruthy()
+  })
+})

tests/e2e-playwright/steps/api/api.ts

@@ -4,11 +4,13 @@ import {
   UsersEnvironment,
   SpacesEnvironment
 } from '../../../e2e/support/environment'
-import { api } from '../../../e2e/support'
+import { api, store } from '../../../e2e/support'
 import { ResourceType } from '../../../e2e/support/api/share/share'
-import { Space } from '../../../e2e/support/types'
+import { Group, Space, User } from '../../../e2e/support/types'
 import fs from 'fs'
 import { integer } from 'vscode-languageserver-types'
+import join from 'join-path'
+import { checkResponseStatus, request } from '../../../e2e/support/api/http'
 
 export async function userHasBeenCreated({
   usersEnvironment,
@@ -293,3 +295,49 @@ export async function userHasDeletedProjectSpace({
   const user = usersEnvironment.getUser({ key: stepUser })
   await api.graph.deleteSpace({ user, space: { id, name } as unknown as Space })
 }
+
+export const createGroups = async ({
+  groupIds,
+  admin
+}: {
+  groupIds: string[]
+  admin: User
+}): Promise<Group[]> => {
+  const usersEnvironment = new UsersEnvironment()
+  const createdGroups: Group[] = []
+  for (const id of groupIds) {
+    const group = usersEnvironment.getGroup({ key: id })
+    const body = JSON.stringify({
+      displayName: group.displayName
+    })
+
+    const response = await request({
+      method: 'POST',
+      path: join('graph', 'v1.0', 'groups'),
+      body,
+      user: admin
+    })
+
+    checkResponseStatus(response, 'Failed while creating group')
+
+    const resBody = (await response.json()) as Group
+    usersEnvironment.storeCreatedGroup({ group: { ...group, uuid: resBody.id } })
+    createdGroups.push({ ...group, uuid: resBody.id })
+  }
+  return createdGroups
+}
+
+export const cleanUpGroup = async (adminUser: User) => {
+  if (config.predefinedUsers) {
+    return
+  }
+  const requests: Promise<Group>[] = []
+  store.createdGroupStore.forEach((group) => {
+    if (!group.id.startsWith('keycloak')) {
+      requests.push(api.graph.deleteGroup({ group, admin: adminUser }))
+    }
+  })
+
+  await Promise.all(requests)
+  store.createdGroupStore.clear()
+}

tests/e2e-playwright/steps/ui/adminSettings.ts

@@ -41,3 +41,123 @@ export async function resetLogo({
   const generalObject = new objects.applicationAdminSettings.General({ page })
   await generalObject.resetLogo()
 }
+
+export async function navigateToGroupsManagementPage({
+  actorsEnvironment,
+  stepUser
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+}): Promise<void> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.page.Groups({ page })
+  await groupsObject.navigate()
+}
+
+export async function createGroups({
+  actorsEnvironment,
+  stepUser,
+  groupIds
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+  groupIds: string[]
+}): Promise<void> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.Groups({ page })
+  for (const groupId of groupIds) {
+    await groupsObject.createGroup({ key: groupId })
+  }
+}
+
+export async function checkGroupsPresenceById({
+  actorsEnvironment,
+  stepUser,
+  expectedGroupIds
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+  expectedGroupIds: string[]
+}): Promise<boolean> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.Groups({ page })
+  const actualGroupsIds = await groupsObject.getDisplayedGroupsIds()
+  for (const group of expectedGroupIds) {
+    if (!actualGroupsIds.includes(groupsObject.getUUID({ key: group }))) {
+      return false
+    }
+  }
+  return true
+}
+
+export async function groupDisplayNameExists({
+  actorsEnvironment,
+  stepUser,
+  groupDisplayName
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+  groupDisplayName: string
+}): Promise<boolean> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.Groups({ page })
+  const groups = await groupsObject.getGroupsDisplayName()
+  return groups.includes(groupDisplayName)
+}
+
+export async function deleteGroups({
+  actorsEnvironment,
+  stepUser,
+  actionType,
+  groupsToBeDeleted
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+  actionType: string
+  groupsToBeDeleted: string[]
+}): Promise<void> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.Groups({ page })
+  const groupIds = []
+  switch (actionType) {
+    case 'batch actions':
+      for (const group of groupsToBeDeleted) {
+        groupIds.push(groupsObject.getUUID({ key: group }))
+        await groupsObject.selectGroup({ key: group })
+      }
+      await groupsObject.deleteGroupUsingBatchAction({ groupIds })
+      break
+    case 'context menu':
+      for (const group of groupsToBeDeleted) {
+        await groupsObject.deleteGroupUsingContextMenu({ key: group })
+      }
+      break
+    default:
+      throw new Error(`'${actionType}' not implemented`)
+  }
+}
+
+export async function changeGroup({
+  actorsEnvironment,
+  stepUser,
+  key,
+  attribute,
+  value,
+  action
+}: {
+  actorsEnvironment: ActorsEnvironment
+  stepUser: string
+  key: string
+  attribute: string
+  value: string
+  action: string
+}): Promise<void> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const groupsObject = new objects.applicationAdminSettings.Groups({ page })
+  await groupsObject.changeGroup({
+    key,
+    attribute: attribute,
+    value,
+    action
+  })
+}

tests/e2e/cucumber/steps/ui/adminSettings.ts

@@ -415,7 +415,7 @@ Then(
   ): Promise<void> {
     const { page } = this.actorsEnvironment.getActor({ key: stepUser })
     const groupsObject = new objects.applicationAdminSettings.Groups({ page })
-    const groups = await groupsObject.getDisplayedGroups()
+    const groups = await groupsObject.getDisplayedGroupsIds()
 
     for (const { group } of stepTable.hashes()) {
       switch (action) {

tests/e2e/support/objects/a11y/actions.ts

@@ -44,7 +44,11 @@ export const selectors = {
   filesView: 'files-view',
   // visible tippy/popover (active)
   tippyBoxVisible: '.tippy-box[data-state="visible"]',
-  logoWrapper: '.logo-wrapper'
+  logoWrapper: '.logo-wrapper',
+  createGroupInput: '#create-group-input-display-name',
+  actionConfirmButton: '.oc-modal-body-actions-confirm',
+  contextMenuContainer: '#oc-files-context-menu',
+  groupList: '.group-list'
 }
 
 const a11yRuleTags = ['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa', 'best-practice']