Merge remote-tracking branch 'upstream/unstable' into standardised_strings

preload.js

@@ -40,7 +40,6 @@ window.saveLog = additionalText => ipc.send('save-debug-log', additionalText);
 window.sessionFeatureFlags = {
   useOnionRequests: true,
   useTestNet: isTestNet() || isTestIntegration(),
-  integrationTestEnv: isTestIntegration(),
   useClosedGroupV3: false,
   replaceLocalizedStringsWithKeys: false,
   debug: {
@@ -73,13 +72,29 @@ window.setPassword = async (passPhrase, oldPhrase) =>
   new Promise((resolve, reject) => {
     ipc.once('set-password-response', (_event, response) => {
       if (!response) {
-        return reject('window.setPassword: No response from main process');
+        // We don't reject here, but return undefined and handle the result in the caller.
+        // The reason is because we sometimes want to reject, but sometimes not depending on what the caller is doing (set/change/remove)
+        // For instance, removing a password makes `!response` true, and so we would reject here even if we
+        // technically didn't have an reason to.
+        return resolve(undefined);
       }
       return resolve(response);
     });
     ipc.send('set-password', passPhrase, oldPhrase);
   });
 
+// called to verify that the password is correct when showing the recovery from seed modal
+window.onTryPassword = async passPhrase =>
+  new Promise((resolve, reject) => {
+    ipcRenderer.once('password-recovery-phrase-response', (_event, error) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve();
+    });
+    ipcRenderer.send('password-recovery-phrase', passPhrase);
+  });
+
 window.setStartInTray = async startInTray =>
   new Promise((resolve, reject) => {
     ipc.once('start-in-tray-on-start-response', (_event, error) => {

ts/components/SessionPasswordPrompt.tsx

@@ -110,10 +110,9 @@ class SessionPasswordPromptInner extends PureComponent<unknown, State> {
   }
 
   public async onLogin(passPhrase: string) {
-    const passPhraseTrimmed = passPhrase.trim();
+    // Note: we don't trim the password anymore. If the user entered a space at the end, so be it.
-
     try {
-      await window.onLogin(passPhraseTrimmed);
+      await window.onLogin(passPhrase);
     } catch (error) {
       // Increment the error counter and show the button if necessary
       this.setState({

ts/components/dialog/EnterPasswordModal.tsx

@@ -2,9 +2,9 @@ import { useDispatch } from 'react-redux';
 import styled from 'styled-components';
 
 import { useRef } from 'react';
+import useAsyncFn from 'react-use/lib/useAsyncFn';
 import useMount from 'react-use/lib/useMount';
 import { ToastUtils } from '../../session/utils';
-import { matchesHash } from '../../util/passwordUtils';
 
 import { updateEnterPasswordModal } from '../../state/ducks/modalDialog';
 import { SpacerSM } from '../basic/Text';
@@ -18,47 +18,48 @@ const StyledModalContainer = styled.div`
 `;
 
 export type EnterPasswordModalProps = {
-  passwordHash: string;
-  passwordValid: boolean;
   setPasswordValid: (value: boolean) => void;
-  onClickOk?: () => any;
+  onClickOk?: () => void;
-  onClickClose?: () => any;
+  onClickClose?: () => void;
-  title?: string;
 };
 
 export const EnterPasswordModal = (props: EnterPasswordModalProps) => {
-  const { passwordHash, setPasswordValid, onClickOk, onClickClose, title } = props;
+  const { setPasswordValid, onClickOk, onClickClose } = props;
+  const title = window.i18n('sessionRecoveryPassword');
 
   const passwordInputRef = useRef<HTMLInputElement>(null);
   const dispatch = useDispatch();
 
-  const onClose = () => {
+  const onPasswordVerified = () => {
-    if (onClickClose) {
+    onClickOk?.();
-      onClickClose();
-    }
     dispatch(updateEnterPasswordModal(null));
   };
 
-  const confirmPassword = () => {
+  const [, verifyPassword] = useAsyncFn(async () => {
-    const passwordValue = passwordInputRef.current?.value;
+    try {
-    if (!passwordValue) {
+      const passwordValue = passwordInputRef.current?.value;
-      ToastUtils.pushToastError('enterPasswordErrorToast', window.i18n('passwordErrorMatch'));
+      if (!passwordValue) {
+        ToastUtils.pushToastError('enterPasswordErrorToast', window.i18n('noGivenPassword'));
 
-      return;
+        return;
-    }
+      }
 
-    const isPasswordValid = matchesHash(passwordValue, passwordHash);
+      // this throws if the password is invalid.
-    if (passwordHash && !isPasswordValid) {
+      await window.onTryPassword(passwordValue);
-      ToastUtils.pushToastError('enterPasswordErrorToast', window.i18n('passwordErrorMatch'));
 
-      return;
+      setPasswordValid(true);
+      onPasswordVerified();
+    } catch (e) {
+      window.log.error('window.onTryPassword failed with', e);
+      ToastUtils.pushToastError('enterPasswordErrorToast', window.i18n('invalidPassword'));
     }
+  });
 
-    setPasswordValid(true);
+  const onClose = () => {
-
+    if (onClickClose) {
-    if (onClickOk) {
+      onClickClose();
-      void onClickOk();
     }
+    dispatch(updateEnterPasswordModal(null));
   };
 
   useMount(() => {
@@ -69,7 +70,7 @@ export const EnterPasswordModal = (props: EnterPasswordModalProps) => {
 
   useHotkey('Enter', (event: KeyboardEvent) => {
     if (event.target === passwordInputRef.current) {
-      confirmPassword();
+      void verifyPassword();
     }
   });
 
@@ -100,7 +101,7 @@ export const EnterPasswordModal = (props: EnterPasswordModalProps) => {
           <SessionButton
             text={window.i18n('done')}
             buttonType={SessionButtonType.Simple}
-            onClick={confirmPassword}
+            onClick={verifyPassword}
             dataTestId="session-confirm-ok-button"
           />
           <SessionButton

ts/components/dialog/SessionSetPasswordDialog.tsx

@@ -208,6 +208,9 @@ export class SessionSetPasswordDialog extends Component<Props, State> {
     }
     try {
       const updatedHash = await window.setPassword(enteredPassword, null);
+      if (!updatedHash) {
+        throw new Error('window.setPassword expected updatedHash to be set for actionSet');
+      }
       await Storage.put('passHash', updatedHash);
 
       ToastUtils.pushToastSuccess(
@@ -258,6 +261,9 @@ export class SessionSetPasswordDialog extends Component<Props, State> {
 
     try {
       const updatedHash = await window.setPassword(newPassword, oldPassword);
+      if (!updatedHash) {
+        throw new Error('window.setPassword expected updatedHash to be set for actionChange');
+      }
       await Storage.put('passHash', updatedHash);
 
       ToastUtils.pushToastSuccess(
@@ -293,7 +299,10 @@ export class SessionSetPasswordDialog extends Component<Props, State> {
     }
 
     try {
-      await window.setPassword(null, oldPassword);
+      const updatedHash = await window.setPassword(null, oldPassword);
+      if (updatedHash) {
+        throw new Error('window.setPassword expected updatedHash to be unset for actionRemove');
+      }
       await Storage.remove('passHash');
 
       ToastUtils.pushToastWarning(

ts/components/inputs/SessionInput.tsx

@@ -427,6 +427,7 @@ export const SessionInput = (props: Props) => {
             ) : (
               <StyledPlaceholder
                 error={textErrorStyle}
+                data-testid={inputDataTestId}
                 textSize={textSize}
                 editable={editable}
                 centerText={centerText}

ts/components/settings/section/CategoryRecoveryPassword.tsx

@@ -1,8 +1,7 @@
-import { isEmpty } from 'lodash';
 import { useState } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
-import useMount from 'react-use/lib/useMount';
 import styled from 'styled-components';
+import { useHotkey } from '../../../hooks/useHotkey';
 import { useIconToImageURL } from '../../../hooks/useIconToImageURL';
 import { usePasswordModal } from '../../../hooks/usePasswordModal';
 import { mnDecode } from '../../../session/crypto/mnemonic';
@@ -11,6 +10,7 @@ import {
   updateLightBoxOptions,
 } from '../../../state/ducks/modalDialog';
 import { showSettingsSection } from '../../../state/ducks/section';
+import { getIsModalVisble } from '../../../state/selectors/modal';
 import { useHideRecoveryPasswordEnabled } from '../../../state/selectors/settings';
 import { useIsDarkTheme } from '../../../state/selectors/theme';
 import { THEME_GLOBALS } from '../../../themes/globals';
@@ -18,6 +18,7 @@ import { prepareQRCodeForLightBox } from '../../../util/qrCodes';
 import { getCurrentRecoveryPhrase } from '../../../util/storage';
 import { QRCodeLogoProps, SessionQRCode } from '../../SessionQRCode';
 import { AnimatedFlex } from '../../basic/Flex';
+import { I18n } from '../../basic/I18n';
 import { SessionButtonColor } from '../../basic/SessionButton';
 import { SpacerMD, SpacerSM } from '../../basic/Text';
 import { CopyToClipboardIcon } from '../../buttons/CopyToClipboardButton';
@@ -27,9 +28,6 @@ import {
   SessionSettingsItemWrapper,
   StyledSettingItem,
 } from '../SessionSettingListItem';
-import { useHotkey } from '../../../hooks/useHotkey';
-import { getIsModalVisble } from '../../../state/selectors/modal';
-import { I18n } from '../../basic/I18n';
 
 const StyledSettingsItemContainer = styled.div`
   p {
@@ -68,9 +66,11 @@ const qrLogoProps: QRCodeLogoProps = {
 };
 
 export const SettingsCategoryRecoveryPassword = () => {
-  const [loadingSeed, setLoadingSeed] = useState(true);
+  const recoveryPhrase = getCurrentRecoveryPhrase();
-  const [recoveryPhrase, setRecoveryPhrase] = useState('');
+  if (!recoveryPhrase) {
-  const [hexEncodedSeed, setHexEncodedSeed] = useState('');
+    throw new Error('SettingsCategoryRecoveryPassword recovery seed is empty');
+  }
+  const hexEncodedSeed = mnDecode(recoveryPhrase, 'english');
   const [isQRVisible, setIsQRVisible] = useState(false);
 
   const hideRecoveryPassword = useHideRecoveryPasswordEnabled();
@@ -82,27 +82,11 @@ export const SettingsCategoryRecoveryPassword = () => {
   const dispatch = useDispatch();
 
   const { hasPassword, passwordValid } = usePasswordModal({
-    title: window.i18n('sessionRecoveryPassword'),
     onClose: () => {
       dispatch(showSettingsSection('privacy'));
     },
   });
 
-  const fetchRecoverPhrase = () => {
-    const newRecoveryPhrase = getCurrentRecoveryPhrase();
-    setRecoveryPhrase(newRecoveryPhrase);
-    if (!isEmpty(newRecoveryPhrase)) {
-      setHexEncodedSeed(mnDecode(newRecoveryPhrase, 'english'));
-    }
-    setLoadingSeed(false);
-  };
-
-  useMount(() => {
-    if (!hasPassword || (hasPassword && passwordValid)) {
-      fetchRecoverPhrase();
-    }
-  });
-
   useHotkey(
     'v',
     () => {
@@ -110,10 +94,10 @@ export const SettingsCategoryRecoveryPassword = () => {
         setIsQRVisible(!isQRVisible);
       }
     },
-    (hasPassword && !passwordValid) || loadingSeed || hideRecoveryPassword
+    (hasPassword && !passwordValid) || hideRecoveryPassword
   );
 
-  if ((hasPassword && !passwordValid) || loadingSeed || hideRecoveryPassword) {
+  if ((hasPassword && !passwordValid) || hideRecoveryPassword) {
     return null;
   }
 

ts/hooks/usePasswordModal.ts

@@ -1,4 +1,3 @@
-import { isEmpty } from 'lodash';
 import { useState } from 'react';
 import { useDispatch } from 'react-redux';
 import useMount from 'react-use/lib/useMount';
@@ -7,63 +6,38 @@ import { getPasswordHash } from '../util/storage';
 
 /**
  * Password protection for a component if a password has been set
- * @param title - Title of the password modal
  * @param onSuccess - Callback when password is correct
  * @param onClose - Callback when modal is cancelled or closed. Definitely use this if your component returns null until a password is entered
  * @returns An object with two properties - hasPassword which is true if a password has been set, passwordValid which is true if the password entered is correct
  */
 export function usePasswordModal({
-  title,
   onSuccess,
   onClose,
 }: {
-  title?: string;
   onSuccess?: () => void;
   onClose?: () => void;
 }) {
-  const [hasPassword, setHasPassword] = useState(false);
-  const [passwordHash, setPasswordHash] = useState('');
-  const [passwordValid, setPasswordValid] = useState(false);
-
   const dispatch = useDispatch();
 
-  const validateAccess = () => {
+  const hashFromStorage = getPasswordHash();
-    if (!isEmpty(passwordHash)) {
+  const [hasPassword] = useState(!!hashFromStorage);
-      return;
-    }
 
-    const hash = getPasswordHash();
+  const [passwordValid, setPasswordValid] = useState(!hasPassword);
-    setHasPassword(!!hash);
 
-    if (hash) {
+  useMount(() => {
-      setPasswordHash(hash);
+    // if no hash is set, the user didn't set a password.
-      dispatch(
+    // we can just show whatever was password protected
-        updateEnterPasswordModal({
+    if (!hashFromStorage || passwordValid) {
-          passwordHash,
+      return;
-          passwordValid,
-          setPasswordValid,
-          onClickOk: () => {
-            if (onSuccess) {
-              onSuccess();
-            }
-            setPasswordHash('');
-            dispatch(updateEnterPasswordModal(null));
-          },
-          onClickClose: () => {
-            if (onClose) {
-              onClose();
-            }
-            setPasswordHash('');
-            dispatch(updateEnterPasswordModal(null));
-          },
-          title,
-        })
-      );
     }
-  };
 
-  useMount(() => {
+    dispatch(
-    validateAccess();
+      updateEnterPasswordModal({
+        setPasswordValid,
+        onClickOk: onSuccess,
+        onClickClose: onClose,
+      })
+    );
   });
 
   return { hasPassword, passwordValid };

ts/mains/main_node.ts

@@ -963,6 +963,28 @@ ipc.on('password-window-login', async (event, passPhrase) => {
   }
 });
 
+ipc.on('password-recovery-phrase', async (event, passPhrase) => {
+  const sendResponse = (e: string | undefined) => {
+    event.sender.send('password-recovery-phrase-response', e);
+  };
+
+  try {
+    // Check if the hash we have stored matches the given password.
+    const hash = sqlNode.getPasswordHash();
+
+    const hashMatches = passPhrase && PasswordUtil.matchesHash(passPhrase, hash);
+    if (hash && !hashMatches) {
+      throw new Error('Invalid password');
+    }
+    // no issues. send back undefined, meaning OK
+    sendResponse(undefined);
+  } catch (e) {
+    const localisedError = locale.messages.removePasswordInvalid;
+    // send back the error
+    sendResponse(localisedError);
+  }
+});
+
 ipc.on('start-in-tray-on-start', (event, newValue) => {
   try {
     userConfig.set('startInTray', newValue);

ts/session/apis/snode_api/onsResolve.ts

@@ -39,6 +39,7 @@ async function getSessionIDForOnsName(onsNameCase: string) {
 
   if (isTestNet()) {
     window.log.info('OnsResolve response are not registered to anything on testnet');
+    throw new Error('OnsResolve response are not registered to anything on testnet');
   }
 
   const onsResolveRequests = buildOnsResolveRequests(base64EncodedNameHash);

ts/session/apis/snode_api/snodePool.ts

@@ -10,6 +10,7 @@ import { ed25519Str } from '../../utils/String';
 import { SeedNodeAPI } from '../seed_node_api';
 import { ServiceNodesList } from './getServiceNodesList';
 import { requestSnodesForPubkeyFromNetwork } from './getSwarmFor';
+import { minimumGuardCount, ONION_REQUEST_HOPS } from '../../onions/onionPath';
 
 /**
  * If we get less than this snode in a swarm, we fetch new snodes for this pubkey
@@ -20,7 +21,7 @@ const minSwarmSnodeCount = 3;
  * If we get less than minSnodePoolCount we consider that we need to fetch the new snode pool from a seed node
  * and not from those snodes.
  */
-export const minSnodePoolCount = 12;
+export const minSnodePoolCount = minimumGuardCount * (ONION_REQUEST_HOPS + 1) * 2;
 
 /**
  * If we get less than this amount of snodes (24), lets try to get an updated list from those while we can

ts/session/constants.ts

@@ -105,3 +105,14 @@ export const ONBOARDING_TIMES = {
   /** 0.2 seconds */
   RECOVERY_FINISHED: 0.2 * DURATION.SECONDS,
 };
+
+export const PASSWORD_LENGTH = {
+  /**
+   * 6 chars
+   */
+  MIN_PASSWORD_LEN: 6,
+  /**
+   * 64 chars
+   */
+  MAX_PASSWORD_LEN: 64,
+};

ts/session/disappearing_messages/timerOptions.ts

@@ -1,4 +1,4 @@
-import { isCI, isDevProd } from '../../shared/env_vars';
+import { isDevProd } from '../../shared/env_vars';
 import { formatAbbreviatedExpireTimer } from '../../util/i18n/formater/expirationTimer';
 import { formatTimeDuration } from '../../util/i18n/formater/generics';
 import { DURATION_SECONDS } from '../constants';
@@ -55,7 +55,7 @@ function getAbbreviated(seconds = 0) {
 }
 
 const filterOutDebugValues = (option: number) => {
-  return isDevProd() || isCI() || option > 60; // when not a dev build nor on CI, filter out options with less than 60s
+  return isDevProd() || option > 60; // when not a dev build, filter out options with less than 60s
 };
 
 const DELETE_AFTER_READ = VALUES.filter(option => {

ts/session/onions/onionPath.ts

@@ -18,9 +18,9 @@ import { UserUtils } from '../utils';
 import { allowOnlyOneAtATime } from '../utils/Promise';
 import { ed25519Str } from '../utils/String';
 
-const desiredGuardCount = 3;
+export const desiredGuardCount = 2;
-const minimumGuardCount = 2;
+export const minimumGuardCount = 1;
-const ONION_REQUEST_HOPS = 3;
+export const ONION_REQUEST_HOPS = 3;
 
 export function getOnionPathMinTimeout() {
   return DURATION.SECONDS;
@@ -31,9 +31,7 @@ export let onionPaths: Array<Array<Snode>> = [];
 /**
  * Used for testing only
  * @returns a copy of the onion path currently used by the app.
- *
  */
-
 export const TEST_getTestOnionPath = () => {
   return _.cloneDeep(onionPaths);
 };

ts/session/utils/job_runners/PersistedJob.ts

@@ -108,7 +108,19 @@ export abstract class PersistedJob<T extends PersistedJobData> {
 
   public async runJob() {
     if (!this.runningPromise) {
-      this.runningPromise = this.run();
+      // eslint-disable-next-line more/no-then
+      this.runningPromise = this.run()
+        .then(jobResult => {
+          this.runningPromise = null;
+          return jobResult;
+        })
+        .catch(e => {
+          window.log.warn(
+            'runJob() threw. this cannot happen, but rethrowing as this should be handled in each jobs run()',
+            e
+          );
+          throw e;
+        });
     }
     return this.runningPromise;
   }

ts/session/utils/job_runners/jobs/ConfigurationSyncJob.ts

@@ -23,8 +23,8 @@ import {
 } from '../PersistedJob';
 import { DURATION } from '../../../constants';
 
-const defaultMsBetweenRetries = 15000; // a long time between retries, to avoid running multiple jobs at the same time, when one was postponed at the same time as one already planned (5s)
+const defaultMsBetweenRetries = 5 * DURATION.SECONDS; // a long time between retries, to avoid running multiple jobs at the same time, when one was postponed at the same time as one already planned (5s)
-const defaultMaxAttempts = 2;
+const defaultMaxAttempts = 4;
 
 /**
  * We want to run each of those jobs at least 3seconds apart.
@@ -56,8 +56,6 @@ async function retrieveSingleDestinationChanges(
   return { messages: outgoingConfResults, allOldHashes: compactedHashes };
 }
 
-let firstJobStart: number | undefined;
-
 /**
  * This function is run once we get the results from the multiple batch-send.
  */
@@ -194,18 +192,6 @@ class ConfigurationSyncJob extends PersistedJob<ConfigurationSyncPersistedData>
         return RunJobResult.Success;
       }
       const singleDestChanges = await retrieveSingleDestinationChanges(thisJobDestination);
-      if (!firstJobStart) {
-        firstJobStart = Date.now();
-      }
-
-      // not ideal, but we need to postpone the first sync job to after we've handled the incoming config messages
-      // otherwise we are pushing an incomplete config to the network, which will need to be merged and that action alone
-      // will bump the timestamp of the config.
-      // We rely on the timestamp of configs to know when to drop messages that would unhide/unremove a conversation.
-      // The whole thing is a dirty fix of a dirty fix, that will **eventually** need proper fixing
-      if (Date.now() - firstJobStart <= 20 * DURATION.SECONDS) {
-        return RunJobResult.RetryJobIfPossible;
-      }
 
       // If there are no pending changes then the job can just complete (next time something
       // is updated we want to try and run immediately so don't scuedule another run in this case)
@@ -332,18 +318,18 @@ async function queueNewJobIfNeeded() {
     !lastRunConfigSyncJobTimestamp ||
     lastRunConfigSyncJobTimestamp < Date.now() - defaultMsBetweenRetries
   ) {
-    // window.log.debug('Scheduling ConfSyncJob: ASAP');
+    // Note: we postpone by 3s for two reasons:
-    // we postpone by 1000ms to make sure whoever is adding this job is done with what is needs to do first
+    // - to make sure whoever is adding this job is done with what is needs to do first
+    // - to allow a recently created device to process incoming config messages before pushing a new one
     // this call will make sure that there is only one configuration sync job at all times
     await runners.configurationSyncRunner.addJob(
-      new ConfigurationSyncJob({ nextAttemptTimestamp: Date.now() + 1000 })
+      new ConfigurationSyncJob({ nextAttemptTimestamp: Date.now() + 3 * DURATION.SECONDS })
     );
   } else {
     // if we did run at t=100, and it is currently t=110, the difference is 10
     const diff = Math.max(Date.now() - lastRunConfigSyncJobTimestamp, 0);
     // but we want to run every 30, so what we need is actually `30-10` from now = 20
-    const leftBeforeNextTick = Math.max(defaultMsBetweenRetries - diff, 1000);
+    const leftBeforeNextTick = Math.max(defaultMsBetweenRetries - diff, DURATION.SECONDS);
-    // window.log.debug('Scheduling ConfSyncJob: LATER');
 
     await runners.configurationSyncRunner.addJob(
       new ConfigurationSyncJob({ nextAttemptTimestamp: Date.now() + leftBeforeNextTick })

ts/shared/env_vars.ts

@@ -5,19 +5,14 @@ function envAppInstanceIncludes(prefix: string) {
   return !!process.env.NODE_APP_INSTANCE.includes(prefix);
 }
 
-export function isCI() {
-  // this is set by session-playwright to run a build on CI
-  return !!process.env.CI;
-}
-
 export function isDevProd() {
   return envAppInstanceIncludes('devprod');
 }
 
 export function isTestNet() {
-  return envAppInstanceIncludes('testnet') || isCI(); // when running on CI, we always want to use testnet
+  return envAppInstanceIncludes('testnet');
 }
 
 export function isTestIntegration() {
-  return envAppInstanceIncludes('test-integration') || isCI(); // when running on CI, we always want the 'test-integration' behavior
+  return envAppInstanceIncludes('test-integration');
 }

ts/test/session/unit/onion/GuardNodes_test.ts

@@ -14,6 +14,7 @@ import {
 } from '../../../test-utils/utils';
 import { SeedNodeAPI } from '../../../../session/apis/seed_node_api';
 import { Snode } from '../../../../data/types';
+import { minSnodePoolCount } from '../../../../session/apis/snode_api/snodePool';
 
 chai.use(chaiAsPromised as any);
 chai.should();
@@ -51,7 +52,7 @@ describe('GuardNodes', () => {
       Sinon.restore();
     });
 
-    it('does not fetch from seed if we got 12 or more snodes in the db', async () => {
+    it('does not fetch from seed if we have 8 or more snodes in the db', async () => {
       stubData('getSnodePoolFromDb').resolves(fakeSnodePool);
 
       getSnodePoolFromDBOrFetchFromSeed = Sinon.stub(
@@ -76,14 +77,12 @@ describe('GuardNodes', () => {
         fetchFromSeedWithRetriesAndWriteToDb.callCount,
         'fetchFromSeedWithRetriesAndWriteToDb should not have been called'
       ).to.be.eq(0);
-      expect(
+      expect(testGuardNode.callCount, 'testGuardNode should have been called two times').to.be.eq(
-        testGuardNode.callCount,
+        2
-        'firstGuardNode should have been called three times'
+      ); // this should be desiredGuardCount
-      ).to.be.eq(3);
       const firstGuardNode = testGuardNode.firstCall.args[0];
       const secondGuardNode = testGuardNode.secondCall.args[0];
-      const thirdGuardNode = testGuardNode.thirdCall.args[0];
+      expect(fetchedGuardNodes).to.deep.equal([firstGuardNode, secondGuardNode]);
-      expect(fetchedGuardNodes).to.deep.equal([firstGuardNode, secondGuardNode, thirdGuardNode]);
     });
 
     it('throws an error if we got enough snodes in the db but none test passes', async () => {
@@ -116,10 +115,9 @@ describe('GuardNodes', () => {
         fetchFromSeedWithRetriesAndWriteToDb.callCount,
         'fetchFromSeedWithRetriesAndWriteToDb should not have been called'
       ).to.be.eq(0);
-      expect(
+      expect(testGuardNode.callCount, 'testGuardNode should have been called 12 times').to.be.eq(
-        testGuardNode.callCount,
+        12
-        'firstGuardNode should have been called three times'
+      );
-      ).to.be.eq(18);
       expect(throwedError).to.be.equal('selectGuardNodes stopping after attempts: 6');
     });
 
@@ -168,13 +166,15 @@ describe('GuardNodes', () => {
       // run the command
       const guardNodes = await OnionPaths.selectGuardNodes();
 
-      expect(guardNodes.length).to.be.equal(3);
+      // 2 because our desiredGuardCount is 2 (not putting the variable to make the test fails if we ever change it)
-      expect(testGuardNode.callCount).to.be.equal(3);
+      expect(guardNodes.length).to.be.equal(2);
+      expect(testGuardNode.callCount).to.be.equal(2);
     });
 
     it('throws if we have to fetch from seed, fetch from seed but not have enough fetched snodes', async () => {
-      const invalidSndodePool = fakeSnodePool.slice(0, 11);
+      const invalidLength = minSnodePoolCount - 1;
-      stubData('getSnodePoolFromDb').resolves(invalidSndodePool);
+      const invalidSnodePool = fakeSnodePool.slice(0, invalidLength);
+      stubData('getSnodePoolFromDb').resolves(invalidSnodePool);
       TestUtils.stubWindow('getSeedNodeList', () => [{ url: 'whatever' }]);
 
       getSnodePoolFromDBOrFetchFromSeed = Sinon.stub(
@@ -184,7 +184,7 @@ describe('GuardNodes', () => {
       fetchFromSeedWithRetriesAndWriteToDb = Sinon.stub(
         SeedNodeAPI,
         'fetchSnodePoolFromSeedNodeWithRetries'
-      ).resolves(invalidSndodePool);
+      ).resolves(invalidSnodePool);
 
       stubData('updateGuardNodes').resolves();
       // run the command
@@ -195,7 +195,7 @@ describe('GuardNodes', () => {
         throwedError = e.message;
       }
       expect(throwedError).to.be.equal(
-        'Could not select guard nodes. Not enough nodes in the pool: 11'
+        'Could not select guard nodes. Not enough nodes in the pool: 7' // this is invalidLength but we want this test to fail if we change minSnodePoolCount
       );
     });
   });

ts/test/session/unit/onion/SnodePoolUpdate_test.ts

@@ -67,10 +67,10 @@ describe('OnionPaths', () => {
       expect(fetched).to.deep.equal(fakeSnodePool);
     });
 
-    it('if the cached snode pool 12 or less snodes, trigger a fetch from the seed nodes', async () => {
+    it('if the cached snode pool is 8 or less snodes, trigger a fetch from the seed nodes', async () => {
-      const length12 = fakeSnodePool.slice(0, 12);
+      const length8 = fakeSnodePool.slice(0, 8);
-      expect(length12.length).to.eq(12);
+      expect(length8.length).to.eq(8);
-      getSnodePoolFromDb = stubData('getSnodePoolFromDb').resolves(length12);
+      getSnodePoolFromDb = stubData('getSnodePoolFromDb').resolves(length8);
 
       stubData('updateSnodePoolOnDb').resolves();
       fetchFromSeedWithRetriesAndWriteToDb = Sinon.stub(

ts/test/session/unit/utils/job_runner/JobRunner_test.ts

@@ -271,6 +271,7 @@ describe('JobRunner', () => {
 
     it('adding one job after the first is done schedules it', async () => {
       await runnerMulti.loadJobsFromDb();
+      TestUtils.stubWindowLog();
       const job = getFakeSleepForMultiJob({ timestamp: 100 });
       runnerMulti.startProcessing();
       clock.tick(110);
@@ -303,6 +304,8 @@ describe('JobRunner', () => {
 
       await job2.waitForCurrentTry();
       await runnerMulti.waitCurrentJob();
+      // we need to give some time for the jobrunner to handle the return of job2 and remove it
+      await sleepFor(100);
 
       expect(runnerMulti.getJobList()).to.deep.eq([]);
     });
@@ -401,7 +404,7 @@ describe('JobRunner', () => {
         currentRetry: 1,
       };
       // just give  time for the runnerMulti to pick up a new job
-      await sleepFor(10);
+      await sleepFor(100);
 
       // the job failed, so the job should still be there
       expect(runnerMulti.getJobList()).to.deep.eq([jobUpdated]);
@@ -409,14 +412,16 @@ describe('JobRunner', () => {
       // that job should be retried now
       clock.tick(11000);
       await runner.waitCurrentJob();
+      await runnerMulti.waitCurrentJob();
+
       const jobUpdated2 = {
         ...job.serializeJob(),
-        nextAttemptTimestamp: clock.now + 10000,
+        nextAttemptTimestamp: clock.now + job.persistedData.delayBetweenRetries,
         currentRetry: 2,
       };
+
       await sleepFor(10);
 
-      await runnerMulti.waitCurrentJob();
       expect(runnerMulti.getJobList()).to.deep.eq([jobUpdated2]);
 
       // that job should be retried one more time and then removed from the list of jobs to be run

ts/types/attachments/VisualAttachment.ts

@@ -13,6 +13,7 @@ import { GoogleChrome } from '../../util';
 import { autoScaleForAvatar, autoScaleForThumbnail } from '../../util/attachmentsUtil';
 import { isAudio } from '../MIME';
 import { formatTimeDuration } from '../../util/i18n/formater/generics';
+import { isTestIntegration } from '../../shared/env_vars';
 
 export const THUMBNAIL_SIDE = 200;
 export const THUMBNAIL_CONTENT_TYPE = 'image/png';
@@ -204,8 +205,8 @@ export async function autoScaleAvatarBlob(file: File) {
  * Shows the system file picker for images, scale the image down for avatar/opengroup measurements and return the blob objectURL on success
  */
 export async function pickFileForAvatar(): Promise<string | null> {
-  if (window.sessionFeatureFlags.integrationTestEnv) {
+  if (isTestIntegration()) {
-    window.log.info(
+    window.log.warn(
       'shorting pickFileForAvatar as it does not work in playwright/notsending the filechooser event'
     );
 

ts/util/passwordUtils.ts

@@ -1,5 +1,6 @@
 import * as crypto from 'crypto';
 import { isString } from 'lodash';
+import { PASSWORD_LENGTH } from '../session/constants';
 
 const ERRORS = {
   TYPE: 'Password must be a string',
@@ -13,29 +14,29 @@ const sha512 = (text: string) => {
   return hash.digest('hex');
 };
 
-export const MAX_PASSWORD_LENGTH = 64;
+export const generateHash = (phrase: string) => phrase && sha512(phrase);
-
-export const generateHash = (phrase: string) => phrase && sha512(phrase.trim());
 export const matchesHash = (phrase: string | null, hash: string) =>
-  phrase && sha512(phrase.trim()) === hash.trim();
+  phrase && sha512(phrase) === hash;
 
 export const validatePassword = (phrase: string) => {
   if (!isString(phrase)) {
     return window?.i18n ? window.i18n('passwordError') : ERRORS.TYPE;
   }
 
-  const trimmed = phrase.trim();
+  if (phrase.length === 0) {
-  if (trimmed.length === 0) {
+    return window?.i18n ? window?.i18n('passwordErrorLength') : ERRORS.LENGTH;
-    return window?.i18n ? window.i18n('passwordCreate') : ERRORS.LENGTH;
   }
 
-  if (trimmed.length < 6 || trimmed.length > MAX_PASSWORD_LENGTH) {
+  if (
-    return window?.i18n ? window.i18n('passwordErrorLength') : ERRORS.LENGTH;
+    phrase.length < PASSWORD_LENGTH.MIN_PASSWORD_LEN ||
+    phrase.length > PASSWORD_LENGTH.MAX_PASSWORD_LEN
+  ) {
+    return window?.i18n ? window?.i18n('passwordErrorLength') : ERRORS.LENGTH;
   }
 
   // Restrict characters to letters, numbers and symbols
   const characterRegex = /^[a-zA-Z0-9-!?/\\()._`~@#$%^&*+=[\]{}|<>,;: ]+$/;
-  if (!characterRegex.test(trimmed)) {
+  if (!characterRegex.test(phrase)) {
     return window?.i18n ? window.i18n('passwordError') : ERRORS.CHARACTER;
   }
 

ts/window.d.ts

@@ -133,7 +133,6 @@ declare global {
       useOnionRequests: boolean;
       useTestNet: boolean;
       useClosedGroupV3: boolean;
-      integrationTestEnv: boolean;
       replaceLocalizedStringsWithKeys: boolean;
       debug: {
         debugLogging: boolean;
@@ -143,11 +142,15 @@ declare global {
         debugOnionRequests: boolean;
       };
     };
-    onLogin: (pw: string) => Promise<void>;
+    onLogin: (pw: string) => Promise<void>; // only set on the password window
+    onTryPassword: (pw: string) => Promise<void>; // only set on the main window
     persistStore?: Persistor;
     restart: () => void;
     getSeedNodeList: () => Array<string> | undefined;
-    setPassword: (newPassword: string | null, oldPassword: string | null) => Promise<string>;
+    setPassword: (
+      newPassword: string | null,
+      oldPassword: string | null
+    ) => Promise<string | undefined>;
     isOnline: boolean;
     toggleMediaPermissions: () => Promise<void>;
     toggleCallMediaPermissionsTo: (enabled: boolean) => Promise<void>;