test: replace cucumber with playwright for internalLink.feature

Signed-off-by: Ashim Shrestha <[email protected]>

Author: Ashim-Stha

package.json

@@ -60,6 +60,7 @@
     "browserslist-useragent-regexp": "^4.0.0",
     "commander": "14.0.0",
     "debug": "^4.4.1",
+    "dotenv": "^17.2.1",
     "ejs": "3.1.10",
     "eslint": "9.29.0",
     "git-repo-info": "2.1.1",

playwright.config.ts

@@ -0,0 +1,70 @@
+import { defineConfig, devices } from '@playwright/test'
+import dotenv from 'dotenv'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+dotenv.config({ path: path.resolve(__dirname, 'e2e', '.env'), override: true })
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+  // Look for test files in the "tests" directory, relative to this configuration file.
+  testDir: 'tests/spec',
+
+  // Run all tests in parallel.
+  fullyParallel: true,
+
+  // Fail the build on CI if you accidentally left test.only in the source code.
+  forbidOnly: !!process.env.CI,
+
+  // Retry on CI only.
+  retries: process.env.CI ? 2 : 0,
+
+  // Opt out of parallel tests on CI.
+  workers: process.env.CI ? 1 : undefined,
+
+  // Reporter to use
+  reporter: 'html',
+
+  use: {
+    // Collect trace when retrying the failed test.
+    trace: 'on-first-retry'
+  },
+  // Configure projects for major browsers.
+  projects: [
+    {
+      name: 'chromium',
+      use: {
+        ...devices['Desktop Chrome'],
+        launchOptions: {
+          args: [
+            '--allow-insecure-localhost',
+            '--ignore-certificate-errors' // Note: This flag is deprecated as of Chrome 119
+          ]
+        }
+      }
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] }
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] }
+    }
+  ]
+  // // Run your local dev server before starting the tests.
+  // webServer: {
+  //   command: 'npm run start',
+  //   url: 'http://localhost:3000',
+  //   reuseExistingServer: !process.env.CI,
+  // },
+})

pnpm-lock.yaml

@@ -0,0 +1,67 @@
+import { config } from '../config'
+import { UsersEnvironment } from '../support/environment'
+import { api } from '../support'
+import { ResourceType } from '../support/api/share/share'
+
+export async function createUserUsingAPI(
+  usersEnvironment: UsersEnvironment,
+  stepUser: string,
+  userToBeCreated: string
+): Promise<void> {
+  const admin = usersEnvironment.getUser({ key: stepUser })
+  const user = usersEnvironment.getUser({ key: userToBeCreated })
+  // do not try to create users when using predefined users
+  if (!config.predefinedUsers) {
+    await api.provision.createUser({ user, admin })
+  }
+}
+
+export async function createFolderInPersonalSpaceUsingAPI(
+  usersEnvironment: UsersEnvironment,
+  stepUser: string,
+  folderName: string
+): Promise<void> {
+  const user = usersEnvironment.getUser({ key: stepUser })
+  await api.dav.createFolderInsidePersonalSpace({ user, folder: folderName })
+}
+
+export async function shareResourceUsingAPI(
+  usersEnvironment: UsersEnvironment,
+  stepUser: string,
+  resource: string,
+  recipient: string,
+  type: string,
+  role: string,
+  resourceType: ResourceType
+): Promise<void> {
+  const user = usersEnvironment.getUser({ key: stepUser })
+  await api.share.createShare({
+    user,
+    path: resource,
+    shareType: type,
+    shareWith: recipient,
+    role: role,
+    resourceType: resourceType as ResourceType
+  })
+}
+
+export async function createPublicLinkOfResourceUsingAPI(
+  usersEnvironment: UsersEnvironment,
+  stepUser: string,
+  resource: string,
+  role: string,
+  name?: string,
+  password?: undefined,
+  space?: 'Personal'
+) {
+  const user = usersEnvironment.getUser({ key: stepUser })
+
+  await api.share.createLinkShare({
+    user,
+    path: resource,
+    password: password,
+    name: name ? name : 'Unnamed link',
+    role: role,
+    spaceName: space
+  })
+}

