store invitation code

tests/e2e/cucumber/features/ocm/ocm.feature

@@ -2,7 +2,7 @@ Feature: federation management
 
   Scenario: user create federated share
     Given using "LOCAL" server
-    Given "Admin" creates following user using API
+    And "Admin" creates following user using API
       | id    |
       | Alice |
     And "Alice" creates the following files into personal space using API
@@ -19,11 +19,12 @@ Feature: federation management
       | Brian |
     And "Brian" logs in
     And "Brian" opens the "open-cloud-mesh" app
-    When "Brian" accept federation share invitation
+    When "Brian" accepts federated share invitation by "Alice"
 #    Then "Brian" should see the following federated connections:
-#      | connections |
+#      | user  | email             | institution |
+#      | Alice | [email protected] | ocis:9200   |
 #    And "Alice" shares the following resource using the sidebar panel
-#      | resource | recipient | type | role     | resourceType | share-type |
-#      | test.odt | Carol     | user | Can view | file         | external   |
+#      | resource | recipient | type | role     | resourceType | userType |
+#      | test.odt | Brian     | user | Can view | file         | external |
     And "Brian" logs out
 

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

@@ -4,19 +4,21 @@ import { objects } from '../../../support'
 
 Given(
   '{string} generates the federation share invitation token',
-  async function (this: World, stepUser: any): Promise<void> {
+  async function (this: World, stepUser: string): Promise<void> {
     const { page } = this.actorsEnvironment.getActor({ key: stepUser })
     const pageObject = new objects.scienceMesh.Federation({ page })
-    await pageObject.generateInvitation()
+    const user = await this.usersEnvironment.getUser({ key: stepUser })
+    await pageObject.generateInvitation(user.id)
   }
 )
 
 When(
-  '{string} accept federation share invitation',
-  async function (this: World, stepUser: any): Promise<void> {
+  '{string} accepts federated share invitation by {string}',
+  async function (this: World, stepUser: string, sharee: string): Promise<void> {
     const { page } = this.actorsEnvironment.getActor({ key: stepUser })
     const pageObject = new objects.scienceMesh.Federation({ page })
-    await pageObject.generateInvitation()
+    const user = this.usersEnvironment.getUser({ key: sharee })
+    await pageObject.acceptInvitation(user.id)
   }
 )
 

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

@@ -13,7 +13,7 @@ const parseShareTable = function (
   usersEnvironment: environment.UsersEnvironment
 ) {
   return stepTable.hashes().reduce<Record<string, ICollaborator[]>>((acc, stepRow) => {
-    const { resource, recipient, type, role, resourceType, expirationDate } = stepRow
+    const { resource, recipient, type, role, resourceType, expirationDate, userType } = stepRow
 
     if (!acc[resource]) {
       acc[resource] = []
@@ -27,7 +27,8 @@ const parseShareTable = function (
       role,
       type: type as CollaboratorType,
       resourceType,
-      expirationDate
+      expirationDate,
+      userType
     })
 
     return acc

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

@@ -1,27 +1,73 @@
 import { expect, Page } from '@playwright/test'
+import { federatedInvitationCode } from '../../store'
 
 const generateInvitationButton =
   '//button[contains(@aria-label,"Generate invitation link that can be shared with one or more invitees")]'
 const descriptionInput = '#invite_token_description'
 const emailInput = '#invite_token_recipient'
 const generateInvitationActionConfirmButton = '.oc-modal-body-actions-confirm'
 const emptyInvitationToken = '#invite-tokens-empty'
+const acceptFederatedInvitation = '//input[starts-with(@id, "oc-textinput-")]'
+const institutionOptionDropdown = '.vs__open-indicator'
 
-export const generateInvitation = async (args: { page: Page }): Promise<void> => {
-  const { page } = args
+export const generateInvitation = async (args: { page: Page; user: string }): Promise<void> => {
+  const { page, user } = args
   await page.locator(generateInvitationButton).click()
   await page.locator(descriptionInput).fill('hello')
   await page.locator(emailInput).fill('[email protected]')
-  await page.locator(generateInvitationActionConfirmButton).click()
+  let inviteCode = ''
+  await Promise.all([
+    page.waitForResponse(async (resp) => {
+      if (
+        resp.url().endsWith('generate-invite') &&
+        resp.status() === 200 &&
+        resp.request().method() === 'POST'
+      ) {
+        const responseBody = await resp.json()
+        inviteCode = responseBody.token
+        return true
+      }
+      return false
+    }),
+    page.locator(generateInvitationActionConfirmButton).click()
+  ])
   await expect(page.locator(emptyInvitationToken)).not.toBeVisible()
+  federatedInvitationCode.set(user, { code: inviteCode })
+  console.log(federatedInvitationCode)
 }
 
-export const acceptInvitation = async (args: { page: Page }): Promise<void> => {
-  const { page } = args
-  // todo: store federation invitation token  and use that token
-  // await page.locator(generateInvitationButton).click()
-  // await page.locator(descriptionInput).fill('hello')
-  // await page.locator(emailInput).fill('[email protected]')
-  // await page.locator(generateInvitationActionConfirmButton).click()
-  // await expect(page.locator(emptyInvitationToken)).not.toBeVisible()
+export const acceptInvitation = async (args: { page: Page; user: string }): Promise<Response> => {
+  const { page, user } = args
+  const invitation = federatedInvitationCode.get(user)
+  await page.locator(acceptFederatedInvitation).fill(invitation.code)
+  await page.locator(institutionOptionDropdown).click()
+  await page.getByRole('option', { name: 'first-ocis-instance ocis-server:' }).click()
+  await Promise.all([
+    page.waitForResponse(
+      (resp) =>
+        resp.url().endsWith('accept-invite') &&
+        resp.status() === 200 &&
+        resp.request().method() === 'POST'
+    ),
+    // async (resp) => {
+    //   if (
+    //     resp.url().endsWith('find-accepted-users') &&
+    //     resp.status() === 200 &&
+    //     resp.request().method() === 'GET'
+    //   ) {
+    //     // Extract and store the API response value
+    //     return await resp.json()
+    //   }
+    //   return false
+    // },
+    page.locator('button:has(span:has-text("Accept invitation"))').click()
+  ])
 }
+
+// export const isConnectionVisible = async (args: {
+//   page: Page
+//   connectionInfo: Response
+// }): Promise<void> => {
+//   const { page, connectionInfo } = args
+// }
+// first-ocis-instance ocis-server:9200

tests/e2e/support/objects/federation/index.ts

@@ -7,11 +7,12 @@ export class Federation {
   constructor({ page }: { page: Page }) {
     this.#page = page
   }
-  async generateInvitation(): Promise<void> {
-    await po.generateInvitation({ page: this.#page })
+  async generateInvitation(user): Promise<void> {
+    await po.generateInvitation({ page: this.#page, user })
   }
 
-  async acceptInvitation(): Promise<void> {
-    await po.acceptInvitation({ page: this.#page })
+  async acceptInvitation(user): Promise<void> {
+    await po.acceptInvitation({ page: this.#page, user })
+    // await po.isConnectionVisible({ page: this.#page, connectionInfo })
   }
 }

tests/e2e/support/store/index.ts

@@ -5,3 +5,4 @@ export { dummyUserStore, createdUserStore } from './user'
 export { dummyGroupStore, createdGroupStore } from './group'
 export { userRoleStore } from './role'
 export { keycloakRealmRoles, keycloakCreatedUser } from './keycloak'
+export { federatedInvitationCode } from './invitation'

tests/e2e/support/store/invitation.ts

@@ -0,0 +1,3 @@
+import { FederatedShareInvitation } from '../types'
+
+export const federatedInvitationCode = new Map<string, FederatedShareInvitation>()

tests/e2e/support/types.ts

@@ -70,3 +70,8 @@ export interface AppRole {
   displayName: string
   id: string
 }
+
+export interface FederatedShareInvitation {
+  code: string
+  description?: string
+}