Updates typing to User and Group, splits openApp function and create user function, updates saved test users for group upkeep function

ts/components/conversation/message/message-item/ReadableMessage.tsx

@@ -186,7 +186,7 @@ export const ReadableMessage = (props: ReadableMessageProps) => {
       triggerOnce={false}
       trackVisibility={true}
       key={`inview-msg-${messageId}`}
-      data-testid="readable-message"
+      data-testid="control-message"
     >
       {props.children}
     </InView>

ts/test/automation/change_avatar.spec.ts

@@ -2,7 +2,7 @@ import { _electron, expect, Page, test } from '@playwright/test';
 import { openAppAndWait } from './setup/open';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
 import { newUser } from './setup/new_user';
-import { clickOnTestIdWithText, waitForTestIdWithText } from './utils';
+import { clickOnTestIdWithText, waitForTestIdWithText } from './utilities/utils';
 import { sleepFor } from '../../session/utils/Promise';
 
 let window: Page | undefined;

ts/test/automation/change_username.spec.ts

@@ -2,7 +2,7 @@ import { _electron, expect, Page, test } from '@playwright/test';
 import { newUser } from './setup/new_user';
 import { openAppAndWait } from './setup/open';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { clickOnTestIdWithText, typeIntoInput } from './utils';
+import { clickOnTestIdWithText, typeIntoInput } from './utilities/utils';
 let window: Page | undefined;
 
 test.beforeEach(beforeAllClean);

ts/test/automation/create_user.spec.ts

@@ -3,16 +3,20 @@ import { newUser } from './setup/new_user';
 import { openAppAndWait } from './setup/open';
 import { sleepFor } from '../../session/utils/Promise';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { clickOnMatchingText, clickOnTestIdWithText, waitForTestIdWithText } from './utils';
+import {
+  clickOnMatchingText,
+  clickOnTestIdWithText,
+  waitForTestIdWithText,
+} from './utilities/utils';
 
 let window: Page | undefined;
 test.beforeEach(beforeAllClean);
 
-test.afterEach(async () => {
+// test.afterEach(async () => {
-  if (window) {
+//   if (window) {
-    await forceCloseAllWindows([window]);
+//     await forceCloseAllWindows([window]);
-  }
+//   }
-});
+// });
 test('Create User', async () => {
   // Launch Electron app.
   window = await openAppAndWait('1');

ts/test/automation/delete_account.spec.ts

@@ -1,8 +1,8 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
 import { openAppsAndNewUsers, openAppsNoNewUsers } from './setup/new_user';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
-import { clickOnMatchingText, clickOnTestIdWithText, typeIntoInput } from './utils';
+import { clickOnMatchingText, clickOnTestIdWithText, typeIntoInput } from './utilities/utils';
 import { sleepFor } from '../../session/utils/Promise';
 // tslint:disable: no-console
 

ts/test/automation/disappearing_messages.spec.ts

@@ -1,15 +1,15 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { messageSent } from './message';
+import { messageSent } from './utilities/message';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
   waitForMatchingText,
   waitForReadableMessageWithText,
   waitForTestIdWithText,
-} from './utils';
+} from './utilities/utils';
 import { sleepFor } from '../../session/utils/Promise';
 
 let windows: Array<Page> = [];

ts/test/automation/group_creation.spec.ts

@@ -1,15 +1,15 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { messageSent } from './message';
+import { messageSent } from './utilities/message';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
   typeIntoInput,
   waitForReadableMessageWithText,
   waitForTestIdWithText,
-} from './utils';
+} from './utilities/utils';
 
 const testGroupName = 'Test Group Name';
 

ts/test/automation/group_testing.spec.ts

@@ -1,38 +1,63 @@
-import { _electron, expect, Page, test } from '@playwright/test';
+import { expect, test } from '@playwright/test';
-import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
+import { beforeAllClean } from './setup/beforeEach';
-// import { recoverFromSeed } from './setup/recovery_using_seed';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
+  waitForControlMessageWithText,
   waitForMatchingText,
