test: replace cucumber with playwright for internalLink.feature

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

Author: Ashim-Stha

.drone.star

@@ -223,9 +223,10 @@ def stagePipelines(ctx):
     if (determineReleasePackage(ctx) != None):
         return unit_test_pipelines
 
+    e2e_playwright_pipeline = e2eTestsOnPlaywright(ctx)
     e2e_pipelines = e2eTests(ctx)
     keycloak_pipelines = e2eTestsOnKeycloak(ctx)
-    return unit_test_pipelines + pipelinesDependsOn(e2e_pipelines + keycloak_pipelines, unit_test_pipelines)
+    return unit_test_pipelines + e2e_playwright_pipeline + pipelinesDependsOn(e2e_pipelines + keycloak_pipelines, unit_test_pipelines)
 
 def afterPipelines(ctx):
     return build(ctx) + pipelinesDependsOn(notify(ctx), build(ctx))
@@ -535,6 +536,70 @@ def unitTests(ctx):
         },
     }]
 
+def e2eTestsOnPlaywright(ctx):
+    e2e_workspace = {
+        "base": dir["base"],
+        "path": config["app"],
+    }
+
+    e2e_trigger = {
+        "ref": [
+            "refs/heads/master",
+            "refs/heads/stable-*",
+            "refs/tags/**",
+            "refs/pull/**",
+        ],
+    }
+
+    pipelines = []
+
+    # pipeline steps
+    steps = skipIfUnchanged(ctx, "e2e-tests-playwright")
+
+    environment = {
+        "HEADLESS": "true",
+        "RETRY": "1",
+        "BASE_URL_OCIS": "ocis:9200",
+        "FAIL_ON_UNCAUGHT_CONSOLE_ERR": "true",
+        "PLAYWRIGHT_BROWSERS_PATH": ".playwright",
+        "BROWSER": "chromium",
+        "FEDERATED_BASE_URL_OCIS": "federation-ocis:9200",
+    }
+
+    steps += restoreBuildArtifactCache(ctx, "pnpm", ".pnpm-store") + \
+             installPnpm() + \
+             restoreBrowsersCache() + \
+             restoreBuildArtifactCache(ctx, "web-dist", "dist")
+
+    if ctx.build.event == "cron":
+        steps += restoreBuildArtifactCache(ctx, "ocis", "ocis")
+    else:
+        steps += restoreOcisCache()
+
+    steps += tikaService() + \
+             ocisService()
+
+    steps += [{
+        "name": "e2e-tests-playwright",
+        "image": OC_CI_NODEJS_IMAGE,
+        "environment": environment,
+        "commands": [
+            "pnpm test:e2e:playwright",
+        ],
+    }]
+
+    pipelines.append({
+        "kind": "pipeline",
+        "type": "docker",
+        "name": "e2e-tests-playwright",
+        "workspace": e2e_workspace,
+        "steps": steps,
+        "depends_on": ["cache-ocis"],
+        "trigger": e2e_trigger,
+    })
+
+    return pipelines
+
 def e2eTests(ctx):
     e2e_workspace = {
         "base": dir["base"],

package.json

@@ -12,6 +12,7 @@
     "lint": "eslint vite.config.ts '{packages,tests}/**/*.{js,ts,vue}' --color",
     "serve": "SERVER=true pnpm build:w",
     "test:e2e:cucumber": "NODE_TLS_REJECT_UNAUTHORIZED=0 TS_NODE_PROJECT=./tests/e2e/cucumber/tsconfig.json cucumber-js --profile=e2e -f json:tests/e2e/cucumber/report/cucumber_report.json",
+    "test:e2e:playwright": "NODE_TLS_REJECT_UNAUTHORIZED=0 npx playwright test --config=tests/e2e-playwright/ --project=chromium",
     "test:unit": "NODE_OPTIONS=--unhandled-rejections=throw vitest",
     "licenses:check": "license-checker-rseidelsohn --summary --relativeLicensePath --onlyAllow 'Python-2.0;Apache*;Apache License, Version 2.0;Apache-2.0;Apache 2.0;Artistic-2.0;BSD;BSD-3-Clause;CC-BY-3.0;CC-BY-4.0;CC0-1.0;ISC;MIT;MPL-2.0;Public Domain;Unicode-TOU;Unlicense;WTFPL;BlueOak-1.0.0' --excludePackages '@ownclouders/babel-preset;@ownclouders/eslint-config;@ownclouders/prettier-config;@ownclouders/tsconfig;@ownclouders/web-client;@ownclouders/web-pkg;external;web-app-files;text-editor;preview;web-app-ocm;@ownclouders/design-system;pdf-viewer;web-app-search;admin-settings;webfinger;web-runtime;@ownclouders/web-test-helpers'",
     "licenses:csv": "license-checker-rseidelsohn --relativeLicensePath --csv --out ./third-party-licenses/third-party-licenses.csv",

test-results/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}

tests/e2e-playwright/helper/cleanup.ts