tests/e2e/helper/api.ts

@@ -0,0 +1,41 @@
+import { config } from '../config.js'
+import { api, environment, store } from '../support'
+import { User, UserState } from '../support/types'
+
+const cleanupPredefinedUser = async (userKey: string, user: User) => {
+  // delete the personal space resources
+  const resources = await api.dav.listSpaceResources({ user, spaceType: 'personal' })
+  for (const fileId in resources) {
+    await api.dav.deleteSpaceResource({ user, fileId })
+  }
+
+  // cleanup trashbin if resources have been deleted
+  if (Object.keys(resources).length) {
+    await api.dav.emptyTrashbin({ user, spaceType: 'personal' })
+  }
+
+  // revert user state
+  const usersEnvironment = new environment.UsersEnvironment()
+  const userState: UserState = usersEnvironment.getUserState(userKey)
+  if (userState.hasOwnProperty('autoAcceptShare')) {
+    await api.settings.configureAutoAcceptShare({ user, state: userState.autoAcceptShare })
+  }
+  if (userState.hasOwnProperty('language')) {
+    await api.settings.changeLanguage({ user, language: userState.language })
+  }
+}
+
+export const cleanUpUser = async (createdUserStore, adminUser: User) => {
+  const requests: Promise<User>[] = []
+  for (const [key, user] of createdUserStore.entries()) {
+    console.log(`Cleanup user: ${user.id}`)
+    if (!config.predefinedUsers) {
+      requests.push(api.provision.deleteUser({ user, admin: adminUser }))
+    } else {
+      await cleanupPredefinedUser(key, user)
+    }
+  }
+  await Promise.all(requests)
+  createdUserStore.clear()
+  store.keycloakCreatedUser.clear()
+}

tests/e2e/helper/cleanUpUser.ts

@@ -0,0 +1,18 @@
+import { objects } from '../support'
+import { ActorsEnvironment, LinksEnvironment } from '../support/environment'
+
+export async function openPublicLink(
+  actorsEnvironment: ActorsEnvironment,
+  linksEnvironment: LinksEnvironment,
+  stepUser: string,
+  name: string
+): Promise<void> {
+  const { page } = await actorsEnvironment.createActor({
+    key: stepUser,
+    namespace: actorsEnvironment.generateNamespace(stepUser, stepUser)
+  })
+
+  const { url } = linksEnvironment.getLink({ name })
+  const pageObject = new objects.applicationFiles.page.Public({ page })
+  await pageObject.open({ url })
+}

tests/e2e/helper/public.ts

@@ -0,0 +1,32 @@
+import { objects } from '../support'
+import { ActorsEnvironment, FilesEnvironment } from '../support/environment'
+
+export async function uploadResource(
+  actorsEnvironment: ActorsEnvironment,
+  filesEnvironment: FilesEnvironment,
+  stepUser: string,
+  resource: string,
+  to: string,
+  type?: string,
+  option?: string
+): Promise<void> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const resourceObject = new objects.applicationFiles.Resource({ page })
+  await resourceObject.upload({
+    to: to,
+    resources: [filesEnvironment.getFile({ name: resource })],
+    option: option,
+    type: type
+  })
+}
+
+export async function isAbleToEditFileOrFolder(
+  actorsEnvironment: ActorsEnvironment,
+  stepUser: string,
+  resource: string
+): Promise<boolean> {
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+  const resourceObject = new objects.applicationFiles.Resource({ page })
+  const userCanEdit = await resourceObject.canManageResource({ resource })
+  return userCanEdit
+}

tests/e2e/helper/resources.ts