-  // waitForTestIdWithText,
+} from './utilities/utils';
-} from './utils';
+import { renameGroup } from './utilities/rename_group';
-// import { testContact, testUser } from './setup/test_user';
-// import { openAppsNoNewUsers } from './setup/new_user';
-import { renameGroup } from './rename_group';
-import { leaveGroup } from './leave_group';
 import { createGroup } from './setup/create_group';
+// import { leaveGroup } from './utilities/leave_group';
+import { newUser, openApp } from './setup/new_user';
 
-let windows: Array<Page> = [];
 test.beforeEach(beforeAllClean);
 
-test.afterEach(() => forceCloseAllWindows(windows));
+// test.afterEach(() => forceCloseAllWindows(windows));
 
-test('Group testing', async () => {
+test('Create group', async () => {
   // Open Electron
-  const { windowA, windowB } = await createGroup('Test Group Name');
+  const [windowA, windowB, windowC] = await openApp(3);
-  windows = [windowA, windowB];
+  const [userA, userB, userC] = await Promise.all([
+    newUser(windowA, 'Alice'),
+    newUser(windowB, 'Bob'),
+    newUser(windowC, 'Chloe'),
+  ]);
+  const testGroupName = 'Tiny Bubble Gang';
+  await createGroup(testGroupName, userA, windowA, userB, windowB, userC, windowC);
+  // Check config messages in all windows
+  await waitForControlMessageWithText(
+    windowA,
+    `"${userC.userName}", "${userB.userName}", You joined the group.`
+  );
+  await waitForControlMessageWithText(
+    windowB,
+    `"${userC.userName}", "${userA.userName}", You joined the group.`
+  );
+  await waitForControlMessageWithText(
+    windowC,
+    `"${userB.userName}", "${userA.userName}", You joined the group.`
+  );
+});
+
+test('Change group name', async () => {
+  const [windowA, windowB, windowC] = await openApp(3);
+  const [userA, userB, userC] = await Promise.all([
+    newUser(windowA, 'Alice'),
+    newUser(windowB, 'Bob'),
+    newUser(windowC, 'Chloe'),
+  ]);
+  const testGroupName = 'Tiny Bubble Gang';
+  const newGroupName = 'Otter lovers';
+  const group = await createGroup(testGroupName, userA, windowA, userB, windowB, userC, windowC);
   // Change the name of the group and check that it syncs to all devices (config messages)
   // Click on already created group
   // Check that renaming a group is working
-  await renameGroup(windowA, 'Test Group Name', 'newGroupName');
+  await renameGroup(windowA, group.userName, newGroupName);
   // Check config message in window B for group name change
-  await clickOnMatchingText(windowB, 'newGroupName');
+  await clickOnMatchingText(windowB, newGroupName);
-  await waitForMatchingText(windowB, "Group name is now 'newGroupName'.");
+  await waitForMatchingText(windowB, `Group name is now ${newGroupName}.`);
-  // Change the group name back to original name
   // Click on conversation options
-  await renameGroup(windowA, 'newGroupName', 'Test Group Name');
-
   // Check to see that you can't change group name to empty string
   // Click on edit group name
   await clickOnMatchingText(windowA, 'Edit group name');
@@ -42,7 +67,4 @@ test('Group testing', async () => {
   await expect(errorMessage).toContainText('Please enter a group name');
   await clickOnMatchingText(windowA, 'Cancel');
   await clickOnTestIdWithText(windowA, 'back-button-conversation-options');
-
-  // Leave group and receive config confirmation
-  await leaveGroup(windowB);
 });

ts/test/automation/group_upkeep.spec.ts

@@ -1,63 +1,71 @@
 import { _electron, Page, test } from '@playwright/test';
-import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
+import { beforeAllClean } from './setup/beforeEach';
-import { openAppsNoNewUsers } from './setup/new_user';
+import { openApp } from './setup/new_user';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
 import { logIn } from './setup/log_in';
-import {
+import { userA, userB, userC, userD, userE } from './setup/test_user';
-  testContactFour,
-  testContactOne,
-  testContactThree,
-  testContactTwo,
-  testUser,
-} from './setup/test_user';
 
 let windows: Array<Page> = [];
 test.beforeEach(beforeAllClean);
 
-test.afterEach(() => forceCloseAllWindows(windows));
-
 test.skip('Group upkeep', async () => {
-  const [windowA, windowB, windowC, windowD, windowE] = await openAppsNoNewUsers(5);
+  const [windowA, windowB, windowC, windowD, windowE] = await openApp(5);
   windows = [windowA, windowB, windowC, windowD, windowE];
   await Promise.all([
-    logIn(windowA, testUser.recoveryPhrase),
+    logIn(windowA, userA.recoveryPhrase),
-    logIn(windowB, testContactOne.recoveryPhrase),
+    logIn(windowB, userB.recoveryPhrase),
-    logIn(windowC, testContactTwo.recoveryPhrase),
+    logIn(windowC, userC.recoveryPhrase),
-    logIn(windowD, testContactThree.recoveryPhrase),
+    logIn(windowD, userD.recoveryPhrase),
-    logIn(windowE, testContactFour.recoveryPhrase),
+    logIn(windowE, userE.recoveryPhrase),
   ]);
   // Send message from test users to all of it's contacts to maintain contact status
 
   // Send message from user A to Whale(TC1)
   await sendNewMessage(
     windowA,
-    testContactOne.sessionid,
+    userB.sessionid,
-    `Test user -> Whale (TC1): ${Date.now()}`
+    `${userA.userName} -> ${userB.userName}: ${Date.now()}`
   );
   // Send message from Whale to user A
-  await sendNewMessage(windowB, testUser.sessionid, `Whale (TC1) -> Test user : ${Date.now()}`);
+  await sendNewMessage(
+    windowB,
+    userA.sessionid,
+    `${userB.userName} -> ${userA.userName} : ${Date.now()}`
+  );
   // Send message from user A to Dragon(TC2)
   await sendNewMessage(
     windowA,
-    testContactTwo.sessionid,
+    userC.sessionid,
-    `Test user -> Dragon (TC2): ${Date.now()}`
+    `${userA.userName} -> ${userC.userName}: ${Date.now()}`
   );
   // Send message from Dragon to user A
-  await sendNewMessage(windowC, testUser.sessionid, `Dragon (TC2) -> Test user : ${Date.now()}`);
+  await sendNewMessage(
+    windowC,
+    userA.sessionid,
+    `${userC.userName} -> ${userA.userName} : ${Date.now()}`
+  );
   // Send message from user A to Fish(TC3)
   await sendNewMessage(
     windowA,
-    testContactThree.sessionid,
+    userD.sessionid,
-    `Test user -> Fish (TC3): ${Date.now()}`
+    `${userA.userName} -> ${userD.userName}: ${Date.now()}`
   );
   // Send message from Fish to user A
-  await sendNewMessage(windowD, testUser.sessionid, `Fish (TC3) -> Test user : ${Date.now()}`);
+  await sendNewMessage(
+    windowD,
+    userA.sessionid,
+    `${userD.userName} -> ${userA.userName} : ${Date.now()}`
+  );
   // Send message from user A to Gopher(TC4)
   await sendNewMessage(
     windowA,
-    testContactFour.sessionid,
+    userE.sessionid,
-    `Test user -> Gopher (TC4): ${Date.now()}`
+    `${userA.userName} -> ${userD.userName}: ${Date.now()}`
   );
   // Send message from Gopher to user A
-  await sendNewMessage(windowE, testUser.sessionid, `Gopher (TC4) -> Test user : ${Date.now()}`);
+  await sendNewMessage(
+    windowE,
+    userA.sessionid,
+    `${userD.userName} -> ${userA.userName} : ${Date.now()}`
+  );
 });

ts/test/automation/linking_device.spec.ts

@@ -1,7 +1,7 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { linkedDevice } from './setup/linked_device';
+import { linkedDevice } from './utilities/linked_device';
-import { clickOnTestIdWithText, typeIntoInput, waitForTestIdWithText } from './utils';
+import { clickOnTestIdWithText, typeIntoInput, waitForTestIdWithText } from './utilities/utils';
 
 const windows: Array<Page> = [];
 test.beforeEach(beforeAllClean);

ts/test/automation/mentions.spec.ts

@@ -1,6 +1,6 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-import { clickOnTestIdWithText, typeIntoInput, waitForTestIdWithText } from './utils';
+import { clickOnTestIdWithText, typeIntoInput, waitForTestIdWithText } from './utilities/utils';
 import { createGroup } from './setup/create_group';
 
 let windows: Array<Page> = [];

ts/test/automation/message_requests.spec.ts

@@ -1,8 +1,12 @@
 import { _electron, Page, test } from '@playwright/test';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { clickOnTestIdWithText, waitForMatchingText, waitForTestIdWithText } from './utils';
+import {
+  clickOnTestIdWithText,
+  waitForMatchingText,
+  waitForTestIdWithText,
+} from './utilities/utils';
 
 const testMessage = 'A -> B';
 

ts/test/automation/new_contact_test.spec.ts

@@ -1,35 +0,0 @@
-import { _electron, Page, test } from '@playwright/test';
-import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
-
-import { sendNewMessage } from './send_message';
-import { openAppsAndNewUsers } from './setup/new_user';
-import { clickOnTestIdWithText, waitForTestIdWithText } from './utils';
-
-const testMessage = 'A -> B';
-const testReply = 'B -> A';
-
-let windows: Array<Page> = [];
-test.beforeEach(beforeAllClean);
-
-test.afterEach(() => forceCloseAllWindows(windows));
-
-// Send message in one to one conversation with new contact
-test('Send message to new contact', async () => {
-  const windowLoggedIn = await openAppsAndNewUsers(2);
-  windows = windowLoggedIn.windows;
-  const users = windowLoggedIn.users;
-  const [windowA, windowB] = windows;
-  const [userA, userB] = users;
-  // User A sends message to User B
-  await sendNewMessage(windowA, userB.sessionid, `${testMessage}${Date.now()}`);
-  // User B sends message to User B to USER A
-  await sendNewMessage(windowB, userA.sessionid, `${testReply}${Date.now()}`);
-  // Navigate to contacts tab in User B's window
-
-  await clickOnTestIdWithText(windowA, 'new-conversation-button');
-  await windowA.waitForTimeout(2000);
-  await waitForTestIdWithText(windowB, 'module-conversation__user__profile-name', userA.userName);
-
-  // Navigate to contacts tab in User A's window
-  await clickOnTestIdWithText(windowA, 'new-conversation-button');
-});

ts/test/automation/password.spec.ts

@@ -9,7 +9,7 @@ import {
   typeIntoInput,
   waitForMatchingText,
   waitForTestIdWithText,
-} from './utils';
+} from './utilities/utils';
 let window: Page | undefined;
 
 test.beforeEach(beforeAllClean);

ts/test/automation/setup/create_group.ts

@@ -1,29 +1,41 @@
 import { _electron, Page } from '@playwright/test';
-import { messageSent } from '../message';
+import { messageSent } from '../utilities/message';
-import { openAppsAndNewUsers } from '../setup/new_user';
+import { sendNewMessage } from '../utilities/send_message';
-import { sendNewMessage } from '../send_message';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
   typeIntoInput,
-  waitForReadableMessageWithText,
+  waitForControlMessageWithText,
   waitForTestIdWithText,
-} from '../utils';
+} from '../utilities/utils';
+import { Group, User } from '../types/testing';
 
-let windows: Array<Page> = [];
+// let windows: Array<Page> = [];
 
-export const createGroup = async (groupName: string) => {
+export const createGroup = async (
-  const windowLoggedIn = await openAppsAndNewUsers(3);
+  userName: string,
-  windows = windowLoggedIn.windows;
+  userOne: User,
-  const users = windowLoggedIn.users;
+  windowA: Page,
-  const [windowA, windowB, windowC] = windows;
+  userTwo: User,
-  const [userA, userB, userC] = users;
+  windowB: Page,
+  userThree: User,
+  windowC: Page
+): Promise<Group> => {
+  const group: Group = { userName, userOne, userTwo, userThree };
+
+  const messageAB = `${userOne.userName} to ${userTwo.userName}`;
+  const messageBA = `${userTwo.userName} to ${userOne.userName}`;
+  const messageCA = `${userThree.userName} to ${userOne.userName}`;
+  const messageAC = `${userOne.userName} to ${userThree.userName}`;
+  const msgAToGroup = `${userOne.userName} -> ${group.userName}`;
+  const msgBToGroup = `${userTwo.userName} -> ${group.userName}`;
+  const msgCToGroup = `${userThree.userName} -> ${group.userName}`;
   // Add contacts
-  await sendNewMessage(windowA, userC.sessionid, `A -> C: ${Date.now()}`);
+  await sendNewMessage(windowA, userThree.sessionid, `${messageAC} Time: ${Date.now()}`);
   await Promise.all([
-    sendNewMessage(windowA, userB.sessionid, `A -> B: ${Date.now()}`),
+    sendNewMessage(windowA, userTwo.sessionid, `${messageAB} Time: ${Date.now()}`),
-    sendNewMessage(windowB, userA.sessionid, `B -> A: ${Date.now()}`),
+    sendNewMessage(windowB, userOne.sessionid, `${messageBA} Time: ${Date.now()}`),
-    sendNewMessage(windowC, userA.sessionid, `C -> A: ${Date.now()}`),
+    sendNewMessage(windowC, userOne.sessionid, `${messageCA} Time: ${Date.now()}`),
   ]);
   // Focus screen on window C to allow user C to become contact
   await clickOnTestIdWithText(windowC, 'messages-container');
@@ -33,18 +45,17 @@ export const createGroup = async (groupName: string) => {
   await clickOnTestIdWithText(windowA, 'new-conversation-button');
   await clickOnTestIdWithText(windowA, 'chooser-new-group');
   // Enter group name
-  await typeIntoInput(windowA, 'new-closed-group-name', groupName);
+  await typeIntoInput(windowA, 'new-closed-group-name', group.userName);
   // Select user B
-  await clickOnMatchingText(windowA, userB.userName);
+  await clickOnMatchingText(windowA, userTwo.userName);
   // Select user C
-  await clickOnMatchingText(windowA, userC.userName);
+  await clickOnMatchingText(windowA, userThree.userName);
   // Click Next
   await clickOnTestIdWithText(windowA, 'next-button');
   // Check group was successfully created
-  await clickOnMatchingText(windowB, groupName);
+  await clickOnMatchingText(windowB, group.userName);
-  await waitForTestIdWithText(windowB, 'header-conversation-name', groupName);
+  await waitForTestIdWithText(windowB, 'header-conversation-name', group.userName);
   // Send message in group chat from user A
-  const msgAToGroup = 'A -> Group';
   await messageSent(windowA, msgAToGroup);
   // Focus screen
   await clickOnMatchingText(windowA, msgAToGroup);
@@ -52,11 +63,10 @@ export const createGroup = async (groupName: string) => {
   // Navigate to group in window B
   await clickOnTestIdWithText(windowB, 'message-section');
   // Click on test group
-  await clickOnMatchingText(windowB, groupName);
+  await clickOnMatchingText(windowB, userName);
   // wait for selector 'test message' in chat window
-  await waitForReadableMessageWithText(windowB, msgAToGroup);
+  await waitForControlMessageWithText(windowB, msgAToGroup);
   // Send reply message
-  const msgBToGroup = 'B -> Group';
   await messageSent(windowB, msgBToGroup);
   // Focus screen
   // await clickOnTestIdWithText(windowB, 'scroll-to-bottom-button');
@@ -64,16 +74,15 @@ export const createGroup = async (groupName: string) => {
   // Navigate to group in window C
   await clickOnTestIdWithText(windowC, 'message-section');
   // Click on test group
-  await clickOnMatchingText(windowC, groupName);
+  await clickOnMatchingText(windowC, userName);
   // windowC must see the message from A and the message from B
-  await waitForReadableMessageWithText(windowC, msgAToGroup);
+  await waitForControlMessageWithText(windowC, msgAToGroup);
-  await waitForReadableMessageWithText(windowC, msgBToGroup);
+  await waitForControlMessageWithText(windowC, msgBToGroup);
   // Send message from C to the group
-  const msgCToGroup = 'C -> Group';
   await messageSent(windowC, msgCToGroup);
   // windowA should see the message from B and the message from C
-  await waitForReadableMessageWithText(windowA, msgBToGroup);
+  await waitForControlMessageWithText(windowA, msgBToGroup);
-  await waitForReadableMessageWithText(windowA, msgCToGroup);
+  await waitForControlMessageWithText(windowA, msgCToGroup);
 
-  return { userA, userB, windowA, windowB, userC, windowC };
+  return { userName, userOne, userTwo, userThree };
 };

ts/test/automation/setup/log_in.ts

@@ -1,5 +1,5 @@
 import { _electron, Page } from '@playwright/test';
-import { clickOnTestIdWithText, typeIntoInput } from '../utils';
+import { clickOnTestIdWithText, typeIntoInput } from '../utilities/utils';
 
 export async function logIn(window: Page, recoveryPhrase: string) {
   await clickOnTestIdWithText(window, 'link-device');

ts/test/automation/setup/new_user.ts

@@ -1,16 +1,11 @@
 import { _electron, Page } from '@playwright/test';
 import _ from 'lodash';
-import { clickOnMatchingText, typeIntoInput } from '../utils';
+import { User } from '../types/testing';
+import { clickOnMatchingText, typeIntoInput } from '../utilities/utils';
 import { openAppAndWait } from './open';
 const multisAvailable = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
 
-export type UserLoggedInType = {
+export const newUser = async (window: Page, userName: string): Promise<User> => {
-  userName: string;
-  sessionid: string;
-  recoveryPhrase: string;
-};
-
-export const newUser = async (window: Page, userName: string): Promise<UserLoggedInType> => {
   // Create User
   await clickOnMatchingText(window, 'Create Session ID');
   // Wait for animation for finish creating ID
@@ -29,7 +24,7 @@ export const newUser = async (window: Page, userName: string): Promise<UserLogge
   return { userName, sessionid, recoveryPhrase };
 };
 
-const openAppAndNewUser = async (multi: string): Promise<UserLoggedInType & { window: Page }> => {
+const openAppAndNewUser = async (multi: string): Promise<User & { window: Page }> => {
   const window = await openAppAndWait(multi);
 
   const userName = `${multi}-user`;
@@ -56,12 +51,12 @@ export async function openAppsAndNewUsers(windowToCreate: number) {
   return { windows, users };
 }
 
-export async function openAppsNoNewUsers(windowToCreate: number) {
+export async function openApp(windowsToCreate: number) {
-  if (windowToCreate >= multisAvailable.length) {
+  if (windowsToCreate >= multisAvailable.length) {
     throw new Error(`Do you really need ${multisAvailable.length} windows?!`);
   }
   // if windowToCreate = 3, this array will be ABC. If windowToCreate = 5, this array will be ABCDE
-  const multisToUse = multisAvailable.slice(0, windowToCreate);
+  const multisToUse = multisAvailable.slice(0, windowsToCreate);
   return Promise.all(
     [...multisToUse].map(async m => {
       return openAppAndWait(`${m}`);

ts/test/automation/setup/recovery_using_seed.ts

@@ -1,5 +1,5 @@
 import { _electron, Page } from '@playwright/test';
-import { clickOnTestIdWithText, typeIntoInput } from '../utils';
+import { clickOnTestIdWithText, typeIntoInput } from '../utilities/utils';
 
 export async function recoverFromSeed(window: Page, userName: string, recoveryPhrase: string) {
   await clickOnTestIdWithText(window, 'restore-using-recovery');

ts/test/automation/setup/test_user.ts

@@ -1,36 +1,36 @@
 import { _electron } from '@playwright/test';
 
-export const testUser = {
+export const userA = {
-  userName: 'testUser',
+  userName: 'Alice',
-  sessionid: '05560802be231abc2fbaa860f09da4c2f20dafa4e5f560f77d61c5f587ef2c741f',
+  sessionid: '059e36f9bb03ac4e1ff9ff7d4aedd791d1f412770c6cd2796b855af12a7c7ea000',
   recoveryPhrase:
-    'pinched total ongoing sushi etched rest gone long oilfield incur code grunt code',
+    'tuition remedy sieve ivory wiggle gemstone hawk optical issued damp selfish fewest damp',
 };
 
-export const testContactOne = {
+export const userB = {
-  userName: 'Whale',
+  userName: 'Bob',
-  sessionid: '059c587e1e027368d4a0ebbf5982fe25e4129fdd79c2328616ceb394cbaf852c52',
+  sessionid: '05ead902602c1f7b59aaa3932b9cdefe8ee4075c03b09811d31bc9b122cb292d0c',
   recoveryPhrase:
-    'jeers apart cuffs mailed sleepless mystery dads tobacco elite lopped fudge arena mystery',
+    'misery testing template jeopardy yahoo asylum kettle wise unveil wept bygones dice dice',
 };
 
-export const testContactTwo = {
+export const userC = {
-  userName: 'Dragon',
+  userName: 'Chloe',
-  sessionid: '05c189b54cea50fa7a3e1fc3ddb6e9c5bcf34ffa7d17af5d8478a45d5a8f629e02',
+  sessionid: '055f4bcc665b94a0f4c2aa9c2d543ae015db167014aac316bc21f5d7c6fdb11025',
   recoveryPhrase:
-    'gossip megabyte rogue pheasants rural romance opus grunt amidst runway erected unveil opus',
+    'bakery broken circle ginger pistons deity deity degrees today insult fidget ouch deity',
 };
 
-export const testContactThree = {
+export const userD = {
-  userName: 'Fish',
+  userName: 'Doug',
-  sessionid: '058781e8f5845c22649c6c6e9fdb5c98e63e04832aec78fe6cacd62c3e71600464',
+  sessionid: '0555274f98d9f681d37446797bdebfa0e53d872213450663141bedb58a8ca67675',
   recoveryPhrase:
-    'hookup reinvest deepest waxing lukewarm aztec invoke fugitive aces onward hire tomorrow hire',
+    'biscuit bomb hire update suede money balding rest fuming alchemy ridges deity update',
 };
 
-export const testContactFour = {
+export const userE = {
-  userName: 'Gopher',
+  userName: 'Egbert',
-  sessionid: '0577ee81a6ac9c1a6f80daddcc22a85bd0dc9cfc3a513b5d2368e2da483886ca11',
+  sessionid: '058b523d3f00773c745c965cf9482dd2fd6ea7a67ec4643c187309e4bbf96a936a',
   recoveryPhrase:
-    'odds annoyed maps apply diplomat custom boat iceberg extra kitchens adventure luggage maps',
+    'dusted coffee hoisting ringing titans dangerous technical bomb bubble pancakes wipeout goldfish technical',
 };

ts/test/automation/switching_theme.spec.ts

@@ -1,7 +1,7 @@
 import { _electron, expect, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { clickOnTestIdWithText } from './utils';
+import { clickOnTestIdWithText } from './utilities/utils';
 
 let windows: Array<Page> = [];
 test.beforeEach(beforeAllClean);

ts/test/automation/types/testing.ts

@@ -0,0 +1,12 @@
+export type User = {
+  userName: string;
+  sessionid: string;
+  recoveryPhrase: string;
+};
+
+export type Group = {
+  userName: string;
+  userOne: User;
+  userTwo: User;
+  userThree: User;
+};

ts/test/automation/unsend_message.spec.ts

@@ -1,13 +1,13 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { sendNewMessage } from './send_message';
+import { sendNewMessage } from './utilities/send_message';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
   waitForMatchingText,
   waitForTestIdWithText,
-} from './utils';
+} from './utilities/utils';
 
 const testMessage = 'A -> B: ';
 const testReply = 'B -> A: ';

ts/test/automation/user_actions.spec.ts

@@ -1,18 +1,43 @@
 import { _electron, Page, test } from '@playwright/test';
 import { beforeAllClean, forceCloseAllWindows } from './setup/beforeEach';
+
+import { sendNewMessage } from './utilities/send_message';
 import { openAppsAndNewUsers } from './setup/new_user';
-import { sendNewMessage } from './send_message';
 import {
   clickOnMatchingText,
   clickOnTestIdWithText,
   waitForMatchingText,
   waitForTestIdWithText,
-} from './utils';
+} from './utilities/utils';
 
 let windows: Array<Page> = [];
 test.beforeEach(beforeAllClean);
 
-test.afterEach(() => forceCloseAllWindows(windows));
+// test.afterEach(() => forceCloseAllWindows(windows));
+
+// Send message in one to one conversation with new contact
+test('Create contact', async () => {
+  const windowLoggedIn = await openAppsAndNewUsers(2);
+  windows = windowLoggedIn.windows;
+  const users = windowLoggedIn.users;
+  const [windowA, windowB] = windows;
+  const [userA, userB] = users;
+
+  const testMessage = `${userA.userName} to ${userB.userName}`;
+  const testReply = `${userB.userName} to ${userA.userName}`;
+  // User A sends message to User B
+  await sendNewMessage(windowA, userB.sessionid, `${testMessage} Time: '${Date.now()}'`);
+  // User B sends message to User B to USER A
+  await sendNewMessage(windowB, userA.sessionid, `${testReply} Time: '${Date.now()}'`);
+  // Navigate to contacts tab in User B's window
+
+  await clickOnTestIdWithText(windowA, 'new-conversation-button');
+  await windowA.waitForTimeout(2000);
+  await waitForTestIdWithText(windowB, 'module-conversation__user__profile-name', userA.userName);
+
+  // Navigate to contacts tab in User A's window
+  await clickOnTestIdWithText(windowA, 'new-conversation-button');
+});
 
 test('Block User', async () => {
   // Open app and create user
@@ -21,14 +46,15 @@ test('Block User', async () => {
   const users = windowLoggedIn.users;
   const [windowA, windowB] = windows;
   const [userA, userB] = users;
+  const testMessage = `${userA.userName} to ${userB.userName}`;
+  const testReply = `${userB.userName} to ${userA.userName}`;
   // Create contact and send new message
 
-  await sendNewMessage(windowA, userB.sessionid, `A -> B: ${Date.now()}`);
+  await sendNewMessage(windowA, userB.sessionid, `${testMessage} Time: '${Date.now()}'`);
-  await sendNewMessage(windowB, userA.sessionid, `B -> A: ${Date.now()}`);
+  await sendNewMessage(windowB, userA.sessionid, `${testReply} Time: '${Date.now()}'`);
   // Check to see if User B is a contact
   await clickOnTestIdWithText(windowA, 'new-conversation-button');
   await waitForTestIdWithText(windowA, 'module-conversation__user__profile-name', userB.userName);
-
   //Click on three dots menu
   await clickOnTestIdWithText(windowA, 'message-section');
 
@@ -40,15 +66,12 @@ test('Block User', async () => {
   // Verify the user was moved to the blocked contact list
   // Click on settings tab
   await clickOnTestIdWithText(windowA, 'settings-section');
-
   // click on settings section 'conversation'
   await clickOnTestIdWithText(windowA, 'conversations-settings-menu-item');
-
   // Navigate to blocked users tab'
   await clickOnTestIdWithText(windowA, 'reveal-blocked-user-settings');
   // select the contact to unblock by clicking on it by name
   await clickOnMatchingText(windowA, userB.userName);
-
   // Unblock user by clicking on unblock
   await clickOnTestIdWithText(windowA, 'unblock-button-settings-screen');
   // Verify toast notification says unblocked

ts/test/automation/utilities/linked_device.ts

@@ -1,5 +1,5 @@
 import { _electron } from 'playwright-core';
-import { openAppsAndNewUsers, openAppsNoNewUsers } from './new_user';
+import { openAppsAndNewUsers, openAppsNoNewUsers } from '../setup/new_user';
 import { logIn } from '../setup/log_in';
 
 export async function linkedDevice() {

ts/test/automation/utilities/utils.ts

@@ -14,8 +14,8 @@ export async function waitForTestIdWithText(window: Page, dataTestId: string, te
   return found;
 }
 
-export async function waitForReadableMessageWithText(window: Page, text: string) {
+export async function waitForControlMessageWithText(window: Page, text: string) {
-  return waitForTestIdWithText(window, 'readable-message', text);
+  return waitForTestIdWithText(window, 'control-message', text);
 }
 
 export async function waitForMatchingText(window: Page, text: string) {