@@ -0,0 +1,41 @@
+import { config } from '../../e2e/config.js'
+import { api, environment, store } from '../../e2e/support'
+import { User, UserState } from '../../e2e/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-playwright/helper/setAccessAndRefreshToken.ts

@@ -0,0 +1,29 @@
+import { config } from '../../e2e/config.js'
+import { api, store } from '../../e2e/support'
+import { User } from '../../e2e/support/types'
+import { UsersEnvironment } from '../../e2e/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)
+    }
+  }
+}

tests/e2e-playwright/playwright.config.ts

@@ -0,0 +1,46 @@
+import { defineConfig, devices } from '@playwright/test'
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+export default defineConfig({
+  // Look for test files in the "tests" directory, relative to this configuration file.
+  testDir: '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 ? 1 : 0,
+
+  // Opt out of parallel tests on CI.
+  workers: process.env.CI ? 1 : undefined,
+
+  // Reporter to use
+  reporter: 'html',
+
+  use: {
+    ignoreHTTPSErrors: true,
+
+    // Collect trace when retrying the failed test.
+    trace: 'on-first-retry'
+  },
+  // Configure projects for major browsers.
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] }
+    },
+    {
+      name: 'firefox',
+      use: { ...devices['Desktop Firefox'] }
+    },
+    {
+      name: 'webkit',
+      use: { ...devices['Desktop Safari'] }
+    }
+  ]
+})

tests/e2e-playwright/spec/internalLink.spec.ts

@@ -0,0 +1,97 @@
+import { expect, test } from '@playwright/test'
+import { config } from '../../e2e/config.js'
+import { store } from '../../e2e/support'
+import {
+  ActorsEnvironment,
+  UsersEnvironment,
+  LinksEnvironment,
+  FilesEnvironment
+} from '../../e2e/support/environment'
+import {
+  userHasBeenCreated,
+  createFolderInPersonalSpaceUsingAPI,
+  shareResourceUsingAPI,
+  createPublicLinkOfResourceUsingAPI
+} from '../steps/api'
+import { setAccessAndRefreshToken } from '../helper/setAccessAndRefreshToken'
+import { cleanUpUser } from '../helper/cleanup'
+import { openPublicLink } from '../steps/ui/public'
+import { navigateToSharedWithMePage, updateShareeRole } from '../steps/ui/shares'
+import { uploadResource, isAbleToEditFileOrFolder } from '../steps/ui/resources'
+import { LogInUser, LogOutUser } from '../steps/ui/session'
+
+test.describe('internal link share', () => {
+  let actorsEnvironment
+  const usersEnvironment = new UsersEnvironment()
+  const linksEnvironment = new LinksEnvironment()
+  const filesEnvironment = new FilesEnvironment()
+
+  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 userHasBeenCreated(usersEnvironment, 'Admin', 'Alice')
+    await userHasBeenCreated(usersEnvironment, 'Admin', 'Brian')
+
+    await LogInUser(usersEnvironment, actorsEnvironment, 'Alice')
+    await LogInUser(usersEnvironment, actorsEnvironment, 'Brian')
+
+    await createFolderInPersonalSpaceUsingAPI(usersEnvironment, 'Alice', 'myfolder')
+
+    await shareResourceUsingAPI(
+      usersEnvironment,
+      'Alice',
+      'myfolder',
+      'Brian',
+      'user',
+      'Can edit',
+      'folder'
+    )
+
+    await createPublicLinkOfResourceUsingAPI(
+      usersEnvironment,
+      'Alice',
+      'myfolder',
+      'Invited people'
+    )
+  })
+
+  test('opening a link with internal role', async () => {
+    await openPublicLink(actorsEnvironment, linksEnvironment, 'Brian', 'Unnamed link')
+    await navigateToSharedWithMePage(actorsEnvironment, 'Brian')
+    await uploadResource(actorsEnvironment, filesEnvironment, 'Brian', 'simple.pdf', 'myfolder')
+    await updateShareeRole(
+      usersEnvironment,
+      actorsEnvironment,
+      'Alice',
+      'myfolder',
+      'Brian',
+      'user',
+      'Can view',
+      'folder'
+    )
+    await LogOutUser(actorsEnvironment, 'Alice')
+
+    expect(await isAbleToEditFileOrFolder(actorsEnvironment, 'Brian', 'myfolder')).toBeFalsy()
+    await LogOutUser(actorsEnvironment, 'Brian')
+  })
+
+  test.afterAll(async () => {
+    await cleanUpUser(
+      store.createdUserStore,
+      usersEnvironment.getUser({ key: config.adminUsername })
+    )
+  })
+})

tests/e2e-playwright/steps/api.ts

@@ -0,0 +1,67 @@
+import { config } from '../../e2e/config.js'
+import { UsersEnvironment } from '../../e2e/support/environment'
+import { api } from '../../e2e/support'
+import { ResourceType } from '../../e2e/support/api/share/share'
+
+export async function userHasBeenCreated(
+  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
+  })
+}