@@ -0,0 +1,66 @@
+import { config } from '../config.js'
+import { api, objects } from '../support'
+import { ActorsEnvironment, UsersEnvironment } from '../support/environment'
+import { User } from '../support/types'
+
+async function createNewSession(actorsEnvironment: ActorsEnvironment, stepUser: string) {
+  const { page } = await actorsEnvironment.createActor({
+    key: stepUser,
+    namespace: actorsEnvironment.generateNamespace(stepUser, stepUser)
+  })
+  return new objects.runtime.Session({ page })
+}
+
+async function initUserStates(userKey: string, user: User, usersEnvironment: UsersEnvironment) {
+  const userInfo = await api.graph.getMeInfo(user)
+  usersEnvironment.storeCreatedUser(userKey, {
+    ...user,
+    uuid: userInfo.id,
+    email: userInfo.mail
+  })
+  usersEnvironment.saveUserState(userKey, {
+    language: userInfo.preferredLanguage,
+    autoAcceptShare: await api.settings.getAutoAcceptSharesValue(user)
+  })
+}
+
+export async function LogInUser(
+  usersEnvironment: UsersEnvironment,
+  actorsEnvironment: ActorsEnvironment,
+  stepUser: string
+): Promise<void> {
+  const sessionObject = await createNewSession(actorsEnvironment, stepUser)
+  const { page } = actorsEnvironment.getActor({ key: stepUser })
+
+  let user = null
+  if (stepUser === 'Admin' || config.predefinedUsers) {
+    user = usersEnvironment.getUser({ key: stepUser })
+  } else {
+    user = usersEnvironment.getCreatedUser({ key: stepUser })
+  }
+
+  await page.goto(config.baseUrl)
+  await sessionObject.login(user)
+
+  await page.locator('#web-content').waitFor()
+
+  // initialize user states: uuid, language, auto-sync
+  if (config.predefinedUsers) {
+    await initUserStates(stepUser, user, usersEnvironment)
+    // test should run with English language
+    await api.settings.changeLanguage({ user, language: 'en' })
+    await page.reload({ waitUntil: 'load' })
+  }
+}
+
+export async function LogOutUser(
+  actorsEnvironment: ActorsEnvironment,
+  stepUser: string
+): Promise<void> {
+  const actor = actorsEnvironment.getActor({ key: stepUser })
+  const canLogout = !!(await actor.page.locator('#_userMenuButton').count())
+
+  const sessionObject = new objects.runtime.Session({ page: actor.page })
+  canLogout && (await sessionObject.logout())
+  await actor.close()
+}

tests/e2e/helper/session.ts

@@ -0,0 +1,29 @@
+import { config } from '../config.js'
+import { api, store } from '../support'
+import { User } from '../support/types'
+import { UsersEnvironment } from '../support/environment'
+
+const storeKeycloakGroups = async (adminUser: User, usersEnvironment) => {
+  const groups = await api.graph.getGroups(adminUser)
+
+  store.dummyKeycloakGroupStore.forEach((dummyGroup) => {
+    const matchingGroup = groups.find((group) => group.displayName === dummyGroup.displayName)
+    if (matchingGroup) {
+      usersEnvironment.storeCreatedGroup({ group: { ...dummyGroup, uuid: matchingGroup.id } })
+    }
+  })
+}
+
+export async function setAccessAndRefreshToken(usersEnvironment: UsersEnvironment) {
+  if (!config.basicAuth && !config.predefinedUsers) {
+    let user = usersEnvironment.getUser({ key: config.adminUsername })
+    if (config.keycloak) {
+      user = usersEnvironment.getUser({ key: config.keycloakAdminUser })
+      await api.keycloak.setAccessTokenForKeycloakOcisUser(user)
+      await api.keycloak.setAccessTokenForKeycloakUser(user)
+      await storeKeycloakGroups(user, usersEnvironment)
+    } else {
+      await api.token.setAccessAndRefreshToken(user)
+    }
+  }
+}