feat(chat-e2e): duplicate shared prompt tests

apps/chat-e2e/src/assertions/api/apiAssertion.ts

@@ -1,5 +1,6 @@
 import { ChatBody } from '@/chat/types/chat';
 import { DialAIEntityModel } from '@/chat/types/models';
+import { Prompt } from '@/chat/types/prompt';
 import { ExpectedConstants, ExpectedMessages } from '@/src/testData';
 import { expect } from '@playwright/test';
 import { APIResponse } from 'playwright-core';
@@ -102,4 +103,31 @@ export class ApiAssertion {
         .toBeDefined();
     }
   }
+
+  public async assertRequestPromptName(request: Prompt, expectedValue: string) {
+    expect
+      .soft(request.name, ExpectedMessages.promptRequestNameIsValid)
+      .toBe(expectedValue);
+  }
+
+  public async assertRequestPromptDescription(
+    request: Prompt,
+    expectedValue: string,
+  ) {
+    expect
+      .soft(
+        request.description,
+        ExpectedMessages.promptRequestDescriptionIsValid,
+      )
+      .toBe(expectedValue);
+  }
+
+  public async assertRequestPromptContent(
+    request: Prompt,
+    expectedValue: string,
+  ) {
+    expect
+      .soft(request.content, ExpectedMessages.promptRequestContentIsValid)
+      .toBe(expectedValue);
+  }
 }

apps/chat-e2e/src/assertions/promptListAssertion.ts

@@ -10,13 +10,16 @@ export class PromptListAssertion {
     this.promptList = promptList;
   }
 
-  public async assertPromptOptionOverflow(name: string) {
+  public async assertPromptOptionOverflow(
+    name: string,
+    expectedOverflow: Overflow,
+  ) {
     const promptOptionOverflow = await this.promptList
       .getPromptOption(name)
       .getComputedStyleProperty(Styles.text_overflow);
     expect
       .soft(promptOptionOverflow[0], ExpectedMessages.entityNameIsTruncated)
-      .toBe(Overflow.ellipsis);
+      .toBe(expectedOverflow);
   }
 
   public async assertPromptListState(expectedState: ElementState) {
@@ -35,12 +38,24 @@ export class PromptListAssertion {
           .toBeHidden();
   }
 
-  public async assertPromptListOptions(expectedOptions: string[]) {
-    expect
-      .soft(
-        await this.promptList.getPromptOptions().getElementsInnerContent(),
-        ExpectedMessages.promptListValuesIsValid,
-      )
-      .toEqual(expectedOptions);
+  public async assertPromptListOptions(
+    expectedIncludedOptions: string[],
+    expectedExcludedOptions?: string[],
+  ) {
+    const listOptions = await this.promptList
+      .getPromptOptions()
+      .getElementsInnerContent();
+    for (const includedOption of expectedIncludedOptions) {
+      expect
+        .soft(listOptions, ExpectedMessages.promptListValuesIsValid)
+        .toContain(includedOption);
+    }
+    if (expectedExcludedOptions) {
+      for (const excludedOption of expectedExcludedOptions) {
+        expect
+          .soft(listOptions, ExpectedMessages.promptListValuesIsValid)
+          .not.toContain(excludedOption);
+      }
+    }
   }
 }

apps/chat-e2e/src/assertions/sendMessageAssertion.ts

@@ -26,11 +26,11 @@ export class SendMessageAssertion {
           .toBe(initialWidth);
   }
 
-  public async assertMessageValue(expectedValue: string) {
+  public async assertMessageValue(expectedValue: string | undefined) {
     const messageValue = await this.sendMessage.getMessage();
     expect
       .soft(messageValue, ExpectedMessages.messageContentIsValid)
-      .toBe(expectedValue);
+      .toBe(expectedValue ?? '');
   }
 
   public async assertContinueReplayButtonState(expectedState: ElementState) {

apps/chat-e2e/src/core/dialSharedWithMeFixtures.ts

@@ -12,6 +12,7 @@ import {
   Conversations,
   DropdownMenu,
   EntitySelector,
+  EntitySettings,
   ErrorToast,
   FolderPrompts,
   PromptBar,
@@ -26,9 +27,11 @@ import {
 
 import config from '@/config/chat.playwright.config';
 import { ConfirmationDialogAssertion } from '@/src/assertions/confirmationDialogAssertion';
+import { EntitySettingAssertion } from '@/src/assertions/entitySettingAssertion';
 import { FolderAssertion } from '@/src/assertions/folderAssertion';
 import { MenuAssertion } from '@/src/assertions/menuAssertion';
 import { PromptAssertion } from '@/src/assertions/promptAssertion';
+import { PromptListAssertion } from '@/src/assertions/promptListAssertion';
 import { PromptModalAssertion } from '@/src/assertions/promptModalAssertion';
 import { SendMessageAssertion } from '@/src/assertions/sendMessageAssertion';
 import { SharedPromptPreviewModalAssertion } from '@/src/assertions/sharedPromptPreviewModalAssertion';
@@ -58,6 +61,7 @@ const dialSharedWithMeTest = dialTest.extend<{
   additionalShareUserSharedFolderPrompts: SharedFolderPrompts;
   additionalShareUserChat: Chat;
   additionalShareUserConversationSettings: ConversationSettings;
+  additionalShareUserEntitySettings: EntitySettings;
   additionalShareUserTalkToSelector: EntitySelector;
   additionalShareUserRecentEntities: RecentEntities;
   additionalShareUserChatHeader: ChatHeader;
@@ -91,6 +95,9 @@ const dialSharedWithMeTest = dialTest.extend<{
   additionalShareUserConfirmationDialogAssertion: ConfirmationDialogAssertion;
   additionalShareUserPromptAssertion: PromptAssertion;
   additionalShareUserPromptModalAssertion: PromptModalAssertion;
+  additionalShareUserPromptBarFolderAssertion: FolderAssertion;
+  additionalShareUserSystemPromptListAssertion: PromptListAssertion;
+  additionalShareUserEntitySettingAssertion: EntitySettingAssertion;
 }>({
   additionalShareUserPage: async ({ browser }, use) => {
     const context = await browser.newContext({
@@ -208,6 +215,14 @@ const dialSharedWithMeTest = dialTest.extend<{
       additionalShareUserAppContainer.getConversationSettings();
     await use(additionalShareUserConversationSettings);
   },
+  additionalShareUserEntitySettings: async (
+    { additionalShareUserConversationSettings },
+    use,
+  ) => {
+    const additionalShareUserEntitySettings =
+      additionalShareUserConversationSettings.getEntitySettings();
+    await use(additionalShareUserEntitySettings);
+  },
   additionalShareUserTalkToSelector: async (
     { additionalShareUserConversationSettings },
     use,
@@ -441,6 +456,33 @@ const dialSharedWithMeTest = dialTest.extend<{
     );
     await use(additionalShareUserPromptModalAssertion);
   },
+  additionalShareUserPromptBarFolderAssertion: async (
+    { additionalShareUserFolderPrompts },
+    use,
+  ) => {
+    const additionalShareUserPromptBarFolderAssertion = new FolderAssertion(
+      additionalShareUserFolderPrompts,
+    );
+    await use(additionalShareUserPromptBarFolderAssertion);
+  },
+  additionalShareUserSystemPromptListAssertion: async (
+    { additionalShareUserEntitySettings },
+    use,
+  ) => {
+    const additionalShareUserSystemPromptListAssertion =
+      new PromptListAssertion(
+        additionalShareUserEntitySettings.getPromptList(),
+      );
+    await use(additionalShareUserSystemPromptListAssertion);
+  },
+  additionalShareUserEntitySettingAssertion: async (
+    { additionalShareUserEntitySettings },
+    use,
+  ) => {
+    const additionalShareUserEntitySettingAssertion =
+      new EntitySettingAssertion(additionalShareUserEntitySettings);
+    await use(additionalShareUserEntitySettingAssertion);
+  },
 });
 
 export let shareUserBucket: string;

apps/chat-e2e/src/testData/expectedMessages.ts

@@ -91,6 +91,9 @@ export enum ExpectedMessages {
   chatRequestAddonsAreValid = 'Chat API request addons are valid',
   chatRequestMessageIsValid = 'Chat API request message is valid',
   chatRequestAttachmentIsValid = 'Chat API request attachment is valid',
+  promptRequestNameIsValid = 'Prompt API request name is valid',
+  promptRequestDescriptionIsValid = 'Prompt API request description is valid',
+  promptRequestContentIsValid = 'Prompt API request content is valid',
   sendMessageButtonDisabled = 'Send message button is disabled',
   sendMessageButtonEnabled = 'Send message button is enabled',
   tooltipContentIsValid = 'Tooltip content is valid',

apps/chat-e2e/src/tests/compareMode.test.ts

@@ -722,7 +722,7 @@ dialTest(
           .selectModel(firstUpdatedRandomModel);
         const leftEntitySettings = leftConversationSettings.getEntitySettings();
         if (firstUpdatedRandomModel.features?.systemPrompt) {
-          await leftEntitySettings.setSystemPrompt(firstUpdatedPrompt);
+          await leftEntitySettings.clearAndSetSystemPrompt(firstUpdatedPrompt);
         }
         await leftEntitySettings
           .getTemperatureSlider()
@@ -734,7 +734,9 @@ dialTest(
         const rightEntitySettings =
           rightConversationSettings.getEntitySettings();
         if (secondUpdatedRandomModel.features?.systemPrompt) {
-          await rightEntitySettings.setSystemPrompt(secondUpdatedPrompt);
+          await rightEntitySettings.clearAndSetSystemPrompt(
+            secondUpdatedPrompt,
+          );
         }
         await rightEntitySettings
           .getTemperatureSlider()

apps/chat-e2e/src/tests/duplicateSharedPrompts.test.ts

@@ -0,0 +1,118 @@
+import { ShareByLinkResponseModel } from '@/chat/types/share';
+import dialSharedWithMeTest from '@/src/core/dialSharedWithMeFixtures';
+import { ExpectedConstants, FolderPrompt, MenuOptions } from '@/src/testData';
+
+dialSharedWithMeTest(
+  'Shared with me. Duplicate prompt.\n' +
+    'Shared with me. Move duplicated prompt to New folder',
+  async ({
+    additionalShareUserDialHomePage,
+    promptData,
+    dataInjector,
+    mainUserShareApiHelper,
+    additionalUserShareApiHelper,
+    additionalShareUserSharedFolderPrompts,
+    additionalShareUserSharedWithMePromptDropdownMenu,
+    additionalShareUserPrompts,
+    additionalShareUserPromptBarFolderAssertion,
+    additionalShareUserPromptDropdownMenu,
+    additionalShareUserFolderPrompts,
+    additionalShareUserPromptAssertion,
+    setTestIds,
+  }) => {
+    setTestIds('EPMRTC-1872', 'EPMRTC-2037');
+    let folderPrompt: FolderPrompt;
+    let promptName: string;
+    let shareFolderByLinkResponse: ShareByLinkResponseModel;
+
+    await dialSharedWithMeTest.step(
+      'Prepare folder with prompt and share it',
+      async () => {
+        folderPrompt = promptData.prepareDefaultPromptInFolder();
+        promptName = folderPrompt.prompts[0].name;
+        await dataInjector.createPrompts(
+          folderPrompt.prompts,
+          folderPrompt.folders,
+        );
+        shareFolderByLinkResponse =
+          await mainUserShareApiHelper.shareEntityByLink(
+            folderPrompt.prompts,
+            true,
+          );
+        await additionalUserShareApiHelper.acceptInvite(
+          shareFolderByLinkResponse,
+        );
+      },
+    );
+
+    await dialSharedWithMeTest.step(
+      'Select "Duplicate" option in dropdown menu for shared folder prompt and verify prompt is duplicated in Recent section',
+      async () => {
+        await additionalShareUserDialHomePage.openHomePage();
+        await additionalShareUserDialHomePage.waitForPageLoaded({
+          isNewConversationVisible: true,
+        });
+        await additionalShareUserSharedFolderPrompts.expandFolder(
+          folderPrompt.folders.name,
+          { isHttpMethodTriggered: true },
+        );
+        await additionalShareUserSharedFolderPrompts.openFolderEntityDropdownMenu(
+          folderPrompt.folders.name,
+          promptName,
+        );
+        await additionalShareUserSharedWithMePromptDropdownMenu.selectMenuOption(
+          MenuOptions.duplicate,
+          { triggeredHttpMethod: 'POST' },
+        );
+        await additionalShareUserPromptAssertion.assertEntityState(
+          { name: promptName },
+          'visible',
+        );
+      },
+    );
+
+    await dialSharedWithMeTest.step(
+      'Verify prompts with incremented names are created on duplication',
+      async () => {
+        for (let i = 1; i <= 2; i++) {
+          await additionalShareUserSharedFolderPrompts.openFolderEntityDropdownMenu(
+            folderPrompt.folders.name,
+            promptName,
+          );
+          await additionalShareUserSharedWithMePromptDropdownMenu.selectMenuOption(
+            MenuOptions.duplicate,
+            { triggeredHttpMethod: 'POST' },
+          );
+          await additionalShareUserPromptAssertion.assertEntityState(
+            { name: `${promptName} ${i}` },
+            'visible',
+          );
+        }
+      },
+    );
+
+    await dialSharedWithMeTest.step(
+      'Select "Move To -> New folder" option in dropdown menu for duplicated prompt and verify prompt is successfully moved',
+      async () => {
+        await additionalShareUserPrompts.openEntityDropdownMenu(
+          `${promptName} 2`,
+        );
+        await additionalShareUserPromptDropdownMenu.selectMenuOption(
+          MenuOptions.moveTo,
+        );
+        await additionalShareUserPromptDropdownMenu.selectMenuOption(
+          MenuOptions.newFolder,
+          { triggeredHttpMethod: 'POST' },
+        );
+        await additionalShareUserFolderPrompts.expandFolder(
+          ExpectedConstants.newFolderWithIndexTitle(1),
+        );
+        await additionalShareUserPromptBarFolderAssertion.assertFolderEntityState(
+          { name: ExpectedConstants.newFolderWithIndexTitle(1) },
+          { name: `${promptName} 2` },
+          'visible',
+        );
+      },
+    );
+  },
+);